1*c5c4113dSnw141292 /* 2*c5c4113dSnw141292 ** 2001 September 15 3*c5c4113dSnw141292 ** 4*c5c4113dSnw141292 ** The author disclaims copyright to this source code. In place of 5*c5c4113dSnw141292 ** a legal notice, here is a blessing: 6*c5c4113dSnw141292 ** 7*c5c4113dSnw141292 ** May you do good and not evil. 8*c5c4113dSnw141292 ** May you find forgiveness for yourself and forgive others. 9*c5c4113dSnw141292 ** May you share freely, never taking more than you give. 10*c5c4113dSnw141292 ** 11*c5c4113dSnw141292 ************************************************************************* 12*c5c4113dSnw141292 ** Internal interface definitions for SQLite. 13*c5c4113dSnw141292 ** 14*c5c4113dSnw141292 ** @(#) $Id: sqliteInt.h,v 1.220.2.1 2004/07/15 13:37:05 drh Exp $ 15*c5c4113dSnw141292 */ 16*c5c4113dSnw141292 #include "config.h" 17*c5c4113dSnw141292 #include "sqlite.h" 18*c5c4113dSnw141292 #include "hash.h" 19*c5c4113dSnw141292 #include "parse.h" 20*c5c4113dSnw141292 #include "btree.h" 21*c5c4113dSnw141292 #include <stdio.h> 22*c5c4113dSnw141292 #include <stdlib.h> 23*c5c4113dSnw141292 #include <string.h> 24*c5c4113dSnw141292 #include <assert.h> 25*c5c4113dSnw141292 26*c5c4113dSnw141292 /* 27*c5c4113dSnw141292 ** The maximum number of in-memory pages to use for the main database 28*c5c4113dSnw141292 ** table and for temporary tables. 29*c5c4113dSnw141292 */ 30*c5c4113dSnw141292 #define MAX_PAGES 2000 31*c5c4113dSnw141292 #define TEMP_PAGES 500 32*c5c4113dSnw141292 33*c5c4113dSnw141292 /* 34*c5c4113dSnw141292 ** If the following macro is set to 1, then NULL values are considered 35*c5c4113dSnw141292 ** distinct for the SELECT DISTINCT statement and for UNION or EXCEPT 36*c5c4113dSnw141292 ** compound queries. No other SQL database engine (among those tested) 37*c5c4113dSnw141292 ** works this way except for OCELOT. But the SQL92 spec implies that 38*c5c4113dSnw141292 ** this is how things should work. 39*c5c4113dSnw141292 ** 40*c5c4113dSnw141292 ** If the following macro is set to 0, then NULLs are indistinct for 41*c5c4113dSnw141292 ** SELECT DISTINCT and for UNION. 42*c5c4113dSnw141292 */ 43*c5c4113dSnw141292 #define NULL_ALWAYS_DISTINCT 0 44*c5c4113dSnw141292 45*c5c4113dSnw141292 /* 46*c5c4113dSnw141292 ** If the following macro is set to 1, then NULL values are considered 47*c5c4113dSnw141292 ** distinct when determining whether or not two entries are the same 48*c5c4113dSnw141292 ** in a UNIQUE index. This is the way PostgreSQL, Oracle, DB2, MySQL, 49*c5c4113dSnw141292 ** OCELOT, and Firebird all work. The SQL92 spec explicitly says this 50*c5c4113dSnw141292 ** is the way things are suppose to work. 51*c5c4113dSnw141292 ** 52*c5c4113dSnw141292 ** If the following macro is set to 0, the NULLs are indistinct for 53*c5c4113dSnw141292 ** a UNIQUE index. In this mode, you can only have a single NULL entry 54*c5c4113dSnw141292 ** for a column declared UNIQUE. This is the way Informix and SQL Server 55*c5c4113dSnw141292 ** work. 56*c5c4113dSnw141292 */ 57*c5c4113dSnw141292 #define NULL_DISTINCT_FOR_UNIQUE 1 58*c5c4113dSnw141292 59*c5c4113dSnw141292 /* 60*c5c4113dSnw141292 ** The maximum number of attached databases. This must be at least 2 61*c5c4113dSnw141292 ** in order to support the main database file (0) and the file used to 62*c5c4113dSnw141292 ** hold temporary tables (1). And it must be less than 256 because 63*c5c4113dSnw141292 ** an unsigned character is used to stored the database index. 64*c5c4113dSnw141292 */ 65*c5c4113dSnw141292 #define MAX_ATTACHED 10 66*c5c4113dSnw141292 67*c5c4113dSnw141292 /* 68*c5c4113dSnw141292 ** The next macro is used to determine where TEMP tables and indices 69*c5c4113dSnw141292 ** are stored. Possible values: 70*c5c4113dSnw141292 ** 71*c5c4113dSnw141292 ** 0 Always use a temporary files 72*c5c4113dSnw141292 ** 1 Use a file unless overridden by "PRAGMA temp_store" 73*c5c4113dSnw141292 ** 2 Use memory unless overridden by "PRAGMA temp_store" 74*c5c4113dSnw141292 ** 3 Always use memory 75*c5c4113dSnw141292 */ 76*c5c4113dSnw141292 #ifndef TEMP_STORE 77*c5c4113dSnw141292 # define TEMP_STORE 1 78*c5c4113dSnw141292 #endif 79*c5c4113dSnw141292 80*c5c4113dSnw141292 /* 81*c5c4113dSnw141292 ** When building SQLite for embedded systems where memory is scarce, 82*c5c4113dSnw141292 ** you can define one or more of the following macros to omit extra 83*c5c4113dSnw141292 ** features of the library and thus keep the size of the library to 84*c5c4113dSnw141292 ** a minimum. 85*c5c4113dSnw141292 */ 86*c5c4113dSnw141292 /* #define SQLITE_OMIT_AUTHORIZATION 1 */ 87*c5c4113dSnw141292 /* #define SQLITE_OMIT_INMEMORYDB 1 */ 88*c5c4113dSnw141292 /* #define SQLITE_OMIT_VACUUM 1 */ 89*c5c4113dSnw141292 /* #define SQLITE_OMIT_DATETIME_FUNCS 1 */ 90*c5c4113dSnw141292 /* #define SQLITE_OMIT_PROGRESS_CALLBACK 1 */ 91*c5c4113dSnw141292 92*c5c4113dSnw141292 /* 93*c5c4113dSnw141292 ** Integers of known sizes. These typedefs might change for architectures 94*c5c4113dSnw141292 ** where the sizes very. Preprocessor macros are available so that the 95*c5c4113dSnw141292 ** types can be conveniently redefined at compile-type. Like this: 96*c5c4113dSnw141292 ** 97*c5c4113dSnw141292 ** cc '-DUINTPTR_TYPE=long long int' ... 98*c5c4113dSnw141292 */ 99*c5c4113dSnw141292 #ifndef UINT32_TYPE 100*c5c4113dSnw141292 # define UINT32_TYPE unsigned int 101*c5c4113dSnw141292 #endif 102*c5c4113dSnw141292 #ifndef UINT16_TYPE 103*c5c4113dSnw141292 # define UINT16_TYPE unsigned short int 104*c5c4113dSnw141292 #endif 105*c5c4113dSnw141292 #ifndef INT16_TYPE 106*c5c4113dSnw141292 # define INT16_TYPE short int 107*c5c4113dSnw141292 #endif 108*c5c4113dSnw141292 #ifndef UINT8_TYPE 109*c5c4113dSnw141292 # define UINT8_TYPE unsigned char 110*c5c4113dSnw141292 #endif 111*c5c4113dSnw141292 #ifndef INT8_TYPE 112*c5c4113dSnw141292 # define INT8_TYPE signed char 113*c5c4113dSnw141292 #endif 114*c5c4113dSnw141292 #ifndef INTPTR_TYPE 115*c5c4113dSnw141292 # if SQLITE_PTR_SZ==4 116*c5c4113dSnw141292 # define INTPTR_TYPE int 117*c5c4113dSnw141292 # else 118*c5c4113dSnw141292 # define INTPTR_TYPE long long 119*c5c4113dSnw141292 # endif 120*c5c4113dSnw141292 #endif 121*c5c4113dSnw141292 typedef UINT32_TYPE u32; /* 4-byte unsigned integer */ 122*c5c4113dSnw141292 typedef UINT16_TYPE u16; /* 2-byte unsigned integer */ 123*c5c4113dSnw141292 typedef INT16_TYPE i16; /* 2-byte signed integer */ 124*c5c4113dSnw141292 typedef UINT8_TYPE u8; /* 1-byte unsigned integer */ 125*c5c4113dSnw141292 typedef UINT8_TYPE i8; /* 1-byte signed integer */ 126*c5c4113dSnw141292 typedef INTPTR_TYPE ptr; /* Big enough to hold a pointer */ 127*c5c4113dSnw141292 typedef unsigned INTPTR_TYPE uptr; /* Big enough to hold a pointer */ 128*c5c4113dSnw141292 129*c5c4113dSnw141292 /* 130*c5c4113dSnw141292 ** Defer sourcing vdbe.h until after the "u8" typedef is defined. 131*c5c4113dSnw141292 */ 132*c5c4113dSnw141292 #include "vdbe.h" 133*c5c4113dSnw141292 134*c5c4113dSnw141292 /* 135*c5c4113dSnw141292 ** Most C compilers these days recognize "long double", don't they? 136*c5c4113dSnw141292 ** Just in case we encounter one that does not, we will create a macro 137*c5c4113dSnw141292 ** for long double so that it can be easily changed to just "double". 138*c5c4113dSnw141292 */ 139*c5c4113dSnw141292 #ifndef LONGDOUBLE_TYPE 140*c5c4113dSnw141292 # define LONGDOUBLE_TYPE long double 141*c5c4113dSnw141292 #endif 142*c5c4113dSnw141292 143*c5c4113dSnw141292 /* 144*c5c4113dSnw141292 ** This macro casts a pointer to an integer. Useful for doing 145*c5c4113dSnw141292 ** pointer arithmetic. 146*c5c4113dSnw141292 */ 147*c5c4113dSnw141292 #define Addr(X) ((uptr)X) 148*c5c4113dSnw141292 149*c5c4113dSnw141292 /* 150*c5c4113dSnw141292 ** The maximum number of bytes of data that can be put into a single 151*c5c4113dSnw141292 ** row of a single table. The upper bound on this limit is 16777215 152*c5c4113dSnw141292 ** bytes (or 16MB-1). We have arbitrarily set the limit to just 1MB 153*c5c4113dSnw141292 ** here because the overflow page chain is inefficient for really big 154*c5c4113dSnw141292 ** records and we want to discourage people from thinking that 155*c5c4113dSnw141292 ** multi-megabyte records are OK. If your needs are different, you can 156*c5c4113dSnw141292 ** change this define and recompile to increase or decrease the record 157*c5c4113dSnw141292 ** size. 158*c5c4113dSnw141292 ** 159*c5c4113dSnw141292 ** The 16777198 is computed as follows: 238 bytes of payload on the 160*c5c4113dSnw141292 ** original pages plus 16448 overflow pages each holding 1020 bytes of 161*c5c4113dSnw141292 ** data. 162*c5c4113dSnw141292 */ 163*c5c4113dSnw141292 #define MAX_BYTES_PER_ROW 1048576 164*c5c4113dSnw141292 /* #define MAX_BYTES_PER_ROW 16777198 */ 165*c5c4113dSnw141292 166*c5c4113dSnw141292 /* 167*c5c4113dSnw141292 ** If memory allocation problems are found, recompile with 168*c5c4113dSnw141292 ** 169*c5c4113dSnw141292 ** -DMEMORY_DEBUG=1 170*c5c4113dSnw141292 ** 171*c5c4113dSnw141292 ** to enable some sanity checking on malloc() and free(). To 172*c5c4113dSnw141292 ** check for memory leaks, recompile with 173*c5c4113dSnw141292 ** 174*c5c4113dSnw141292 ** -DMEMORY_DEBUG=2 175*c5c4113dSnw141292 ** 176*c5c4113dSnw141292 ** and a line of text will be written to standard error for 177*c5c4113dSnw141292 ** each malloc() and free(). This output can be analyzed 178*c5c4113dSnw141292 ** by an AWK script to determine if there are any leaks. 179*c5c4113dSnw141292 */ 180*c5c4113dSnw141292 #ifdef MEMORY_DEBUG 181*c5c4113dSnw141292 # define sqliteMalloc(X) sqliteMalloc_(X,1,__FILE__,__LINE__) 182*c5c4113dSnw141292 # define sqliteMallocRaw(X) sqliteMalloc_(X,0,__FILE__,__LINE__) 183*c5c4113dSnw141292 # define sqliteFree(X) sqliteFree_(X,__FILE__,__LINE__) 184*c5c4113dSnw141292 # define sqliteRealloc(X,Y) sqliteRealloc_(X,Y,__FILE__,__LINE__) 185*c5c4113dSnw141292 # define sqliteStrDup(X) sqliteStrDup_(X,__FILE__,__LINE__) 186*c5c4113dSnw141292 # define sqliteStrNDup(X,Y) sqliteStrNDup_(X,Y,__FILE__,__LINE__) 187*c5c4113dSnw141292 void sqliteStrRealloc(char**); 188*c5c4113dSnw141292 #else 189*c5c4113dSnw141292 # define sqliteRealloc_(X,Y) sqliteRealloc(X,Y) 190*c5c4113dSnw141292 # define sqliteStrRealloc(X) 191*c5c4113dSnw141292 #endif 192*c5c4113dSnw141292 193*c5c4113dSnw141292 /* 194*c5c4113dSnw141292 ** This variable gets set if malloc() ever fails. After it gets set, 195*c5c4113dSnw141292 ** the SQLite library shuts down permanently. 196*c5c4113dSnw141292 */ 197*c5c4113dSnw141292 extern int sqlite_malloc_failed; 198*c5c4113dSnw141292 199*c5c4113dSnw141292 /* 200*c5c4113dSnw141292 ** The following global variables are used for testing and debugging 201*c5c4113dSnw141292 ** only. They only work if MEMORY_DEBUG is defined. 202*c5c4113dSnw141292 */ 203*c5c4113dSnw141292 #ifdef MEMORY_DEBUG 204*c5c4113dSnw141292 extern int sqlite_nMalloc; /* Number of sqliteMalloc() calls */ 205*c5c4113dSnw141292 extern int sqlite_nFree; /* Number of sqliteFree() calls */ 206*c5c4113dSnw141292 extern int sqlite_iMallocFail; /* Fail sqliteMalloc() after this many calls */ 207*c5c4113dSnw141292 #endif 208*c5c4113dSnw141292 209*c5c4113dSnw141292 /* 210*c5c4113dSnw141292 ** Name of the master database table. The master database table 211*c5c4113dSnw141292 ** is a special table that holds the names and attributes of all 212*c5c4113dSnw141292 ** user tables and indices. 213*c5c4113dSnw141292 */ 214*c5c4113dSnw141292 #define MASTER_NAME "sqlite_master" 215*c5c4113dSnw141292 #define TEMP_MASTER_NAME "sqlite_temp_master" 216*c5c4113dSnw141292 217*c5c4113dSnw141292 /* 218*c5c4113dSnw141292 ** The name of the schema table. 219*c5c4113dSnw141292 */ 220*c5c4113dSnw141292 #define SCHEMA_TABLE(x) (x?TEMP_MASTER_NAME:MASTER_NAME) 221*c5c4113dSnw141292 222*c5c4113dSnw141292 /* 223*c5c4113dSnw141292 ** A convenience macro that returns the number of elements in 224*c5c4113dSnw141292 ** an array. 225*c5c4113dSnw141292 */ 226*c5c4113dSnw141292 #define ArraySize(X) (sizeof(X)/sizeof(X[0])) 227*c5c4113dSnw141292 228*c5c4113dSnw141292 /* 229*c5c4113dSnw141292 ** Forward references to structures 230*c5c4113dSnw141292 */ 231*c5c4113dSnw141292 typedef struct Column Column; 232*c5c4113dSnw141292 typedef struct Table Table; 233*c5c4113dSnw141292 typedef struct Index Index; 234*c5c4113dSnw141292 typedef struct Instruction Instruction; 235*c5c4113dSnw141292 typedef struct Expr Expr; 236*c5c4113dSnw141292 typedef struct ExprList ExprList; 237*c5c4113dSnw141292 typedef struct Parse Parse; 238*c5c4113dSnw141292 typedef struct Token Token; 239*c5c4113dSnw141292 typedef struct IdList IdList; 240*c5c4113dSnw141292 typedef struct SrcList SrcList; 241*c5c4113dSnw141292 typedef struct WhereInfo WhereInfo; 242*c5c4113dSnw141292 typedef struct WhereLevel WhereLevel; 243*c5c4113dSnw141292 typedef struct Select Select; 244*c5c4113dSnw141292 typedef struct AggExpr AggExpr; 245*c5c4113dSnw141292 typedef struct FuncDef FuncDef; 246*c5c4113dSnw141292 typedef struct Trigger Trigger; 247*c5c4113dSnw141292 typedef struct TriggerStep TriggerStep; 248*c5c4113dSnw141292 typedef struct TriggerStack TriggerStack; 249*c5c4113dSnw141292 typedef struct FKey FKey; 250*c5c4113dSnw141292 typedef struct Db Db; 251*c5c4113dSnw141292 typedef struct AuthContext AuthContext; 252*c5c4113dSnw141292 253*c5c4113dSnw141292 /* 254*c5c4113dSnw141292 ** Each database file to be accessed by the system is an instance 255*c5c4113dSnw141292 ** of the following structure. There are normally two of these structures 256*c5c4113dSnw141292 ** in the sqlite.aDb[] array. aDb[0] is the main database file and 257*c5c4113dSnw141292 ** aDb[1] is the database file used to hold temporary tables. Additional 258*c5c4113dSnw141292 ** databases may be attached. 259*c5c4113dSnw141292 */ 260*c5c4113dSnw141292 struct Db { 261*c5c4113dSnw141292 char *zName; /* Name of this database */ 262*c5c4113dSnw141292 Btree *pBt; /* The B*Tree structure for this database file */ 263*c5c4113dSnw141292 int schema_cookie; /* Database schema version number for this file */ 264*c5c4113dSnw141292 Hash tblHash; /* All tables indexed by name */ 265*c5c4113dSnw141292 Hash idxHash; /* All (named) indices indexed by name */ 266*c5c4113dSnw141292 Hash trigHash; /* All triggers indexed by name */ 267*c5c4113dSnw141292 Hash aFKey; /* Foreign keys indexed by to-table */ 268*c5c4113dSnw141292 u8 inTrans; /* 0: not writable. 1: Transaction. 2: Checkpoint */ 269*c5c4113dSnw141292 u16 flags; /* Flags associated with this database */ 270*c5c4113dSnw141292 void *pAux; /* Auxiliary data. Usually NULL */ 271*c5c4113dSnw141292 void (*xFreeAux)(void*); /* Routine to free pAux */ 272*c5c4113dSnw141292 }; 273*c5c4113dSnw141292 274*c5c4113dSnw141292 /* 275*c5c4113dSnw141292 ** These macros can be used to test, set, or clear bits in the 276*c5c4113dSnw141292 ** Db.flags field. 277*c5c4113dSnw141292 */ 278*c5c4113dSnw141292 #define DbHasProperty(D,I,P) (((D)->aDb[I].flags&(P))==(P)) 279*c5c4113dSnw141292 #define DbHasAnyProperty(D,I,P) (((D)->aDb[I].flags&(P))!=0) 280*c5c4113dSnw141292 #define DbSetProperty(D,I,P) (D)->aDb[I].flags|=(P) 281*c5c4113dSnw141292 #define DbClearProperty(D,I,P) (D)->aDb[I].flags&=~(P) 282*c5c4113dSnw141292 283*c5c4113dSnw141292 /* 284*c5c4113dSnw141292 ** Allowed values for the DB.flags field. 285*c5c4113dSnw141292 ** 286*c5c4113dSnw141292 ** The DB_Locked flag is set when the first OP_Transaction or OP_Checkpoint 287*c5c4113dSnw141292 ** opcode is emitted for a database. This prevents multiple occurances 288*c5c4113dSnw141292 ** of those opcodes for the same database in the same program. Similarly, 289*c5c4113dSnw141292 ** the DB_Cookie flag is set when the OP_VerifyCookie opcode is emitted, 290*c5c4113dSnw141292 ** and prevents duplicate OP_VerifyCookies from taking up space and slowing 291*c5c4113dSnw141292 ** down execution. 292*c5c4113dSnw141292 ** 293*c5c4113dSnw141292 ** The DB_SchemaLoaded flag is set after the database schema has been 294*c5c4113dSnw141292 ** read into internal hash tables. 295*c5c4113dSnw141292 ** 296*c5c4113dSnw141292 ** DB_UnresetViews means that one or more views have column names that 297*c5c4113dSnw141292 ** have been filled out. If the schema changes, these column names might 298*c5c4113dSnw141292 ** changes and so the view will need to be reset. 299*c5c4113dSnw141292 */ 300*c5c4113dSnw141292 #define DB_Locked 0x0001 /* OP_Transaction opcode has been emitted */ 301*c5c4113dSnw141292 #define DB_Cookie 0x0002 /* OP_VerifyCookie opcode has been emiited */ 302*c5c4113dSnw141292 #define DB_SchemaLoaded 0x0004 /* The schema has been loaded */ 303*c5c4113dSnw141292 #define DB_UnresetViews 0x0008 /* Some views have defined column names */ 304*c5c4113dSnw141292 305*c5c4113dSnw141292 306*c5c4113dSnw141292 /* 307*c5c4113dSnw141292 ** Each database is an instance of the following structure. 308*c5c4113dSnw141292 ** 309*c5c4113dSnw141292 ** The sqlite.file_format is initialized by the database file 310*c5c4113dSnw141292 ** and helps determines how the data in the database file is 311*c5c4113dSnw141292 ** represented. This field allows newer versions of the library 312*c5c4113dSnw141292 ** to read and write older databases. The various file formats 313*c5c4113dSnw141292 ** are as follows: 314*c5c4113dSnw141292 ** 315*c5c4113dSnw141292 ** file_format==1 Version 2.1.0. 316*c5c4113dSnw141292 ** file_format==2 Version 2.2.0. Add support for INTEGER PRIMARY KEY. 317*c5c4113dSnw141292 ** file_format==3 Version 2.6.0. Fix empty-string index bug. 318*c5c4113dSnw141292 ** file_format==4 Version 2.7.0. Add support for separate numeric and 319*c5c4113dSnw141292 ** text datatypes. 320*c5c4113dSnw141292 ** 321*c5c4113dSnw141292 ** The sqlite.temp_store determines where temporary database files 322*c5c4113dSnw141292 ** are stored. If 1, then a file is created to hold those tables. If 323*c5c4113dSnw141292 ** 2, then they are held in memory. 0 means use the default value in 324*c5c4113dSnw141292 ** the TEMP_STORE macro. 325*c5c4113dSnw141292 ** 326*c5c4113dSnw141292 ** The sqlite.lastRowid records the last insert rowid generated by an 327*c5c4113dSnw141292 ** insert statement. Inserts on views do not affect its value. Each 328*c5c4113dSnw141292 ** trigger has its own context, so that lastRowid can be updated inside 329*c5c4113dSnw141292 ** triggers as usual. The previous value will be restored once the trigger 330*c5c4113dSnw141292 ** exits. Upon entering a before or instead of trigger, lastRowid is no 331*c5c4113dSnw141292 ** longer (since after version 2.8.12) reset to -1. 332*c5c4113dSnw141292 ** 333*c5c4113dSnw141292 ** The sqlite.nChange does not count changes within triggers and keeps no 334*c5c4113dSnw141292 ** context. It is reset at start of sqlite_exec. 335*c5c4113dSnw141292 ** The sqlite.lsChange represents the number of changes made by the last 336*c5c4113dSnw141292 ** insert, update, or delete statement. It remains constant throughout the 337*c5c4113dSnw141292 ** length of a statement and is then updated by OP_SetCounts. It keeps a 338*c5c4113dSnw141292 ** context stack just like lastRowid so that the count of changes 339*c5c4113dSnw141292 ** within a trigger is not seen outside the trigger. Changes to views do not 340*c5c4113dSnw141292 ** affect the value of lsChange. 341*c5c4113dSnw141292 ** The sqlite.csChange keeps track of the number of current changes (since 342*c5c4113dSnw141292 ** the last statement) and is used to update sqlite_lsChange. 343*c5c4113dSnw141292 */ 344*c5c4113dSnw141292 struct sqlite { 345*c5c4113dSnw141292 int nDb; /* Number of backends currently in use */ 346*c5c4113dSnw141292 Db *aDb; /* All backends */ 347*c5c4113dSnw141292 Db aDbStatic[2]; /* Static space for the 2 default backends */ 348*c5c4113dSnw141292 int flags; /* Miscellanous flags. See below */ 349*c5c4113dSnw141292 u8 file_format; /* What file format version is this database? */ 350*c5c4113dSnw141292 u8 safety_level; /* How aggressive at synching data to disk */ 351*c5c4113dSnw141292 u8 want_to_close; /* Close after all VDBEs are deallocated */ 352*c5c4113dSnw141292 u8 temp_store; /* 1=file, 2=memory, 0=compile-time default */ 353*c5c4113dSnw141292 u8 onError; /* Default conflict algorithm */ 354*c5c4113dSnw141292 int next_cookie; /* Next value of aDb[0].schema_cookie */ 355*c5c4113dSnw141292 int cache_size; /* Number of pages to use in the cache */ 356*c5c4113dSnw141292 int nTable; /* Number of tables in the database */ 357*c5c4113dSnw141292 void *pBusyArg; /* 1st Argument to the busy callback */ 358*c5c4113dSnw141292 int (*xBusyCallback)(void *,const char*,int); /* The busy callback */ 359*c5c4113dSnw141292 void *pCommitArg; /* Argument to xCommitCallback() */ 360*c5c4113dSnw141292 int (*xCommitCallback)(void*);/* Invoked at every commit. */ 361*c5c4113dSnw141292 Hash aFunc; /* All functions that can be in SQL exprs */ 362*c5c4113dSnw141292 int lastRowid; /* ROWID of most recent insert (see above) */ 363*c5c4113dSnw141292 int priorNewRowid; /* Last randomly generated ROWID */ 364*c5c4113dSnw141292 int magic; /* Magic number for detect library misuse */ 365*c5c4113dSnw141292 int nChange; /* Number of rows changed (see above) */ 366*c5c4113dSnw141292 int lsChange; /* Last statement change count (see above) */ 367*c5c4113dSnw141292 int csChange; /* Current statement change count (see above) */ 368*c5c4113dSnw141292 struct sqliteInitInfo { /* Information used during initialization */ 369*c5c4113dSnw141292 int iDb; /* When back is being initialized */ 370*c5c4113dSnw141292 int newTnum; /* Rootpage of table being initialized */ 371*c5c4113dSnw141292 u8 busy; /* TRUE if currently initializing */ 372*c5c4113dSnw141292 } init; 373*c5c4113dSnw141292 struct Vdbe *pVdbe; /* List of active virtual machines */ 374*c5c4113dSnw141292 void (*xTrace)(void*,const char*); /* Trace function */ 375*c5c4113dSnw141292 void *pTraceArg; /* Argument to the trace function */ 376*c5c4113dSnw141292 #ifndef SQLITE_OMIT_AUTHORIZATION 377*c5c4113dSnw141292 int (*xAuth)(void*,int,const char*,const char*,const char*,const char*); 378*c5c4113dSnw141292 /* Access authorization function */ 379*c5c4113dSnw141292 void *pAuthArg; /* 1st argument to the access auth function */ 380*c5c4113dSnw141292 #endif 381*c5c4113dSnw141292 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK 382*c5c4113dSnw141292 int (*xProgress)(void *); /* The progress callback */ 383*c5c4113dSnw141292 void *pProgressArg; /* Argument to the progress callback */ 384*c5c4113dSnw141292 int nProgressOps; /* Number of opcodes for progress callback */ 385*c5c4113dSnw141292 #endif 386*c5c4113dSnw141292 }; 387*c5c4113dSnw141292 388*c5c4113dSnw141292 /* 389*c5c4113dSnw141292 ** Possible values for the sqlite.flags and or Db.flags fields. 390*c5c4113dSnw141292 ** 391*c5c4113dSnw141292 ** On sqlite.flags, the SQLITE_InTrans value means that we have 392*c5c4113dSnw141292 ** executed a BEGIN. On Db.flags, SQLITE_InTrans means a statement 393*c5c4113dSnw141292 ** transaction is active on that particular database file. 394*c5c4113dSnw141292 */ 395*c5c4113dSnw141292 #define SQLITE_VdbeTrace 0x00000001 /* True to trace VDBE execution */ 396*c5c4113dSnw141292 #define SQLITE_Initialized 0x00000002 /* True after initialization */ 397*c5c4113dSnw141292 #define SQLITE_Interrupt 0x00000004 /* Cancel current operation */ 398*c5c4113dSnw141292 #define SQLITE_InTrans 0x00000008 /* True if in a transaction */ 399*c5c4113dSnw141292 #define SQLITE_InternChanges 0x00000010 /* Uncommitted Hash table changes */ 400*c5c4113dSnw141292 #define SQLITE_FullColNames 0x00000020 /* Show full column names on SELECT */ 401*c5c4113dSnw141292 #define SQLITE_ShortColNames 0x00000040 /* Show short columns names */ 402*c5c4113dSnw141292 #define SQLITE_CountRows 0x00000080 /* Count rows changed by INSERT, */ 403*c5c4113dSnw141292 /* DELETE, or UPDATE and return */ 404*c5c4113dSnw141292 /* the count using a callback. */ 405*c5c4113dSnw141292 #define SQLITE_NullCallback 0x00000100 /* Invoke the callback once if the */ 406*c5c4113dSnw141292 /* result set is empty */ 407*c5c4113dSnw141292 #define SQLITE_ReportTypes 0x00000200 /* Include information on datatypes */ 408*c5c4113dSnw141292 /* in 4th argument of callback */ 409*c5c4113dSnw141292 410*c5c4113dSnw141292 /* 411*c5c4113dSnw141292 ** Possible values for the sqlite.magic field. 412*c5c4113dSnw141292 ** The numbers are obtained at random and have no special meaning, other 413*c5c4113dSnw141292 ** than being distinct from one another. 414*c5c4113dSnw141292 */ 415*c5c4113dSnw141292 #define SQLITE_MAGIC_OPEN 0xa029a697 /* Database is open */ 416*c5c4113dSnw141292 #define SQLITE_MAGIC_CLOSED 0x9f3c2d33 /* Database is closed */ 417*c5c4113dSnw141292 #define SQLITE_MAGIC_BUSY 0xf03b7906 /* Database currently in use */ 418*c5c4113dSnw141292 #define SQLITE_MAGIC_ERROR 0xb5357930 /* An SQLITE_MISUSE error occurred */ 419*c5c4113dSnw141292 420*c5c4113dSnw141292 /* 421*c5c4113dSnw141292 ** Each SQL function is defined by an instance of the following 422*c5c4113dSnw141292 ** structure. A pointer to this structure is stored in the sqlite.aFunc 423*c5c4113dSnw141292 ** hash table. When multiple functions have the same name, the hash table 424*c5c4113dSnw141292 ** points to a linked list of these structures. 425*c5c4113dSnw141292 */ 426*c5c4113dSnw141292 struct FuncDef { 427*c5c4113dSnw141292 void (*xFunc)(sqlite_func*,int,const char**); /* Regular function */ 428*c5c4113dSnw141292 void (*xStep)(sqlite_func*,int,const char**); /* Aggregate function step */ 429*c5c4113dSnw141292 void (*xFinalize)(sqlite_func*); /* Aggregate function finializer */ 430*c5c4113dSnw141292 signed char nArg; /* Number of arguments. -1 means unlimited */ 431*c5c4113dSnw141292 signed char dataType; /* Arg that determines datatype. -1=NUMERIC, */ 432*c5c4113dSnw141292 /* -2=TEXT. -3=SQLITE_ARGS */ 433*c5c4113dSnw141292 u8 includeTypes; /* Add datatypes to args of xFunc and xStep */ 434*c5c4113dSnw141292 void *pUserData; /* User data parameter */ 435*c5c4113dSnw141292 FuncDef *pNext; /* Next function with same name */ 436*c5c4113dSnw141292 }; 437*c5c4113dSnw141292 438*c5c4113dSnw141292 /* 439*c5c4113dSnw141292 ** information about each column of an SQL table is held in an instance 440*c5c4113dSnw141292 ** of this structure. 441*c5c4113dSnw141292 */ 442*c5c4113dSnw141292 struct Column { 443*c5c4113dSnw141292 char *zName; /* Name of this column */ 444*c5c4113dSnw141292 char *zDflt; /* Default value of this column */ 445*c5c4113dSnw141292 char *zType; /* Data type for this column */ 446*c5c4113dSnw141292 u8 notNull; /* True if there is a NOT NULL constraint */ 447*c5c4113dSnw141292 u8 isPrimKey; /* True if this column is part of the PRIMARY KEY */ 448*c5c4113dSnw141292 u8 sortOrder; /* Some combination of SQLITE_SO_... values */ 449*c5c4113dSnw141292 u8 dottedName; /* True if zName contains a "." character */ 450*c5c4113dSnw141292 }; 451*c5c4113dSnw141292 452*c5c4113dSnw141292 /* 453*c5c4113dSnw141292 ** The allowed sort orders. 454*c5c4113dSnw141292 ** 455*c5c4113dSnw141292 ** The TEXT and NUM values use bits that do not overlap with DESC and ASC. 456*c5c4113dSnw141292 ** That way the two can be combined into a single number. 457*c5c4113dSnw141292 */ 458*c5c4113dSnw141292 #define SQLITE_SO_UNK 0 /* Use the default collating type. (SCT_NUM) */ 459*c5c4113dSnw141292 #define SQLITE_SO_TEXT 2 /* Sort using memcmp() */ 460*c5c4113dSnw141292 #define SQLITE_SO_NUM 4 /* Sort using sqliteCompare() */ 461*c5c4113dSnw141292 #define SQLITE_SO_TYPEMASK 6 /* Mask to extract the collating sequence */ 462*c5c4113dSnw141292 #define SQLITE_SO_ASC 0 /* Sort in ascending order */ 463*c5c4113dSnw141292 #define SQLITE_SO_DESC 1 /* Sort in descending order */ 464*c5c4113dSnw141292 #define SQLITE_SO_DIRMASK 1 /* Mask to extract the sort direction */ 465*c5c4113dSnw141292 466*c5c4113dSnw141292 /* 467*c5c4113dSnw141292 ** Each SQL table is represented in memory by an instance of the 468*c5c4113dSnw141292 ** following structure. 469*c5c4113dSnw141292 ** 470*c5c4113dSnw141292 ** Table.zName is the name of the table. The case of the original 471*c5c4113dSnw141292 ** CREATE TABLE statement is stored, but case is not significant for 472*c5c4113dSnw141292 ** comparisons. 473*c5c4113dSnw141292 ** 474*c5c4113dSnw141292 ** Table.nCol is the number of columns in this table. Table.aCol is a 475*c5c4113dSnw141292 ** pointer to an array of Column structures, one for each column. 476*c5c4113dSnw141292 ** 477*c5c4113dSnw141292 ** If the table has an INTEGER PRIMARY KEY, then Table.iPKey is the index of 478*c5c4113dSnw141292 ** the column that is that key. Otherwise Table.iPKey is negative. Note 479*c5c4113dSnw141292 ** that the datatype of the PRIMARY KEY must be INTEGER for this field to 480*c5c4113dSnw141292 ** be set. An INTEGER PRIMARY KEY is used as the rowid for each row of 481*c5c4113dSnw141292 ** the table. If a table has no INTEGER PRIMARY KEY, then a random rowid 482*c5c4113dSnw141292 ** is generated for each row of the table. Table.hasPrimKey is true if 483*c5c4113dSnw141292 ** the table has any PRIMARY KEY, INTEGER or otherwise. 484*c5c4113dSnw141292 ** 485*c5c4113dSnw141292 ** Table.tnum is the page number for the root BTree page of the table in the 486*c5c4113dSnw141292 ** database file. If Table.iDb is the index of the database table backend 487*c5c4113dSnw141292 ** in sqlite.aDb[]. 0 is for the main database and 1 is for the file that 488*c5c4113dSnw141292 ** holds temporary tables and indices. If Table.isTransient 489*c5c4113dSnw141292 ** is true, then the table is stored in a file that is automatically deleted 490*c5c4113dSnw141292 ** when the VDBE cursor to the table is closed. In this case Table.tnum 491*c5c4113dSnw141292 ** refers VDBE cursor number that holds the table open, not to the root 492*c5c4113dSnw141292 ** page number. Transient tables are used to hold the results of a 493*c5c4113dSnw141292 ** sub-query that appears instead of a real table name in the FROM clause 494*c5c4113dSnw141292 ** of a SELECT statement. 495*c5c4113dSnw141292 */ 496*c5c4113dSnw141292 struct Table { 497*c5c4113dSnw141292 char *zName; /* Name of the table */ 498*c5c4113dSnw141292 int nCol; /* Number of columns in this table */ 499*c5c4113dSnw141292 Column *aCol; /* Information about each column */ 500*c5c4113dSnw141292 int iPKey; /* If not less then 0, use aCol[iPKey] as the primary key */ 501*c5c4113dSnw141292 Index *pIndex; /* List of SQL indexes on this table. */ 502*c5c4113dSnw141292 int tnum; /* Root BTree node for this table (see note above) */ 503*c5c4113dSnw141292 Select *pSelect; /* NULL for tables. Points to definition if a view. */ 504*c5c4113dSnw141292 u8 readOnly; /* True if this table should not be written by the user */ 505*c5c4113dSnw141292 u8 iDb; /* Index into sqlite.aDb[] of the backend for this table */ 506*c5c4113dSnw141292 u8 isTransient; /* True if automatically deleted when VDBE finishes */ 507*c5c4113dSnw141292 u8 hasPrimKey; /* True if there exists a primary key */ 508*c5c4113dSnw141292 u8 keyConf; /* What to do in case of uniqueness conflict on iPKey */ 509*c5c4113dSnw141292 Trigger *pTrigger; /* List of SQL triggers on this table */ 510*c5c4113dSnw141292 FKey *pFKey; /* Linked list of all foreign keys in this table */ 511*c5c4113dSnw141292 }; 512*c5c4113dSnw141292 513*c5c4113dSnw141292 /* 514*c5c4113dSnw141292 ** Each foreign key constraint is an instance of the following structure. 515*c5c4113dSnw141292 ** 516*c5c4113dSnw141292 ** A foreign key is associated with two tables. The "from" table is 517*c5c4113dSnw141292 ** the table that contains the REFERENCES clause that creates the foreign 518*c5c4113dSnw141292 ** key. The "to" table is the table that is named in the REFERENCES clause. 519*c5c4113dSnw141292 ** Consider this example: 520*c5c4113dSnw141292 ** 521*c5c4113dSnw141292 ** CREATE TABLE ex1( 522*c5c4113dSnw141292 ** a INTEGER PRIMARY KEY, 523*c5c4113dSnw141292 ** b INTEGER CONSTRAINT fk1 REFERENCES ex2(x) 524*c5c4113dSnw141292 ** ); 525*c5c4113dSnw141292 ** 526*c5c4113dSnw141292 ** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2". 527*c5c4113dSnw141292 ** 528*c5c4113dSnw141292 ** Each REFERENCES clause generates an instance of the following structure 529*c5c4113dSnw141292 ** which is attached to the from-table. The to-table need not exist when 530*c5c4113dSnw141292 ** the from-table is created. The existance of the to-table is not checked 531*c5c4113dSnw141292 ** until an attempt is made to insert data into the from-table. 532*c5c4113dSnw141292 ** 533*c5c4113dSnw141292 ** The sqlite.aFKey hash table stores pointers to this structure 534*c5c4113dSnw141292 ** given the name of a to-table. For each to-table, all foreign keys 535*c5c4113dSnw141292 ** associated with that table are on a linked list using the FKey.pNextTo 536*c5c4113dSnw141292 ** field. 537*c5c4113dSnw141292 */ 538*c5c4113dSnw141292 struct FKey { 539*c5c4113dSnw141292 Table *pFrom; /* The table that constains the REFERENCES clause */ 540*c5c4113dSnw141292 FKey *pNextFrom; /* Next foreign key in pFrom */ 541*c5c4113dSnw141292 char *zTo; /* Name of table that the key points to */ 542*c5c4113dSnw141292 FKey *pNextTo; /* Next foreign key that points to zTo */ 543*c5c4113dSnw141292 int nCol; /* Number of columns in this key */ 544*c5c4113dSnw141292 struct sColMap { /* Mapping of columns in pFrom to columns in zTo */ 545*c5c4113dSnw141292 int iFrom; /* Index of column in pFrom */ 546*c5c4113dSnw141292 char *zCol; /* Name of column in zTo. If 0 use PRIMARY KEY */ 547*c5c4113dSnw141292 } *aCol; /* One entry for each of nCol column s */ 548*c5c4113dSnw141292 u8 isDeferred; /* True if constraint checking is deferred till COMMIT */ 549*c5c4113dSnw141292 u8 updateConf; /* How to resolve conflicts that occur on UPDATE */ 550*c5c4113dSnw141292 u8 deleteConf; /* How to resolve conflicts that occur on DELETE */ 551*c5c4113dSnw141292 u8 insertConf; /* How to resolve conflicts that occur on INSERT */ 552*c5c4113dSnw141292 }; 553*c5c4113dSnw141292 554*c5c4113dSnw141292 /* 555*c5c4113dSnw141292 ** SQLite supports many different ways to resolve a contraint 556*c5c4113dSnw141292 ** error. ROLLBACK processing means that a constraint violation 557*c5c4113dSnw141292 ** causes the operation in process to fail and for the current transaction 558*c5c4113dSnw141292 ** to be rolled back. ABORT processing means the operation in process 559*c5c4113dSnw141292 ** fails and any prior changes from that one operation are backed out, 560*c5c4113dSnw141292 ** but the transaction is not rolled back. FAIL processing means that 561*c5c4113dSnw141292 ** the operation in progress stops and returns an error code. But prior 562*c5c4113dSnw141292 ** changes due to the same operation are not backed out and no rollback 563*c5c4113dSnw141292 ** occurs. IGNORE means that the particular row that caused the constraint 564*c5c4113dSnw141292 ** error is not inserted or updated. Processing continues and no error 565*c5c4113dSnw141292 ** is returned. REPLACE means that preexisting database rows that caused 566*c5c4113dSnw141292 ** a UNIQUE constraint violation are removed so that the new insert or 567*c5c4113dSnw141292 ** update can proceed. Processing continues and no error is reported. 568*c5c4113dSnw141292 ** 569*c5c4113dSnw141292 ** RESTRICT, SETNULL, and CASCADE actions apply only to foreign keys. 570*c5c4113dSnw141292 ** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the 571*c5c4113dSnw141292 ** same as ROLLBACK for DEFERRED keys. SETNULL means that the foreign 572*c5c4113dSnw141292 ** key is set to NULL. CASCADE means that a DELETE or UPDATE of the 573*c5c4113dSnw141292 ** referenced table row is propagated into the row that holds the 574*c5c4113dSnw141292 ** foreign key. 575*c5c4113dSnw141292 ** 576*c5c4113dSnw141292 ** The following symbolic values are used to record which type 577*c5c4113dSnw141292 ** of action to take. 578*c5c4113dSnw141292 */ 579*c5c4113dSnw141292 #define OE_None 0 /* There is no constraint to check */ 580*c5c4113dSnw141292 #define OE_Rollback 1 /* Fail the operation and rollback the transaction */ 581*c5c4113dSnw141292 #define OE_Abort 2 /* Back out changes but do no rollback transaction */ 582*c5c4113dSnw141292 #define OE_Fail 3 /* Stop the operation but leave all prior changes */ 583*c5c4113dSnw141292 #define OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */ 584*c5c4113dSnw141292 #define OE_Replace 5 /* Delete existing record, then do INSERT or UPDATE */ 585*c5c4113dSnw141292 586*c5c4113dSnw141292 #define OE_Restrict 6 /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */ 587*c5c4113dSnw141292 #define OE_SetNull 7 /* Set the foreign key value to NULL */ 588*c5c4113dSnw141292 #define OE_SetDflt 8 /* Set the foreign key value to its default */ 589*c5c4113dSnw141292 #define OE_Cascade 9 /* Cascade the changes */ 590*c5c4113dSnw141292 591*c5c4113dSnw141292 #define OE_Default 99 /* Do whatever the default action is */ 592*c5c4113dSnw141292 593*c5c4113dSnw141292 /* 594*c5c4113dSnw141292 ** Each SQL index is represented in memory by an 595*c5c4113dSnw141292 ** instance of the following structure. 596*c5c4113dSnw141292 ** 597*c5c4113dSnw141292 ** The columns of the table that are to be indexed are described 598*c5c4113dSnw141292 ** by the aiColumn[] field of this structure. For example, suppose 599*c5c4113dSnw141292 ** we have the following table and index: 600*c5c4113dSnw141292 ** 601*c5c4113dSnw141292 ** CREATE TABLE Ex1(c1 int, c2 int, c3 text); 602*c5c4113dSnw141292 ** CREATE INDEX Ex2 ON Ex1(c3,c1); 603*c5c4113dSnw141292 ** 604*c5c4113dSnw141292 ** In the Table structure describing Ex1, nCol==3 because there are 605*c5c4113dSnw141292 ** three columns in the table. In the Index structure describing 606*c5c4113dSnw141292 ** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed. 607*c5c4113dSnw141292 ** The value of aiColumn is {2, 0}. aiColumn[0]==2 because the 608*c5c4113dSnw141292 ** first column to be indexed (c3) has an index of 2 in Ex1.aCol[]. 609*c5c4113dSnw141292 ** The second column to be indexed (c1) has an index of 0 in 610*c5c4113dSnw141292 ** Ex1.aCol[], hence Ex2.aiColumn[1]==0. 611*c5c4113dSnw141292 ** 612*c5c4113dSnw141292 ** The Index.onError field determines whether or not the indexed columns 613*c5c4113dSnw141292 ** must be unique and what to do if they are not. When Index.onError=OE_None, 614*c5c4113dSnw141292 ** it means this is not a unique index. Otherwise it is a unique index 615*c5c4113dSnw141292 ** and the value of Index.onError indicate the which conflict resolution 616*c5c4113dSnw141292 ** algorithm to employ whenever an attempt is made to insert a non-unique 617*c5c4113dSnw141292 ** element. 618*c5c4113dSnw141292 */ 619*c5c4113dSnw141292 struct Index { 620*c5c4113dSnw141292 char *zName; /* Name of this index */ 621*c5c4113dSnw141292 int nColumn; /* Number of columns in the table used by this index */ 622*c5c4113dSnw141292 int *aiColumn; /* Which columns are used by this index. 1st is 0 */ 623*c5c4113dSnw141292 Table *pTable; /* The SQL table being indexed */ 624*c5c4113dSnw141292 int tnum; /* Page containing root of this index in database file */ 625*c5c4113dSnw141292 u8 onError; /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */ 626*c5c4113dSnw141292 u8 autoIndex; /* True if is automatically created (ex: by UNIQUE) */ 627*c5c4113dSnw141292 u8 iDb; /* Index in sqlite.aDb[] of where this index is stored */ 628*c5c4113dSnw141292 Index *pNext; /* The next index associated with the same table */ 629*c5c4113dSnw141292 }; 630*c5c4113dSnw141292 631*c5c4113dSnw141292 /* 632*c5c4113dSnw141292 ** Each token coming out of the lexer is an instance of 633*c5c4113dSnw141292 ** this structure. Tokens are also used as part of an expression. 634*c5c4113dSnw141292 ** 635*c5c4113dSnw141292 ** Note if Token.z==0 then Token.dyn and Token.n are undefined and 636*c5c4113dSnw141292 ** may contain random values. Do not make any assuptions about Token.dyn 637*c5c4113dSnw141292 ** and Token.n when Token.z==0. 638*c5c4113dSnw141292 */ 639*c5c4113dSnw141292 struct Token { 640*c5c4113dSnw141292 const char *z; /* Text of the token. Not NULL-terminated! */ 641*c5c4113dSnw141292 unsigned dyn : 1; /* True for malloced memory, false for static */ 642*c5c4113dSnw141292 unsigned n : 31; /* Number of characters in this token */ 643*c5c4113dSnw141292 }; 644*c5c4113dSnw141292 645*c5c4113dSnw141292 /* 646*c5c4113dSnw141292 ** Each node of an expression in the parse tree is an instance 647*c5c4113dSnw141292 ** of this structure. 648*c5c4113dSnw141292 ** 649*c5c4113dSnw141292 ** Expr.op is the opcode. The integer parser token codes are reused 650*c5c4113dSnw141292 ** as opcodes here. For example, the parser defines TK_GE to be an integer 651*c5c4113dSnw141292 ** code representing the ">=" operator. This same integer code is reused 652*c5c4113dSnw141292 ** to represent the greater-than-or-equal-to operator in the expression 653*c5c4113dSnw141292 ** tree. 654*c5c4113dSnw141292 ** 655*c5c4113dSnw141292 ** Expr.pRight and Expr.pLeft are subexpressions. Expr.pList is a list 656*c5c4113dSnw141292 ** of argument if the expression is a function. 657*c5c4113dSnw141292 ** 658*c5c4113dSnw141292 ** Expr.token is the operator token for this node. For some expressions 659*c5c4113dSnw141292 ** that have subexpressions, Expr.token can be the complete text that gave 660*c5c4113dSnw141292 ** rise to the Expr. In the latter case, the token is marked as being 661*c5c4113dSnw141292 ** a compound token. 662*c5c4113dSnw141292 ** 663*c5c4113dSnw141292 ** An expression of the form ID or ID.ID refers to a column in a table. 664*c5c4113dSnw141292 ** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is 665*c5c4113dSnw141292 ** the integer cursor number of a VDBE cursor pointing to that table and 666*c5c4113dSnw141292 ** Expr.iColumn is the column number for the specific column. If the 667*c5c4113dSnw141292 ** expression is used as a result in an aggregate SELECT, then the 668*c5c4113dSnw141292 ** value is also stored in the Expr.iAgg column in the aggregate so that 669*c5c4113dSnw141292 ** it can be accessed after all aggregates are computed. 670*c5c4113dSnw141292 ** 671*c5c4113dSnw141292 ** If the expression is a function, the Expr.iTable is an integer code 672*c5c4113dSnw141292 ** representing which function. If the expression is an unbound variable 673*c5c4113dSnw141292 ** marker (a question mark character '?' in the original SQL) then the 674*c5c4113dSnw141292 ** Expr.iTable holds the index number for that variable. 675*c5c4113dSnw141292 ** 676*c5c4113dSnw141292 ** The Expr.pSelect field points to a SELECT statement. The SELECT might 677*c5c4113dSnw141292 ** be the right operand of an IN operator. Or, if a scalar SELECT appears 678*c5c4113dSnw141292 ** in an expression the opcode is TK_SELECT and Expr.pSelect is the only 679*c5c4113dSnw141292 ** operand. 680*c5c4113dSnw141292 */ 681*c5c4113dSnw141292 struct Expr { 682*c5c4113dSnw141292 u8 op; /* Operation performed by this node */ 683*c5c4113dSnw141292 u8 dataType; /* Either SQLITE_SO_TEXT or SQLITE_SO_NUM */ 684*c5c4113dSnw141292 u8 iDb; /* Database referenced by this expression */ 685*c5c4113dSnw141292 u8 flags; /* Various flags. See below */ 686*c5c4113dSnw141292 Expr *pLeft, *pRight; /* Left and right subnodes */ 687*c5c4113dSnw141292 ExprList *pList; /* A list of expressions used as function arguments 688*c5c4113dSnw141292 ** or in "<expr> IN (<expr-list)" */ 689*c5c4113dSnw141292 Token token; /* An operand token */ 690*c5c4113dSnw141292 Token span; /* Complete text of the expression */ 691*c5c4113dSnw141292 int iTable, iColumn; /* When op==TK_COLUMN, then this expr node means the 692*c5c4113dSnw141292 ** iColumn-th field of the iTable-th table. */ 693*c5c4113dSnw141292 int iAgg; /* When op==TK_COLUMN and pParse->useAgg==TRUE, pull 694*c5c4113dSnw141292 ** result from the iAgg-th element of the aggregator */ 695*c5c4113dSnw141292 Select *pSelect; /* When the expression is a sub-select. Also the 696*c5c4113dSnw141292 ** right side of "<expr> IN (<select>)" */ 697*c5c4113dSnw141292 }; 698*c5c4113dSnw141292 699*c5c4113dSnw141292 /* 700*c5c4113dSnw141292 ** The following are the meanings of bits in the Expr.flags field. 701*c5c4113dSnw141292 */ 702*c5c4113dSnw141292 #define EP_FromJoin 0x0001 /* Originated in ON or USING clause of a join */ 703*c5c4113dSnw141292 704*c5c4113dSnw141292 /* 705*c5c4113dSnw141292 ** These macros can be used to test, set, or clear bits in the 706*c5c4113dSnw141292 ** Expr.flags field. 707*c5c4113dSnw141292 */ 708*c5c4113dSnw141292 #define ExprHasProperty(E,P) (((E)->flags&(P))==(P)) 709*c5c4113dSnw141292 #define ExprHasAnyProperty(E,P) (((E)->flags&(P))!=0) 710*c5c4113dSnw141292 #define ExprSetProperty(E,P) (E)->flags|=(P) 711*c5c4113dSnw141292 #define ExprClearProperty(E,P) (E)->flags&=~(P) 712*c5c4113dSnw141292 713*c5c4113dSnw141292 /* 714*c5c4113dSnw141292 ** A list of expressions. Each expression may optionally have a 715*c5c4113dSnw141292 ** name. An expr/name combination can be used in several ways, such 716*c5c4113dSnw141292 ** as the list of "expr AS ID" fields following a "SELECT" or in the 717*c5c4113dSnw141292 ** list of "ID = expr" items in an UPDATE. A list of expressions can 718*c5c4113dSnw141292 ** also be used as the argument to a function, in which case the a.zName 719*c5c4113dSnw141292 ** field is not used. 720*c5c4113dSnw141292 */ 721*c5c4113dSnw141292 struct ExprList { 722*c5c4113dSnw141292 int nExpr; /* Number of expressions on the list */ 723*c5c4113dSnw141292 int nAlloc; /* Number of entries allocated below */ 724*c5c4113dSnw141292 struct ExprList_item { 725*c5c4113dSnw141292 Expr *pExpr; /* The list of expressions */ 726*c5c4113dSnw141292 char *zName; /* Token associated with this expression */ 727*c5c4113dSnw141292 u8 sortOrder; /* 1 for DESC or 0 for ASC */ 728*c5c4113dSnw141292 u8 isAgg; /* True if this is an aggregate like count(*) */ 729*c5c4113dSnw141292 u8 done; /* A flag to indicate when processing is finished */ 730*c5c4113dSnw141292 } *a; /* One entry for each expression */ 731*c5c4113dSnw141292 }; 732*c5c4113dSnw141292 733*c5c4113dSnw141292 /* 734*c5c4113dSnw141292 ** An instance of this structure can hold a simple list of identifiers, 735*c5c4113dSnw141292 ** such as the list "a,b,c" in the following statements: 736*c5c4113dSnw141292 ** 737*c5c4113dSnw141292 ** INSERT INTO t(a,b,c) VALUES ...; 738*c5c4113dSnw141292 ** CREATE INDEX idx ON t(a,b,c); 739*c5c4113dSnw141292 ** CREATE TRIGGER trig BEFORE UPDATE ON t(a,b,c) ...; 740*c5c4113dSnw141292 ** 741*c5c4113dSnw141292 ** The IdList.a.idx field is used when the IdList represents the list of 742*c5c4113dSnw141292 ** column names after a table name in an INSERT statement. In the statement 743*c5c4113dSnw141292 ** 744*c5c4113dSnw141292 ** INSERT INTO t(a,b,c) ... 745*c5c4113dSnw141292 ** 746*c5c4113dSnw141292 ** If "a" is the k-th column of table "t", then IdList.a[0].idx==k. 747*c5c4113dSnw141292 */ 748*c5c4113dSnw141292 struct IdList { 749*c5c4113dSnw141292 int nId; /* Number of identifiers on the list */ 750*c5c4113dSnw141292 int nAlloc; /* Number of entries allocated for a[] below */ 751*c5c4113dSnw141292 struct IdList_item { 752*c5c4113dSnw141292 char *zName; /* Name of the identifier */ 753*c5c4113dSnw141292 int idx; /* Index in some Table.aCol[] of a column named zName */ 754*c5c4113dSnw141292 } *a; 755*c5c4113dSnw141292 }; 756*c5c4113dSnw141292 757*c5c4113dSnw141292 /* 758*c5c4113dSnw141292 ** The following structure describes the FROM clause of a SELECT statement. 759*c5c4113dSnw141292 ** Each table or subquery in the FROM clause is a separate element of 760*c5c4113dSnw141292 ** the SrcList.a[] array. 761*c5c4113dSnw141292 ** 762*c5c4113dSnw141292 ** With the addition of multiple database support, the following structure 763*c5c4113dSnw141292 ** can also be used to describe a particular table such as the table that 764*c5c4113dSnw141292 ** is modified by an INSERT, DELETE, or UPDATE statement. In standard SQL, 765*c5c4113dSnw141292 ** such a table must be a simple name: ID. But in SQLite, the table can 766*c5c4113dSnw141292 ** now be identified by a database name, a dot, then the table name: ID.ID. 767*c5c4113dSnw141292 */ 768*c5c4113dSnw141292 struct SrcList { 769*c5c4113dSnw141292 i16 nSrc; /* Number of tables or subqueries in the FROM clause */ 770*c5c4113dSnw141292 i16 nAlloc; /* Number of entries allocated in a[] below */ 771*c5c4113dSnw141292 struct SrcList_item { 772*c5c4113dSnw141292 char *zDatabase; /* Name of database holding this table */ 773*c5c4113dSnw141292 char *zName; /* Name of the table */ 774*c5c4113dSnw141292 char *zAlias; /* The "B" part of a "A AS B" phrase. zName is the "A" */ 775*c5c4113dSnw141292 Table *pTab; /* An SQL table corresponding to zName */ 776*c5c4113dSnw141292 Select *pSelect; /* A SELECT statement used in place of a table name */ 777*c5c4113dSnw141292 int jointype; /* Type of join between this table and the next */ 778*c5c4113dSnw141292 int iCursor; /* The VDBE cursor number used to access this table */ 779*c5c4113dSnw141292 Expr *pOn; /* The ON clause of a join */ 780*c5c4113dSnw141292 IdList *pUsing; /* The USING clause of a join */ 781*c5c4113dSnw141292 } a[1]; /* One entry for each identifier on the list */ 782*c5c4113dSnw141292 }; 783*c5c4113dSnw141292 784*c5c4113dSnw141292 /* 785*c5c4113dSnw141292 ** Permitted values of the SrcList.a.jointype field 786*c5c4113dSnw141292 */ 787*c5c4113dSnw141292 #define JT_INNER 0x0001 /* Any kind of inner or cross join */ 788*c5c4113dSnw141292 #define JT_NATURAL 0x0002 /* True for a "natural" join */ 789*c5c4113dSnw141292 #define JT_LEFT 0x0004 /* Left outer join */ 790*c5c4113dSnw141292 #define JT_RIGHT 0x0008 /* Right outer join */ 791*c5c4113dSnw141292 #define JT_OUTER 0x0010 /* The "OUTER" keyword is present */ 792*c5c4113dSnw141292 #define JT_ERROR 0x0020 /* unknown or unsupported join type */ 793*c5c4113dSnw141292 794*c5c4113dSnw141292 /* 795*c5c4113dSnw141292 ** For each nested loop in a WHERE clause implementation, the WhereInfo 796*c5c4113dSnw141292 ** structure contains a single instance of this structure. This structure 797*c5c4113dSnw141292 ** is intended to be private the the where.c module and should not be 798*c5c4113dSnw141292 ** access or modified by other modules. 799*c5c4113dSnw141292 */ 800*c5c4113dSnw141292 struct WhereLevel { 801*c5c4113dSnw141292 int iMem; /* Memory cell used by this level */ 802*c5c4113dSnw141292 Index *pIdx; /* Index used */ 803*c5c4113dSnw141292 int iCur; /* Cursor number used for this index */ 804*c5c4113dSnw141292 int score; /* How well this indexed scored */ 805*c5c4113dSnw141292 int brk; /* Jump here to break out of the loop */ 806*c5c4113dSnw141292 int cont; /* Jump here to continue with the next loop cycle */ 807*c5c4113dSnw141292 int op, p1, p2; /* Opcode used to terminate the loop */ 808*c5c4113dSnw141292 int iLeftJoin; /* Memory cell used to implement LEFT OUTER JOIN */ 809*c5c4113dSnw141292 int top; /* First instruction of interior of the loop */ 810*c5c4113dSnw141292 int inOp, inP1, inP2;/* Opcode used to implement an IN operator */ 811*c5c4113dSnw141292 int bRev; /* Do the scan in the reverse direction */ 812*c5c4113dSnw141292 }; 813*c5c4113dSnw141292 814*c5c4113dSnw141292 /* 815*c5c4113dSnw141292 ** The WHERE clause processing routine has two halves. The 816*c5c4113dSnw141292 ** first part does the start of the WHERE loop and the second 817*c5c4113dSnw141292 ** half does the tail of the WHERE loop. An instance of 818*c5c4113dSnw141292 ** this structure is returned by the first half and passed 819*c5c4113dSnw141292 ** into the second half to give some continuity. 820*c5c4113dSnw141292 */ 821*c5c4113dSnw141292 struct WhereInfo { 822*c5c4113dSnw141292 Parse *pParse; 823*c5c4113dSnw141292 SrcList *pTabList; /* List of tables in the join */ 824*c5c4113dSnw141292 int iContinue; /* Jump here to continue with next record */ 825*c5c4113dSnw141292 int iBreak; /* Jump here to break out of the loop */ 826*c5c4113dSnw141292 int nLevel; /* Number of nested loop */ 827*c5c4113dSnw141292 int savedNTab; /* Value of pParse->nTab before WhereBegin() */ 828*c5c4113dSnw141292 int peakNTab; /* Value of pParse->nTab after WhereBegin() */ 829*c5c4113dSnw141292 WhereLevel a[1]; /* Information about each nest loop in the WHERE */ 830*c5c4113dSnw141292 }; 831*c5c4113dSnw141292 832*c5c4113dSnw141292 /* 833*c5c4113dSnw141292 ** An instance of the following structure contains all information 834*c5c4113dSnw141292 ** needed to generate code for a single SELECT statement. 835*c5c4113dSnw141292 ** 836*c5c4113dSnw141292 ** The zSelect field is used when the Select structure must be persistent. 837*c5c4113dSnw141292 ** Normally, the expression tree points to tokens in the original input 838*c5c4113dSnw141292 ** string that encodes the select. But if the Select structure must live 839*c5c4113dSnw141292 ** longer than its input string (for example when it is used to describe 840*c5c4113dSnw141292 ** a VIEW) we have to make a copy of the input string so that the nodes 841*c5c4113dSnw141292 ** of the expression tree will have something to point to. zSelect is used 842*c5c4113dSnw141292 ** to hold that copy. 843*c5c4113dSnw141292 ** 844*c5c4113dSnw141292 ** nLimit is set to -1 if there is no LIMIT clause. nOffset is set to 0. 845*c5c4113dSnw141292 ** If there is a LIMIT clause, the parser sets nLimit to the value of the 846*c5c4113dSnw141292 ** limit and nOffset to the value of the offset (or 0 if there is not 847*c5c4113dSnw141292 ** offset). But later on, nLimit and nOffset become the memory locations 848*c5c4113dSnw141292 ** in the VDBE that record the limit and offset counters. 849*c5c4113dSnw141292 */ 850*c5c4113dSnw141292 struct Select { 851*c5c4113dSnw141292 ExprList *pEList; /* The fields of the result */ 852*c5c4113dSnw141292 u8 op; /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */ 853*c5c4113dSnw141292 u8 isDistinct; /* True if the DISTINCT keyword is present */ 854*c5c4113dSnw141292 SrcList *pSrc; /* The FROM clause */ 855*c5c4113dSnw141292 Expr *pWhere; /* The WHERE clause */ 856*c5c4113dSnw141292 ExprList *pGroupBy; /* The GROUP BY clause */ 857*c5c4113dSnw141292 Expr *pHaving; /* The HAVING clause */ 858*c5c4113dSnw141292 ExprList *pOrderBy; /* The ORDER BY clause */ 859*c5c4113dSnw141292 Select *pPrior; /* Prior select in a compound select statement */ 860*c5c4113dSnw141292 int nLimit, nOffset; /* LIMIT and OFFSET values. -1 means not used */ 861*c5c4113dSnw141292 int iLimit, iOffset; /* Memory registers holding LIMIT & OFFSET counters */ 862*c5c4113dSnw141292 char *zSelect; /* Complete text of the SELECT command */ 863*c5c4113dSnw141292 }; 864*c5c4113dSnw141292 865*c5c4113dSnw141292 /* 866*c5c4113dSnw141292 ** The results of a select can be distributed in several ways. 867*c5c4113dSnw141292 */ 868*c5c4113dSnw141292 #define SRT_Callback 1 /* Invoke a callback with each row of result */ 869*c5c4113dSnw141292 #define SRT_Mem 2 /* Store result in a memory cell */ 870*c5c4113dSnw141292 #define SRT_Set 3 /* Store result as unique keys in a table */ 871*c5c4113dSnw141292 #define SRT_Union 5 /* Store result as keys in a table */ 872*c5c4113dSnw141292 #define SRT_Except 6 /* Remove result from a UNION table */ 873*c5c4113dSnw141292 #define SRT_Table 7 /* Store result as data with a unique key */ 874*c5c4113dSnw141292 #define SRT_TempTable 8 /* Store result in a trasient table */ 875*c5c4113dSnw141292 #define SRT_Discard 9 /* Do not save the results anywhere */ 876*c5c4113dSnw141292 #define SRT_Sorter 10 /* Store results in the sorter */ 877*c5c4113dSnw141292 #define SRT_Subroutine 11 /* Call a subroutine to handle results */ 878*c5c4113dSnw141292 879*c5c4113dSnw141292 /* 880*c5c4113dSnw141292 ** When a SELECT uses aggregate functions (like "count(*)" or "avg(f1)") 881*c5c4113dSnw141292 ** we have to do some additional analysis of expressions. An instance 882*c5c4113dSnw141292 ** of the following structure holds information about a single subexpression 883*c5c4113dSnw141292 ** somewhere in the SELECT statement. An array of these structures holds 884*c5c4113dSnw141292 ** all the information we need to generate code for aggregate 885*c5c4113dSnw141292 ** expressions. 886*c5c4113dSnw141292 ** 887*c5c4113dSnw141292 ** Note that when analyzing a SELECT containing aggregates, both 888*c5c4113dSnw141292 ** non-aggregate field variables and aggregate functions are stored 889*c5c4113dSnw141292 ** in the AggExpr array of the Parser structure. 890*c5c4113dSnw141292 ** 891*c5c4113dSnw141292 ** The pExpr field points to an expression that is part of either the 892*c5c4113dSnw141292 ** field list, the GROUP BY clause, the HAVING clause or the ORDER BY 893*c5c4113dSnw141292 ** clause. The expression will be freed when those clauses are cleaned 894*c5c4113dSnw141292 ** up. Do not try to delete the expression attached to AggExpr.pExpr. 895*c5c4113dSnw141292 ** 896*c5c4113dSnw141292 ** If AggExpr.pExpr==0, that means the expression is "count(*)". 897*c5c4113dSnw141292 */ 898*c5c4113dSnw141292 struct AggExpr { 899*c5c4113dSnw141292 int isAgg; /* if TRUE contains an aggregate function */ 900*c5c4113dSnw141292 Expr *pExpr; /* The expression */ 901*c5c4113dSnw141292 FuncDef *pFunc; /* Information about the aggregate function */ 902*c5c4113dSnw141292 }; 903*c5c4113dSnw141292 904*c5c4113dSnw141292 /* 905*c5c4113dSnw141292 ** An SQL parser context. A copy of this structure is passed through 906*c5c4113dSnw141292 ** the parser and down into all the parser action routine in order to 907*c5c4113dSnw141292 ** carry around information that is global to the entire parse. 908*c5c4113dSnw141292 */ 909*c5c4113dSnw141292 struct Parse { 910*c5c4113dSnw141292 sqlite *db; /* The main database structure */ 911*c5c4113dSnw141292 int rc; /* Return code from execution */ 912*c5c4113dSnw141292 char *zErrMsg; /* An error message */ 913*c5c4113dSnw141292 Token sErrToken; /* The token at which the error occurred */ 914*c5c4113dSnw141292 Token sFirstToken; /* The first token parsed */ 915*c5c4113dSnw141292 Token sLastToken; /* The last token parsed */ 916*c5c4113dSnw141292 const char *zTail; /* All SQL text past the last semicolon parsed */ 917*c5c4113dSnw141292 Table *pNewTable; /* A table being constructed by CREATE TABLE */ 918*c5c4113dSnw141292 Vdbe *pVdbe; /* An engine for executing database bytecode */ 919*c5c4113dSnw141292 u8 colNamesSet; /* TRUE after OP_ColumnName has been issued to pVdbe */ 920*c5c4113dSnw141292 u8 explain; /* True if the EXPLAIN flag is found on the query */ 921*c5c4113dSnw141292 u8 nameClash; /* A permanent table name clashes with temp table name */ 922*c5c4113dSnw141292 u8 useAgg; /* If true, extract field values from the aggregator 923*c5c4113dSnw141292 ** while generating expressions. Normally false */ 924*c5c4113dSnw141292 int nErr; /* Number of errors seen */ 925*c5c4113dSnw141292 int nTab; /* Number of previously allocated VDBE cursors */ 926*c5c4113dSnw141292 int nMem; /* Number of memory cells used so far */ 927*c5c4113dSnw141292 int nSet; /* Number of sets used so far */ 928*c5c4113dSnw141292 int nAgg; /* Number of aggregate expressions */ 929*c5c4113dSnw141292 int nVar; /* Number of '?' variables seen in the SQL so far */ 930*c5c4113dSnw141292 AggExpr *aAgg; /* An array of aggregate expressions */ 931*c5c4113dSnw141292 const char *zAuthContext; /* The 6th parameter to db->xAuth callbacks */ 932*c5c4113dSnw141292 Trigger *pNewTrigger; /* Trigger under construct by a CREATE TRIGGER */ 933*c5c4113dSnw141292 TriggerStack *trigStack; /* Trigger actions being coded */ 934*c5c4113dSnw141292 }; 935*c5c4113dSnw141292 936*c5c4113dSnw141292 /* 937*c5c4113dSnw141292 ** An instance of the following structure can be declared on a stack and used 938*c5c4113dSnw141292 ** to save the Parse.zAuthContext value so that it can be restored later. 939*c5c4113dSnw141292 */ 940*c5c4113dSnw141292 struct AuthContext { 941*c5c4113dSnw141292 const char *zAuthContext; /* Put saved Parse.zAuthContext here */ 942*c5c4113dSnw141292 Parse *pParse; /* The Parse structure */ 943*c5c4113dSnw141292 }; 944*c5c4113dSnw141292 945*c5c4113dSnw141292 /* 946*c5c4113dSnw141292 ** Bitfield flags for P2 value in OP_PutIntKey and OP_Delete 947*c5c4113dSnw141292 */ 948*c5c4113dSnw141292 #define OPFLAG_NCHANGE 1 /* Set to update db->nChange */ 949*c5c4113dSnw141292 #define OPFLAG_LASTROWID 2 /* Set to update db->lastRowid */ 950*c5c4113dSnw141292 #define OPFLAG_CSCHANGE 4 /* Set to update db->csChange */ 951*c5c4113dSnw141292 952*c5c4113dSnw141292 /* 953*c5c4113dSnw141292 * Each trigger present in the database schema is stored as an instance of 954*c5c4113dSnw141292 * struct Trigger. 955*c5c4113dSnw141292 * 956*c5c4113dSnw141292 * Pointers to instances of struct Trigger are stored in two ways. 957*c5c4113dSnw141292 * 1. In the "trigHash" hash table (part of the sqlite* that represents the 958*c5c4113dSnw141292 * database). This allows Trigger structures to be retrieved by name. 959*c5c4113dSnw141292 * 2. All triggers associated with a single table form a linked list, using the 960*c5c4113dSnw141292 * pNext member of struct Trigger. A pointer to the first element of the 961*c5c4113dSnw141292 * linked list is stored as the "pTrigger" member of the associated 962*c5c4113dSnw141292 * struct Table. 963*c5c4113dSnw141292 * 964*c5c4113dSnw141292 * The "step_list" member points to the first element of a linked list 965*c5c4113dSnw141292 * containing the SQL statements specified as the trigger program. 966*c5c4113dSnw141292 */ 967*c5c4113dSnw141292 struct Trigger { 968*c5c4113dSnw141292 char *name; /* The name of the trigger */ 969*c5c4113dSnw141292 char *table; /* The table or view to which the trigger applies */ 970*c5c4113dSnw141292 u8 iDb; /* Database containing this trigger */ 971*c5c4113dSnw141292 u8 iTabDb; /* Database containing Trigger.table */ 972*c5c4113dSnw141292 u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT */ 973*c5c4113dSnw141292 u8 tr_tm; /* One of TK_BEFORE, TK_AFTER */ 974*c5c4113dSnw141292 Expr *pWhen; /* The WHEN clause of the expresion (may be NULL) */ 975*c5c4113dSnw141292 IdList *pColumns; /* If this is an UPDATE OF <column-list> trigger, 976*c5c4113dSnw141292 the <column-list> is stored here */ 977*c5c4113dSnw141292 int foreach; /* One of TK_ROW or TK_STATEMENT */ 978*c5c4113dSnw141292 Token nameToken; /* Token containing zName. Use during parsing only */ 979*c5c4113dSnw141292 980*c5c4113dSnw141292 TriggerStep *step_list; /* Link list of trigger program steps */ 981*c5c4113dSnw141292 Trigger *pNext; /* Next trigger associated with the table */ 982*c5c4113dSnw141292 }; 983*c5c4113dSnw141292 984*c5c4113dSnw141292 /* 985*c5c4113dSnw141292 * An instance of struct TriggerStep is used to store a single SQL statement 986*c5c4113dSnw141292 * that is a part of a trigger-program. 987*c5c4113dSnw141292 * 988*c5c4113dSnw141292 * Instances of struct TriggerStep are stored in a singly linked list (linked 989*c5c4113dSnw141292 * using the "pNext" member) referenced by the "step_list" member of the 990*c5c4113dSnw141292 * associated struct Trigger instance. The first element of the linked list is 991*c5c4113dSnw141292 * the first step of the trigger-program. 992*c5c4113dSnw141292 * 993*c5c4113dSnw141292 * The "op" member indicates whether this is a "DELETE", "INSERT", "UPDATE" or 994*c5c4113dSnw141292 * "SELECT" statement. The meanings of the other members is determined by the 995*c5c4113dSnw141292 * value of "op" as follows: 996*c5c4113dSnw141292 * 997*c5c4113dSnw141292 * (op == TK_INSERT) 998*c5c4113dSnw141292 * orconf -> stores the ON CONFLICT algorithm 999*c5c4113dSnw141292 * pSelect -> If this is an INSERT INTO ... SELECT ... statement, then 1000*c5c4113dSnw141292 * this stores a pointer to the SELECT statement. Otherwise NULL. 1001*c5c4113dSnw141292 * target -> A token holding the name of the table to insert into. 1002*c5c4113dSnw141292 * pExprList -> If this is an INSERT INTO ... VALUES ... statement, then 1003*c5c4113dSnw141292 * this stores values to be inserted. Otherwise NULL. 1004*c5c4113dSnw141292 * pIdList -> If this is an INSERT INTO ... (<column-names>) VALUES ... 1005*c5c4113dSnw141292 * statement, then this stores the column-names to be 1006*c5c4113dSnw141292 * inserted into. 1007*c5c4113dSnw141292 * 1008*c5c4113dSnw141292 * (op == TK_DELETE) 1009*c5c4113dSnw141292 * target -> A token holding the name of the table to delete from. 1010*c5c4113dSnw141292 * pWhere -> The WHERE clause of the DELETE statement if one is specified. 1011*c5c4113dSnw141292 * Otherwise NULL. 1012*c5c4113dSnw141292 * 1013*c5c4113dSnw141292 * (op == TK_UPDATE) 1014*c5c4113dSnw141292 * target -> A token holding the name of the table to update rows of. 1015*c5c4113dSnw141292 * pWhere -> The WHERE clause of the UPDATE statement if one is specified. 1016*c5c4113dSnw141292 * Otherwise NULL. 1017*c5c4113dSnw141292 * pExprList -> A list of the columns to update and the expressions to update 1018*c5c4113dSnw141292 * them to. See sqliteUpdate() documentation of "pChanges" 1019*c5c4113dSnw141292 * argument. 1020*c5c4113dSnw141292 * 1021*c5c4113dSnw141292 */ 1022*c5c4113dSnw141292 struct TriggerStep { 1023*c5c4113dSnw141292 int op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */ 1024*c5c4113dSnw141292 int orconf; /* OE_Rollback etc. */ 1025*c5c4113dSnw141292 Trigger *pTrig; /* The trigger that this step is a part of */ 1026*c5c4113dSnw141292 1027*c5c4113dSnw141292 Select *pSelect; /* Valid for SELECT and sometimes 1028*c5c4113dSnw141292 INSERT steps (when pExprList == 0) */ 1029*c5c4113dSnw141292 Token target; /* Valid for DELETE, UPDATE, INSERT steps */ 1030*c5c4113dSnw141292 Expr *pWhere; /* Valid for DELETE, UPDATE steps */ 1031*c5c4113dSnw141292 ExprList *pExprList; /* Valid for UPDATE statements and sometimes 1032*c5c4113dSnw141292 INSERT steps (when pSelect == 0) */ 1033*c5c4113dSnw141292 IdList *pIdList; /* Valid for INSERT statements only */ 1034*c5c4113dSnw141292 1035*c5c4113dSnw141292 TriggerStep * pNext; /* Next in the link-list */ 1036*c5c4113dSnw141292 }; 1037*c5c4113dSnw141292 1038*c5c4113dSnw141292 /* 1039*c5c4113dSnw141292 * An instance of struct TriggerStack stores information required during code 1040*c5c4113dSnw141292 * generation of a single trigger program. While the trigger program is being 1041*c5c4113dSnw141292 * coded, its associated TriggerStack instance is pointed to by the 1042*c5c4113dSnw141292 * "pTriggerStack" member of the Parse structure. 1043*c5c4113dSnw141292 * 1044*c5c4113dSnw141292 * The pTab member points to the table that triggers are being coded on. The 1045*c5c4113dSnw141292 * newIdx member contains the index of the vdbe cursor that points at the temp 1046*c5c4113dSnw141292 * table that stores the new.* references. If new.* references are not valid 1047*c5c4113dSnw141292 * for the trigger being coded (for example an ON DELETE trigger), then newIdx 1048*c5c4113dSnw141292 * is set to -1. The oldIdx member is analogous to newIdx, for old.* references. 1049*c5c4113dSnw141292 * 1050*c5c4113dSnw141292 * The ON CONFLICT policy to be used for the trigger program steps is stored 1051*c5c4113dSnw141292 * as the orconf member. If this is OE_Default, then the ON CONFLICT clause 1052*c5c4113dSnw141292 * specified for individual triggers steps is used. 1053*c5c4113dSnw141292 * 1054*c5c4113dSnw141292 * struct TriggerStack has a "pNext" member, to allow linked lists to be 1055*c5c4113dSnw141292 * constructed. When coding nested triggers (triggers fired by other triggers) 1056*c5c4113dSnw141292 * each nested trigger stores its parent trigger's TriggerStack as the "pNext" 1057*c5c4113dSnw141292 * pointer. Once the nested trigger has been coded, the pNext value is restored 1058*c5c4113dSnw141292 * to the pTriggerStack member of the Parse stucture and coding of the parent 1059*c5c4113dSnw141292 * trigger continues. 1060*c5c4113dSnw141292 * 1061*c5c4113dSnw141292 * Before a nested trigger is coded, the linked list pointed to by the 1062*c5c4113dSnw141292 * pTriggerStack is scanned to ensure that the trigger is not about to be coded 1063*c5c4113dSnw141292 * recursively. If this condition is detected, the nested trigger is not coded. 1064*c5c4113dSnw141292 */ 1065*c5c4113dSnw141292 struct TriggerStack { 1066*c5c4113dSnw141292 Table *pTab; /* Table that triggers are currently being coded on */ 1067*c5c4113dSnw141292 int newIdx; /* Index of vdbe cursor to "new" temp table */ 1068*c5c4113dSnw141292 int oldIdx; /* Index of vdbe cursor to "old" temp table */ 1069*c5c4113dSnw141292 int orconf; /* Current orconf policy */ 1070*c5c4113dSnw141292 int ignoreJump; /* where to jump to for a RAISE(IGNORE) */ 1071*c5c4113dSnw141292 Trigger *pTrigger; /* The trigger currently being coded */ 1072*c5c4113dSnw141292 TriggerStack *pNext; /* Next trigger down on the trigger stack */ 1073*c5c4113dSnw141292 }; 1074*c5c4113dSnw141292 1075*c5c4113dSnw141292 /* 1076*c5c4113dSnw141292 ** The following structure contains information used by the sqliteFix... 1077*c5c4113dSnw141292 ** routines as they walk the parse tree to make database references 1078*c5c4113dSnw141292 ** explicit. 1079*c5c4113dSnw141292 */ 1080*c5c4113dSnw141292 typedef struct DbFixer DbFixer; 1081*c5c4113dSnw141292 struct DbFixer { 1082*c5c4113dSnw141292 Parse *pParse; /* The parsing context. Error messages written here */ 1083*c5c4113dSnw141292 const char *zDb; /* Make sure all objects are contained in this database */ 1084*c5c4113dSnw141292 const char *zType; /* Type of the container - used for error messages */ 1085*c5c4113dSnw141292 const Token *pName; /* Name of the container - used for error messages */ 1086*c5c4113dSnw141292 }; 1087*c5c4113dSnw141292 1088*c5c4113dSnw141292 /* 1089*c5c4113dSnw141292 * This global flag is set for performance testing of triggers. When it is set 1090*c5c4113dSnw141292 * SQLite will perform the overhead of building new and old trigger references 1091*c5c4113dSnw141292 * even when no triggers exist 1092*c5c4113dSnw141292 */ 1093*c5c4113dSnw141292 extern int always_code_trigger_setup; 1094*c5c4113dSnw141292 1095*c5c4113dSnw141292 /* 1096*c5c4113dSnw141292 ** Internal function prototypes 1097*c5c4113dSnw141292 */ 1098*c5c4113dSnw141292 int sqliteStrICmp(const char *, const char *); 1099*c5c4113dSnw141292 int sqliteStrNICmp(const char *, const char *, int); 1100*c5c4113dSnw141292 int sqliteHashNoCase(const char *, int); 1101*c5c4113dSnw141292 int sqliteIsNumber(const char*); 1102*c5c4113dSnw141292 int sqliteCompare(const char *, const char *); 1103*c5c4113dSnw141292 int sqliteSortCompare(const char *, const char *); 1104*c5c4113dSnw141292 void sqliteRealToSortable(double r, char *); 1105*c5c4113dSnw141292 #ifdef MEMORY_DEBUG 1106*c5c4113dSnw141292 void *sqliteMalloc_(int,int,char*,int); 1107*c5c4113dSnw141292 void sqliteFree_(void*,char*,int); 1108*c5c4113dSnw141292 void *sqliteRealloc_(void*,int,char*,int); 1109*c5c4113dSnw141292 char *sqliteStrDup_(const char*,char*,int); 1110*c5c4113dSnw141292 char *sqliteStrNDup_(const char*, int,char*,int); 1111*c5c4113dSnw141292 void sqliteCheckMemory(void*,int); 1112*c5c4113dSnw141292 #else 1113*c5c4113dSnw141292 void *sqliteMalloc(int); 1114*c5c4113dSnw141292 void *sqliteMallocRaw(int); 1115*c5c4113dSnw141292 void sqliteFree(void*); 1116*c5c4113dSnw141292 void *sqliteRealloc(void*,int); 1117*c5c4113dSnw141292 char *sqliteStrDup(const char*); 1118*c5c4113dSnw141292 char *sqliteStrNDup(const char*, int); 1119*c5c4113dSnw141292 # define sqliteCheckMemory(a,b) 1120*c5c4113dSnw141292 #endif 1121*c5c4113dSnw141292 char *sqliteMPrintf(const char*, ...); 1122*c5c4113dSnw141292 char *sqliteVMPrintf(const char*, va_list); 1123*c5c4113dSnw141292 void sqliteSetString(char **, const char *, ...); 1124*c5c4113dSnw141292 void sqliteSetNString(char **, ...); 1125*c5c4113dSnw141292 void sqliteErrorMsg(Parse*, const char*, ...); 1126*c5c4113dSnw141292 void sqliteDequote(char*); 1127*c5c4113dSnw141292 int sqliteKeywordCode(const char*, int); 1128*c5c4113dSnw141292 int sqliteRunParser(Parse*, const char*, char **); 1129*c5c4113dSnw141292 void sqliteExec(Parse*); 1130*c5c4113dSnw141292 Expr *sqliteExpr(int, Expr*, Expr*, Token*); 1131*c5c4113dSnw141292 void sqliteExprSpan(Expr*,Token*,Token*); 1132*c5c4113dSnw141292 Expr *sqliteExprFunction(ExprList*, Token*); 1133*c5c4113dSnw141292 void sqliteExprDelete(Expr*); 1134*c5c4113dSnw141292 ExprList *sqliteExprListAppend(ExprList*,Expr*,Token*); 1135*c5c4113dSnw141292 void sqliteExprListDelete(ExprList*); 1136*c5c4113dSnw141292 int sqliteInit(sqlite*, char**); 1137*c5c4113dSnw141292 void sqlitePragma(Parse*,Token*,Token*,int); 1138*c5c4113dSnw141292 void sqliteResetInternalSchema(sqlite*, int); 1139*c5c4113dSnw141292 void sqliteBeginParse(Parse*,int); 1140*c5c4113dSnw141292 void sqliteRollbackInternalChanges(sqlite*); 1141*c5c4113dSnw141292 void sqliteCommitInternalChanges(sqlite*); 1142*c5c4113dSnw141292 Table *sqliteResultSetOfSelect(Parse*,char*,Select*); 1143*c5c4113dSnw141292 void sqliteOpenMasterTable(Vdbe *v, int); 1144*c5c4113dSnw141292 void sqliteStartTable(Parse*,Token*,Token*,int,int); 1145*c5c4113dSnw141292 void sqliteAddColumn(Parse*,Token*); 1146*c5c4113dSnw141292 void sqliteAddNotNull(Parse*, int); 1147*c5c4113dSnw141292 void sqliteAddPrimaryKey(Parse*, IdList*, int); 1148*c5c4113dSnw141292 void sqliteAddColumnType(Parse*,Token*,Token*); 1149*c5c4113dSnw141292 void sqliteAddDefaultValue(Parse*,Token*,int); 1150*c5c4113dSnw141292 int sqliteCollateType(const char*, int); 1151*c5c4113dSnw141292 void sqliteAddCollateType(Parse*, int); 1152*c5c4113dSnw141292 void sqliteEndTable(Parse*,Token*,Select*); 1153*c5c4113dSnw141292 void sqliteCreateView(Parse*,Token*,Token*,Select*,int); 1154*c5c4113dSnw141292 int sqliteViewGetColumnNames(Parse*,Table*); 1155*c5c4113dSnw141292 void sqliteDropTable(Parse*, Token*, int); 1156*c5c4113dSnw141292 void sqliteDeleteTable(sqlite*, Table*); 1157*c5c4113dSnw141292 void sqliteInsert(Parse*, SrcList*, ExprList*, Select*, IdList*, int); 1158*c5c4113dSnw141292 IdList *sqliteIdListAppend(IdList*, Token*); 1159*c5c4113dSnw141292 int sqliteIdListIndex(IdList*,const char*); 1160*c5c4113dSnw141292 SrcList *sqliteSrcListAppend(SrcList*, Token*, Token*); 1161*c5c4113dSnw141292 void sqliteSrcListAddAlias(SrcList*, Token*); 1162*c5c4113dSnw141292 void sqliteSrcListAssignCursors(Parse*, SrcList*); 1163*c5c4113dSnw141292 void sqliteIdListDelete(IdList*); 1164*c5c4113dSnw141292 void sqliteSrcListDelete(SrcList*); 1165*c5c4113dSnw141292 void sqliteCreateIndex(Parse*,Token*,SrcList*,IdList*,int,Token*,Token*); 1166*c5c4113dSnw141292 void sqliteDropIndex(Parse*, SrcList*); 1167*c5c4113dSnw141292 void sqliteAddKeyType(Vdbe*, ExprList*); 1168*c5c4113dSnw141292 void sqliteAddIdxKeyType(Vdbe*, Index*); 1169*c5c4113dSnw141292 int sqliteSelect(Parse*, Select*, int, int, Select*, int, int*); 1170*c5c4113dSnw141292 Select *sqliteSelectNew(ExprList*,SrcList*,Expr*,ExprList*,Expr*,ExprList*, 1171*c5c4113dSnw141292 int,int,int); 1172*c5c4113dSnw141292 void sqliteSelectDelete(Select*); 1173*c5c4113dSnw141292 void sqliteSelectUnbind(Select*); 1174*c5c4113dSnw141292 Table *sqliteSrcListLookup(Parse*, SrcList*); 1175*c5c4113dSnw141292 int sqliteIsReadOnly(Parse*, Table*, int); 1176*c5c4113dSnw141292 void sqliteDeleteFrom(Parse*, SrcList*, Expr*); 1177*c5c4113dSnw141292 void sqliteUpdate(Parse*, SrcList*, ExprList*, Expr*, int); 1178*c5c4113dSnw141292 WhereInfo *sqliteWhereBegin(Parse*, SrcList*, Expr*, int, ExprList**); 1179*c5c4113dSnw141292 void sqliteWhereEnd(WhereInfo*); 1180*c5c4113dSnw141292 void sqliteExprCode(Parse*, Expr*); 1181*c5c4113dSnw141292 int sqliteExprCodeExprList(Parse*, ExprList*, int); 1182*c5c4113dSnw141292 void sqliteExprIfTrue(Parse*, Expr*, int, int); 1183*c5c4113dSnw141292 void sqliteExprIfFalse(Parse*, Expr*, int, int); 1184*c5c4113dSnw141292 Table *sqliteFindTable(sqlite*,const char*, const char*); 1185*c5c4113dSnw141292 Table *sqliteLocateTable(Parse*,const char*, const char*); 1186*c5c4113dSnw141292 Index *sqliteFindIndex(sqlite*,const char*, const char*); 1187*c5c4113dSnw141292 void sqliteUnlinkAndDeleteIndex(sqlite*,Index*); 1188*c5c4113dSnw141292 void sqliteCopy(Parse*, SrcList*, Token*, Token*, int); 1189*c5c4113dSnw141292 void sqliteVacuum(Parse*, Token*); 1190*c5c4113dSnw141292 int sqliteRunVacuum(char**, sqlite*); 1191*c5c4113dSnw141292 int sqliteGlobCompare(const unsigned char*,const unsigned char*); 1192*c5c4113dSnw141292 int sqliteLikeCompare(const unsigned char*,const unsigned char*); 1193*c5c4113dSnw141292 char *sqliteTableNameFromToken(Token*); 1194*c5c4113dSnw141292 int sqliteExprCheck(Parse*, Expr*, int, int*); 1195*c5c4113dSnw141292 int sqliteExprType(Expr*); 1196*c5c4113dSnw141292 int sqliteExprCompare(Expr*, Expr*); 1197*c5c4113dSnw141292 int sqliteFuncId(Token*); 1198*c5c4113dSnw141292 int sqliteExprResolveIds(Parse*, SrcList*, ExprList*, Expr*); 1199*c5c4113dSnw141292 int sqliteExprAnalyzeAggregates(Parse*, Expr*); 1200*c5c4113dSnw141292 Vdbe *sqliteGetVdbe(Parse*); 1201*c5c4113dSnw141292 void sqliteRandomness(int, void*); 1202*c5c4113dSnw141292 void sqliteRollbackAll(sqlite*); 1203*c5c4113dSnw141292 void sqliteCodeVerifySchema(Parse*, int); 1204*c5c4113dSnw141292 void sqliteBeginTransaction(Parse*, int); 1205*c5c4113dSnw141292 void sqliteCommitTransaction(Parse*); 1206*c5c4113dSnw141292 void sqliteRollbackTransaction(Parse*); 1207*c5c4113dSnw141292 int sqliteExprIsConstant(Expr*); 1208*c5c4113dSnw141292 int sqliteExprIsInteger(Expr*, int*); 1209*c5c4113dSnw141292 int sqliteIsRowid(const char*); 1210*c5c4113dSnw141292 void sqliteGenerateRowDelete(sqlite*, Vdbe*, Table*, int, int); 1211*c5c4113dSnw141292 void sqliteGenerateRowIndexDelete(sqlite*, Vdbe*, Table*, int, char*); 1212*c5c4113dSnw141292 void sqliteGenerateConstraintChecks(Parse*,Table*,int,char*,int,int,int,int); 1213*c5c4113dSnw141292 void sqliteCompleteInsertion(Parse*, Table*, int, char*, int, int, int); 1214*c5c4113dSnw141292 int sqliteOpenTableAndIndices(Parse*, Table*, int); 1215*c5c4113dSnw141292 void sqliteBeginWriteOperation(Parse*, int, int); 1216*c5c4113dSnw141292 void sqliteEndWriteOperation(Parse*); 1217*c5c4113dSnw141292 Expr *sqliteExprDup(Expr*); 1218*c5c4113dSnw141292 void sqliteTokenCopy(Token*, Token*); 1219*c5c4113dSnw141292 ExprList *sqliteExprListDup(ExprList*); 1220*c5c4113dSnw141292 SrcList *sqliteSrcListDup(SrcList*); 1221*c5c4113dSnw141292 IdList *sqliteIdListDup(IdList*); 1222*c5c4113dSnw141292 Select *sqliteSelectDup(Select*); 1223*c5c4113dSnw141292 FuncDef *sqliteFindFunction(sqlite*,const char*,int,int,int); 1224*c5c4113dSnw141292 void sqliteRegisterBuiltinFunctions(sqlite*); 1225*c5c4113dSnw141292 void sqliteRegisterDateTimeFunctions(sqlite*); 1226*c5c4113dSnw141292 int sqliteSafetyOn(sqlite*); 1227*c5c4113dSnw141292 int sqliteSafetyOff(sqlite*); 1228*c5c4113dSnw141292 int sqliteSafetyCheck(sqlite*); 1229*c5c4113dSnw141292 void sqliteChangeCookie(sqlite*, Vdbe*); 1230*c5c4113dSnw141292 void sqliteBeginTrigger(Parse*, Token*,int,int,IdList*,SrcList*,int,Expr*,int); 1231*c5c4113dSnw141292 void sqliteFinishTrigger(Parse*, TriggerStep*, Token*); 1232*c5c4113dSnw141292 void sqliteDropTrigger(Parse*, SrcList*); 1233*c5c4113dSnw141292 void sqliteDropTriggerPtr(Parse*, Trigger*, int); 1234*c5c4113dSnw141292 int sqliteTriggersExist(Parse* , Trigger* , int , int , int, ExprList*); 1235*c5c4113dSnw141292 int sqliteCodeRowTrigger(Parse*, int, ExprList*, int, Table *, int, int, 1236*c5c4113dSnw141292 int, int); 1237*c5c4113dSnw141292 void sqliteViewTriggers(Parse*, Table*, Expr*, int, ExprList*); 1238*c5c4113dSnw141292 void sqliteDeleteTriggerStep(TriggerStep*); 1239*c5c4113dSnw141292 TriggerStep *sqliteTriggerSelectStep(Select*); 1240*c5c4113dSnw141292 TriggerStep *sqliteTriggerInsertStep(Token*, IdList*, ExprList*, Select*, int); 1241*c5c4113dSnw141292 TriggerStep *sqliteTriggerUpdateStep(Token*, ExprList*, Expr*, int); 1242*c5c4113dSnw141292 TriggerStep *sqliteTriggerDeleteStep(Token*, Expr*); 1243*c5c4113dSnw141292 void sqliteDeleteTrigger(Trigger*); 1244*c5c4113dSnw141292 int sqliteJoinType(Parse*, Token*, Token*, Token*); 1245*c5c4113dSnw141292 void sqliteCreateForeignKey(Parse*, IdList*, Token*, IdList*, int); 1246*c5c4113dSnw141292 void sqliteDeferForeignKey(Parse*, int); 1247*c5c4113dSnw141292 #ifndef SQLITE_OMIT_AUTHORIZATION 1248*c5c4113dSnw141292 void sqliteAuthRead(Parse*,Expr*,SrcList*); 1249*c5c4113dSnw141292 int sqliteAuthCheck(Parse*,int, const char*, const char*, const char*); 1250*c5c4113dSnw141292 void sqliteAuthContextPush(Parse*, AuthContext*, const char*); 1251*c5c4113dSnw141292 void sqliteAuthContextPop(AuthContext*); 1252*c5c4113dSnw141292 #else 1253*c5c4113dSnw141292 # define sqliteAuthRead(a,b,c) 1254*c5c4113dSnw141292 # define sqliteAuthCheck(a,b,c,d,e) SQLITE_OK 1255*c5c4113dSnw141292 # define sqliteAuthContextPush(a,b,c) 1256*c5c4113dSnw141292 # define sqliteAuthContextPop(a) ((void)(a)) 1257*c5c4113dSnw141292 #endif 1258*c5c4113dSnw141292 void sqliteAttach(Parse*, Token*, Token*, Token*); 1259*c5c4113dSnw141292 void sqliteDetach(Parse*, Token*); 1260*c5c4113dSnw141292 int sqliteBtreeFactory(const sqlite *db, const char *zFilename, 1261*c5c4113dSnw141292 int mode, int nPg, Btree **ppBtree); 1262*c5c4113dSnw141292 int sqliteFixInit(DbFixer*, Parse*, int, const char*, const Token*); 1263*c5c4113dSnw141292 int sqliteFixSrcList(DbFixer*, SrcList*); 1264*c5c4113dSnw141292 int sqliteFixSelect(DbFixer*, Select*); 1265*c5c4113dSnw141292 int sqliteFixExpr(DbFixer*, Expr*); 1266*c5c4113dSnw141292 int sqliteFixExprList(DbFixer*, ExprList*); 1267*c5c4113dSnw141292 int sqliteFixTriggerStep(DbFixer*, TriggerStep*); 1268*c5c4113dSnw141292 double sqliteAtoF(const char *z, const char **); 1269*c5c4113dSnw141292 char *sqlite_snprintf(int,char*,const char*,...); 1270*c5c4113dSnw141292 int sqliteFitsIn32Bits(const char *); 1271