Lines Matching defs:db
2459 sqlite3 *db, /* An open database */
2527 ** sqlite3_exec(db, zSQL, 0, 0, 0);
2555 ** sqlite3_exec(db, zSQL, 0, 0, 0);
3126 ** <tr><td> file:data.db <td>
3127 ** Open the file "data.db" in the current directory.
3128 ** <tr><td> file:/home/fred/data.db<br>
3129 ** file:///home/fred/data.db <br>
3130 ** file://localhost/home/fred/data.db <br> <td>
3131 ** Open the database file "/home/fred/data.db".
3132 ** <tr><td> file://darkstar/home/fred/data.db <td>
3135 ** file:///C:/Documents%20and%20Settings/fred/Desktop/data.db
3136 ** <td> Windows only: Open the file "data.db" on fred's desktop on drive
3140 ** <tr><td> file:data.db?mode=ro&cache=private <td>
3141 ** Open file "data.db" in the current directory for read-only access.
3144 ** <tr><td> file:/home/fred/data.db?vfs=unix-dotfile <td>
3145 ** Open file "/home/fred/data.db". Use the special VFS "unix-dotfile"
3147 ** <tr><td> file:data.db?mode=readonly <td>
3174 sqlite3 **ppDb /* OUT: SQLite db handle */
3178 sqlite3 **ppDb /* OUT: SQLite db handle */
3182 sqlite3 **ppDb, /* OUT: SQLite db handle */
3272 SQLITE_API int SQLITE_STDCALL sqlite3_errcode(sqlite3 *db);
3273 SQLITE_API int SQLITE_STDCALL sqlite3_extended_errcode(sqlite3 *db);
3424 ** The first argument, "db", is a [database connection] obtained from a
3497 sqlite3 *db, /* Database handle */
3504 sqlite3 *db, /* Database handle */
3511 sqlite3 *db, /* Database handle */
3518 sqlite3 *db, /* Database handle */
4426 sqlite3 *db,
4436 sqlite3 *db,
4446 sqlite3 *db,
4990 sqlite3 *db, /* Database to be rekeyed */
4994 sqlite3 *db, /* Database to be rekeyed */
5008 sqlite3 *db
5012 sqlite3 *db, /* Database to be rekeyed */
5202 SQLITE_API const char *SQLITE_STDCALL sqlite3_db_filename(sqlite3 *db, const char *zDbName);
5212 SQLITE_API int SQLITE_STDCALL sqlite3_db_readonly(sqlite3 *db, const char *zDbName);
5533 sqlite3 *db, /* Connection handle */
5580 sqlite3 *db, /* Load the extension into this database connection */
5600 SQLITE_API int SQLITE_STDCALL sqlite3_enable_load_extension(sqlite3 *db, int onoff);
5617 ** sqlite3 *db,
5863 sqlite3 *db, /* SQLite connection to register module with */
5869 sqlite3 *db, /* SQLite connection to register module with */
7582 SQLITE_API int SQLITE_STDCALL sqlite3_wal_autocheckpoint(sqlite3 *db, int N);
7604 SQLITE_API int SQLITE_STDCALL sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb);
7675 ** [database connection] db. In this case the
7699 sqlite3 *db, /* Database handle */
7746 ** [sqlite3_vtab_config](db,SQLITE_VTAB_CONSTRAINT_SUPPORT,X) are supported,
7964 sqlite3 *db,
7990 sqlite3 *db,
9295 typedef struct Db Db;
9389 sqlite3 *db, /* Associated database connection */
9402 #define BTREE_MEMORY 2 /* This is an in-memory DB */
10863 struct Db {
10903 ** Db.pSchema->flags field.
10911 ** Allowed values for the DB.pSchema->flags field.
11022 Db *aDb; /* All backends */
11048 u8 iDb; /* Which db file is being initialized */
11102 Db aDbStatic[2]; /* Static space for the 2 default backends */
11135 #define SCHEMA_ENC(db) ((db)->aDb[0].pSchema->enc)
11136 #define ENC(db) ((db)->enc)
11197 #define OptimizationDisabled(db, mask) (((db)->dbOptFlags&(mask))!=0)
11198 #define OptimizationEnabled(db, mask) (((db)->dbOptFlags&(mask))==0)
11200 #define OptimizationDisabled(db, mask) 0
11201 #define OptimizationEnabled(db, mask) 1
11488 ** sqlite3DbMalloc(), using the connection handle stored in VTable.db as
11492 sqlite3 *db; /* Database connection associated with this table */
11672 sqlite3 *db; /* The database connection */
11742 int tnum; /* DB Page containing root of this index */
12058 unsigned bSpanIsTab :1; /* zSpan holds DB.TABLE.COLUMN */
12500 sqlite3 *db; /* The main database structure */
12593 const char *zAuthContext; /* The 6th parameter to db->xAuth callbacks */
12626 #define OPFLAG_NCHANGE 0x01 /* Set to update db->nChange */
12628 #define OPFLAG_LASTROWID 0x02 /* Set to update db->lastRowid */
12749 sqlite3 *db; /* Optional database for lookaside. Can be NULL */
12765 sqlite3 *db; /* The database being initialized */
13496 SQLITE_PRIVATE int sqlite3SchemaToIndex(sqlite3 *db, Schema *);
13509 SQLITE_PRIVATE int sqlite3ApiExit(sqlite3 *db, int);
13564 # define sqlite3VtabInSync(db) 0
13571 SQLITE_PRIVATE void sqlite3VtabClear(sqlite3 *db, Table*);
13572 SQLITE_PRIVATE void sqlite3VtabDisconnect(sqlite3 *db, Table *p);
13573 SQLITE_PRIVATE int sqlite3VtabSync(sqlite3 *db, Vdbe*);
13574 SQLITE_PRIVATE int sqlite3VtabRollback(sqlite3 *db);
13575 SQLITE_PRIVATE int sqlite3VtabCommit(sqlite3 *db);
13582 # define sqlite3VtabInSync(db) ((db)->nVTrans>0 && (db)->aVTrans==0)
13710 SQLITE_PRIVATE void sqlite3ConnectionUnlocked(sqlite3 *db);
13711 SQLITE_PRIVATE void sqlite3ConnectionClosed(sqlite3 *db);
14575 i8 iDb; /* Index of cursor database in db->aDb[] (or -1) */
14650 int nDbChange; /* Value of db->nChange */
14682 sqlite3 *db; /* The associated database connection */
14819 sqlite3 *db; /* The database connection that owns this statement */
14831 Vdbe *pPrev,*pNext; /* Linked list of VDBEs with the same Vdbe.db */
14855 int nChange; /* Number of db changes made since last reset */
14856 yDbMask btreeMask; /* Bitmask of db->aDb[] entries referenced */
15154 sqlite3 *db, /* The database connection whose status is desired */
15162 if( !sqlite3SafetyCheckOk(db) || pCurrent==0|| pHighwater==0 ){
15166 sqlite3_mutex_enter(db->mutex);
15169 *pCurrent = db->lookaside.nOut;
15170 *pHighwater = db->lookaside.mxOut;
15172 db->lookaside.mxOut = db->lookaside.nOut;
15186 *pHighwater = db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT];
15188 db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT] = 0;
15201 sqlite3BtreeEnterAll(db);
15202 for(i=0; i<db->nDb; i++){
15203 Btree *pBt = db->aDb[i].pBt;
15209 sqlite3BtreeLeaveAll(db);
15224 sqlite3BtreeEnterAll(db);
15225 db->pnBytesFreed = &nByte;
15226 for(i=0; i<db->nDb; i++){
15227 Schema *pSchema = db->aDb[i].pSchema;
15243 sqlite3DeleteTrigger(db, (Trigger*)sqliteHashData(p));
15246 sqlite3DeleteTable(db, (Table *)sqliteHashData(p));
15250 db->pnBytesFreed = 0;
15251 sqlite3BtreeLeaveAll(db);
15267 db->pnBytesFreed = &nByte;
15268 for(pVdbe=db->pVdbe; pVdbe; pVdbe=pVdbe->pNext){
15269 sqlite3VdbeClearObject(db, pVdbe);
15270 sqlite3DbFree(db, pVdbe);
15272 db->pnBytesFreed = 0;
15293 for(i=0; i<db->nDb; i++){
15294 if( db->aDb[i].pBt ){
15295 Pager *pPager = sqlite3BtreePager(db->aDb[i].pBt);
15312 *pCurrent = db->nDeferredImmCons>0 || db->nDeferredCons>0;
15320 sqlite3_mutex_leave(db->mutex);
16221 sqlite3 *db;
16227 db = sqlite3_context_db_handle(context);
16263 testcase( n==(u64)db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
16264 testcase( n==(u64)db->aLimit[SQLITE_LIMIT_LENGTH] );
16267 }else if( n>(u64)db->aLimit[SQLITE_LIMIT_LENGTH] ){
16271 z = sqlite3DbMallocRaw(db, (int)n);
16407 sqlite3 *db;
20959 ** TRUE if p is a lookaside memory allocation from db
20962 static int isLookaside(sqlite3 *db, void *p){
20963 return p>=db->lookaside.pStart && p<db->lookaside.pEnd;
20977 SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3 *db, void *p){
20978 if( db==0 ){
20983 assert( sqlite3_mutex_held(db->mutex) );
20984 if( isLookaside(db, p) ){
20985 return db->lookaside.sz;
21019 ** *db->pnBytesFreed.
21021 static SQLITE_NOINLINE void measureAllocationSize(sqlite3 *db, void *p){
21022 *db->pnBytesFreed += sqlite3DbMallocSize(db,p);
21029 SQLITE_PRIVATE void sqlite3DbFree(sqlite3 *db, void *p){
21030 assert( db==0 || sqlite3_mutex_held(db->mutex) );
21032 if( db ){
21033 if( db->pnBytesFreed ){
21034 measureAllocationSize(db, p);
21037 if( isLookaside(db, p) ){
21041 memset(p, 0xaa, db->lookaside.sz);
21043 pBuf->pNext = db->lookaside.pFree;
21044 db->lookaside.pFree = pBuf;
21045 db->lookaside.nOut--;
21051 assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );
21141 SQLITE_PRIVATE void *sqlite3DbMallocZero(sqlite3 *db, u64 n){
21142 void *p = sqlite3DbMallocRaw(db, n);
21153 ** If db!=0 and db->mallocFailed is true (indicating a prior malloc
21160 ** int *a = (int*)sqlite3DbMallocRaw(db, 100);
21161 ** int *b = (int*)sqlite3DbMallocRaw(db, 200);
21167 SQLITE_PRIVATE void *sqlite3DbMallocRaw(sqlite3 *db, u64 n){
21169 assert( db==0 || sqlite3_mutex_held(db->mutex) );
21170 assert( db==0 || db->pnBytesFreed==0 );
21172 if( db ){
21174 if( db->mallocFailed ){
21177 if( db->lookaside.bEnabled ){
21178 if( n>db->lookaside.sz ){
21179 db->lookaside.anStat[1]++;
21180 }else if( (pBuf = db->lookaside.pFree)==0 ){
21181 db->lookaside.anStat[2]++;
21183 db->lookaside.pFree = pBuf->pNext;
21184 db->lookaside.nOut++;
21185 db->lookaside.anStat[0]++;
21186 if( db->lookaside.nOut>db->lookaside.mxOut ){
21187 db->lookaside.mxOut = db->lookaside.nOut;
21194 if( db && db->mallocFailed ){
21199 if( !p && db ){
21200 db->mallocFailed = 1;
21203 (db && db->lookaside.bEnabled) ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP);
21211 SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *db, void *p, u64 n){
21213 assert( db!=0 );
21214 assert( sqlite3_mutex_held(db->mutex) );
21215 if( db->mallocFailed==0 ){
21217 return sqlite3DbMallocRaw(db, n);
21219 if( isLookaside(db, p) ){
21220 if( n<=db->lookaside.sz ){
21223 pNew = sqlite3DbMallocRaw(db, n);
21225 memcpy(pNew, p, db->lookaside.sz);
21226 sqlite3DbFree(db, p);
21234 db->mallocFailed = 1;
21237 (db->lookaside.bEnabled ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));
21247 SQLITE_PRIVATE void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, u64 n){
21249 pNew = sqlite3DbRealloc(db, p, n);
21251 sqlite3DbFree(db, p);
21263 SQLITE_PRIVATE char *sqlite3DbStrDup(sqlite3 *db, const char *z){
21271 zNew = sqlite3DbMallocRaw(db, (int)n);
21277 SQLITE_PRIVATE char *sqlite3DbStrNDup(sqlite3 *db, const char *z, u64 n){
21283 zNew = sqlite3DbMallocRaw(db, n+1);
21296 SQLITE_PRIVATE void sqlite3SetString(char **pz, sqlite3 *db, const char *zFormat, ...){
21301 z = sqlite3VMPrintf(db, zFormat, ap);
21303 sqlite3DbFree(db, *pz);
21310 static SQLITE_NOINLINE int apiOomError(sqlite3 *db){
21311 db->mallocFailed = 0;
21312 sqlite3Error(db, SQLITE_NOMEM);
21325 ** If the first argument, db, is not NULL and a malloc() error has occurred,
21329 SQLITE_PRIVATE int sqlite3ApiExit(sqlite3* db, int rc){
21330 /* If the db handle is not NULL, then we must hold the connection handle
21331 ** mutex here. Otherwise the read (and possible write) of db->mallocFailed
21334 assert( !db || sqlite3_mutex_held(db->mutex) );
21335 if( db==0 ) return rc & 0xff;
21336 if( db->mallocFailed || rc==SQLITE_IOERR_NOMEM ){
21337 return apiOomError(db);
21339 return rc & db->errMask;
22119 if( p->db ){
22120 zNew = sqlite3DbRealloc(p->db, zOld, p->nAlloc);
22128 p->nAlloc = sqlite3DbMallocSize(p->db, zNew);
22200 p->zText = sqlite3DbMallocRaw(p->db, p->nChar+1 );
22216 sqlite3DbFree(p->db, p->zText);
22225 ** db: Pointer to a database connection. May be NULL. Lookaside
22226 ** memory is used if not NULL. db->mallocFailed is set appropriately
22235 SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum *p, sqlite3 *db, char *zBase, int n, int mx){
22237 p->db = db;
22248 SQLITE_PRIVATE char *sqlite3VMPrintf(sqlite3 *db, const char *zFormat, va_list ap){
22252 assert( db!=0 );
22253 sqlite3StrAccumInit(&acc, db, zBase, sizeof(zBase),
22254 db->aLimit[SQLITE_LIMIT_LENGTH]);
22258 db->mallocFailed = 1;
22267 SQLITE_PRIVATE char *sqlite3MPrintf(sqlite3 *db, const char *zFormat, ...){
22271 z = sqlite3VMPrintf(db, zFormat, ap);
22281 ** x = sqlite3MPrintf(db, x, "prefix %s suffix", x);
22284 SQLITE_PRIVATE char *sqlite3MAppendf(sqlite3 *db, char *zStr, const char *zFormat, ...){
22288 z = sqlite3VMPrintf(db, zFormat, ap);
22290 sqlite3DbFree(db, zStr);
23104 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
23168 zOut = sqlite3DbMallocRaw(pMem->db, len);
23217 pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->z);
23331 SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte, u8 enc){
23334 m.db = db;
23337 if( db->mallocFailed ){
23341 assert( (m.flags & MEM_Term)!=0 || db->mallocFailed );
23342 assert( (m.flags & MEM_Str)!=0 || db->mallocFailed );
23343 assert( m.z || db->mallocFailed );
23543 SQLITE_PRIVATE void sqlite3Error(sqlite3 *db, int err_code){
23544 assert( db!=0 );
23545 db->errCode = err_code;
23546 if( db->pErr ) sqlite3ValueSetNull(db->pErr);
23551 ** handle "db". The error code is set to "err_code".
23566 ** To clear the most recent error for sqlite handle "db", sqlite3Error
23570 SQLITE_PRIVATE void sqlite3ErrorWithMsg(sqlite3 *db, int err_code, const char *zFormat, ...){
23571 assert( db!=0 );
23572 db->errCode = err_code;
23574 sqlite3Error(db, err_code);
23575 }else if( db->pErr || (db->pErr = sqlite3ValueNew(db))!=0 ){
23579 z = sqlite3VMPrintf(db, zFormat, ap);
23581 sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC);
23605 sqlite3 *db = pParse->db;
23607 zMsg = sqlite3VMPrintf(db, zFormat, ap);
23609 if( db->suppressErr ){
23610 sqlite3DbFree(db, zMsg);
23613 sqlite3DbFree(db, pParse->zErrMsg);
24544 SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){
24548 zBlob = (char *)sqlite3DbMallocRaw(db, n/2 + 1);
24573 ** Check to make sure we have a valid db pointer. This test is not
24575 ** misuse of the interface such as passing in db pointers that are
24577 ** 1 it means that the db pointer is valid and 0 if it should not be
24581 ** sqlite3SafetyCheckOk() requires that the db pointer be valid for
24582 ** use. sqlite3SafetyCheckSickOrOk() allows a db pointer that failed to
24586 SQLITE_PRIVATE int sqlite3SafetyCheckOk(sqlite3 *db){
24588 if( db==0 ){
24592 magic = db->magic;
24594 if( sqlite3SafetyCheckSickOrOk(db) ){
24603 SQLITE_PRIVATE int sqlite3SafetyCheckSickOrOk(sqlite3 *db){
24605 magic = db->magic;
24706 ** test.db-journal => test.nal
24707 ** test.db-wal => test.wal
24708 ** test.db-shm => test.shm
24709 ** test.db-mj7f3319fa => test.9fa
26824 db file %s", pFile->zPath);
29698 ** is "/home/user1/config.db" then the file that is created and mmapped
29699 ** for shared memory will be called "/home/user1/config.db-shm".
30223 int h = pFd->h; /* File descriptor open on db file */
30769 ** proxyLock activation is possible (remote proxy is based on db name)
31076 ** "<path to db>-journal"
31077 ** "<path to db>-wal"
31078 ** "<path to db>-journalNN"
31079 ** "<path to db>-walNN"
31188 /* The main DB, main journal, WAL file and master journal are never
31781 ** sqlite3_file_control(db, dbname, SQLITE_FCNTL_SET_LOCKPROXYFILE,
31783 ** sqlite3_file_control(db, dbname, SQLITE_FCNTL_GET_LOCKPROXYFILE,
31799 ** For database path "/Users/me/foo.db"
31800 ** The lock path will be "<tmpdir>/sqliteplocks/_Users_me_foo.db:auto:")
31934 /* transform the db path to a unique cache name */
32592 /* afp style keeps a reference to the db path in the filePath field
32605 /* all other styles use the locking context to store the db file path */
37881 /* The main DB, main journal, WAL file and master journal are never
41107 sqlite3 *db; /* The database connection */
41125 ** are available at pSpace. The db pointer is used as a memory context
41135 SQLITE_PRIVATE RowSet *sqlite3RowSetInit(sqlite3 *db, void *pSpace, unsigned int N){
41140 p->db = db;
41160 sqlite3DbFree(p->db, pChunk);
41175 ** In an OOM situation, the RowSet.db->mallocFailed flag is set and this
41182 pNew = sqlite3DbMallocRaw(p->db, sizeof(*pNew));
41635 int sync_flags, /* Flags to sync db file with (or 0) */
41662 ** stored in each frame (i.e. the db page-size when the WAL was created).
41933 ** db size etc.) are consistent with the contents of the file-system.
42371 SQLITE_API int sqlite3_pager_readdb_count = 0; /* Number of full pages read from DB */
42372 SQLITE_API int sqlite3_pager_writedb_count = 0; /* Number of full pages written to DB */
43568 int rc2 = SQLITE_OK; /* Error code from db file unlock operation */
44038 ** "/home/bill/a.db-journal\x00/home/bill/b.db-journal\x00"
44807 i64 n = 0; /* Size of db file in bytes */
44844 ** function. Because an EXCLUSIVE lock on the db file is required to delete
46273 ROUND8(pVfs->szOsFile) + /* The main db file */
46817 ** possibility by unmapping the db here. */
46930 ** flag was specified by the caller. And so long as the db is not a
47758 int noSync /* True to omit the xSync on the db file */
47779 /* If this is an in-memory db, or no pages have been written to, or this
47838 /* Update the db file change counter via the direct-write method. The
47887 ** last page in the db image moved to the free-list. In this case the
49285 u32 nBackfill; /* Number of WAL frames backfilled into DB */
49592 u32 nTruncate, /* New db size (or 0 for non-commit frames) */
49619 u32 *pnTruncate, /* OUT: New db size (or 0 if not commit) */
50689 ** about the eventual size of the db file to the VFS layer.
50700 /* Iterate through the contents of the WAL, copying data to the db file */
51884 int sync_flags, /* Flags to sync db file with (or 0) */
52447 sqlite3 *db; /* The database connection holding this btree */
52450 u8 sharable; /* True if we can share pBt with another db */
52451 u8 locked; /* True if db currently has pBt locked */
52455 Btree *pNext; /* List of other sharable Btrees from the same db */
52510 sqlite3 *db; /* Database connection currently using this Btree */
52517 u8 bDoTruncate; /* True to truncate db on commit */
52592 ** particular database connection identified BtCursor.pBtree.db.
52765 u8 *aPgRef; /* 1 bit per page in the db (see above) */
52790 ** set BtShared.db to the database handle associated with p and the
52796 assert( sqlite3_mutex_held(p->db->mutex) );
52799 p->pBt->db = p->db;
52811 assert( sqlite3_mutex_held(p->db->mutex) );
52812 assert( p->db==pBt->db );
52844 assert( p->pNext==0 || p->pNext->db==p->db );
52845 assert( p->pPrev==0 || p->pPrev->db==p->db );
52853 assert( sqlite3_mutex_held(p->db->mutex) );
52855 /* Unless the database is sharable and unlocked, then BtShared.db
52857 assert( (p->locked==0 && p->sharable) || p->pBt->db==p->db );
52879 p->pBt->db = p->db;
52910 assert( sqlite3_mutex_held(p->db->mutex) );
52929 assert( p->sharable==0 || p->locked==0 || p->db==p->pBt->db );
52931 assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->db->mutex) );
52967 SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3 *db){
52970 assert( sqlite3_mutex_held(db->mutex) );
52971 for(i=0; i<db->nDb; i++){
52972 p = db->aDb[i].pBt;
52976 SQLITE_PRIVATE void sqlite3BtreeLeaveAll(sqlite3 *db){
52979 assert( sqlite3_mutex_held(db->mutex) );
52980 for(i=0; i<db->nDb; i++){
52981 p = db->aDb[i].pBt;
53001 SQLITE_PRIVATE int sqlite3BtreeHoldsAllMutexes(sqlite3 *db){
53003 if( !sqlite3_mutex_held(db->mutex) ){
53006 for(i=0; i<db->nDb; i++){
53008 p = db->aDb[i].pBt;
53021 ** db->aDb[iDb].pSchema structure. The mutexes required for schema
53024 ** (1) The mutex on db
53025 ** (2) if iDb!=1, then the mutex on db->aDb[iDb].pBt.
53028 ** db using sqlite3SchemaToIndex().
53030 SQLITE_PRIVATE int sqlite3SchemaMutexHeld(sqlite3 *db, int iDb, Schema *pSchema){
53032 assert( db!=0 );
53033 if( pSchema ) iDb = sqlite3SchemaToIndex(db, pSchema);
53034 assert( iDb>=0 && iDb<db->nDb );
53035 if( !sqlite3_mutex_held(db->mutex) ) return 0;
53037 p = db->aDb[iDb].pBt;
53055 p->pBt->db = p->db;
53057 SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3 *db){
53059 for(i=0; i<db->nDb; i++){
53060 Btree *p = db->aDb[i].pBt;
53062 p->pBt->db = p->db;
53224 || (eLockType==READ_LOCK && (pBtree->db->flags & SQLITE_ReadUncommitted))
53301 && 0==(p->pBtree->db->flags & SQLITE_ReadUncommitted)
53322 assert( p->db!=0 );
53323 assert( !(p->db->flags&SQLITE_ReadUncommitted)||eLock==WRITE_LOCK||iTab==1 );
53341 sqlite3ConnectionBlocked(p->db, pBt->pWriter->db);
53358 sqlite3ConnectionBlocked(p->db, pIter->pBtree->db);
53395 assert( p->db!=0 );
53401 assert( 0==(p->db->flags&SQLITE_ReadUncommitted) || eLock==WRITE_LOCK );
53801 sqlite3DbFree(pCur->pKeyInfo->db, pFree);
53809 sqlite3DbFree(pCur->pKeyInfo->db, pFree);
54941 assert( pBt->db );
54942 assert( sqlite3_mutex_held(pBt->db->mutex) );
54943 return sqlite3InvokeBusyHandler(&pBt->db->busyHandler);
54970 sqlite3 *db, /* Associated database handle */
54992 || (isTempDb && sqlite3TempInMemory(db))
54996 assert( db!=0 );
54998 assert( sqlite3_mutex_held(db->mutex) );
55018 p->db = db;
55063 for(iDb=db->nDb-1; iDb>=0; iDb--){
55064 Btree *pExisting = db->aDb[iDb].pBt;
55113 sqlite3PagerSetMmapLimit(pBt->pPager, db->szMmap);
55120 pBt->db = db;
55177 db->mallocFailed = 0;
55197 for(i=0; i<db->nDb; i++){
55198 if( (pSib = db->aDb[i].pBt)!=0 && pSib->sharable ){
55336 assert( sqlite3_mutex_held(p->db->mutex) );
55403 assert( sqlite3_mutex_held(p->db->mutex) );
55417 assert( sqlite3_mutex_held(p->db->mutex) );
55439 assert( sqlite3_mutex_held(p->db->mutex) );
55454 assert( sqlite3_mutex_held(p->db->mutex) );
55760 if( (pBt->db->flags & SQLITE_RecoveryMode)==0 && nPage>nPageFile ){
55979 pBlock = pBt->pWriter->db;
55984 pBlock = pIter->pBtree->db;
55990 sqlite3ConnectionBlocked(p->db, pBlock);
56018 rc = sqlite3PagerBegin(pBt->pPager,wrflag>1,sqlite3TempInMemory(p->db));
56056 /* If the db-size header field is incorrect (as it may be if an old
56078 rc = sqlite3PagerOpenSavepoint(pBt->pPager, p->db->nSavepoint);
56568 sqlite3 *db = p->db;
56574 if( p->inTrans>TRANS_NONE && db->nVdbeRead>1 ){
56816 assert( iStatement>p->db->nSavepoint );
57374 assert( pCur->pBtree->db==pBt->db );
57526 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
57792 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
57815 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
57891 assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
57943 ** would have already detected db corruption. Similarly, pPage must
58038 && (pIdxKey->errCode!=SQLITE_NOMEM || pCur->pBtree->db->mallocFailed)
61175 sqlite3ConnectionBlocked(p->db, pBt->pCursor->pBtree->db);
62071 assert( p==0 || sqlite3_mutex_held(p->db->mutex) );
62105 assert( sqlite3_mutex_held(p->db->mutex) );
62111 assert( sqlite3_mutex_held(p->db->mutex) );
62153 assert( sqlite3_mutex_held(p->db->mutex) );
62201 assert( sqlite3_mutex_held(pCsr->pBtree->db->mutex) );
62409 pParse->db = pDb;
62445 ** message in database handle db.
62447 static int checkReadTransaction(sqlite3 *db, Btree *p){
62449 sqlite3ErrorWithMsg(db, SQLITE_ERROR, "destination database is in use");
62691 int nSrcPage = -1; /* Size of source db in pages */
62692 int bCloseTrans = 0; /* True if src db requires unlocking */
63076 b.pSrcDb = pFrom->db;
63149 || p->szMalloc==sqlite3DbMallocSize(p->db,p->zMalloc) );
63195 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63230 db, pMem->zMalloc) );
63234 pMem->z = pMem->zMalloc = sqlite3DbReallocOrFree(pMem->db, pMem->z, n);
63237 if( pMem->szMalloc>0 ) sqlite3DbFree(pMem->db, pMem->zMalloc);
63238 pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, n);
63246 pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc);
63296 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63326 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63363 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63391 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63437 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63441 t.db = pMem->db;
63447 if( pMem->szMalloc>0 ) sqlite3DbFree(pMem->db, pMem->zMalloc);
63464 assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) );
63498 sqlite3DbFree(p->db, p->zMalloc);
63564 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63588 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63613 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63638 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63652 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63671 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63698 assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );
63722 assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );
63734 SQLITE_PRIVATE void sqlite3VdbeMemInit(Mem *pMem, sqlite3 *db, u16 flags){
63737 pMem->db = db;
63822 sqlite3 *db = pMem->db;
63823 assert( db!=0 );
63826 pMem->zMalloc = sqlite3DbMallocRaw(db, 64);
63827 if( db->mallocFailed ){
63832 pMem->szMalloc = sqlite3DbMallocSize(db, pMem->zMalloc);
63833 pMem->u.pRowSet = sqlite3RowSetInit(db, pMem->zMalloc, pMem->szMalloc);
63844 assert( p->db!=0 );
63850 return n>p->db->aLimit[SQLITE_LIMIT_LENGTH];
63890 assert( pTo->db==pFrom->db );
63907 assert( pTo->db==pFrom->db );
63929 assert( pFrom->db==0 || sqlite3_mutex_held(pFrom->db->mutex) );
63930 assert( pTo->db==0 || sqlite3_mutex_held(pTo->db->mutex) );
63931 assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db );
63965 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
63974 if( pMem->db ){
63975 iLimit = pMem->db->aLimit[SQLITE_LIMIT_LENGTH];
64013 pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc);
64111 assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
64134 assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
64135 || pVal->db->mallocFailed );
64155 assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
64170 SQLITE_PRIVATE sqlite3_value *sqlite3ValueNew(sqlite3 *db){
64171 Mem *p = sqlite3DbMallocZero(db, sizeof(*p));
64174 p->db = db;
64201 static sqlite3_value *valueNew(sqlite3 *db, struct ValueNewStat4Ctx *p){
64213 pRec = (UnpackedRecord*)sqlite3DbMallocZero(db, nByte);
64218 assert( pRec->pKeyInfo->enc==ENC(db) );
64222 pRec->aMem[i].db = db;
64225 sqlite3DbFree(db, pRec);
64239 return sqlite3ValueNew(db);
64264 sqlite3 *db, /* The database connection */
64286 pFunc = sqlite3FindFunction(db, p->u.zToken, nName, nVal, enc, 0);
64295 apVal = (sqlite3_value**)sqlite3DbMallocZero(db, sizeof(apVal[0]) * nVal);
64301 rc = sqlite3ValueFromExpr(db, pList->a[i].pExpr, enc, aff, &apVal[i]);
64306 pVal = valueNew(db, pCtx);
64339 sqlite3DbFree(db, apVal);
64360 sqlite3 *db, /* The database connection */
64389 rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx);
64410 pVal = valueNew(db, pCtx);
64415 zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken);
64430 if( SQLITE_OK==sqlite3ValueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal)
64445 pVal = valueNew(db, pCtx);
64453 pVal = valueNew(db, pCtx);
64458 sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(db, zVal, nVal), nVal/2,
64465 rc = valueFromFunction(db, pExpr, enc, affinity, &pVal, pCtx);
64473 db->mallocFailed = 1;
64474 sqlite3DbFree(db, zVal);
64495 sqlite3 *db, /* The database connection */
64501 return valueFromExpr(db, pExpr, enc, affinity, ppVal, 0);
64523 sqlite3 *db;
64530 db = sqlite3_context_db_handle(context);
64533 aRet = sqlite3DbMallocRaw(db, nRet);
64541 sqlite3DbFree(db, aRet);
64587 sqlite3 *db = pParse->db;
64593 pVal = valueNew(db, pAlloc);
64604 pVal = valueNew(db, pAlloc);
64608 sqlite3ValueApplyAffinity(pVal, affinity, ENC(db));
64610 pVal->db = pParse->db;
64614 rc = valueFromExpr(db, pExpr, ENC(db), affinity, &pVal, pAlloc);
64617 assert( pVal==0 || pVal->db==db );
64671 assert( pVal==0 || pVal->db==pParse->db );
64704 sqlite3 *db, /* Database handle */
64735 pMem = *ppVal = sqlite3ValueNew(db);
64739 db);
64753 sqlite3 *db = aMem[0].db;
64758 sqlite3DbFree(db, pRec);
64782 sqlite3DbFree(((Mem*)v)->db, v);
64822 sqlite3 *db = pParse->db;
64824 p = sqlite3DbMallocZero(db, sizeof(Vdbe) );
64826 p->db = db;
64827 if( db->pVdbe ){
64828 db->pVdbe->pPrev = p;
64830 p->pNext = db->pVdbe;
64832 db->pVdbe = p;
64851 p->zSql = sqlite3DbStrNDup(p->db, z, n);
64914 pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op));
64916 p->nOpAlloc = sqlite3DbMallocSize(p->db, pNew)/sizeof(Op);
64974 if( p->db->flags & SQLITE_VdbeAddopTrace ){
65037 for(j=0; j<p->db->nDb; j++) sqlite3VdbeUsesBtree(p, j);
65075 p->aLabel = sqlite3DbReallocOrFree(p->db, p->aLabel,
65122 ** sqlite3DbFree(v->db, sIter.apSub);
65164 p->apSub = sqlite3DbReallocOrFree(v->db, p->apSub, nByte);
65220 sqlite3DbFree(v->db, sIter.apSub);
65227 return ( v->db->mallocFailed || hasAbort==mayAbort || hasFkCounter );
65316 sqlite3DbFree(p->db, pParse->aLabel);
65344 assert( aOp && !p->db->mallocFailed );
65393 if( p->db->flags & SQLITE_VdbeAddopTrace ){
65417 aNew = (ScanStatus*)sqlite3DbRealloc(p->db, p->aScan, nByte);
65424 pNew->zName = sqlite3DbStrDup(p->db, zName);
65491 static void freeEphemeralFunction(sqlite3 *db, FuncDef *pDef){
65493 sqlite3DbFree(db, pDef);
65502 static void freeP4(sqlite3 *db, int p4type, void *p4){
65504 assert( db );
65510 sqlite3DbFree(db, p4);
65514 if( db->pnBytesFreed==0 ) sqlite3KeyInfoUnref((KeyInfo*)p4);
65518 if( db->pnBytesFreed==0 ) sqlite3_free(p4);
65522 freeEphemeralFunction(db, (FuncDef*)p4);
65526 if( db->pnBytesFreed==0 ){
65530 if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc);
65531 sqlite3DbFree(db, p);
65536 if( db->pnBytesFreed==0 ) sqlite3VtabUnlock((VTable *)p4);
65548 static void vdbeFreeOpArray(sqlite3 *db, Op *aOp, int nOp){
65552 freeP4(db, pOp->p4type, pOp->p4.p);
65554 sqlite3DbFree(db, pOp->zComment);
65558 sqlite3DbFree(db, aOp);
65577 sqlite3 *db = p->db;
65578 freeP4(db, pOp->p4type, pOp->p4.p);
65617 sqlite3 *db;
65619 db = p->db;
65621 if( p->aOp==0 || db->mallocFailed ){
65623 freeP4(db, n, (void*)*(char**)&zP4);
65636 freeP4(db, pOp->p4type, pOp->p4.p);
65653 assert( ((VTable *)zP4)->db==p->db );
65659 pOp->p4.z = sqlite3DbStrNDup(p->db, zP4, n);
65685 assert( p->aOp==0 || p->aOp[p->nOp-1].zComment==0 || p->db->mallocFailed );
65688 sqlite3DbFree(p->db, p->aOp[p->nOp-1].zComment);
65689 p->aOp[p->nOp-1].zComment = sqlite3VMPrintf(p->db, zFormat, ap);
65741 assert( (addr>=0 && addr<p->nOp) || p->db->mallocFailed );
65742 if( p->db->mallocFailed ){
65951 ** Declare to the Vdbe that the BTree object at db->aDb[i] is used.
65959 assert( i>=0 && i<p->db->nDb && i<(int)sizeof(yDbMask)*8 );
65962 if( i!=1 && sqlite3BtreeSharable(p->db->aDb[i].pBt) ){
65972 ** sets the BtShared.db member of each of the BtShared structures, ensuring
65976 ** sqlite3BtreeEnter() is invoked to set the BtShared.db variables
65991 sqlite3 *db;
65992 Db *aDb;
65995 db = p->db;
65996 aDb = db->aDb;
65997 nDb = db->nDb;
66012 sqlite3 *db;
66013 Db *aDb;
66016 db = p->db;
66017 aDb = db->aDb;
66018 nDb = db->nDb;
66060 sqlite3 *db = p->db;
66061 u8 malloc_failed = db->mallocFailed;
66062 if( db->pnBytesFreed ){
66064 if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc);
66069 assert( (&p[1])==pEnd || p[0].db==p[1].db );
66091 sqlite3DbFree(db, p->zMalloc);
66097 db->mallocFailed = malloc_failed;
66113 sqlite3DbFree(p->v->db, p);
66139 sqlite3 *db = p->db; /* The database connection */
66158 db->mallocFailed = 1;
66194 }else if( db->u1.isInterrupted ){
66197 sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3ErrStr(p->rc));
66260 assert( p->db->mallocFailed );
66276 assert( p->db->mallocFailed );
66287 assert( p->db->mallocFailed );
66416 assert( p->aMem[i].db==p->db );
66458 sqlite3 *db; /* The database connection */
66474 db = p->db;
66475 assert( db->mallocFailed==0 );
66533 p->pFree = sqlite3DbMallocZero(db, nByte);
66537 }while( nByte && !db->mallocFailed );
66545 p->aVar[n].db = db;
66558 p->aMem[n].db = db;
66573 sqlite3VdbeSorterClose(p->db, pCx);
66627 v->db->lastRowid = pFrame->lastRowid;
66629 v->db->nChange = pFrame->nDbChange;
66669 sqlite3 *db = p->db;
66681 sqlite3DbFree(db, p->zErrMsg);
66695 sqlite3 *db = p->db;
66698 sqlite3DbFree(db, p->aColName);
66701 p->aColName = pColName = (Mem*)sqlite3DbMallocZero(db, sizeof(Mem)*n );
66705 pColName->db = p->db;
66731 if( p->db->mallocFailed ){
66744 ** db. If a transaction is active, commit it. If there is a
66748 static int vdbeCommit(sqlite3 *db, Vdbe *p){
66767 rc = sqlite3VtabSync(db, p);
66775 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
66776 Btree *pBt = db->aDb[i].pBt;
66790 if( needXcommit && db->xCommitCallback ){
66791 rc = db->xCommitCallback(db->pCommitArg);
66806 if( 0==sqlite3Strlen30(sqlite3BtreeGetFilename(db->aDb[0].pBt))
66809 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
66810 Btree *pBt = db->aDb[i].pBt;
66821 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
66822 Btree *pBt = db->aDb[i].pBt;
66828 sqlite3VtabCommit(db);
66838 sqlite3_vfs *pVfs = db->pVfs;
66841 char const *zMainFile = sqlite3BtreeGetFilename(db->aDb[0].pBt);
66850 zMaster = sqlite3MPrintf(db, "%s-mjXXXXXX9XXz", zMainFile);
66881 sqlite3DbFree(db, zMaster);
66891 for(i=0; i<db->nDb; i++){
66892 Btree *pBt = db->aDb[i].pBt;
66907 sqlite3DbFree(db, zMaster);
66922 sqlite3DbFree(db, zMaster);
66926 /* Sync all the db files involved in the transaction. The same call
66936 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
66937 Btree *pBt = db->aDb[i].pBt;
66945 sqlite3DbFree(db, zMaster);
66954 sqlite3DbFree(db, zMaster);
66969 for(i=0; i<db->nDb; i++){
66970 Btree *pBt = db->aDb[i].pBt;
66978 sqlite3VtabCommit(db);
66995 static void checkActiveVdbeCnt(sqlite3 *db){
67000 p = db->pVdbe;
67009 assert( cnt==db->nVdbeActive );
67010 assert( nWrite==db->nVdbeWrite );
67011 assert( nRead==db->nVdbeRead );
67028 sqlite3 *const db = p->db;
67034 ** In this case (db->nStatement==0), and there is nothing to do.
67036 if( db->nStatement && p->iStatement ){
67041 assert( db->nStatement>0 );
67042 assert( p->iStatement==(db->nStatement+db->nSavepoint) );
67044 for(i=0; i<db->nDb; i++){
67046 Btree *pBt = db->aDb[i].pBt;
67059 db->nStatement--;
67064 rc = sqlite3VtabSavepoint(db, SAVEPOINT_ROLLBACK, iSavepoint);
67067 rc = sqlite3VtabSavepoint(db, SAVEPOINT_RELEASE, iSavepoint);
67075 db->nDeferredCons = p->nStmtDefCons;
67076 db->nDeferredImmCons = p->nStmtDefImmCons;
67094 sqlite3 *db = p->db;
67095 if( (deferred && (db->nDeferredCons+db->nDeferredImmCons)>0)
67100 sqlite3SetString(&p->zErrMsg, db, "FOREIGN KEY constraint failed");
67122 sqlite3 *db = p->db;
67140 if( p->db->mallocFailed ){
67148 checkActiveVdbeCnt(db);
67184 sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK);
67185 sqlite3CloseSavepoints(db);
67186 db->autoCommit = 1;
67203 if( !sqlite3VtabInSync(db)
67204 && db->autoCommit
67205 && db->nVdbeWrite==(p->readOnly==0)
67220 rc = vdbeCommit(db, p);
67227 sqlite3RollbackAll(db, SQLITE_OK);
67230 db->nDeferredCons = 0;
67231 db->nDeferredImmCons = 0;
67232 db->flags &= ~SQLITE_DeferFKs;
67233 sqlite3CommitInternalChanges(db);
67236 sqlite3RollbackAll(db, SQLITE_OK);
67239 db->nStatement = 0;
67246 sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK);
67247 sqlite3CloseSavepoints(db);
67248 db->autoCommit = 1;
67264 sqlite3DbFree(db, p->zErrMsg);
67267 sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK);
67268 sqlite3CloseSavepoints(db);
67269 db->autoCommit = 1;
67279 sqlite3VdbeSetChanges(db, p->nChange);
67281 sqlite3VdbeSetChanges(db, 0);
67292 db->nVdbeActive--;
67293 if( !p->readOnly ) db->nVdbeWrite--;
67294 if( p->bIsReader ) db->nVdbeRead--;
67295 assert( db->nVdbeActive>=db->nVdbeRead );
67296 assert( db->nVdbeRead>=db->nVdbeWrite );
67297 assert( db->nVdbeWrite>=0 );
67300 checkActiveVdbeCnt(db);
67301 if( p->db->mallocFailed ){
67306 ** by connection db have now been released. Call sqlite3ConnectionUnlocked()
67309 if( db->autoCommit ){
67310 sqlite3ConnectionUnlocked(db);
67313 assert( db->nVdbeActive>0 || db->autoCommit==0 || db->nStatement==0 );
67335 sqlite3 *db = p->db;
67338 u8 mallocFailed = db->mallocFailed;
67340 if( db->pErr==0 ) db->pErr = sqlite3ValueNew(db);
67341 sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, SQLITE_TRANSIENT);
67343 db->mallocFailed = mallocFailed;
67344 db->errCode = rc;
67346 sqlite3Error(db, rc);
67359 assert( v->db
67362 sqlite3GlobalConfig.pSqllogArg, v->db, zExpanded, 1
67364 sqlite3DbFree(v->db, zExpanded);
67384 sqlite3 *db;
67385 db = p->db;
67401 sqlite3DbFree(db, p->zErrMsg);
67409 sqlite3ErrorWithMsg(db, p->rc, p->zErrMsg ? "%s" : 0, p->zErrMsg);
67410 sqlite3DbFree(db, p->zErrMsg);
67456 return p->rc & db->errMask;
67467 assert( (rc & p->db->errMask)==rc );
67501 sqlite3DbFree(pVdbe->db, pAux);
67516 SQLITE_PRIVATE void sqlite3VdbeClearObject(sqlite3 *db, Vdbe *p){
67519 assert( p->db==0 || p->db==db );
67524 vdbeFreeOpArray(db, pSub->aOp, pSub->nOp);
67525 sqlite3DbFree(db, pSub);
67527 for(i=p->nzVar-1; i>=0; i--) sqlite3DbFree(db, p->azVar[i]);
67528 vdbeFreeOpArray(db, p->aOp, p->nOp);
67529 sqlite3DbFree(db, p->aColName);
67530 sqlite3DbFree(db, p->zSql);
67531 sqlite3DbFree(db, p->pFree);
67534 sqlite3DbFree(db, p->aScan[i].zName);
67536 sqlite3DbFree(db, p->aScan);
67544 sqlite3 *db;
67547 db = p->db;
67548 assert( sqlite3_mutex_held(db->mutex) );
67549 sqlite3VdbeClearObject(db, p);
67553 assert( db->pVdbe==p );
67554 db->pVdbe = p->pNext;
67560 p->db = 0;
67561 sqlite3DbFree(db, p);
67712 assert( pMem->db->mallocFailed || flags&(MEM_Str|MEM_Blob) );
68001 p = (UnpackedRecord *)sqlite3DbMallocRaw(pKeyInfo->db, nByte);
68044 pMem->db = pKeyInfo->db;
68082 if( pKeyInfo->db==0 ) return 1;
68084 mem1.db = pKeyInfo->db;
68154 if( pKeyInfo->db->mallocFailed ) return 1;
68217 sqlite3VdbeMemInit(&c1, pMem1->db, MEM_Null);
68218 sqlite3VdbeMemInit(&c2, pMem1->db, MEM_Null);
68393 ** malloc-failed flag set on database handle (pPKey2->pKeyInfo->db).
68507 mem1.db = pKeyInfo->db;
68573 || pKeyInfo->db->mallocFailed
68735 || pPKey2->pKeyInfo->db->mallocFailed
68791 SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){
68810 sqlite3VdbeMemInit(&m, db, 0);
68870 sqlite3 *db, /* Database connection */
68889 sqlite3VdbeMemInit(&m, db, 0);
68901 ** sqlite3_changes() on the database handle 'db'.
68903 SQLITE_PRIVATE void sqlite3VdbeSetChanges(sqlite3 *db, int nChange){
68904 assert( sqlite3_mutex_held(db->mutex) );
68905 db->nChange = nChange;
68906 db->nTotalChange += nChange;
68927 SQLITE_PRIVATE void sqlite3ExpirePreparedStatements(sqlite3 *db){
68929 for(p = db->pVdbe; p; p=p->pNext){
68938 return v->db;
68954 sqlite3_value *pRet = sqlite3ValueNew(v->db);
68986 sqlite3 *db = p->db;
68987 sqlite3DbFree(db, p->zErrMsg);
68988 p->zErrMsg = sqlite3DbStrDup(db, pVtab->zErrMsg);
69033 if( p->db==0 ){
69066 sqlite3 *db = v->db;
69068 sqlite3_mutex_enter(db->mutex);
69070 rc = sqlite3ApiExit(db, rc);
69071 sqlite3LeaveMutexAndCloseZombie(db);
69090 sqlite3_mutex_enter(v->db->mutex);
69093 assert( (rc & (v->db->errMask))==rc );
69094 rc = sqlite3ApiExit(v->db, rc);
69095 sqlite3_mutex_leave(v->db->mutex);
69108 sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;
69253 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69262 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69271 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69275 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69282 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69289 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69293 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69297 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69306 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69316 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69332 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69341 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69350 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69355 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69359 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69376 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69385 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69389 pCtx->pOut->db->mallocFailed = 1;
69396 static int doWalCallbacks(sqlite3 *db){
69400 for(i=0; i<db->nDb; i++){
69401 Btree *pBt = db->aDb[i].pBt;
69407 if( db->xWalCallback && nEntry>0 && rc==SQLITE_OK ){
69408 rc = db->xWalCallback(db->pWalArg, db, db->aDb[i].zName, nEntry);
69426 sqlite3 *db;
69459 db = p->db;
69460 if( db->mallocFailed ){
69475 if( db->nVdbeActive==0 ){
69476 db->u1.isInterrupted = 0;
69479 assert( db->nVdbeWrite>0 || db->autoCommit==0
69480 || (db->nDeferredCons==0 && db->nDeferredImmCons==0)
69484 if( db->xProfile && !db->init.busy ){
69485 sqlite3OsCurrentTimeInt64(db->pVfs, &p->startTime);
69489 db->nVdbeActive++;
69490 if( p->readOnly==0 ) db->nVdbeWrite++;
69491 if( p->bIsReader ) db->nVdbeRead++;
69503 db->nVdbeExec++;
69505 db->nVdbeExec--;
69511 if( rc!=SQLITE_ROW && db->xProfile && !db->init.busy && p->zSql ){
69513 sqlite3OsCurrentTimeInt64(db->pVfs, &iNow);
69514 db->xProfile(db->pProfileArg, p->zSql, (iNow - p->startTime)*1000000);
69520 p->rc = doWalCallbacks(db);
69526 db->errCode = rc;
69527 if( SQLITE_NOMEM==sqlite3ApiExit(p->db, p->rc) ){
69549 return (rc&db->errMask);
69562 sqlite3 *db; /* The database connection */
69567 db = v->db;
69568 sqlite3_mutex_enter(db->mutex);
69588 const char *zErr = (const char *)sqlite3_value_text(db->pErr);
69589 sqlite3DbFree(db, v->zErrMsg);
69590 if( !db->mallocFailed ){
69591 v->zErrMsg = sqlite3DbStrDup(db, zErr);
69598 rc = sqlite3ApiExit(db, rc);
69599 sqlite3_mutex_leave(db->mutex);
69625 return p->pOut->db;
69645 rc = sqlite3OsCurrentTimeInt64(p->pOut->db->pVfs, piTime);
69701 assert( sqlite3_mutex_held(p->pOut->db->mutex) );
69717 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69744 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
69756 pAuxData = sqlite3DbMallocZero(pVdbe->db, sizeof(AuxData));
69840 /* .db = */ 0,
69862 sqlite3_mutex_enter(pVm->db->mutex);
69865 if( pVm && ALWAYS(pVm->db) ){
69866 sqlite3_mutex_enter(pVm->db->mutex);
69867 sqlite3Error(pVm->db, SQLITE_RANGE);
69901 p->rc = sqlite3ApiExit(p->db, p->rc);
69902 sqlite3_mutex_leave(p->db->mutex);
69997 sqlite3 *db;
70006 db = p->db;
70007 assert( db!=0 );
70011 sqlite3_mutex_enter(db->mutex);
70012 assert( db->mallocFailed==0 );
70017 if( db->mallocFailed ){
70018 db->mallocFailed = 0;
70021 sqlite3_mutex_leave(db->mutex);
70130 ** The error code stored in database p->db is overwritten with the return
70138 sqlite3_mutex_enter(p->db->mutex);
70140 sqlite3Error(p->db, SQLITE_MISUSE);
70141 sqlite3_mutex_leave(p->db->mutex);
70147 sqlite3Error(p->db, SQLITE_RANGE);
70148 sqlite3_mutex_leave(p->db->mutex);
70155 sqlite3Error(p->db, SQLITE_OK);
70195 rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));
70197 sqlite3Error(p->db, rc);
70198 rc = sqlite3ApiExit(p->db, rc);
70200 sqlite3_mutex_leave(p->db->mutex);
70240 sqlite3_mutex_leave(p->db->mutex);
70253 sqlite3_mutex_leave(p->db->mutex);
70262 sqlite3_mutex_leave(p->db->mutex);
70339 sqlite3_mutex_leave(p->db->mutex);
70398 assert( pTo->db==pFrom->db );
70400 sqlite3_mutex_enter(pTo->db->mutex);
70404 sqlite3_mutex_leave(pTo->db->mutex);
70444 return pStmt ? ((Vdbe*)pStmt)->db : 0;
70648 sqlite3 *db; /* The database connection */
70658 db = p->db;
70659 sqlite3StrAccumInit(&out, db, zBase, sizeof(zBase),
70660 db->aLimit[SQLITE_LIMIT_LENGTH]);
70661 if( db->nVdbeExec>1 ){
70709 u8 enc = ENC(db);
70713 utf8.db = db;
71243 # define REGISTER_TRACE(R,M) if(db->flags&SQLITE_VdbeTrace)registerTrace(R,M)
71357 ** assert( checkSavepointCount(db) );
71359 static int checkSavepointCount(sqlite3 *db){
71362 for(p=db->pSavepoint; p; p=p->pNext) n++;
71363 assert( n==(db->nSavepoint + db->isTransactionSavepoint) );
71397 sqlite3 *db = p->db; /* The database */
71399 u8 encoding = ENC(db); /* The database encoding */
71411 i64 lastRowid = db->lastRowid; /* Saved value of the last insert ROWID */
71430 db->busyHandler.nBusy = 0;
71431 if( db->u1.isInterrupted ) goto abort_due_to_interrupt;
71434 if( db->xProgress ){
71435 assert( 0 < db->nProgressOps );
71438 nProgressLimit = db->nProgressOps;
71440 nProgressLimit %= (unsigned)db->nProgressOps;
71447 && (p->db->flags & (SQLITE_VdbeListing|SQLITE_VdbeEQP|SQLITE_VdbeTrace))!=0
71452 if( p->db->flags & SQLITE_VdbeListing ){
71458 if( p->db->flags & SQLITE_VdbeEQP ){
71467 if( p->db->flags & SQLITE_VdbeTrace ) printf("VDBE Trace:\n");
71473 if( db->mallocFailed ) goto no_mem;
71485 if( db->flags & SQLITE_VdbeTrace ){
71498 sqlite3_interrupt(db);
71606 if( db->u1.isInterrupted ) goto abort_due_to_interrupt;
71614 if( db->xProgress!=0 && nVmStep>=nProgressLimit ){
71615 assert( db->nProgressOps!=0 );
71616 nProgressLimit = nVmStep + db->nProgressOps - (nVmStep%db->nProgressOps);
71617 if( db->xProgress(db->pProgressArg) ){
71786 sqlite3VdbeSetChanges(db, p->nChange);
71788 lastRowid = db->lastRowid;
71821 sqlite3SetString(&p->zErrMsg, db, "%s constraint failed: %s",
71824 sqlite3SetString(&p->zErrMsg, db, "%s", pOp->p4.z);
71826 sqlite3SetString(&p->zErrMsg, db, "%s constraint failed", zType);
71836 assert( rc==SQLITE_OK || db->nDeferredCons>0 || db->nDeferredImmCons>0 );
71906 sqlite3DbFree(db, pOp->p4.z);
71913 if( pOp->p1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
72142 if( db->xProgress!=0
72144 && db->xProgress(db->pProgressArg)!=0
72155 assert( db->flags&SQLITE_CountRows );
72175 assert( p->iStatement==0 || db->flags&SQLITE_CountRows );
72197 if( db->mallocFailed ) goto no_mem;
72234 if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
72451 db->lastRowid = lastRowid;
72453 lastRowid = db->lastRowid; /* Remember rowid changes made by xFunc */
72458 sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3_value_text(ctx.pOut));
72816 if( db->mallocFailed ) goto no_mem;
73223 if( pC->payloadSize > (u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
73547 if( nByte+nZero>db->aLimit[SQLITE_LIMIT_LENGTH] ){
73634 assert( db->pSavepoint==0 || db->autoCommit==0 );
73636 assert( db->pSavepoint || db->isTransactionSavepoint==0 );
73637 assert( checkSavepointCount(db) );
73641 if( db->nVdbeWrite>0 ){
73645 sqlite3SetString(&p->zErrMsg, db, "cannot open savepoint - "
73655 ** that the db->aVTrans[] array is empty. */
73656 assert( db->autoCommit==0 || db->nVTrans==0 );
73657 rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN,
73658 db->nStatement+db->nSavepoint);
73663 pNew = sqlite3DbMallocRaw(db, sizeof(Savepoint)+nName+1);
73670 if( db->autoCommit ){
73671 db->autoCommit = 0;
73672 db->isTransactionSavepoint = 1;
73674 db->nSavepoint++;
73678 pNew->pNext = db->pSavepoint;
73679 db->pSavepoint = pNew;
73680 pNew->nDeferredCons = db->nDeferredCons;
73681 pNew->nDeferredImmCons = db->nDeferredImmCons;
73690 pSavepoint = db->pSavepoint;
73697 sqlite3SetString(&p->zErrMsg, db, "no such savepoint: %s", zName);
73699 }else if( db->nVdbeWrite>0 && p1==SAVEPOINT_RELEASE ){
73703 sqlite3SetString(&p->zErrMsg, db,
73713 int isTransaction = pSavepoint->pNext==0 && db->isTransactionSavepoint;
73718 db->autoCommit = 1;
73721 db->autoCommit = 0;
73725 db->isTransactionSavepoint = 0;
73729 iSavepoint = db->nSavepoint - iSavepoint - 1;
73731 isSchemaChange = (db->flags & SQLITE_InternChanges)!=0;
73732 for(ii=0; ii<db->nDb; ii++){
73733 rc = sqlite3BtreeTripAllCursors(db->aDb[ii].pBt,
73741 for(ii=0; ii<db->nDb; ii++){
73742 rc = sqlite3BtreeSavepoint(db->aDb[ii].pBt, p1, iSavepoint);
73748 sqlite3ExpirePreparedStatements(db);
73749 sqlite3ResetAllSchemasOfConnection(db);
73750 db->flags = (db->flags | SQLITE_InternChanges);
73756 while( db->pSavepoint!=pSavepoint ){
73757 pTmp = db->pSavepoint;
73758 db->pSavepoint = pTmp->pNext;
73759 sqlite3DbFree(db, pTmp);
73760 db->nSavepoint--;
73768 assert( pSavepoint==db->pSavepoint );
73769 db->pSavepoint = pSavepoint->pNext;
73770 sqlite3DbFree(db, pSavepoint);
73772 db->nSavepoint--;
73775 db->nDeferredCons = pSavepoint->nDeferredCons;
73776 db->nDeferredImmCons = pSavepoint->nDeferredImmCons;
73780 rc = sqlite3VtabSavepoint(db, p1, iSavepoint);
73805 turnOnAC = desiredAutoCommit && !db->autoCommit;
73808 assert( db->nVdbeActive>0 ); /* At least this one VM is active */
73812 if( turnOnAC && iRollback && db->nVdbeActive>1 ){
73817 sqlite3SetString(&p->zErrMsg, db, "cannot rollback transaction - "
73822 if( turnOnAC && !iRollback && db->nVdbeWrite>0 ){
73826 sqlite3SetString(&p->zErrMsg, db, "cannot commit transaction - "
73829 }else if( desiredAutoCommit!=db->autoCommit ){
73832 sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK);
73833 db->autoCommit = 1;
73837 db->autoCommit = (u8)desiredAutoCommit;
73840 db->autoCommit = (u8)(1-desiredAutoCommit);
73845 assert( db->nStatement==0 );
73846 sqlite3CloseSavepoints(db);
73854 sqlite3SetString(&p->zErrMsg, db,
73905 assert( pOp->p1>=0 && pOp->p1<db->nDb );
73907 if( pOp->p2 && (db->flags & SQLITE_QueryOnly)!=0 ){
73911 pBt = db->aDb[pOp->p1].pBt;
73925 && (db->autoCommit==0 || db->nVdbeRead>1)
73929 assert( db->nStatement>=0 && db->nSavepoint>=0 );
73930 db->nStatement++;
73931 p->iStatement = db->nSavepoint + db->nStatement;
73934 rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN, p->iStatement-1);
73942 p->nStmtDefCons = db->nDeferredCons;
73943 p->nStmtDefImmCons = db->nDeferredImmCons;
73953 iGen = db->aDb[pOp->p1].pSchema->iGeneration;
73959 sqlite3DbFree(db, p->zErrMsg);
73960 p->zErrMsg = sqlite3DbStrDup(db, "database schema has changed");
73974 if( db->aDb[pOp->p1].pSchema->schema_cookie!=iMeta ){
73975 sqlite3ResetOneSchema(db, pOp->p1);
74004 assert( iDb>=0 && iDb<db->nDb );
74005 assert( db->aDb[iDb].pBt!=0 );
74008 sqlite3BtreeGetMeta(db->aDb[iDb].pBt, iCookie, (u32 *)&iMeta);
74025 Db *pDb;
74027 assert( pOp->p1>=0 && pOp->p1<db->nDb );
74030 pDb = &db->aDb[pOp->p1];
74032 assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
74040 db->flags |= SQLITE_InternChanges;
74048 sqlite3ExpirePreparedStatements(db);
74127 Db *pDb;
74156 assert( iDb>=0 && iDb<db->nDb );
74158 pDb = &db->aDb[iDb];
74163 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
74189 assert( pKeyInfo->enc==ENC(db) );
74190 assert( pKeyInfo->db==db );
74262 rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pCx->pBt,
74279 assert( pKeyInfo->db==db );
74280 assert( pKeyInfo->enc==ENC(db) );
74312 assert( pCx->pKeyInfo->db==db );
74313 assert( pCx->pKeyInfo->enc==ENC(db) );
74314 rc = sqlite3VdbeSorterInit(db, pOp->p3, pCx);
74752 sqlite3DbFree(db, pFree);
75051 if( pOp->p5 & OPFLAG_LASTROWID ) db->lastRowid = lastRowid = iKey;
75072 if( rc==SQLITE_OK && db->xUpdateCallback && pOp->p4.z ){
75073 zDb = db->aDb[pC->iDb].zName;
75077 db->xUpdateCallback(db->pUpdateArg, op, zDb, zTbl, iKey);
75127 if( rc==SQLITE_OK && db->xUpdateCallback && pOp->p4.z && pC->isTable ){
75128 db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE,
75129 db->aDb[pC->iDb].zName, pOp->p4.z, pC->movetoTarget);
75143 sqlite3VdbeSetChanges(db, p->nChange);
75267 db->aLimit[SQLITE_LIMIT_LENGTH] ){
75274 if( n>(u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
75535 rc = sqlite3VdbeSorterNext(db, pC, &res);
75708 rc = sqlite3VdbeIdxRowid(db, pCrsr, &rowid);
75792 rc = sqlite3VdbeIdxKeyCompare(db, pC, &r, &res);
75833 if( db->nVdbeRead > db->nVDestroy+1 ){
75840 rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved);
75845 sqlite3RootPageMoved(db, iDb, iMoved, pOp->p1);
75880 db->aDb[pOp->p2].pBt, pOp->p1, (pOp->p3 ? &nChange : 0)
75908 sqlite3VdbeSorterReset(db, pC->pSorter);
75944 Db *pDb;
75948 assert( pOp->p1>=0 && pOp->p1<db->nDb );
75951 pDb = &db->aDb[pOp->p1];
75983 for(iDb=0; iDb<db->nDb; iDb++){
75984 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
75989 assert( iDb>=0 && iDb<db->nDb );
75990 assert( DbHasProperty(db, iDb, DB_SchemaLoaded) );
75993 initData.db = db;
75996 zSql = sqlite3MPrintf(db,
75998 db->aDb[iDb].zName, zMaster, pOp->p4.z);
76002 assert( db->init.busy==0 );
76003 db->init.busy = 1;
76005 assert( !db->mallocFailed );
76006 rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
76008 sqlite3DbFree(db, zSql);
76009 db->init.busy = 0;
76012 if( rc ) sqlite3ResetAllSchemasOfConnection(db);
76027 assert( pOp->p1>=0 && pOp->p1<db->nDb );
76028 rc = sqlite3AnalysisLoad(db, pOp->p1);
76042 sqlite3UnlinkAndDeleteTable(db, pOp->p1, pOp->p4.z);
76055 sqlite3UnlinkAndDeleteIndex(db, pOp->p1, pOp->p4.z);
76068 sqlite3UnlinkAndDeleteTrigger(db, pOp->p1, pOp->p4.z);
76105 aRoot = sqlite3DbMallocRaw(db, sizeof(int)*(nRoot+1) );
76116 assert( pOp->p5<db->nDb );
76118 z = sqlite3BtreeIntegrityCheck(db->aDb[pOp->p5].pBt, aRoot, nRoot,
76120 sqlite3DbFree(db, aRoot);
76285 if( p->nFrame>=db->aLimit[SQLITE_LIMIT_TRIGGER_DEPTH] ){
76287 sqlite3SetString(&p->zErrMsg, db, "too many levels of trigger recursion");
76306 pFrame = sqlite3DbMallocZero(db, nByte);
76334 pMem->db = db;
76347 pFrame->nDbChange = p->db->nChange;
76401 if( db->flags & SQLITE_DeferFKs ){
76402 db->nDeferredImmCons += pOp->p2;
76404 db->nDeferredCons += pOp->p2;
76425 VdbeBranchTaken(db->nDeferredCons==0 && db->nDeferredImmCons==0, 2);
76426 if( db->nDeferredCons==0 && db->nDeferredImmCons==0 ) goto jump_to_p2;
76428 VdbeBranchTaken(p->nFkConstraint==0 && db->nDeferredImmCons==0, 2);
76429 if( p->nFkConstraint==0 && db->nDeferredImmCons==0 ) goto jump_to_p2;
76582 sqlite3VdbeMemInit(&t, db, MEM_Null);
76590 sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3_value_text(&t));
76622 sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3_value_text(pMem));
76657 rc = sqlite3Checkpoint(db, pOp->p1, pOp->p2, &aRes[1], &aRes[2]);
76700 assert( pOp->p1>=0 && pOp->p1<db->nDb );
76703 pBt = db->aDb[pOp->p1].pBt;
76725 if( !db->autoCommit || db->nVdbeRead>1 ){
76727 sqlite3SetString(&p->zErrMsg, db,
76784 rc = sqlite3RunVacuum(&p->zErrMsg, db);
76799 assert( pOp->p1>=0 && pOp->p1<db->nDb );
76802 pBt = db->aDb[pOp->p1].pBt;
76825 sqlite3ExpirePreparedStatements(db);
76850 if( isWriteLock || 0==(db->flags&SQLITE_ReadUncommitted) ){
76852 assert( p1>=0 && p1<db->nDb );
76855 rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock);
76858 sqlite3SetString(&p->zErrMsg, db, "database table is locked: %s", z);
76878 rc = sqlite3VtabBegin(db, pVTab);
76895 sMem.db = db;
76903 assert( zTab || db->mallocFailed );
76905 rc = sqlite3VtabCallCreate(db, pOp->p1, zTab, &p->zErrMsg);
76919 db->nVDestroy++;
76920 rc = sqlite3VtabCallDestroy(db, pOp->p1, pOp->p4.z);
76921 db->nVDestroy--;
76960 assert( db->mallocFailed );
77204 u8 vtabOnConflict = db->vtabOnConflict;
77213 db->vtabOnConflict = pOp->p5;
77215 db->vtabOnConflict = vtabOnConflict;
77219 db->lastRowid = lastRowid = rowid;
77242 pOut->u.i = sqlite3BtreeLastPage(db->aDb[pOp->p1].pBt);
77262 pBt = db->aDb[pOp->p1].pBt;
77291 if( db->xTrace
77296 db->xTrace(db->pTraceArg, z);
77297 sqlite3DbFree(db, z);
77303 for(i=0; i<db->nDb; i++){
77305 sqlite3_file_control(db, db->aDb[i].zName, SQLITE_FCNTL_TRACE, zTrace);
77310 if( (db->flags & SQLITE_SqlTrace)!=0
77363 if( db->flags & SQLITE_VdbeTrace ){
77386 if( rc==SQLITE_IOERR_NOMEM ) db->mallocFailed = 1;
77389 sqlite3ResetOneSchema(db, resetSchemaOnFault-1);
77396 db->lastRowid = lastRowid;
77406 sqlite3SetString(&p->zErrMsg, db, "string or blob too big");
77413 db->mallocFailed = 1;
77414 sqlite3SetString(&p->zErrMsg, db, "out of memory");
77423 if( db->mallocFailed ) rc = SQLITE_NOMEM;
77425 sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3ErrStr(rc));
77433 assert( db->u1.isInterrupted );
77436 sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3ErrStr(rc));
77472 sqlite3 *db; /* The associated database */
77510 zErr = sqlite3MPrintf(p->db, "cannot open value of type %s",
77530 zErr = sqlite3MPrintf(p->db, "no such rowid: %lld", iRow);
77533 zErr = sqlite3MPrintf(p->db, "%s", sqlite3_errmsg(p->db));
77548 sqlite3* db, /* The database connection */
77560 ** db/table/row entry. The reason for using a vdbe program instead
77603 if( !sqlite3SafetyCheckOk(db) || zTable==0 ){
77609 sqlite3_mutex_enter(db->mutex);
77611 pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob));
77613 pParse = sqlite3StackAllocRaw(db, sizeof(*pParse));
77618 pParse->db = db;
77619 sqlite3DbFree(db, zErr);
77622 sqlite3BtreeEnterAll(db);
77640 sqlite3DbFree(db, zErr);
77645 sqlite3BtreeLeaveAll(db);
77656 sqlite3DbFree(db, zErr);
77657 zErr = sqlite3MPrintf(db, "no such column: \"%s\"", zColumn);
77659 sqlite3BtreeLeaveAll(db);
77671 if( db->flags&SQLITE_ForeignKeys ){
77696 sqlite3DbFree(db, zErr);
77697 zErr = sqlite3MPrintf(db, "cannot open %s column for writing", zFault);
77699 sqlite3BtreeLeaveAll(db);
77705 assert( pBlob->pStmt || db->mallocFailed );
77708 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
77745 if( !db->mallocFailed ){
77755 pBlob->db = db;
77756 sqlite3BtreeLeaveAll(db);
77757 if( db->mallocFailed ){
77765 if( rc==SQLITE_OK && db->mallocFailed==0 ){
77769 sqlite3DbFree(db, pBlob);
77771 sqlite3ErrorWithMsg(db, rc, (zErr ? "%s" : 0), zErr);
77772 sqlite3DbFree(db, zErr);
77774 sqlite3StackFree(db, pParse);
77775 rc = sqlite3ApiExit(db, rc);
77776 sqlite3_mutex_leave(db->mutex);
77787 sqlite3 *db;
77790 db = p->db;
77791 sqlite3_mutex_enter(db->mutex);
77793 sqlite3DbFree(db, p);
77794 sqlite3_mutex_leave(db->mutex);
77814 sqlite3 *db;
77817 db = p->db;
77818 sqlite3_mutex_enter(db->mutex);
77833 assert( db == v->db );
77844 sqlite3Error(db, rc);
77845 rc = sqlite3ApiExit(db, rc);
77846 sqlite3_mutex_leave(db->mutex);
77888 sqlite3 *db;
77891 db = p->db;
77892 sqlite3_mutex_enter(db->mutex);
77903 sqlite3ErrorWithMsg(db, rc, (zErr ? "%s" : 0), zErr);
77904 sqlite3DbFree(db, zErr);
77909 rc = sqlite3ApiExit(db, rc);
77911 sqlite3_mutex_leave(db->mutex);
78240 sqlite3 *db; /* Database connection */
78531 if( pFile->iEof<=(i64)(pTask->pSorter->db->nMaxSorterMmap) ){
78844 sqlite3 *db, /* Database connection (for malloc()) */
78852 KeyInfo *pKeyInfo; /* Copy of pCsr->pKeyInfo with db==0 */
78864 if( sqlite3TempInMemory(db) || sqlite3GlobalConfig.bCoreMutex==0 ){
78867 nWorker = db->aLimit[SQLITE_LIMIT_WORKER_THREADS];
78883 pSorter = (VdbeSorter*)sqlite3DbMallocZero(db, sz + szKeyInfo);
78890 pKeyInfo->db = 0;
78895 pSorter->pgsz = pgsz = sqlite3BtreeGetPageSize(db->aDb[0].pBt);
78899 pSorter->db = db;
78905 if( !sqlite3TempInMemory(db) ){
78908 mxCache = db->aDb[0].pSchema->cache_size;
78925 && (pKeyInfo->aColl[0]==0 || pKeyInfo->aColl[0]==db->pDfltColl)
78938 static void vdbeSorterRecordFree(sqlite3 *db, SorterRecord *pRecord){
78943 sqlite3DbFree(db, p);
78951 static void vdbeSortSubtaskCleanup(sqlite3 *db, SortSubtask *pTask){
78952 sqlite3DbFree(db, pTask->pUnpacked);
78977 sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t);
78991 sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t);
79001 sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t);
79134 SQLITE_PRIVATE void sqlite3VdbeSorterReset(sqlite3 *db, VdbeSorter *pSorter){
79141 sqlite3DbFree(db, pSorter->pReader);
79149 vdbeSortSubtaskCleanup(db, pTask);
79160 sqlite3DbFree(db, pSorter->pUnpacked);
79167 SQLITE_PRIVATE void sqlite3VdbeSorterClose(sqlite3 *db, VdbeCursor *pCsr){
79170 sqlite3VdbeSorterReset(db, pSorter);
79172 sqlite3DbFree(db, pSorter);
79187 static void vdbeSorterExtendFile(sqlite3 *db, sqlite3_file *pFd, i64 nByte){
79188 if( nByte<=(i64)(db->nMaxSorterMmap) && pFd->pMethods->iVersion>=3 ){
79207 sqlite3 *db, /* Database handle doing sort */
79213 rc = sqlite3OsOpenMalloc(db->pVfs, 0, ppFd,
79222 vdbeSorterExtendFile(db, *ppFd, nExtend);
79452 sqlite3 *db = pTask->pSorter->db;
79468 rc = vdbeSorterOpenTempFile(db, 0, &pTask->file.pFd);
79476 vdbeSorterExtendFile(db, pTask->file.pFd, pTask->file.iEof+pList->szPMA+9);
80082 sqlite3 *db = pTask->pSorter->db;
80096 rc = vdbeSorterOpenTempFile(db, mxSz, &pIncr->aFile[0].pFd);
80098 rc = vdbeSorterOpenTempFile(db, mxSz, &pIncr->aFile[1].pFd);
80105 rc = vdbeSorterOpenTempFile(db, pTask->file2.iEof, &pTask->file2.pFd);
80393 sqlite3 *db = pTask0->pSorter->db;
80411 pReadr = (PmaReader*)sqlite3DbMallocZero(db, sizeof(PmaReader));
80516 SQLITE_PRIVATE int sqlite3VdbeSorterNext(sqlite3 *db, const VdbeCursor *pCsr, int *pbEof){
80540 if( pSorter->list.aMemory==0 ) vdbeSorterRecordFree(db, pFree);
81411 sqlite3 *db; /* The database connection */
81416 db = pParse->db;
81417 pDup = sqlite3ExprDup(db, pOrig, 0);
81437 ** sqlite3DbFree(db, pDup) on the last line of this block, so be sure to
81441 sqlite3ExprDelete(db, pExpr);
81445 pExpr->u.zToken = sqlite3DbStrDup(db, pExpr->u.zToken);
81448 sqlite3DbFree(db, pDup);
81504 ** pExpr->iDb Set the index in db->aDb[] of the database X
81537 sqlite3 *db = pParse->db; /* The database connection */
81569 for(i=0; i<db->nDb; i++){
81570 assert( db->aDb[i].zName );
81571 if( sqlite3StrICmp(db->aDb[i].zName,zDb)==0 ){
81572 pSchema = db->aDb[i].pSchema;
81815 sqlite3ExprDelete(db, pExpr->pLeft);
81817 sqlite3ExprDelete(db, pExpr->pRight);
81844 SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){
81845 Expr *p = sqlite3ExprAlloc(db, TK_COLUMN, 0, 0);
82004 u8 enc = ENC(pParse->db); /* The database encoding */
82010 pDef = sqlite3FindFunction(pParse->db, zId, nId, n, enc, 0);
82012 pDef = sqlite3FindFunction(pParse->db, zId, nId, -2, enc, 0);
82063 }else if( no_such_func && pParse->db->init.busy==0 ){
82119 return (pParse->nErr || pParse->db->mallocFailed) ? WRC_Abort : WRC_Continue;
82181 sqlite3 *db; /* Database connection */
82183 u8 savedSuppErr; /* Saved value of db->suppressErr */
82196 db = pParse->db;
82197 savedSuppErr = db->suppressErr;
82198 db->suppressErr = 1;
82200 db->suppressErr = savedSuppErr;
82253 sqlite3 *db;
82258 db = pParse->db;
82260 if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
82291 pDup = sqlite3ExprDup(db, pE, 0);
82292 if( !db->mallocFailed ){
82296 sqlite3ExprDelete(db, pDup);
82302 Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
82315 sqlite3ExprDelete(db, pE);
82351 sqlite3 *db = pParse->db;
82355 if( pOrderBy==0 || pParse->db->mallocFailed ) return 0;
82357 if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
82463 sqlite3 *db; /* Database connection */
82472 db = pParse->db;
82484 return (pParse->nErr || db->mallocFailed) ? WRC_Abort : WRC_Prune;
82538 if( pParse->nErr || db->mallocFailed ) return WRC_Abort;
82626 if( db->mallocFailed ){
82636 if( resolveOrderGroupBy(&sNC, p, pGroupBy, "GROUP") || db->mallocFailed ){
82887 ** If a memory allocation error occurs, that fact is recorded in pParse->db
82897 Expr *pNew = sqlite3ExprAlloc(pParse->db, TK_COLLATE, pCollName, dequote);
82943 sqlite3 *db = pParse->db;
82954 pColl = sqlite3GetCollSeq(pParse, ENC(db), 0, p->u.zToken);
82966 pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
83142 int mxHeight = pParse->db->aLimit[SQLITE_LIMIT_EXPR_DEPTH];
83269 sqlite3 *db, /* Handle for sqlite3DbMallocZero() (may be null) */
83285 pNew = sqlite3DbMallocZero(db, sizeof(Expr)+nExtra);
83318 sqlite3 *db, /* Handle for sqlite3DbMallocZero() (may be null) */
83325 return sqlite3ExprAlloc(db, op, &x, 0);
83335 sqlite3 *db,
83341 assert( db->mallocFailed );
83342 sqlite3ExprDelete(db, pLeft);
83343 sqlite3ExprDelete(db, pRight);
83361 ** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
83374 p = sqlite3ExprAnd(pParse->db, pLeft, pRight);
83376 p = sqlite3ExprAlloc(pParse->db, op, pToken, 1);
83377 sqlite3ExprAttachSubtrees(pParse->db, p, pLeft, pRight);
83420 SQLITE_PRIVATE Expr *sqlite3ExprAnd(sqlite3 *db, Expr *pLeft, Expr *pRight){
83426 sqlite3ExprDelete(db, pLeft);
83427 sqlite3ExprDelete(db, pRight);
83428 return sqlite3ExprAlloc(db, TK_INTEGER, &sqlite3IntTokens[0], 0);
83430 Expr *pNew = sqlite3ExprAlloc(db, TK_AND, 0, 0);
83431 sqlite3ExprAttachSubtrees(db, pNew, pLeft, pRight);
83442 sqlite3 *db = pParse->db;
83444 pNew = sqlite3ExprAlloc(db, TK_FUNCTION, pToken, 1);
83446 sqlite3ExprListDelete(db, pList); /* Avoid memory leak when malloc fails */
83472 sqlite3 *db = pParse->db;
83495 testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]-1 );
83496 testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] );
83497 if( bOk==0 || i<1 || i>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
83499 db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]);
83522 a = sqlite3DbRealloc(db, pParse->azVar, x*sizeof(a[0]));
83523 if( a==0 ) return; /* Error reported through db->mallocFailed */
83529 sqlite3DbFree(db, pParse->azVar[x-1]);
83530 pParse->azVar[x-1] = sqlite3DbStrNDup(db, z, n);
83534 if( !pParse->nErr && pParse->nVar>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
83542 SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3 *db, Expr *p){
83549 sqlite3ExprDelete(db, p->pLeft);
83550 sqlite3ExprDelete(db, p->pRight);
83551 if( ExprHasProperty(p, EP_MemToken) ) sqlite3DbFree(db, p->u.zToken);
83553 sqlite3SelectDelete(db, p->x.pSelect);
83555 sqlite3ExprListDelete(db, p->x.pList);
83559 sqlite3DbFree(db, p);
83675 static Expr *exprDup(sqlite3 *db, Expr *p, int flags, u8 **pzBuffer){
83689 zAlloc = sqlite3DbMallocRaw(db, dupedExprSize(p, flags));
83730 pNew->x.pSelect = sqlite3SelectDup(db, p->x.pSelect, isReduced);
83732 pNew->x.pList = sqlite3ExprListDup(db, p->x.pList, isReduced);
83740 pNew->pLeft = exprDup(db, p->pLeft, EXPRDUP_REDUCE, &zAlloc);
83741 pNew->pRight = exprDup(db, p->pRight, EXPRDUP_REDUCE, &zAlloc);
83748 pNew->pLeft = sqlite3ExprDup(db, p->pLeft, 0);
83749 pNew->pRight = sqlite3ExprDup(db, p->pRight, 0);
83761 ** and the db->mallocFailed flag set.
83764 static With *withDup(sqlite3 *db, With *p){
83768 pRet = sqlite3DbMallocZero(db, nByte);
83773 pRet->a[i].pSelect = sqlite3SelectDup(db, p->a[i].pSelect, 0);
83774 pRet->a[i].pCols = sqlite3ExprListDup(db, p->a[i].pCols, 0);
83775 pRet->a[i].zName = sqlite3DbStrDup(db, p->a[i].zName);
83802 SQLITE_PRIVATE Expr *sqlite3ExprDup(sqlite3 *db, Expr *p, int flags){
83803 return exprDup(db, p, flags, 0);
83805 SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p, int flags){
83810 pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
83814 pNew->a = pItem = sqlite3DbMallocRaw(db, i*sizeof(p->a[0]) );
83816 sqlite3DbFree(db, pNew);
83822 pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags);
83823 pItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
83824 pItem->zSpan = sqlite3DbStrDup(db, pOldItem->zSpan);
83841 SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){
83847 pNew = sqlite3DbMallocRaw(db, nByte );
83855 pNewItem->zDatabase = sqlite3DbStrDup(db, pOldItem->zDatabase);
83856 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
83857 pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias);
83865 pNewItem->zIndex = sqlite3DbStrDup(db, pOldItem->zIndex);
83872 pNewItem->pSelect = sqlite3SelectDup(db, pOldItem->pSelect, flags);
83873 pNewItem->pOn = sqlite3ExprDup(db, pOldItem->pOn, flags);
83874 pNewItem->pUsing = sqlite3IdListDup(db, pOldItem->pUsing);
83879 SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){
83883 pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
83886 pNew->a = sqlite3DbMallocRaw(db, p->nId*sizeof(p->a[0]) );
83888 sqlite3DbFree(db, pNew);
83897 pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
83902 SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){
83905 pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
83907 pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags);
83908 pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags);
83909 pNew->pWhere = sqlite3ExprDup(db, p->pWhere, flags);
83910 pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy, flags);
83911 pNew->pHaving = sqlite3ExprDup(db, p->pHaving, flags);
83912 pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, flags);
83914 pNew->pPrior = pPrior = sqlite3SelectDup(db, p->pPrior, flags);
83917 pNew->pLimit = sqlite3ExprDup(db, p->pLimit, flags);
83918 pNew->pOffset = sqlite3ExprDup(db, p->pOffset, flags);
83925 pNew->pWith = withDup(db, p->pWith);
83930 SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){
83950 sqlite3 *db = pParse->db;
83952 pList = sqlite3DbMallocZero(db, sizeof(ExprList) );
83956 pList->a = sqlite3DbMallocRaw(db, sizeof(pList->a[0]));
83961 a = sqlite3DbRealloc(db, pList->a, pList->nExpr*2*sizeof(pList->a[0]));
83977 sqlite3ExprDelete(db, pExpr);
83978 sqlite3ExprListDelete(db, pList);
83987 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
83996 assert( pList!=0 || pParse->db->mallocFailed!=0 );
84002 pItem->zName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n);
84012 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
84020 sqlite3 *db = pParse->db;
84021 assert( pList!=0 || db->mallocFailed!=0 );
84025 assert( db->mallocFailed || pItem->pExpr==pSpan->pExpr );
84026 sqlite3DbFree(db, pItem->zSpan);
84027 pItem->zSpan = sqlite3DbStrNDup(db, (char*)pSpan->zStart,
84041 int mx = pParse->db->aLimit[SQLITE_LIMIT_COLUMN];
84052 SQLITE_PRIVATE void sqlite3ExprListDelete(sqlite3 *db, ExprList *pList){
84058 sqlite3ExprDelete(db, pItem->pExpr);
84059 sqlite3DbFree(db, pItem->zName);
84060 sqlite3DbFree(db, pItem->zSpan);
84062 sqlite3DbFree(db, pList->a);
84063 sqlite3DbFree(db, pList);
84517 sqlite3 *db = pParse->db; /* Database connection */
84532 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
84565 && sqlite3FindCollSeq(db, ENC(db), pIdx->azColl[0], 0)==pReq
84682 pParse->db, "EXECUTE %s%s SUBQUERY %d", jmpIfDynamic>=0?"":"CORRELATED ",
84713 pKeyInfo = isRowid ? 0 : sqlite3KeyInfoAlloc(pParse->db, 1, 1);
84837 sqlite3ExprDelete(pParse->db, pSel->pLimit);
85131 assert( iReg>0 || pParse->nErr || pParse->db->mallocFailed );
85138 if( OptimizationDisabled(pParse->db, SQLITE_ColumnCache) ) return;
85210 if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
85227 if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
85326 if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
85403 sqlite3 *db = pParse->db; /* The database connection */
85408 assert( pParse->db->mallocFailed );
85650 u8 enc = ENC(db); /* The text encoding used by this database */
85663 pDef = sqlite3FindFunction(db, zId, nId, nFarg, enc, 0);
85755 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr);
85757 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr);
85761 if( !pColl ) pColl = db->pDfltColl;
85970 assert( db->mallocFailed || pParse->nErr>0
86021 pExpr = sqlite3ExprDup(pParse->db, pExpr, 0);
86090 assert( pParse->pVdbe || pParse->db->mallocFailed );
86981 static int addAggInfoColumn(sqlite3 *db, AggInfo *pInfo){
86984 db,
86997 static int addAggInfoFunc(sqlite3 *db, AggInfo *pInfo){
87000 db,
87049 && (k = addAggInfoColumn(pParse->db, pAggInfo))>=0
87107 u8 enc = ENC(pParse->db);
87108 i = addAggInfoFunc(pParse->db, pAggInfo);
87115 pItem->pFunc = sqlite3FindFunction(pParse->db,
87296 sqlite3 *db = sqlite3_context_db_handle(context);
87325 zRet = sqlite3MPrintf(db, "%.*s\"%w\"%s", (int)(((u8*)tname.z) - zSql),
87352 sqlite3 *db = sqlite3_context_db_handle(context);
87375 zParent = sqlite3DbStrNDup(db, (const char *)z, n);
87379 char *zOut = sqlite3MPrintf(db, "%s%.*s\"%w\"",
87382 sqlite3DbFree(db, zOutput);
87386 sqlite3DbFree(db, zParent);
87390 zResult = sqlite3MPrintf(db, "%s%s", (zOutput?zOutput:""), zInput),
87392 sqlite3DbFree(db, zOutput);
87418 sqlite3 *db = sqlite3_context_db_handle(context);
87466 zRet = sqlite3MPrintf(db, "%.*s\"%w\"%s", (int)(((u8*)tname.z) - zSql),
87511 static char *whereOrName(sqlite3 *db, char *zWhere, char *zConstant){
87514 zNew = sqlite3MPrintf(db, "name=%Q", zConstant);
87516 zNew = sqlite3MPrintf(db, "%s OR name=%Q", zWhere, zConstant);
87517 sqlite3DbFree(db, zWhere);
87533 zWhere = whereOrName(pParse->db, zWhere, p->pFrom->zName);
87548 const Schema *pTempSchema = pParse->db->aDb[1].pSchema; /* Temp db schema */
87550 /* If the table is not located in the temp-db (in which case NULL is
87552 ** that is not part of the temp-db schema, add a clause to the WHERE
87556 sqlite3 *db = pParse->db;
87559 zWhere = whereOrName(db, zWhere, pTrig->zName);
87564 char *zNew = sqlite3MPrintf(pParse->db, "type='trigger' AND (%s)", zWhere);
87565 sqlite3DbFree(pParse->db, zWhere);
87589 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
87590 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
87596 int iTrigDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
87606 zWhere = sqlite3MPrintf(pParse->db, "tbl_name=%Q", zName);
87649 sqlite3 *db = pParse->db; /* Database connection */
87657 int savedDbFlags; /* Saved value of db->flags */
87659 savedDbFlags = db->flags;
87660 if( NEVER(db->mallocFailed) ) goto exit_rename_table;
87662 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
87666 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
87667 zDb = db->aDb[iDb].zName;
87668 db->flags |= SQLITE_PreferBuiltin;
87671 zName = sqlite3NameFromToken(db, pName);
87677 if( sqlite3FindTable(db, zName, zDb) || sqlite3FindIndex(db, zName, zDb) ){
87712 pVTab = sqlite3GetVTable(db, pTab);
87750 if( db->flags&SQLITE_ForeignKeys ){
87759 sqlite3DbFree(db, zWhere);
87793 if( sqlite3FindTable(db, "sqlite_sequence", zDb) ){
87811 sqlite3DbFree(db, zWhere);
87816 if( db->flags&SQLITE_ForeignKeys ){
87831 db, pSrc);
87832 sqlite3DbFree(db, zName);
87833 db->flags = savedDbFlags;
87880 sqlite3 *db; /* The database connection; */
87882 db = pParse->db;
87883 if( pParse->nErr || db->mallocFailed ) return;
87887 assert( sqlite3BtreeHoldsAllMutexes(db) );
87888 iDb = sqlite3SchemaToIndex(db, pNew->pSchema);
87889 zDb = db->aDb[iDb].zName;
87893 pTab = sqlite3FindTable(db, zTab, zDb);
87923 if( (db->flags&SQLITE_ForeignKeys) && pNew->pFKey && pDflt ){
87940 rc = sqlite3ValueFromExpr(db, pDflt, SQLITE_UTF8, SQLITE_AFF_NONE, &pVal);
87943 db->mallocFailed = 1;
87954 zCol = sqlite3DbStrNDup(db, (char*)pColDef->z, pColDef->n);
87957 int savedDbFlags = db->flags;
87961 db->flags |= SQLITE_PreferBuiltin;
87969 sqlite3DbFree(db, zCol);
87970 db->flags = savedDbFlags;
88005 sqlite3 *db = pParse->db;
88009 assert( sqlite3BtreeHoldsAllMutexes(db) );
88010 if( db->mallocFailed ) goto exit_begin_add_column;
88031 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
88040 pNew = (Table*)sqlite3DbMallocZero(db, sizeof(Table));
88048 pNew->aCol = (Column*)sqlite3DbMallocZero(db, sizeof(Column)*nAlloc);
88049 pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
88051 db->mallocFailed = 1;
88057 pCol->zName = sqlite3DbStrDup(db, pCol->zName);
88063 pNew->pSchema = db->aDb[iDb].pSchema;
88074 sqlite3SrcListDelete(db, pSrc);
88275 sqlite3 *db = pParse->db;
88276 Db *pDb;
88282 assert( sqlite3BtreeHoldsAllMutexes(db) );
88283 assert( sqlite3VdbeDb(v)==db );
88284 pDb = &db->aDb[iDb];
88292 if( (pStat = sqlite3FindTable(db, zTab, pDb->zName))==0 ){
88374 sqlite3 *db; /* Database connection, for malloc() */
88380 static void sampleClear(sqlite3 *db, Stat4Sample *p){
88381 assert( db!=0 );
88383 sqlite3DbFree(db, p->u.aRowid);
88392 static void sampleSetRowid(sqlite3 *db, Stat4Sample *p, int n, const u8 *pData){
88393 assert( db!=0 );
88394 if( p->nRowid ) sqlite3DbFree(db, p->u.aRowid);
88395 p->u.aRowid = sqlite3DbMallocRaw(db, n);
88408 static void sampleSetRowidInt64(sqlite3 *db, Stat4Sample *p, i64 iRowid){
88409 assert( db!=0 );
88410 if( p->nRowid ) sqlite3DbFree(db, p->u.aRowid);
88429 sampleSetRowid(p->db, pTo, pFrom->nRowid, pFrom->u.aRowid);
88431 sampleSetRowidInt64(p->db, pTo, pFrom->u.iRowid);
88443 for(i=0; i<p->nCol; i++) sampleClear(p->db, p->aBest+i);
88444 for(i=0; i<p->mxSample; i++) sampleClear(p->db, p->a+i);
88445 sampleClear(p->db, &p->current);
88447 sqlite3DbFree(p->db, p);
88483 sqlite3 *db; /* Database connection */
88507 db = sqlite3_context_db_handle(context);
88508 p = sqlite3DbMallocZero(db, n);
88514 p->db = db;
88672 sampleClear(p->db, pMin);
88826 sampleSetRowidInt64(p->db, &p->current, sqlite3_value_int64(argv[2]));
88828 sampleSetRowid(p->db, &p->current, sqlite3_value_bytes(argv[2]),
89042 sqlite3 *db = pParse->db; /* Database handle */
89076 assert( sqlite3BtreeHoldsAllMutexes(db) );
89077 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
89079 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
89082 db->aDb[iDb].zName ) ){
89160 assert( iDb==sqlite3SchemaToIndex(db, pIdx->pSchema) );
89200 aGotoChng = sqlite3DbMallocRaw(db, sizeof(int)*nColTest);
89248 sqlite3DbFree(db, aGotoChng);
89372 sqlite3 *db = pParse->db;
89373 Schema *pSchema = db->aDb[iDb].pSchema; /* Schema of database iDb */
89385 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
89403 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
89404 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
89430 sqlite3 *db = pParse->db;
89441 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
89449 for(i=0; i<db->nDb; i++){
89455 iDb = sqlite3FindDb(db, pName1);
89459 z = sqlite3NameFromToken(db, pName1);
89461 if( (pIdx = sqlite3FindIndex(db, z, 0))!=0 ){
89466 sqlite3DbFree(db, z);
89473 zDb = db->aDb[iDb].zName;
89474 z = sqlite3NameFromToken(db, pTableName);
89476 if( (pIdx = sqlite3FindIndex(db, z, zDb))!=0 ){
89481 sqlite3DbFree(db, z);
89495 sqlite3 *db;
89587 pTable = sqlite3FindTable(pInfo->db, argv[0], pInfo->zDatabase);
89596 pIndex = sqlite3FindIndex(pInfo->db, argv[1], pInfo->zDatabase);
89609 if( pIndex->aiRowEst==0 ) pInfo->db->mallocFailed = 1;
89633 SQLITE_PRIVATE void sqlite3DeleteIndexSamples(sqlite3 *db, Index *pIdx){
89639 sqlite3DbFree(db, p->p);
89641 sqlite3DbFree(db, pIdx->aSample);
89643 if( db && db->pnBytesFreed==0 ){
89648 UNUSED_PARAMETER(db);
89718 sqlite3 *db,
89722 Index *pIdx = sqlite3FindIndex(db, zName, zDb);
89724 db, zName, zDb);
89744 sqlite3 *db, /* Database handle */
89756 assert( db->lookaside.bEnabled==0 );
89757 zSql = sqlite3MPrintf(db, zSql1, zDb);
89761 rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
89762 sqlite3DbFree(db, zSql);
89778 pIdx = findIndexOrPrimaryKey(db, zIndex, zDb);
89796 pIdx->aSample = sqlite3DbMallocZero(db, nByte);
89813 zSql = sqlite3MPrintf(db, zSql2, zDb);
89817 rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
89818 sqlite3DbFree(db, zSql);
89828 pIdx = findIndexOrPrimaryKey(db, zIndex, zDb);
89850 pSample->p = sqlite3DbMallocZero(db, pSample->n + 2);
89867 static int loadStat4(sqlite3 *db, const char *zDb){
89870 assert( db->lookaside.bEnabled==0 );
89871 if( sqlite3FindTable(db, "sqlite_stat4", zDb) ){
89872 rc = loadStatTbl(db, 0,
89879 if( rc==SQLITE_OK && sqlite3FindTable(db, "sqlite_stat3", zDb) ){
89880 rc = loadStatTbl(db, 1,
89907 ** If an OOM error occurs, this function always sets db->mallocFailed.
89911 SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
89917 assert( iDb>=0 && iDb<db->nDb );
89918 assert( db->aDb[iDb].pBt!=0 );
89921 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
89922 for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){
89926 sqlite3DeleteIndexSamples(db, pIdx);
89932 sInfo.db = db;
89933 sInfo.zDatabase = db->aDb[iDb].zName;
89934 if( sqlite3FindTable(db, "sqlite_stat1", sInfo.zDatabase)==0 ){
89939 zSql = sqlite3MPrintf(db,
89944 rc = sqlite3_exec(db, zSql, analysisLoader, &sInfo, 0);
89945 sqlite3DbFree(db, zSql);
89951 if( rc==SQLITE_OK && OptimizationEnabled(db, SQLITE_Stat34) ){
89952 int lookasideEnabled = db->lookaside.bEnabled;
89953 db->lookaside.bEnabled = 0;
89954 rc = loadStat4(db, sInfo.zDatabase);
89955 db->lookaside.bEnabled = lookasideEnabled;
89957 for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){
89965 db->mallocFailed = 1;
90039 sqlite3 *db = sqlite3_context_db_handle(context);
90045 Db *aNew;
90062 if( db->nDb>=db->aLimit[SQLITE_LIMIT_ATTACHED]+2 ){
90063 zErrDyn = sqlite3MPrintf(db, "too many attached databases - max %d",
90064 db->aLimit[SQLITE_LIMIT_ATTACHED]
90068 if( !db->autoCommit ){
90069 zErrDyn = sqlite3MPrintf(db, "cannot ATTACH database within transaction");
90072 for(i=0; i<db->nDb; i++){
90073 char *z = db->aDb[i].zName;
90076 zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName);
90081 /* Allocate the new entry in the db->aDb[] array and initialize the schema
90084 if( db->aDb==db->aDbStatic ){
90085 aNew = sqlite3DbMallocRaw(db, sizeof(db->aDb[0])*3 );
90087 memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2);
90089 aNew = sqlite3DbRealloc(db, db->aDb, sizeof(db->aDb[0])*(db->nDb+1) );
90092 db->aDb = aNew;
90093 aNew = &db->aDb[db->nDb];
90100 flags = db->openFlags;
90101 rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
90103 if( rc==SQLITE_NOMEM ) db->mallocFailed = 1;
90110 rc = sqlite3BtreeOpen(pVfs, zPath, db, &aNew->pBt, 0, flags);
90112 db->nDb++;
90115 zErrDyn = sqlite3MPrintf(db, "database is already attached");
90118 aNew->pSchema = sqlite3SchemaGet(db, aNew->pBt);
90121 }else if( aNew->pSchema->file_format && aNew->pSchema->enc!=ENC(db) ){
90122 zErrDyn = sqlite3MPrintf(db,
90128 sqlite3PagerLockingMode(pPager, db->dfltLockMode);
90130 sqlite3BtreeSecureDelete(db->aDb[0].pBt,-1) );
90132 sqlite3BtreeSetPagerFlags(aNew->pBt, 3 | (db->flags & PAGER_FLAGS_MASK));
90137 aNew->zName = sqlite3DbStrDup(db, zName);
90153 zErrDyn = sqlite3DbStrDup(db, "Invalid key value");
90161 rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
90166 sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
90167 if( nKey>0 || sqlite3BtreeGetOptimalReserve(db->aDb[0].pBt)>0 ){
90168 rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
90177 ** remove the entry from the db->aDb[] array. i.e. put everything back the way
90181 sqlite3BtreeEnterAll(db);
90182 rc = sqlite3Init(db, &zErrDyn);
90183 sqlite3BtreeLeaveAll(db);
90188 rc = sqlite3UserAuthCheckLogin(db, zName, &newAuth);
90189 if( newAuth<db->auth.authLevel ){
90195 int iDb = db->nDb - 1;
90197 if( db->aDb[iDb].pBt ){
90198 sqlite3BtreeClose(db->aDb[iDb].pBt);
90199 db->aDb[iDb].pBt = 0;
90200 db->aDb[iDb].pSchema = 0;
90202 sqlite3ResetAllSchemasOfConnection(db);
90203 db->nDb = iDb;
90205 db->mallocFailed = 1;
90206 sqlite3DbFree(db, zErrDyn);
90207 zErrDyn = sqlite3MPrintf(db, "out of memory");
90209 zErrDyn = sqlite3MPrintf(db, "unable to open database: %s", zFile);
90220 sqlite3DbFree(db, zErrDyn);
90239 sqlite3 *db = sqlite3_context_db_handle(context);
90241 Db *pDb = 0;
90247 for(i=0; i<db->nDb; i++){
90248 pDb = &db->aDb[i];
90253 if( i>=db->nDb ){
90261 if( !db->autoCommit ){
90274 sqlite3CollapseDatabaseArray(db);
90297 sqlite3* db = pParse->db;
90333 assert( v || db->mallocFailed );
90348 sqlite3ExprDelete(db, pFilename);
90349 sqlite3ExprDelete(db, pDbname);
90350 sqlite3ExprDelete(db, pKey);
90407 sqlite3 *db;
90409 db = pParse->db;
90410 assert( db->nDb>iDb );
90412 pFix->zDb = db->aDb[iDb].zName;
90413 pFix->pSchema = db->aDb[iDb].pSchema;
90451 sqlite3DbFree(pFix->pParse->db, pItem->zDatabase);
90502 if( pFix->pParse->db->init.busy ){
90630 sqlite3 *db,
90635 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
90637 sqlite3_mutex_enter(db->mutex);
90638 db->xAuth = (sqlite3_xauth)xAuth;
90639 db->pAuthArg = pArg;
90640 sqlite3ExpirePreparedStatements(db);
90641 sqlite3_mutex_leave(db->mutex);
90669 sqlite3 *db = pParse->db; /* Database handle */
90670 char *zDb = db->aDb[iDb].zName; /* Name of attached database */
90673 rc = db->xAuth(db->pAuthArg, SQLITE_READ, zTab,zCol,zDb,pParse->zAuthContext
90675 ,db->auth.zAuthUser
90679 if( db->nDb>2 || iDb!=0 ){
90706 sqlite3 *db = pParse->db;
90713 if( db->xAuth==0 ) return;
90714 iDb = sqlite3SchemaToIndex(pParse->db, pSchema);
90745 assert( iDb>=0 && iDb<db->nDb );
90764 sqlite3 *db = pParse->db;
90770 if( db->init.busy || IN_DECLARE_VTAB ){
90774 if( db->xAuth==0 ){
90777 rc = db->xAuth(db->pAuthArg, code, zArg1, zArg2, zArg3, pParse->zAuthContext
90779 ,db->auth.zAuthUser
90902 sqlite3DbReallocOrFree(pToplevel->db, pToplevel->aTableLock, nBytes);
90911 pToplevel->db->mallocFailed = 1;
90961 sqlite3 *db;
90965 db = pParse->db;
90967 if( db->mallocFailed || pParse->nErr ){
90983 if( pParse->nTableLock>0 && db->init.busy==0 ){
90984 sqlite3UserAuthInit(db);
90985 if( db->auth.authLevel<UAUTH_User ){
90999 if( db->mallocFailed==0
91005 for(iDb=0; iDb<db->nDb; iDb++){
91013 db->aDb[iDb].pSchema->iGeneration /* P4 */
91015 if( db->init.busy==0 ) sqlite3VdbeChangeP5(v, 1);
91019 char *vtab = (char *)sqlite3GetVTable(db, pParse->apVtabLock[i]);
91052 if( v && pParse->nErr==0 && !db->mallocFailed ){
91086 sqlite3 *db = pParse->db;
91093 zSql = sqlite3VMPrintf(db, zFormat, ap);
91102 sqlite3DbFree(db, zErrMsg);
91103 sqlite3DbFree(db, zSql);
91130 SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){
91135 assert( zDatabase!=0 || sqlite3BtreeHoldsAllMutexes(db) );
91139 if( db->auth.authLevel<UAUTH_Admin && sqlite3UserAuthTable(zName)!=0 ){
91143 for(i=OMIT_TEMPDB; i<db->nDb; i++){
91145 if( zDatabase!=0 && sqlite3StrICmp(zDatabase, db->aDb[j].zName) ) continue;
91146 assert( sqlite3SchemaMutexHeld(db, j, 0) );
91147 p = sqlite3HashFind(&db->aDb[j].pSchema->tblHash, zName);
91177 p = sqlite3FindTable(pParse->db, zName, zDbase);
91188 else if( pParse->db->auth.authLevel<UAUTH_User ){
91213 int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema);
91214 zDb = pParse->db->aDb[iDb].zName;
91233 SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){
91237 assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
91238 for(i=OMIT_TEMPDB; i<db->nDb; i++){
91240 Schema *pSchema = db->aDb[j].pSchema;
91242 if( zDb && sqlite3StrICmp(zDb, db->aDb[j].zName) ) continue;
91243 assert( sqlite3SchemaMutexHeld(db, j, 0) );
91253 db, Index *p){
91255 sqlite3DeleteIndexSamples(db, p);
91257 sqlite3ExprDelete(db, p->pPartIdxWhere);
91258 sqlite3DbFree(db, p->zColAff);
91259 if( p->isResized ) sqlite3DbFree(db, p->azColl);
91263 sqlite3DbFree(db, p);
91272 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){
91276 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
91277 pHash = &db->aDb[iDb].pSchema->idxHash;
91292 freeIndex(db, pIndex);
91294 db->flags |= SQLITE_InternChanges;
91298 ** Look through the list of open database files in db->aDb[] and if
91300 ** db->aDb[] structure to a smaller size, if possible.
91305 SQLITE_PRIVATE void sqlite3CollapseDatabaseArray(sqlite3 *db){
91307 for(i=j=2; i<db->nDb; i++){
91308 struct Db *pDb = &db->aDb[i];
91310 sqlite3DbFree(db, pDb->zName);
91315 db->aDb[j] = db->aDb[i];
91319 memset(&db->aDb[j], 0, (db->nDb-j)*sizeof(db->aDb[j]));
91320 db->nDb = j;
91321 if( db->nDb<=2 && db->aDb!=db->aDbStatic ){
91322 memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));
91323 sqlite3DbFree(db, db->aDb);
91324 db->aDb = db->aDbStatic;
91332 SQLITE_PRIVATE void sqlite3ResetOneSchema(sqlite3 *db, int iDb){
91333 Db *pDb;
91334 assert( iDb<db->nDb );
91337 pDb = &db->aDb[iDb];
91338 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
91347 pDb = &db->aDb[1];
91358 SQLITE_PRIVATE void sqlite3ResetAllSchemasOfConnection(sqlite3 *db){
91360 sqlite3BtreeEnterAll(db);
91361 for(i=0; i<db->nDb; i++){
91362 Db *pDb = &db->aDb[i];
91367 db->flags &= ~SQLITE_InternChanges;
91368 sqlite3VtabUnlockList(db);
91369 sqlite3BtreeLeaveAll(db);
91370 sqlite3CollapseDatabaseArray(db);
91376 SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3 *db){
91377 db->flags &= ~SQLITE_InternChanges;
91384 static void sqliteDeleteColumnNames(sqlite3 *db, Table *pTable){
91390 sqlite3DbFree(db, pCol->zName);
91391 sqlite3ExprDelete(db, pCol->pDflt);
91392 sqlite3DbFree(db, pCol->zDflt);
91393 sqlite3DbFree(db, pCol->zType);
91394 sqlite3DbFree(db, pCol->zColl);
91396 sqlite3DbFree(db, pTable->aCol);
91409 ** The db parameter is optional. It is needed if the Table object
91412 ** db parameter can be used with db->pnBytesFreed to measure the memory
91415 SQLITE_PRIVATE void sqlite3DeleteTable(sqlite3 *db, Table *pTable){
91423 if( ((!db || db->pnBytesFreed==0) && (--pTable->nRef)>0) ) return;
91428 TESTONLY( nLookaside = (db && (pTable->tabFlags & TF_Ephemeral)==0) ?
91429 db->lookaside.nOut : 0 );
91435 if( !db || db->pnBytesFreed==0 ){
91440 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
91443 freeIndex(db, pIndex);
91447 sqlite3FkDelete(db, pTable);
91451 sqliteDeleteColumnNames(db, pTable);
91452 sqlite3DbFree(db, pTable->zName);
91453 sqlite3DbFree(db, pTable->zColAff);
91454 sqlite3SelectDelete(db, pTable->pSelect);
91456 sqlite3ExprListDelete(db, pTable->pCheck);
91459 sqlite3VtabClear(db, pTable);
91461 sqlite3DbFree(db, pTable);
91464 assert( nLookaside==0 || nLookaside==db->lookaside.nOut );
91471 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){
91473 Db *pDb;
91475 assert( db!=0 );
91476 assert( iDb>=0 && iDb<db->nDb );
91478 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
91480 pDb = &db->aDb[iDb];
91482 sqlite3DeleteTable(db, p);
91483 db->flags |= SQLITE_InternChanges;
91499 SQLITE_PRIVATE char *sqlite3NameFromToken(sqlite3 *db, Token *pName){
91502 zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n);
91525 ** of a database ("main", "temp" or the name of an attached db). This
91526 ** function returns the index of the named database in db->aDb[], or
91527 ** -1 if the named db cannot be found.
91529 SQLITE_PRIVATE int sqlite3FindDbName(sqlite3 *db, const char *zName){
91532 Db *pDb;
91534 for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){
91546 ** "temp" or the name of an attached db). This routine returns the
91547 ** index of the named database in db->aDb[], or -1 if the named db
91550 SQLITE_PRIVATE int sqlite3FindDb(sqlite3 *db, Token *pName){
91553 zName = sqlite3NameFromToken(db, pName);
91554 i = sqlite3FindDbName(db, zName);
91555 sqlite3DbFree(db, zName);
91582 sqlite3 *db = pParse->db;
91585 if( db->init.busy ) {
91590 iDb = sqlite3FindDb(db, pName1);
91596 assert( db->init.iDb==0 || db->init.busy );
91597 iDb = db->init.iDb;
91611 if( !pParse->db->init.busy && pParse->nested==0
91612 && (pParse->db->flags & SQLITE_WriteSchema)==0
91668 sqlite3 *db = pParse->db;
91701 zName = sqlite3NameFromToken(db, pName);
91706 if( db->init.iDb==1 ) isTemp = 1;
91711 char *zDb = db->aDb[iDb].zName;
91742 char *zDb = db->aDb[iDb].zName;
91746 pTable = sqlite3FindTable(db, zName, zDb);
91751 assert( !db->init.busy || CORRUPT_DB );
91756 if( sqlite3FindIndex(db, zName, zDb)!=0 ){
91762 pTable = sqlite3DbMallocZero(db, sizeof(Table));
91764 db->mallocFailed = 1;
91771 pTable->pSchema = db->aDb[iDb].pSchema;
91783 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
91796 if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){
91817 fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ?
91821 sqlite3VdbeAddOp2(v, OP_Integer, ENC(db), reg3);
91855 sqlite3DbFree(db, zName);
91885 sqlite3 *db = pParse->db;
91888 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
91893 z = sqlite3NameFromToken(db, pName);
91898 sqlite3DbFree(db, z);
91904 aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
91906 sqlite3DbFree(db, z);
92041 sqlite3DbFree(pParse->db, pCol->zType);
92042 pCol->zType = sqlite3NameFromToken(pParse->db, pType);
92059 sqlite3 *db = pParse->db;
92063 if( !sqlite3ExprIsConstantOrFunction(pSpan->pExpr, db->init.busy) ){
92071 sqlite3ExprDelete(db, pCol->pDflt);
92072 pCol->pDflt = sqlite3ExprDup(db, pSpan->pExpr, EXPRDUP_REDUCE);
92073 sqlite3DbFree(db, pCol->zDflt);
92074 pCol->zDflt = sqlite3DbStrNDup(db, (char*)pSpan->zStart,
92078 sqlite3ExprDelete(db, pSpan->pExpr);
92162 sqlite3ExprListDelete(pParse->db, pList);
92175 sqlite3 *db = pParse->db;
92177 && !sqlite3BtreeIsReadonly(db->aDb[db->init.iDb].pBt)
92186 sqlite3ExprDelete(pParse->db, pCheckExpr);
92198 sqlite3 *db;
92202 db = pParse->db;
92203 zColl = sqlite3NameFromToken(db, pToken);
92208 sqlite3DbFree(db, p->aCol[i].zColl);
92222 sqlite3DbFree(db, zColl);
92247 sqlite3 *db = pParse->db;
92248 u8 enc = ENC(db);
92249 u8 initbusy = db->init.busy;
92252 pColl = sqlite3FindCollSeq(db, enc, zName, initbusy);
92279 sqlite3 *db = pParse->db;
92281 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
92282 sqlite3VdbeAddOp2(v, OP_Integer, db->aDb[iDb].pSchema->schema_cookie+1, r1);
92344 static char *createTableStmt(sqlite3 *db, Table *p){
92366 db->mallocFailed = 1;
92412 static int resizeIndexObject(sqlite3 *db, Index *pIdx, int N){
92418 zExtra = sqlite3DbMallocZero(db, nByte);
92497 sqlite3 *db = pParse->db;
92524 pList->a[0].zName = sqlite3DbStrDup(pParse->db,
92554 if( !db->init.imposterTable ){
92578 if( resizeIndexObject(db, pIdx, pIdx->nKeyCol+n) ) return;
92593 if( resizeIndexObject(db, pPk, pTab->nCol) ) return;
92618 ** this is a temporary table or db->init.busy==1. When db->init.busy==1
92637 sqlite3 *db = pParse->db; /* The database connection */
92641 if( (pEnd==0 && pSelect==0) || db->mallocFailed ){
92647 assert( !db->init.busy || !pSelect );
92649 /* If the db->init.busy is 1 it means we are reading the SQL off the
92652 ** for the table from the db->init.newTnum field. (The page number
92655 if( db->init.busy ){
92656 p->tnum = db->init.newTnum;
92674 iDb = sqlite3SchemaToIndex(db, p->pSchema);
92696 if( !db->init.busy ){
92755 sqlite3DeleteTable(db, pSelTab);
92761 zStmt = createTableStmt(db, p);
92766 zStmt = sqlite3MPrintf(db,
92779 db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
92787 sqlite3DbFree(db, zStmt);
92795 Db *pDb = &db->aDb[iDb];
92796 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
92808 sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName));
92814 if( db->init.busy ){
92817 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
92821 db->mallocFailed = 1;
92825 db->flags |= SQLITE_InternChanges;
92862 sqlite3 *db = pParse->db;
92866 sqlite3SelectDelete(db, pSelect);
92872 sqlite3SelectDelete(db, pSelect);
92876 iDb = sqlite3SchemaToIndex(db, p->pSchema);
92879 sqlite3SelectDelete(db, pSelect);
92888 p->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
92889 sqlite3SelectDelete(db, pSelect);
92890 if( db->mallocFailed ){
92893 if( !db->init.busy ){
92928 sqlite3 *db = pParse->db; /* Database connection for malloc errors */
92975 pSel = sqlite3SelectDup(db, pTable->pSelect, 0);
92977 u8 enableLookaside = db->lookaside.bEnabled;
92981 db->lookaside.bEnabled = 0;
92983 xAuth = db->xAuth;
92984 db->xAuth = 0;
92986 db->xAuth = xAuth;
92990 db->lookaside.bEnabled = enableLookaside;
92998 sqlite3DeleteTable(db, pSelTab);
92999 assert( sqlite3SchemaMutexHeld(db, 0, pTable->pSchema) );
93005 sqlite3SelectDelete(db, pSel);
93018 static void sqliteViewResetAll(sqlite3 *db, int idx){
93020 assert( sqlite3SchemaMutexHeld(db, idx, 0) );
93021 if( !DbHasProperty(db, idx, DB_UnresetViews) ) return;
93022 for(i=sqliteHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqliteHashNext(i)){
93025 sqliteDeleteColumnNames(db, pTab);
93030 DbClearProperty(db, idx, DB_UnresetViews);
93054 SQLITE_PRIVATE void sqlite3RootPageMoved(sqlite3 *db, int iDb, int iFrom, int iTo){
93057 Db *pDb;
93059 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
93060 pDb = &db->aDb[iDb];
93101 pParse->db->aDb[iDb].zName, SCHEMA_TABLE(iDb), iTable, r1, r1);
93115 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
93157 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
93158 assert( iDb>=0 && iDb<pParse->db->nDb );
93177 const char *zDbName = pParse->db->aDb[iDb].zName;
93181 if( sqlite3FindTable(pParse->db, zTab, zDbName) ){
93195 sqlite3 *db = pParse->db;
93197 Db *pDb = &db->aDb[iDb];
93216 pTrigger->pSchema==db->aDb[1].pSchema );
93257 sqliteViewResetAll(db, iDb);
93267 sqlite3 *db = pParse->db;
93270 if( db->mallocFailed ){
93276 if( noErr ) db->suppressErr++;
93278 if( noErr ) db->suppressErr--;
93284 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
93285 assert( iDb>=0 && iDb<db->nDb );
93297 const char *zDb = db->aDb[iDb].zName;
93311 zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
93360 sqlite3SrcListDelete(db, pName);
93386 sqlite3 *db = pParse->db;
93422 pFKey = sqlite3DbMallocZero(db, nByte );
93467 assert( sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
93472 db->mallocFailed = 1;
93487 sqlite3DbFree(db, pFKey);
93489 sqlite3ExprListDelete(db, pFromCol);
93490 sqlite3ExprListDelete(db, pToCol);
93533 sqlite3 *db = pParse->db; /* The database connection */
93534 int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
93538 db->aDb[iDb].zName ) ){
93577 assert( pKey!=0 || db->mallocFailed || pParse->nErr );
93609 sqlite3 *db, /* Database connection */
93622 p = sqlite3DbMallocZero(db, nByte + nExtra);
93672 sqlite3 *db = pParse->db;
93673 Db *pDb; /* The specific table containing the indexed database */
93683 if( db->mallocFailed || IN_DECLARE_VTAB || pParse->nErr>0 ){
93696 ** to search for the table. 'Fix' the table name to this db
93709 if( !db->init.busy ){
93711 if( pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){
93724 assert( db->mallocFailed==0 || pTab==0 );
93726 if( iDb==1 && db->aDb[iDb].pSchema!=pTab->pSchema ){
93738 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
93740 pDb = &db->aDb[iDb];
93745 && db->init.busy==0
93780 zName = sqlite3NameFromToken(db, pName);
93786 if( !db->init.busy ){
93787 if( sqlite3FindTable(db, zName, 0)!=0 ){
93792 if( sqlite3FindIndex(db, zName, pDb->zName)!=0 ){
93796 assert( !db->init.busy );
93805 zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
93834 pList->a[0].zName = sqlite3DbStrDup(pParse->db,
93855 pIndex = sqlite3AllocateIndexObject(db, pList->nExpr + nExtraCol,
93857 if( db->mallocFailed ){
93869 pIndex->pSchema = db->aDb[iDb].pSchema;
93876 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
93926 if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl) ){
94018 if( db->init.busy ){
94020 assert( sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
94025 db->mallocFailed = 1;
94028 db->flags |= SQLITE_InternChanges;
94030 pIndex->tnum = db->init.newTnum;
94068 zStmt = sqlite3MPrintf(db, "CREATE%s INDEX %.*s",
94080 db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
94086 sqlite3DbFree(db, zStmt);
94095 sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName));
94106 if( db->init.busy || pTblName==0 ){
94125 if( pIndex ) freeIndex(db, pIndex);
94126 sqlite3ExprDelete(db, pPIWhere);
94127 sqlite3ExprListDelete(db, pList);
94128 sqlite3SrcListDelete(db, pTblName);
94129 sqlite3DbFree(db, zName);
94182 sqlite3 *db = pParse->db;
94186 if( db->mallocFailed ){
94193 pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
94208 iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
94213 const char *zDb = db->aDb[iDb].zName;
94231 db->aDb[iDb].zName, SCHEMA_TABLE(iDb), pIndex->zName
94240 sqlite3SrcListDelete(db, pName);
94261 sqlite3 *db, /* Connection to notify of malloc failures */
94271 void *pNew = sqlite3DbRealloc(db, pArray, sz*szEntry);
94291 SQLITE_PRIVATE IdList *sqlite3IdListAppend(sqlite3 *db, IdList *pList, Token *pToken){
94294 pList = sqlite3DbMallocZero(db, sizeof(IdList) );
94298 db,
94305 sqlite3IdListDelete(db, pList);
94308 pList->a[i].zName = sqlite3NameFromToken(db, pToken);
94315 SQLITE_PRIVATE void sqlite3IdListDelete(sqlite3 *db, IdList *pList){
94319 sqlite3DbFree(db, pList->a[i].zName);
94321 sqlite3DbFree(db, pList->a);
94322 sqlite3DbFree(db, pList);
94346 ** sqlite3SrcListEnlarge(db, pSrclist, 3, 2);
94355 ** db->mallocFailed flag will be set to true.
94358 sqlite3 *db, /* Database connection to notify of OOM errors */
94376 pNew = sqlite3DbRealloc(db, pSrc,
94379 assert( db->mallocFailed );
94383 nGot = (sqlite3DbMallocSize(db, pNew) - sizeof(*pSrc))/sizeof(pSrc->a[0])+1;
94440 sqlite3 *db, /* Connection to notify of malloc failures */
94448 pList = sqlite3DbMallocZero(db, sizeof(SrcList) );
94452 pList = sqlite3SrcListEnlarge(db, pList, 1, pList->nSrc);
94453 if( db->mallocFailed ){
94454 sqlite3SrcListDelete(db, pList);
94466 pItem->zName = sqlite3NameFromToken(db, pTable);
94467 pItem->zDatabase = sqlite3NameFromToken(db, pDatabase);
94477 assert(pList || pParse->db->mallocFailed );
94492 SQLITE_PRIVATE void sqlite3SrcListDelete(sqlite3 *db, SrcList *pList){
94497 sqlite3DbFree(db, pItem->zDatabase);
94498 sqlite3DbFree(db, pItem->zName);
94499 sqlite3DbFree(db, pItem->zAlias);
94500 sqlite3DbFree(db, pItem->zIndex);
94501 sqlite3DeleteTable(db, pItem->pTab);
94502 sqlite3SelectDelete(db, pItem->pSelect);
94503 sqlite3ExprDelete(db, pItem->pOn);
94504 sqlite3IdListDelete(db, pItem->pUsing);
94506 sqlite3DbFree(db, pList);
94536 sqlite3 *db = pParse->db;
94543 p = sqlite3SrcListAppend(db, p, pTable, pDatabase);
94550 pItem->zAlias = sqlite3NameFromToken(db, pAlias);
94559 sqlite3ExprDelete(db, pOn);
94560 sqlite3IdListDelete(db, pUsing);
94561 sqlite3SelectDelete(db, pSubquery);
94579 pItem->zIndex = sqlite3NameFromToken(pParse->db, pIndexedBy);
94613 sqlite3 *db;
94618 db = pParse->db;
94619 assert( db!=0 );
94620 /* if( db->aDb[0].pBt==0 ) return; */
94627 for(i=0; i<db->nDb; i++){
94642 assert( pParse->db!=0 );
94659 assert( pParse->db!=0 );
94674 char *zName = sqlite3NameFromToken(pParse->db, pName);
94682 sqlite3DbFree(pParse->db, zName);
94694 sqlite3 *db = pParse->db;
94695 if( db->aDb[1].pBt==0 && !pParse->explain ){
94705 rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pBt, 0, flags);
94712 db->aDb[1].pBt = pBt;
94713 assert( db->aDb[1].pSchema );
94714 if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, -1, 0) ){
94715 db->mallocFailed = 1;
94730 sqlite3 *db = pToplevel->db;
94732 assert( iDb>=0 && iDb<db->nDb );
94733 assert( db->aDb[iDb].pBt!=0 || iDb==1 );
94735 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
94738 pToplevel->cookieValue[iDb] = db->aDb[iDb].pSchema->schema_cookie;
94750 sqlite3 *db = pParse->db;
94752 for(i=0; i<db->nDb; i++){
94753 Db *pDb = &db->aDb[i];
94848 sqlite3StrAccumInit(&errMsg, pParse->db, 0, 0, 200);
94875 zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
94879 zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
94915 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
94930 Db *pDb; /* A single database */
94932 sqlite3 *db = pParse->db; /* The database connection */
94936 assert( sqlite3BtreeHoldsAllMutexes(db) ); /* Needed for schema access */
94937 for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
94968 sqlite3 *db = pParse->db; /* The database connection */
94983 zColl = sqlite3NameFromToken(pParse->db, pName1);
94985 pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
94988 sqlite3DbFree(db, zColl);
94991 sqlite3DbFree(db, zColl);
94995 z = sqlite3NameFromToken(db, pObjName);
94997 zDb = db->aDb[iDb].zName;
94998 pTab = sqlite3FindTable(db, z, zDb);
95001 sqlite3DbFree(db, z);
95004 pIndex = sqlite3FindIndex(db, z, zDb);
95005 sqlite3DbFree(db, z);
95032 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
95034 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
95065 sqlite3 *db = pParse->db;
95071 zName = sqlite3NameFromToken(pParse->db, pName);
95083 pNew = sqlite3DbRealloc(db, pWith, nByte);
95085 pNew = sqlite3DbMallocZero(db, sizeof(*pWith));
95088 assert( db->mallocFailed==0 || pNew==0 );
95091 sqlite3ExprListDelete(db, pArglist);
95092 sqlite3SelectDelete(db, pQuery);
95093 sqlite3DbFree(db, zName);
95109 SQLITE_PRIVATE void sqlite3WithDelete(sqlite3 *db, With *pWith){
95114 sqlite3ExprListDelete(db, pCte->pCols);
95115 sqlite3SelectDelete(db, pCte->pSelect);
95116 sqlite3DbFree(db, pCte->zName);
95118 sqlite3DbFree(db, pWith);
95146 static void callCollNeeded(sqlite3 *db, int enc, const char *zName){
95147 assert( !db->xCollNeeded || !db->xCollNeeded16 );
95148 if( db->xCollNeeded ){
95149 char *zExternal = sqlite3DbStrDup(db, zName);
95151 db->xCollNeeded(db->pCollNeededArg, db, enc, zExternal);
95152 sqlite3DbFree(db, zExternal);
95155 if( db->xCollNeeded16 ){
95157 sqlite3_value *pTmp = sqlite3ValueNew(db);
95161 db->xCollNeeded16(db->pCollNeededArg, db, (int)ENC(db), zExternal);
95175 static int synthCollSeq(sqlite3 *db, CollSeq *pColl){
95181 pColl2 = sqlite3FindCollSeq(db, aEnc[i], z, 0);
95200 ** db for collation type name zName, length nName, or NULL, if no collation
95212 sqlite3 *db = pParse->db;
95216 p = sqlite3FindCollSeq(db, enc, zName, 0);
95222 callCollNeeded(db, enc, zName);
95223 p = sqlite3FindCollSeq(db, enc, zName, 0);
95225 if( p && !p->xCmp && synthCollSeq(db, p) ){
95249 sqlite3 *db = pParse->db;
95250 CollSeq *p = sqlite3GetCollSeq(pParse, ENC(db), pColl, zName);
95262 ** Locate and return an entry from the db.aCollSeq hash table. If the entry
95275 sqlite3 *db, /* Database connection */
95280 pColl = sqlite3HashFind(&db->aCollSeq, zName);
95284 pColl = sqlite3DbMallocZero(db, 3*sizeof(*pColl) + nName + 1);
95295 pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, pColl);
95303 db->mallocFailed = 1;
95304 sqlite3DbFree(db, pDel);
95315 ** for the encoding 'enc' from the database 'db'.
95328 sqlite3 *db,
95335 pColl = findCollSeqEntry(db, zName, create);
95337 pColl = db->pDfltColl;
95456 ** structure is created and liked into the "db" structure if a
95469 sqlite3 *db, /* An open database */
95483 h = (sqlite3UpperToLower[(u8)zName[0]] + nName) % ArraySize(db->aFunc.a);
95487 p = functionSearch(&db->aFunc, h, zName, nName);
95509 if( !createFlag && (pBest==0 || (db->flags & SQLITE_PreferBuiltin)!=0) ){
95528 (pBest = sqlite3DbMallocZero(db, sizeof(*pBest)+nName+1))!=0 ){
95534 sqlite3FuncDefInsert(&db->aFunc, pBest);
95545 ** at a Schema struct. This function does not call sqlite3DbFree(db, ) on the
95583 SQLITE_PRIVATE Schema *sqlite3SchemaGet(sqlite3 *db, Btree *pBt){
95591 db->mallocFailed = 1;
95638 sqlite3DeleteTable(pParse->db, pItem->pTab);
95666 && sqlite3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0 )
95668 && (pParse->db->flags & SQLITE_WriteSchema)==0
95700 sqlite3 *db = pParse->db;
95701 int iDb = sqlite3SchemaToIndex(db, pView->pSchema);
95702 pWhere = sqlite3ExprDup(db, pWhere, 0);
95703 pFrom = sqlite3SrcListAppend(db, 0, 0, 0);
95706 pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName);
95707 pFrom->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zName);
95714 sqlite3SelectDelete(db, pSel);
95775 pSelectSrc = sqlite3SrcListDup(pParse->db, pSrc, 0);
95777 sqlite3ExprListDelete(pParse->db, pEList);
95799 sqlite3SelectDelete(pParse->db, pSelect);
95803 sqlite3ExprDelete(pParse->db, pWhere);
95804 sqlite3ExprListDelete(pParse->db, pOrderBy);
95805 sqlite3ExprDelete(pParse->db, pLimit);
95806 sqlite3ExprDelete(pParse->db, pOffset);
95834 sqlite3 *db; /* Main database structure */
95861 db = pParse->db;
95862 if( pParse->nErr || db->mallocFailed ){
95899 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
95900 assert( iDb<db->nDb );
95901 zDb = db->aDb[iDb].zName;
95954 if( db->flags & SQLITE_CountRows ){
96009 if( db->flags & SQLITE_CountRows ){
96032 aToOpen = sqlite3DbMallocRaw(db, nIdx+2);
96103 const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
96148 if( (db->flags&SQLITE_CountRows) && !pParse->nested && !pParse->pTriggerTab ){
96156 sqlite3SrcListDelete(db, pTabList);
96157 sqlite3ExprDelete(db, pWhere);
96158 sqlite3DbFree(db, aToOpen);
96677 sqlite3 *db = sqlite3_context_db_handle(context);
96683 sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]);
96841 sqlite3 *db = sqlite3_context_db_handle(context);
96843 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] );
96844 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
96845 if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
96967 sqlite3 *db = sqlite3_context_db_handle(context);
96972 sqlite3_result_int64(context, sqlite3_last_insert_rowid(db));
96987 sqlite3 *db = sqlite3_context_db_handle(context);
96989 sqlite3_result_int(context, sqlite3_changes(db));
97001 sqlite3 *db = sqlite3_context_db_handle(context);
97005 sqlite3_result_int(context, sqlite3_total_changes(db));
97241 sqlite3 *db = sqlite3_context_db_handle(context);
97250 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] );
97251 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 );
97252 if( nPat > db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){
97570 sqlite3 *db = sqlite3_context_db_handle(context);
97574 testcase( n==db->aLimit[SQLITE_LIMIT_LENGTH] );
97575 testcase( n==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
97576 if( n>db->aLimit[SQLITE_LIMIT_LENGTH] ){
97640 sqlite3 *db = sqlite3_context_db_handle(context);
97642 testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] );
97643 testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] );
97644 if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
97821 sqlite3 *db = sqlite3_context_db_handle(context);
97829 if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){
97967 ** returns (void *)db, where db is the sqlite3* database pointer.
97979 pBest->db = sqlite3_context_db_handle(context);
98011 sqlite3 *db = sqlite3_context_db_handle(context);
98013 pAccum->mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH];
98049 SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(sqlite3 *db){
98050 int rc = sqlite3_overload_function(db, "MATCH", 2);
98053 db->mallocFailed = 1;
98060 static void setLikeOptFlag(sqlite3 *db, const char *zName, u8 flagVal){
98062 pDef = sqlite3FindFunction(db, zName, sqlite3Strlen30(zName),
98074 SQLITE_PRIVATE void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){
98081 sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0);
98082 sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0);
98083 sqlite3CreateFunc(db, "glob", 2, SQLITE_UTF8,
98085 setLikeOptFlag(db, "glob", SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE);
98086 setLikeOptFlag(db, "like",
98102 SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){
98111 pDef = sqlite3FindFunction(db, pExpr->u.zToken,
98426 ** pParse->db->mallocFailed flag is set.
98467 aiCol = (int *)sqlite3DbMallocRaw(pParse->db, nCol*sizeof(int));
98529 sqlite3DbFree(pParse->db, aiCol);
98672 if( !pFKey->isDeferred && !(pParse->db->flags & SQLITE_DeferFKs)
98712 sqlite3 *db = pParse->db;
98714 pExpr = sqlite3Expr(db, TK_REGISTER, 0);
98721 if( zColl==0 ) zColl = db->pDfltColl->zName;
98736 sqlite3 *db, /* The database connection */
98741 Expr *pExpr = sqlite3Expr(db, TK_COLUMN, 0);
98758 ** the number of FK violations in the db) or +1 when deleting one (as this
98792 sqlite3 *db = pParse->db; /* Database handle */
98830 pRight = sqlite3Expr(db, TK_ID, zCol);
98832 pWhere = sqlite3ExprAnd(db, pWhere, pEq);
98852 pRight = exprTableColumn(db, pTab, pSrc->a[0].iCursor, -1);
98861 pRight = exprTableColumn(db, pTab, pSrc->a[0].iCursor, iCol);
98863 pAll = sqlite3ExprAnd(db, pAll, pEq);
98867 pWhere = sqlite3ExprAnd(db, pWhere, pNe);
98886 sqlite3ExprDelete(db, pWhere);
98947 sqlite3 *db = pParse->db;
98948 if( (db->flags&SQLITE_ForeignKeys) && !IsVirtual(pTab) && !pTab->pSelect ){
98961 if( p->isDeferred || (db->flags & SQLITE_DeferFKs) ) break;
98969 sqlite3DeleteFrom(pParse, sqlite3SrcListDup(db, pName, 0), 0);
98981 if( (db->flags & SQLITE_DeferFKs)==0 ){
99104 sqlite3 *db = pParse->db; /* Database handle */
99114 if( (db->flags&SQLITE_ForeignKeys)==0 ) return;
99116 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
99117 zDb = db->aDb[iDb].zName;
99142 pTo = sqlite3FindTable(db, pFKey->zTo, zDb);
99148 if( !isIgnoreErrors || db->mallocFailed ) return;
99183 if( db->xAuth ){
99216 sqlite3DbFree(db, aiFree);
99230 if( !pFKey->isDeferred && !(db->flags & SQLITE_DeferFKs)
99240 if( !isIgnoreErrors || db->mallocFailed ) return;
99247 pSrc = sqlite3SrcListAppend(db, 0, 0, 0);
99283 sqlite3SrcListDelete(db, pSrc);
99285 sqlite3DbFree(db, aiCol);
99300 if( pParse->db->flags&SQLITE_ForeignKeys ){
99338 if( pParse->db->flags&SQLITE_ForeignKeys ){
99398 sqlite3 *db = pParse->db; /* Database handle */
99407 u8 enableLookaside; /* Copy of db->lookaside.bEnabled */
99445 sqlite3ExprAlloc(db, TK_ID, &tOld, 0),
99446 sqlite3ExprAlloc(db, TK_ID, &tToCol, 0)
99448 sqlite3ExprAlloc(db, TK_ID, &tFromCol, 0)
99450 pWhere = sqlite3ExprAnd(db, pWhere, pEq);
99460 sqlite3ExprAlloc(db, TK_ID, &tOld, 0),
99461 sqlite3ExprAlloc(db, TK_ID, &tToCol, 0),
99464 sqlite3ExprAlloc(db, TK_ID, &tNew, 0),
99465 sqlite3ExprAlloc(db, TK_ID, &tToCol, 0),
99468 pWhen = sqlite3ExprAnd(db, pWhen, pEq);
99475 sqlite3ExprAlloc(db, TK_ID, &tNew, 0),
99476 sqlite3ExprAlloc(db, TK_ID, &tToCol, 0)
99481 pNew = sqlite3ExprDup(db, pDflt, 0);
99492 sqlite3DbFree(db, aiCol);
99503 pRaise = sqlite3Expr(db, TK_RAISE, "FOREIGN KEY constraint failed");
99509 sqlite3SrcListAppend(db, 0, &tFrom, 0),
99517 enableLookaside = db->lookaside.bEnabled;
99518 db->lookaside.bEnabled = 0;
99520 pTrigger = (Trigger *)sqlite3DbMallocZero(db,
99530 pStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);
99531 pStep->pExprList = sqlite3ExprListDup(db, pList, EXPRDUP_REDUCE);
99532 pStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
99535 pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE);
99540 db->lookaside.bEnabled = enableLookaside;
99542 sqlite3ExprDelete(db, pWhere);
99543 sqlite3ExprDelete(db, pWhen);
99544 sqlite3ExprListDelete(db, pList);
99545 sqlite3SelectDelete(db, pSelect);
99546 if( db->mallocFailed==1 ){
99547 fkTriggerDelete(db, pTrigger);
99590 if( pParse->db->flags&SQLITE_ForeignKeys ){
99610 SQLITE_PRIVATE void sqlite3FkDelete(sqlite3 *db, Table *pTab){
99614 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pTab->pSchema) );
99618 if( !db || db->pnBytesFreed==0 ){
99638 fkTriggerDelete(db, pFKey->apTrigger[0]);
99639 fkTriggerDelete(db, pFKey->apTrigger[1]);
99643 sqlite3DbFree(db, pFKey);
99732 sqlite3 *db = sqlite3VdbeDb(v);
99735 db->mallocFailed = 1;
99772 sqlite3 *db = sqlite3VdbeDb(v);
99775 db->mallocFailed = 1;
99808 VTable *pVTab = IsVirtual(pTab) ? sqlite3GetVTable(p->db, pTab) : 0;
99871 pInfo = sqlite3DbMallocRaw(pParse->db, sizeof(*pInfo));
99892 sqlite3 *db = pParse->db; /* The database connection */
99893 Db *pDb; /* Database only autoinc table */
99905 pDb = &db->aDb[p->iDb];
99907 assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
99949 sqlite3 *db = pParse->db;
99953 Db *pDb = &db->aDb[p->iDb];
99959 assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
100094 sqlite3 *db; /* The main database structure */
100112 Db *pDb; /* The database containing table being inserted into */
100134 db = pParse->db;
100136 if( pParse->nErr || db->mallocFailed ){
100147 sqlite3SelectDelete(db, pSelect);
100160 iDb = sqlite3SchemaToIndex(db
100161 assert( iDb<db->nDb );
100162 pDb = &db->aDb[iDb];
100300 if( rc || db->mallocFailed || pParse->nErr ) goto insert_cleanup;
100393 if( db->flags & SQLITE_CountRows ){
100403 aRegIdx = sqlite3DbMallocRaw(db, sizeof(int)*(nIdx+1));
100602 const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
100622 if( (db->flags & SQLITE_CountRows)!=0 ){
100667 if( (db->flags&SQLITE_CountRows) && !pParse->nested && !pParse->pTriggerTab ){
100674 sqlite3SrcListDelete(db, pTabList);
100675 sqlite3ExprListDelete(db, pList);
100676 sqlite3SelectDelete(db, pSelect);
100677 sqlite3IdListDelete(db, pColumn);
100678 sqlite3DbFree(db, aRegIdx);
100793 sqlite3 *db; /* Database connection */
100808 db = pParse->db;
100854 char *zMsg = sqlite3MPrintf(db, "%s.%s", pTab->zName,
100880 if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){
100980 if( db->flags&SQLITE_RecTriggers ){
101156 if( db->flags&SQLITE_RecTriggers ){
101293 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
101420 sqlite3 *db = pParse->db;
101568 if( (db->flags & SQLITE_ForeignKeys)!=0 && pDest->pFKey!=0 ){
101572 if( (db->flags & SQLITE_CountRows)!=0 ){
101583 iDbSrc = sqlite3SchemaToIndex(db, pSrc->pSchema);
101593 if( (db->flags & SQLITE_Vacuum)==0 && (
101661 if( db->flags & SQLITE_Vacuum ){
101738 sqlite3 *db, /* The database on which the SQL executes */
101750 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
101753 sqlite3_mutex_enter(db->mutex);
101754 sqlite3Error(db, SQLITE_OK);
101760 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
101781 && db->flags&SQLITE_NullCallback)) ){
101783 azCols = sqlite3DbMallocZero(db, 2*nCol*sizeof(const char*) + 1);
101800 db->mallocFailed = 1;
101812 sqlite3Error(db, SQLITE_ABORT);
101826 sqlite3DbFree(db, azCols);
101832 sqlite3DbFree(db, azCols);
101834 rc = sqlite3ApiExit(db, rc);
101836 int nErrMsg = 1 + sqlite3Strlen30(sqlite3_errmsg(db));
101839 memcpy(*pzErrMsg, sqlite3_errmsg(db), nErrMsg);
101842 sqlite3Error(db, SQLITE_NOMEM);
101848 assert( (rc&db->errMask)==rc );
101849 sqlite3_mutex_leave(db->mutex);
101970 int (*errcode)(sqlite3*db);
102791 ** by calling sqlite3DbFree(db, ).
102794 sqlite3 *db, /* Load the extension into this database connection */
102799 sqlite3_vfs *pVfs = db->pVfs;
102829 if( (db->flags & SQLITE_LoadExtension)==0 ){
102909 if( xInit(db, &zErrmsg, &sqlite3Apis) ){
102918 /* Append the new shared library handle to the db->aExtension array. */
102919 aHandle = sqlite3DbMallocZero(db, sizeof(handle)*(db->nExtension+1));
102923 if( db->nExtension>0 ){
102924 memcpy(aHandle, db->aExtension, sizeof(handle)*db->nExtension);
102926 sqlite3DbFree(db, db->aExtension);
102927 db->aExtension = aHandle;
102929 db->aExtension[db->nExtension++] = handle;
102933 sqlite3 *db, /* Load the extension into this database connection */
102939 sqlite3_mutex_enter(db->mutex);
102940 rc = sqlite3LoadExtension(db, zFile, zProc, pzErrMsg);
102941 rc = sqlite3ApiExit(db, rc);
102942 sqlite3_mutex_leave(db->mutex);
102950 SQLITE_PRIVATE void sqlite3CloseExtensions(sqlite3 *db){
102952 assert( sqlite3_mutex_held(db->mutex) );
102953 for(i=0; i<db->nExtension; i++){
102954 sqlite3OsDlClose(db->pVfs, db->aExtension[i]);
102956 sqlite3DbFree(db, db->aExtension);
102963 SQLITE_API int SQLITE_STDCALL sqlite3_enable_load_extension(sqlite3 *db, int onoff){
102964 sqlite3_mutex_enter(db->mutex);
102966 db->flags |= SQLITE_LoadExtension;
102968 db->flags &= ~SQLITE_LoadExtension;
102970 sqlite3_mutex_leave(db->mutex);
103110 SQLITE_PRIVATE void sqlite3AutoLoadExtensions(sqlite3 *db){
103136 if( xInit && (rc = xInit(db, &zErrmsg, &sqlite3Apis))!=0 ){
103137 sqlite3ErrorWithMsg(db, rc,
103714 ** Interpret the given string as a temp db location. Return 1 for file
103737 sqlite3 *db = pParse->db;
103738 if( db->aDb[1].pBt!=0 ){
103739 if( !db->autoCommit || sqlite3BtreeIsInReadTrans(db->aDb[1].pBt) ){
103744 sqlite3BtreeClose(db->aDb[1].pBt);
103745 db->aDb[1].pBt = 0;
103746 sqlite3ResetAllSchemasOfConnection(db);
103760 sqlite3 *db = pParse->db;
103761 if( db->temp_store==ts ) return SQLITE_OK;
103765 db->temp_store = (u8)ts;
103776 i64 *pI64 = sqlite3DbMallocRaw(pParse->db, sizeof(value));
103792 static void setAllPagerFlags(sqlite3 *db){
103793 if( db->autoCommit ){
103794 Db *pDb = db->aDb;
103795 int n = db->nDb;
103805 pDb->safety_level | (db->flags & PAGER_FLAGS_MASK) );
103889 sqlite3 *db = pParse->db; /* The database connection */
103890 Db *pDb; /* The specific database being pragmaed */
103899 ** index of the database this pragma is being applied to in db.aDb[]. */
103902 pDb = &db->aDb[iDb];
103911 zLeft = sqlite3NameFromToken(db, pId);
103914 zRight = sqlite3MPrintf(db, "-%T", pValue);
103916 zRight = sqlite3NameFromToken(db, pValue);
103944 db->busyHandler.nBusy = 0;
103945 rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_PRAGMA, (void*)aFcntl);
104036 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
104064 db->nextPagesize = sqlite3Atoi(zRight);
104065 if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize,-1,0) ){
104066 db->mallocFailed = 1;
104089 for(ii=0; ii<db->nDb; ii++){
104090 sqlite3BtreeSecureDelete(db->aDb[ii].pBt, b);
104144 eMode = db->dfltLockMode;
104150 ** set on all attached databases, as well as the main db file.
104157 assert(pDb==&db->aDb[0]);
104158 for(ii=2; ii<db->nDb; ii++){
104159 pPager = sqlite3BtreePager(db->aDb[ii].pBt);
104162 db->dfltLockMode = (u8)eMode;
104213 for(ii=db->nDb-1; ii>=0; ii--){
104214 if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
104259 db->nextAutovac = (u8)eAuto;
104263 ** as an auto-vacuum capable db.
104330 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
104358 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
104363 if( pId2->n==0 ) db->szMmap = sz;
104364 for(ii=db->nDb-1; ii>=0; ii--){
104365 if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
104366 sqlite3BtreeSetMmapLimit(db->aDb[ii].pBt, sz);
104371 rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_MMAP_SIZE, &sz);
104398 returnSingleInt(pParse, "temp_store", db->temp_store);
104428 rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res);
104435 || (SQLITE_TEMP_STORE==1 && db->temp_store<=1)
104436 || (SQLITE_TEMP_STORE==2 && db->temp_store==1)
104478 rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res);
104553 if( !db->autoCommit ){
104560 setAllPagerFlags(db);
104570 returnSingleInt(pParse, pPragma->zName, (db->flags & pPragma->iArg)!=0 );
104573 if( db->autoCommit==0 ){
104579 if( db->auth.authLevel==UAUTH_User ){
104586 db->flags |= mask;
104588 db->flags &= ~mask;
104589 if( mask==SQLITE_DeferFKs ) db->nDeferredImmCons = 0;
104597 setAllPagerFlags(db);
104618 pTab = sqlite3FindTable(db, zRight, zDb);
104698 pIdx = sqlite3FindIndex(db, zRight, zDb);
104746 pTab = sqlite3FindTable(db, zRight, zDb);
104777 for(i=0; i<db->nDb; i++){
104778 if( db->aDb[i].pBt==0 ) continue;
104779 assert( db->aDb[i].zName!=0 );
104781 sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, db->aDb[i].zName, 0);
104783 sqlite3BtreeGetFilename(db->aDb[i].pBt), 0);
104796 for(p=sqliteHashFirst(&db->aCollSeq); p; p=sqliteHashNext(p)){
104810 pTab = sqlite3FindTable(db, zRight, zDb);
104882 k = sqliteHashFirst(&db->aDb[iDb].pSchema->tblHash);
104898 pParent = sqlite3FindTable(db, pFK->zTo, zDb);
104920 pParent = sqlite3FindTable(db, pFK->zTo, zDb);
104962 sqlite3DbFree(db, aiCols);
104990 sqlite3RegisterLikeFunctions(db, sqlite3GetBoolean(zRight, 0));
105020 /* If the PRAGMA command was of the form "PRAGMA <db>.integrity_check",
105021 ** then iDb is set to the index of the database identified by <db>.
105049 for(i=0; i<db->nDb; i++){
105068 assert( sqlite3SchemaMutexHeld(db, i, 0) );
105069 pTbls = &db->aDb[i].pSchema->tblHash;
105093 sqlite3MPrintf(db, "*** in database %s ***\n", db->aDb[i].zName),
105136 zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName,
105274 sqlite3VdbeChangeP4(v, -1, encnames[ENC(pParse->db)].zName, P4_STATIC);
105283 !(DbHasProperty(db, 0, DB_SchemaLoaded)) ||
105284 DbHasProperty(db, 0, DB_Empty)
105288 SCHEMA_ENC(db) = ENC(db) =
105426 db, sqlite3Atoi(zRight));
105429 db->xWalCallback==sqlite3WalDefaultHook ?
105430 SQLITE_PTR_TO_INT(db->pWalArg) : 0);
105443 sqlite3_db_release_memory(db);
105451 ** Call sqlite3_busy_timeout(db, N). Return the current timeout value
105459 sqlite3_busy_timeout(db, sqlite3Atoi(zRight));
105461 returnSingleInt(pParse, "timeout", db->busyTimeout);
105498 sqlite3_limit(db, SQLITE_LIMIT_WORKER_THREADS, (int)(N&0x7fffffff));
105501 sqlite3_limit(db, SQLITE_LIMIT_WORKER_THREADS, -1));
105518 for(i=0; i<db->nDb; i++){
105522 if( db->aDb[i].zName==0 ) continue;
105523 sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, db->aDb[i].zName, P4_STATIC);
105524 pBt = db->aDb[i].pBt;
105527 }else if( sqlite3_file_control(db, i ? db->aDb[i].zName : 0,
105540 if( zRight ) sqlite3_key_v2(db, zDb, zRight, sqlite3Strlen30(zRight));
105544 if( zRight ) sqlite3_rekey_v2(db, zDb, zRight, sqlite3Strlen30(zRight));
105557 sqlite3_key_v2(db, zDb, zKey, i/2);
105559 sqlite3_rekey_v2(db, zDb, zKey, i/2);
105584 sqlite3DbFree(db, zLeft);
105585 sqlite3DbFree(db, zRight);
105617 sqlite3 *db = pData->db;
105618 if( !db->mallocFailed && (db->flags & SQLITE_RecoveryMode)==0 ){
105620 sqlite3SetString(pData->pzErrMsg, db,
105623 *pData->pzErrMsg = sqlite3MAppendf(db, *pData->pzErrMsg,
105627 pData->rc = db->mallocFailed ? SQLITE_NOMEM : SQLITE_CORRUPT_BKPT;
105644 sqlite3 *db = pData->db;
105649 assert( sqlite3_mutex_held(db->mutex) );
105650 DbClearProperty(db, iDb, DB_Empty);
105651 if( db->mallocFailed ){
105656 assert( iDb>=0 && iDb<db->nDb );
105662 ** But because db->init.busy is set to 1, no VDBE code is generated
105670 assert( db->init.busy );
105671 db->init.iDb = iDb;
105672 db->init.newTnum = sqlite3Atoi(argv[1]);
105673 db->init.orphanTrigger = 0;
105674 TESTONLY(rcp = ) sqlite3_prepare(db, argv[2], -1, &pStmt, 0);
105675 rc = db->errCode;
105677 db->init.iDb = 0;
105679 if( db->init.orphanTrigger ){
105684 db->mallocFailed = 1;
105686 corruptSchema(pData, argv[0], sqlite3_errmsg(db));
105701 pIndex = sqlite3FindIndex(db, argv[0], db->aDb[iDb].zName);
105724 static int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg){
105731 Db *pDb;
105765 assert( iDb>=0 && iDb<db->nDb );
105766 assert( db->aDb[iDb].pSchema );
105767 assert( sqlite3_mutex_held(db->mutex) );
105768 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
105786 initData.db = db;
105795 pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName);
105802 pDb = &db->aDb[iDb];
105805 DbSetProperty(db, 1, DB_SchemaLoaded);
105817 sqlite3SetString(pzErrMsg, db, "%s", sqlite3ErrStr(rc));
105830 ** meta[4] Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE
105847 ** For an attached db, it is an error if the encoding is not the same
105854 /* If opening the main database, set ENC(db). */
105857 ENC(db) = encoding;
105859 ENC(db) = SQLITE_UTF8;
105862 /* If opening an attached database, the encoding much match ENC(db) */
105863 if( meta[BTREE_TEXT_ENCODING-1]!=ENC(db) ){
105864 sqlite3SetString(pzErrMsg, db, "attached databases must use the same"
105871 DbSetProperty(db, iDb, DB_Empty);
105873 pDb->pSchema->enc = ENC(db);
105897 sqlite3SetString(pzErrMsg, db, "unsupported file format");
105908 db->flags &= ~SQLITE_LegacyFileFmt;
105913 assert( db->init.busy );
105916 zSql = sqlite3MPrintf(db,
105918 db->aDb[iDb].zName, zMasterName);
105922 xAuth = db->xAuth;
105923 db->xAuth = 0;
105925 rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
105927 db->xAuth = xAuth;
105931 sqlite3DbFree(db, zSql);
105934 sqlite3AnalysisLoad(db, iDb);
105938 if( db->mallocFailed ){
105940 sqlite3ResetAllSchemasOfConnection(db);
105942 if( rc==SQLITE_OK || (db->flags&SQLITE_RecoveryMode)){
105951 DbSetProperty(db, iDb, DB_SchemaLoaded);
105967 db->mallocFailed = 1;
105979 ** bit is set in the flags field of the Db structure. If the database
105982 SQLITE_PRIVATE int sqlite3Init(sqlite3 *db, char **pzErrMsg){
105984 int commit_internal = !(db->flags&SQLITE_InternChanges);
105986 assert( sqlite3_mutex_held(db->mutex) );
105987 assert( sqlite3BtreeHoldsMutex(db->aDb[0].pBt) );
105988 assert( db->init.busy==0 );
105990 db->init.busy = 1;
105991 ENC(db) = SCHEMA_ENC(db);
105992 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
105993 if( DbHasProperty(db, i, DB_SchemaLoaded) || i==1 ) continue;
105994 rc = sqlite3InitOne(db, i, pzErrMsg);
105996 sqlite3ResetOneSchema(db, i);
106005 assert( db->nDb>1 );
106006 if( rc==SQLITE_OK && !DbHasProperty(db, 1, DB_SchemaLoaded) ){
106007 rc = sqlite3InitOne(db, 1, pzErrMsg);
106009 sqlite3ResetOneSchema(db, 1);
106014 db->init.busy = 0;
106016 sqlite3CommitInternalChanges(db);
106028 sqlite3 *db = pParse->db;
106029 assert( sqlite3_mutex_held(db->mutex) );
106030 if( !db->init.busy ){
106031 rc = sqlite3Init(db, &pParse->zErrMsg);
106047 sqlite3 *db = pParse->db;
106053 assert( sqlite3_mutex_held(db->mutex) );
106054 for(iDb=0; iDb<db->nDb; iDb++){
106056 Btree *pBt = db->aDb[iDb].pBt; /* Btree database to read cookie from */
106065 db->mallocFailed = 1;
106075 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
106076 if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){
106077 sqlite3ResetOneSchema(db, iDb);
106090 ** which database file in db->aDb[] the schema refers to.
106095 SQLITE_PRIVATE int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){
106104 ** -1000000 as the incorrect index into db->aDb[] is much
106108 assert( sqlite3_mutex_held(db->mutex) );
106110 for(i=0; ALWAYS(i<db->nDb); i++){
106111 if( db->aDb[i].pSchema==pSchema ){
106115 assert( i>=0 && i<db->nDb );
106125 sqlite3 *db = pParse->db;
106126 sqlite3DbFree(db, pParse->aLabel);
106127 sqlite3ExprListDelete(db, pParse->pConstExpr);
106135 sqlite3 *db, /* Database handle. */
106149 pParse = sqlite3StackAllocZero(db, sizeof(*pParse));
106156 assert( !db->mallocFailed );
106157 assert( sqlite3_mutex_held(db->mutex) );
106182 for(i=0; i<db->nDb; i++) {
106183 Btree *pBt = db->aDb[i].pBt;
106188 const char *zDb = db->aDb[i].zName;
106189 sqlite3ErrorWithMsg(db, rc, "database schema is locked: %s", zDb);
106190 testcase( db->flags & SQLITE_ReadUncommitted );
106196 sqlite3VtabUnlockList(db);
106198 pParse->db = db;
106202 int mxLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH];
106206 sqlite3ErrorWithMsg(db, SQLITE_TOOBIG, "statement too long");
106207 rc = sqlite3ApiExit(db, SQLITE_TOOBIG);
106210 zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes);
106213 sqlite3DbFree(db, zSqlCopy);
106223 if( db->mallocFailed ){
106230 if( db->mallocFailed ){
106261 if( db->init.busy==0 ){
106265 if( pParse->pVdbe && (rc!=SQLITE_OK || db->mallocFailed) ){
106273 sqlite3ErrorWithMsg(db, rc, "%s", zErrMsg);
106274 sqlite3DbFree(db, zErrMsg);
106276 sqlite3Error(db, rc);
106283 sqlite3DbFree(db, pT);
106289 sqlite3StackFree(db, pParse);
106290 rc = sqlite3ApiExit(db, rc);
106291 assert( (rc&db->errMask)==rc );
106295 sqlite3 *db, /* Database handle. */
106309 if( !sqlite3SafetyCheckOk(db)||zSql==0 ){
106312 sqlite3_mutex_enter(db->mutex);
106313 sqlite3BtreeEnterAll(db);
106314 rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail);
106317 rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail);
106319 sqlite3BtreeLeaveAll(db);
106320 sqlite3_mutex_leave(db->mutex);
106337 sqlite3 *db;
106342 db = sqlite3VdbeDb(p);
106343 assert( sqlite3_mutex_held(db->mutex) );
106344 rc = sqlite3LockAndPrepare(db, zSql, -1, 0, p, &pNew, 0);
106347 db->mallocFailed = 1;
106371 sqlite3 *db, /* Database handle. */
106378 rc = sqlite3LockAndPrepare(db,zSql,nBytes,0,0,ppStmt,pzTail);
106383 sqlite3 *db, /* Database handle. */
106390 rc = sqlite3LockAndPrepare(db,zSql,nBytes,1,0,ppStmt,pzTail);
106401 sqlite3 *db, /* Database handle. */
106420 if( !sqlite3SafetyCheckOk(db)||zSql==0 ){
106429 sqlite3_mutex_enter(db->mutex);
106430 zSql8 = sqlite3Utf16to8(db, zSql, nBytes, SQLITE_UTF16NATIVE);
106432 rc = sqlite3LockAndPrepare(db, zSql8, -1, saveSqlFlag, 0, ppStmt, &zTail8);
106444 sqlite3DbFree(db
106445 rc = sqlite3ApiExit(db, rc);
106446 sqlite3_mutex_leave(db->mutex);
106459 sqlite3 *db, /* Database handle. */
106466 rc = sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail);
106471 sqlite3 *db, /* Database handle. */
106478 rc = sqlite3Prepare16(db,zSql,nBytes,1,ppStmt,pzTail);
106549 static void clearSelect(sqlite3 *db, Select *p, int bFree){
106552 sqlite3ExprListDelete(db, p->pEList);
106553 sqlite3SrcListDelete(db, p->pSrc);
106554 sqlite3ExprDelete(db, p->pWhere);
106555 sqlite3ExprListDelete(db, p->pGroupBy);
106556 sqlite3ExprDelete(db, p->pHaving);
106557 sqlite3ExprListDelete(db, p->pOrderBy);
106558 sqlite3ExprDelete(db, p->pLimit);
106559 sqlite3ExprDelete(db, p->pOffset);
106560 sqlite3WithDelete(db, p->pWith);
106561 if( bFree ) sqlite3DbFree(db, p);
106597 sqlite3 *db = pParse->db;
106598 pNew = sqlite3DbMallocZero(db, sizeof(*pNew) );
106600 assert( db->mallocFailed );
106605 pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db,TK_ALL,0));
106608 if( pSrc==0 ) pSrc = sqlite3DbMallocZero(db, sizeof(*pSrc));
106618 assert( pOffset==0 || pLimit!=0 || pParse->nErr>0 || db->mallocFailed!=0 );
106621 if( db->mallocFailed ) {
106622 clearSelect(db, pNew, pNew!=&standin);
106646 SQLITE_PRIVATE void sqlite3SelectDelete(sqlite3 *db, Select *p){
106647 clearSelect(db, p, 1);
106798 sqlite3 *db = pParse->db;
106808 pE1 = sqlite3CreateColumnExpr(db, pSrc, iLeft, iColLeft);
106809 pE2 = sqlite3CreateColumnExpr(db, pSrc, iRight, iColRight);
106818 *ppWhere = sqlite3ExprAnd(db, *ppWhere, pEq);
106924 p->pWhere = sqlite3ExprAnd(pParse->db
107025 if( pParse->db->mallocFailed ) return;
107245 assert( sqlite3VdbeCurrentAddr(v)==iJump || pParse->db->mallocFailed );
107465 SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoAlloc(sqlite3 *db, int N, int X){
107472 p->enc = ENC(db);
107473 p->db = db;
107476 db->mallocFailed = 1;
107536 sqlite3 *db = pParse->db;
107540 pInfo = sqlite3KeyInfoAlloc(db, nExpr-iStart, nExtra+1);
107546 if( !pColl ) pColl = db->pDfltColl;
107584 char *zMsg = sqlite3MPrintf(pParse->db, "USE TEMP B-TREE FOR %s", zUsage);
107630 pParse->db, "COMPOUND SUBQUERIES %d AND %d %s(%s)", iSub1, iSub2,
107896 int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
107897 zOrigDb = pNC->pParse->db->aDb[iDb].zName;
107992 sqlite3 *db = pParse->db;
108002 if( pParse->colNamesSet || NEVER(v==0) || db->mallocFailed ) return;
108004 fullNames = (db->flags & SQLITE_FullColNames)!=0;
108005 shortNames = (db->flags & SQLITE_ShortColNames)!=0;
108032 sqlite3DbStrDup(db, pEList->a[i].zSpan), SQLITE_DYNAMIC);
108035 zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol);
108042 z = z==0 ? sqlite3MPrintf(db, "column%d", i+1) : sqlite3DbStrDup(db, z);
108068 sqlite3 *db = pParse->db; /* Database connection */
108079 aCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
108094 zName = sqlite3DbStrDup(db, zName);
108107 zName = sqlite3MPrintf(db, "%s",
108111 zName = sqlite3MPrintf(db, "%s", pColExpr->u.zToken);
108114 zName = sqlite3MPrintf(db, "%s", pEList->a[i].zSpan);
108117 if( db->mallocFailed ){
108118 sqlite3DbFree(db, zName);
108133 zNewName = sqlite3MPrintf(db, "%s:%d", zName, ++cnt);
108134 sqlite3DbFree(db, zName);
108142 if( db->mallocFailed ){
108144 sqlite3DbFree(db, aCol[j].zName);
108146 sqlite3DbFree(db, aCol);
108170 sqlite3 *db = pParse->db;
108181 assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed );
108182 if( db->mallocFailed ) return;
108189 pCol->zType = sqlite3DbStrDup(db, columnType(&sNC, p,0,0,0, &pCol->szEst));
108196 pCol->zColl = sqlite3DbStrDup(db, pColl->zName);
108208 sqlite3 *db = pParse->db;
108211 savedFlags = db->flags;
108212 db->flags &= ~SQLITE_FullColNames;
108213 db->flags |= SQLITE_ShortColNames;
108217 db->flags = savedFlags;
108218 pTab = sqlite3DbMallocZero(db, sizeof(Table) );
108224 assert( db->lookaside.bEnabled==0 );
108231 if( db->mallocFailed ){
108232 sqlite3DeleteTable(db, pTab);
108248 && OptimizationEnabled(pParse->db,SQLITE_FactorOutConst)
108367 sqlite3 *db = pParse->db;
108368 KeyInfo *pRet = sqlite3KeyInfoAlloc(db, nOrderBy+nExtra, 1);
108380 if( pColl==0 ) pColl = db->pDfltColl;
108549 sqlite3ExprListDelete(pParse->db, p->pOrderBy);
108665 sqlite3 *db; /* Database connection */
108676 db = pParse->db;
108836 sqlite3ExprListDelete(db, p->pOrderBy);
108841 sqlite3ExprDelete(db, p->pLimit);
108921 sqlite3ExprDelete(db, p->pLimit);
108973 pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1);
108981 *apColl = db->pDfltColl;
109006 sqlite3SelectDelete(db, pDelete);
109060 if( pParse->db->mallocFailed ) return 0;
109288 sqlite3 *db; /* Database connection */
109299 db = pParse->db;
109320 for(i=1; db->mallocFailed==0 && i<=p->pEList->nExpr; i++){
109327 Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
109344 aPermute = sqlite3DbMallocRaw(db, sizeof(int)*nOrderBy);
109362 pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy, 0);
109372 assert( nOrderBy>=nExpr || db->mallocFailed );
109376 pKeyDup = sqlite3KeyInfoAlloc(db, nExpr, 1);
109406 sqlite3ExprDelete(db, p->pLimit);
109408 sqlite3ExprDelete(db, p->pOffset);
109553 sqlite3SelectDelete(db, p->pPrior);
109584 sqlite3 *db, /* Report malloc errors to this connection */
109597 pNew = sqlite3ExprDup(db, pEList->a[pExpr->iColumn].pExpr, 0);
109598 sqlite3ExprDelete(db, pExpr);
109602 pExpr->pLeft = substExpr(db, pExpr->pLeft, iTable, pEList);
109603 pExpr->pRight = substExpr(db, pExpr->pRight, iTable, pEList);
109605 substSelect(db, pExpr->x.pSelect, iTable, pEList);
109607 substExprList(db, pExpr->x.pList, iTable, pEList);
109613 sqlite3 *db, /* Report malloc errors here */
109621 pList->a[i].pExpr = substExpr(db, pList->a[i].pExpr, iTable, pEList);
109625 sqlite3 *db, /* Report malloc errors here */
109634 substExprList(db, p->pEList, iTable, pEList);
109635 substExprList(db, p->pGroupBy, iTable, pEList);
109636 substExprList(db, p->pOrderBy, iTable, pEList);
109637 p->pHaving = substExpr(db, p->pHaving, iTable, pEList);
109638 p->pWhere = substExpr(db, p->pWhere, iTable, pEList);
109639 substSelect(db, p->pPrior, iTable, pEList);
109644 substSelect(db, pItem->pSelect, iTable, pEList);
109808 sqlite3 *db = pParse->db;
109814 if( OptimizationDisabled(db, SQLITE_QueryFlattener) ) return 0;
109994 pNew = sqlite3SelectDup(db, p, 0);
110012 if( db->mallocFailed ) return 1;
110023 sqlite3DbFree(db, pSubitem->zDatabase);
110024 sqlite3DbFree(db, pSubitem->zName);
110025 sqlite3DbFree(db, pSubitem->zAlias);
110075 pSrc = pParent->pSrc = sqlite3SrcListAppend(db, 0, 0, 0);
110077 assert( db->mallocFailed );
110098 pParent->pSrc = pSrc = sqlite3SrcListEnlarge(db, pSrc, nSubSrc-1,iFrom+1);
110099 if( db->mallocFailed ){
110108 sqlite3IdListDelete(db, pSrc->a[i+iFrom].pUsing);
110129 char *zName = sqlite3DbStrDup(db, pList->a[i].zSpan);
110134 substExprList(db, pParent->pEList, iParent, pSub->pEList);
110136 substExprList(db, pParent->pGroupBy, iParent, pSub->pEList);
110137 pParent->pHaving = substExpr(db, pParent->pHaving, iParent, pSub->pEList);
110159 substExprList(db, pParent->pOrderBy, iParent, pSub->pEList);
110162 pWhere = sqlite3ExprDup(db, pSub->pWhere, 0);
110170 pParent->pHaving = substExpr(db, pParent->pHaving, iParent, pSub->pEList);
110171 pParent->pHaving = sqlite3ExprAnd(db, pParent->pHaving,
110172 sqlite3ExprDup(db, pSub->pHaving, 0));
110174 pParent->pGroupBy = sqlite3ExprListDup(db, pSub->pGroupBy, 0);
110176 pParent->pWhere = substExpr(db, pParent->pWhere, iParent, pSub->pEList);
110177 pParent->pWhere = sqlite3ExprAnd(db, pParent->pWhere, pWhere);
110200 sqlite3SelectDelete(db, pSub1);
110338 sqlite3 *db;
110357 db = pParse->db;
110358 pNew = sqlite3DbMallocZero(db, sizeof(*pNew) );
110365 p->pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ALL, 0));
110455 sqlite3 *db = pParse->db;
110480 pFrom->pTab = pTab = sqlite3DbMallocZero(db, sizeof(Table));
110483 pTab->zName = sqlite3DbStrDup(db, pCte->zName);
110487 pFrom->pSelect = sqlite3SelectDup(db, pCte->pSelect, 0);
110488 if( db->mallocFailed ) return SQLITE_NOMEM;
110606 sqlite3 *db = pParse->db;
110611 if( db->mallocFailed ){
110656 pFrom->pTab = pTab = sqlite3DbMallocZero(db, sizeof(Table));
110659 pTab->zName = sqlite3MPrintf(db, "sqlite_sq_%p", (void*)pTab);
110683 pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect, 0);
110698 if( db->mallocFailed || sqliteProcessJoin(pParse, p) ){
110727 int flags = pParse->db->flags;
110772 if( db->mallocFailed ) break;
110778 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
110779 zSchemaName = iDb>=0 ? db->aDb[iDb].zName : "*";
110818 pRight = sqlite3Expr(db, TK_ID, zName);
110823 pLeft = sqlite3Expr(db, TK_ID, zTabName);
110826 pLeft = sqlite3Expr(db, TK_ID, zSchemaName);
110830 zColname = sqlite3MPrintf(db, "%s.%s", zTabName, zName);
110843 pX->zSpan = sqlite3DbStrDup(db, pSub->pEList->a[j].zSpan);
110846 pX->zSpan = sqlite3MPrintf(db, "%s.%s.%s",
110852 sqlite3DbFree(db, zToFree);
110864 sqlite3ExprListDelete(db, pEList);
110868 if( p->pEList && p->pEList->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
110900 ** and/or pParse->db->mallocFailed.
110996 sqlite3 *db;
110998 db = pParse->db;
110999 if( db->mallocFailed ) return;
111002 if( pParse->nErr || db
111004 if( pParse->nErr || db->mallocFailed ) return;
111111 pColl = pParse->db->pDfltColl;
111163 char *zEqp = sqlite3MPrintf(pParse->db, "SCAN TABLE %s%s%s",
111209 sqlite3 *db; /* The database connection */
111216 db = pParse->db;
111217 if( p==0 || db->mallocFailed || pParse->nErr ){
111241 sqlite3ExprListDelete(db, p->pOrderBy);
111250 if( pParse->nErr || db->mallocFailed ){
111319 && OptimizationEnabled(db, SQLITE_SubqCoroutine)
111370 if( /*pParse->nErr ||*/ db->mallocFailed ){
111419 p->pGroupBy = sqlite3ExprListDup(db, p->pEList, 0);
111588 if( db->mallocFailed ) goto select_end;
111715 if( orderByGrp && OptimizationEnabled(db, SQLITE_GroupByOrder)
111838 const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
111919 pMinMax = sqlite3ExprListDup(db, pMinMax, 0);
111921 if( pMinMax && !db->mallocFailed ){
111934 sqlite3ExprListDelete(db, pDel);
111952 sqlite3ExprListDelete(db, pDel);
111990 sqlite3DbFree(db, sAggInfo.aCol);
111991 sqlite3DbFree(db, sAggInfo.aFunc);
112212 sqlite3 *db, /* The database on which the SQL executes */
112223 if( !sqlite3SafetyCheckOk(db) || pazResult==0 ) return SQLITE_MISUSE_BKPT;
112237 db->errCode = SQLITE_NOMEM;
112241 rc = sqlite3_exec(db, zSql, sqlite3_get_table_cb, &res, pzErrMsg);
112253 db->errCode = res.rc; /* Assume 32-bit assignment is atomic */
112266 db->errCode = SQLITE_NOMEM;
112314 SQLITE_PRIVATE void sqlite3DeleteTriggerStep(sqlite3 *db, TriggerStep *pTriggerStep){
112319 sqlite3ExprDelete(db, pTmp->pWhere);
112320 sqlite3ExprListDelete(db, pTmp->pExprList);
112321 sqlite3SelectDelete(db, pTmp->pSelect);
112322 sqlite3IdListDelete(db, pTmp->pIdList);
112324 sqlite3DbFree(db, pTmp);
112343 Schema * const pTmpSchema = pParse->db->aDb[1].pSchema;
112352 assert( sqlite3SchemaMutexHeld(pParse->db, 0, pTmpSchema) );
112390 sqlite3 *db = pParse->db; /* The database connection */
112392 Token *pName; /* The unqualified db name */
112393 DbFixer sFix; /* State vector for the DB fixer */
112409 /* Figure out the db that the trigger will be created in */
112415 if( !pTableName || db->mallocFailed ){
112427 if( db->init.busy && iDb!=1 ){
112428 sqlite3DbFree(db, pTableName->a[0].zDatabase);
112438 if( db->init.busy==0 && pName2->n==0 && pTab
112439 && pTab->pSchema==db->aDb[1].pSchema ){
112444 if( db->mallocFailed ) goto trigger_cleanup;
112453 if( db->init.iDb==1 ){
112462 db->init.orphanTrigger = 1;
112473 zName = sqlite3NameFromToken(db, pName);
112477 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
112478 if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),zName) ){
112482 assert( !db->init.busy );
112507 iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
112512 const char *zDb = db->aDb[iTabDb].zName;
112513 const char *zDbTrig = isTemp ? db->aDb[1].zName : zDb;
112534 pTrigger = (Trigger*)sqlite3DbMallocZero(db, sizeof(Trigger));
112538 pTrigger->table = sqlite3DbStrDup(db, pTableName->a[0].zName);
112539 pTrigger->pSchema = db->aDb[iDb].pSchema;
112543 pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE);
112544 pTrigger->pColumns = sqlite3IdListDup(db, pColumns);
112549 sqlite3DbFree(db, zName);
112550 sqlite3SrcListDelete(db, pTableName);
112551 sqlite3IdListDelete(db, pColumns);
112552 sqlite3ExprDelete(db, pWhen);
112554 sqlite3DeleteTrigger(db, pTrigger);
112571 sqlite3 *db = pParse->db; /* The database */
112579 iDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
112597 if( !db->init.busy ){
112605 z = sqlite3DbStrNDup(db, (char*)pAll->z, pAll->n);
112608 db->aDb[iDb].zName, SCHEMA_TABLE(iDb), zName,
112610 sqlite3DbFree(db, z);
112613 sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName));
112616 if( db->init.busy ){
112618 Hash *pHash = &db->aDb[iDb].pSchema->trigHash;
112619 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
112622 db->mallocFailed = 1;
112633 sqlite3DeleteTrigger(db, pTrig);
112635 sqlite3DeleteTriggerStep(db, pStepList);
112645 SQLITE_PRIVATE TriggerStep *sqlite3TriggerSelectStep(sqlite3 *db, Select *pSelect){
112646 TriggerStep *pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep));
112648 sqlite3SelectDelete(db, pSelect);
112661 ** If an OOM error occurs, NULL is returned and db->mallocFailed is set.
112664 sqlite3 *db, /* Database connection */
112670 pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep) + pName->n + 1);
112689 sqlite3 *db, /* The database connection */
112697 assert(pSelect != 0 || db->mallocFailed);
112699 pTriggerStep = triggerStepAllocate(db, TK_INSERT, pTableName);
112701 pTriggerStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
112705 sqlite3IdListDelete(db, pColumn);
112707 sqlite3SelectDelete(db, pSelect);
112718 sqlite3 *db, /* The database connection */
112726 pTriggerStep = triggerStepAllocate(db, TK_UPDATE, pTableName);
112728 pTriggerStep->pExprList = sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE);
112729 pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);
112732 sqlite3ExprListDelete(db, pEList);
112733 sqlite3ExprDelete(db, pWhere);
112743 sqlite3 *db, /* Database connection */
112749 pTriggerStep = triggerStepAllocate(db, TK_DELETE, pTableName);
112751 pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);
112754 sqlite3ExprDelete(db, pWhere);
112761 SQLITE_PRIVATE void sqlite3DeleteTrigger(sqlite3 *db, Trigger *pTrigger){
112763 sqlite3DeleteTriggerStep(db, pTrigger->step_list);
112764 sqlite3DbFree(db, pTrigger->zName);
112765 sqlite3DbFree(db, pTrigger->table);
112766 sqlite3ExprDelete(db, pTrigger->pWhen);
112767 sqlite3IdListDelete(db, pTrigger->pColumns);
112768 sqlite3DbFree(db, pTrigger);
112784 db = pParse->db;
112786 if( db->mallocFailed ) goto drop_trigger_cleanup;
112794 assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
112795 for(i=OMIT_TEMPDB; i<db->nDb; i++){
112797 if( zDb && sqlite3StrICmp(db->aDb[j].zName, zDb) ) continue;
112798 assert( sqlite3SchemaMutexHeld(db, j, 0) );
112799 pTrigger = sqlite3HashFind(&(db->aDb[j].pSchema->trigHash), zName);
112814 sqlite3SrcListDelete(db, pName);
112832 sqlite3 *db = pParse->db;
112835 iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema);
112836 assert( iDb>=0 && iDb<db->nDb );
112843 const char *zDb = db->aDb[iDb].zName;
112888 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){
112892 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
112893 pHash = &(db->aDb[iDb].pSchema->trigHash);
112902 sqlite3DeleteTrigger(db, pTrigger);
112903 db->flags |= SQLITE_InternChanges;
112942 if( (pParse->db->flags & SQLITE_EnableTrigger)!=0 ){
112971 sqlite3 *db = pParse->db;
112975 pSrc = sqlite3SrcListAppend(db, 0, 0, 0);
112978 pSrc->a[pSrc->nSrc-1].zName = sqlite3DbStrDup(db, pStep->zTarget);
112979 iDb = sqlite3SchemaToIndex(db, pStep->pTrig->pSchema);
112981 assert( iDb<db->nDb );
112982 pSrc->a[pSrc->nSrc-1].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zName);
112999 sqlite3 *db = pParse->db;
113025 sqlite3ExprListDup(db, pStep->pExprList, 0),
113026 sqlite3ExprDup(db, pStep->pWhere, 0),
113034 sqlite3SelectDup(db, pStep->pSelect, 0),
113035 sqlite3IdListDup(db, pStep->pIdList),
113043 sqlite3ExprDup(db, pStep->pWhere, 0)
113049 Select *pSelect = sqlite3SelectDup(db, pStep->pSelect, 0);
113052 sqlite3SelectDelete(db, pSelect);
113095 sqlite3DbFree(pFrom->db, pFrom->zErrMsg);
113110 sqlite3 *db = pParse->db; /* Database handle */
113125 pPrg = sqlite3DbMallocZero(db, sizeof(TriggerPrg));
113129 pPrg->pProgram = pProgram = sqlite3DbMallocZero(db, sizeof(SubProgram));
113139 pSubParse = sqlite3StackAllocZero(db, sizeof(Parse));
113143 pSubParse->db = db;
113162 sqlite3MPrintf(db, "-- TRIGGER %s", pTrigger->zName), P4_DYNAMIC
113170 pWhen = sqlite3ExprDup(db, pTrigger->pWhen, 0);
113172 && db->mallocFailed==0
113177 sqlite3ExprDelete(db, pWhen);
113191 if( db->mallocFailed==0 ){
113206 sqlite3StackFree(db, pSubParse);
113262 assert( pPrg || pParse->nErr || pParse->db->mallocFailed );
113267 int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers));
113348 || p->pSchema==pParse->db->aDb[1].pSchema );
113523 sqlite3 *db; /* The database structure */
113561 db = pParse->db;
113562 if( pParse->nErr || db->mallocFailed ){
113571 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
113616 aXRef = sqlite3DbMallocRaw(db, sizeof(int) * (pTab->nCol+nIdx) + nIdx+2 );
113668 db->aDb[iDb].zName);
113817 if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab ){
114030 if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab){
114072 if( (db->flags&SQLITE_CountRows) && !pParse->pTriggerTab && !pParse->nested ){
114080 sqlite3DbFree(db, aXRef); /* Also frees aRegIdx[] and aToOpen[] */
114081 sqlite3SrcListDelete(db, pTabList);
114082 sqlite3ExprListDelete(db, pChanges);
114083 sqlite3ExprDelete(db, pWhere);
114134 sqlite3 *db = pParse->db; /* Database connection */
114135 const char *pVTab = (const char*)sqlite3GetVTable(db, pTab);
114141 pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ID, "_rowid_"));
114144 sqlite3ExprDup(db, pRowid, 0));
114149 pExpr = sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr, 0);
114151 pExpr = sqlite3Expr(db, TK_ID, pTab->aCol[i].zName);
114188 sqlite3SelectDelete(db, pSelect);
114216 static int vacuumFinalize(sqlite3 *db, sqlite3_stmt *pStmt, char **pzErrMsg){
114220 sqlite3SetString(pzErrMsg, db, sqlite3_errmsg(db));
114226 ** Execute zSql on database db. Return an error code.
114228 static int execSql(sqlite3 *db, char **pzErrMsg, const char *zSql){
114234 if( SQLITE_OK!=sqlite3_prepare(db, zSql, -1, &pStmt, 0) ){
114235 sqlite3SetString(pzErrMsg, db, sqlite3_errmsg(db));
114236 return sqlite3_errcode(db);
114239 assert( rc!=SQLITE_ROW || (db->flags&SQLITE_CountRows) );
114240 return vacuumFinalize(db, pStmt, pzErrMsg);
114244 ** Execute zSql on database db. The statement returns exactly
114247 static int execExecSql(sqlite3 *db, char **pzErrMsg, const char *zSql){
114251 rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
114255 rc = execSql(db, pzErrMsg, (char*)sqlite3_column_text(pStmt, 0));
114257 vacuumFinalize(db, pStmt, pzErrMsg);
114262 return vacuumFinalize(db, pStmt, pzErrMsg);
114307 SQLITE_PRIVATE int sqlite3RunVacuum(char **pzErrMsg, sqlite3 *db){
114312 int saved_flags; /* Saved value of the db->flags */
114313 int saved_nChange; /* Saved value of db->nChange */
114314 int saved_nTotalChange; /* Saved value of db->nTotalChange */
114315 void (*saved_xTrace)(void*,const char*); /* Saved db->xTrace */
114316 Db *pDb = 0; /* Database to detach at end of vacuum */
114321 if( !db->autoCommit ){
114322 sqlite3SetString(pzErrMsg, db, "cannot VACUUM from within a transaction");
114325 if( db->nVdbeActive>1 ){
114326 sqlite3SetString(pzErrMsg, db,"cannot VACUUM - SQL statements in progress");
114333 saved_flags = db->flags;
114334 saved_nChange = db->nChange;
114335 saved_nTotalChange = db->nTotalChange;
114336 saved_xTrace = db->xTrace;
114337 db->flags |= SQLITE_WriteSchema | SQLITE_IgnoreChecks | SQLITE_PreferBuiltin;
114338 db->flags &= ~(SQLITE_ForeignKeys | SQLITE_ReverseOrder);
114339 db->xTrace = 0;
114341 pMain = db->aDb[0].pBt;
114358 nDb = db->nDb;
114359 if( sqlite3TempInMemory(db) ){
114364 rc = execSql(db, pzErrMsg, zSql);
114365 if( db->nDb>nDb ){
114366 pDb = &db->aDb[db->nDb-1];
114370 pTemp = db->aDb[db->nDb-1].pBt;
114382 if( db->nextPagesize ){
114386 sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
114387 if( nKey ) db->nextPagesize = 0;
114391 rc = execSql(db, pzErrMsg, "PRAGMA vacuum_db.synchronous=OFF");
114398 rc = execSql(db, pzErrMsg, "BEGIN;");
114406 db->nextPagesize = 0;
114410 || (!isMemDb && sqlite3BtreeSetPageSize(pTemp, db->nextPagesize, nRes, 0))
114411 || NEVER(db->mallocFailed)
114418 sqlite3BtreeSetAutoVacuum(pTemp, db->nextAutovac>=0 ? db->nextAutovac :
114425 rc = execExecSql(db, pzErrMsg,
114431 rc = execExecSql(db, pzErrMsg,
114435 rc = execExecSql(db, pzErrMsg,
114444 assert( (db->flags & SQLITE_Vacuum)==0 );
114445 db->flags |= SQLITE_Vacuum;
114446 rc = execExecSql(db, pzErrMsg,
114453 assert( (db->flags & SQLITE_Vacuum)!=0 );
114454 db->flags &= ~SQLITE_Vacuum;
114459 rc = execExecSql(db, pzErrMsg,
114464 rc = execExecSql(db, pzErrMsg,
114477 rc = execSql(db, pzErrMsg,
114535 /* Restore the original value of db->flags */
114536 db->flags = saved_flags;
114537 db->nChange = saved_nChange;
114538 db->nTotalChange = saved_nTotalChange;
114539 db->xTrace = saved_xTrace;
114549 db->autoCommit = 1;
114557 /* This both clears the schemas and reduces the size of the db->aDb[]
114559 sqlite3ResetAllSchemasOfConnection(db);
114603 sqlite3 *db, /* Database in which module is registered */
114612 sqlite3_mutex_enter(db->mutex);
114614 if( sqlite3HashFind(&db->aModule, zName) ){
114618 pMod = (Module *)sqlite3DbMallocRaw(db, sizeof(Module) + nName + 1);
114627 pDel = (Module *)sqlite3HashInsert(&db->aModule,zCopy,(void*)pMod);
114630 db->mallocFailed = 1;
114631 sqlite3DbFree(db, pDel);
114635 rc = sqlite3ApiExit(db, rc);
114638 sqlite3_mutex_leave(db->mutex);
114647 sqlite3 *db, /* Database in which module is registered */
114653 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
114655 return createModule(db, zName, pModule, pAux, 0);
114662 sqlite3 *db, /* Database in which module is registered */
114669 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
114671 return createModule(db, zName, pModule, pAux, xDestroy);
114689 ** Return a pointer to the VTable object used by connection db to access
114692 SQLITE_PRIVATE VTable *sqlite3GetVTable(sqlite3 *db, Table *pTab){
114695 for(pVtab=pTab->pVTable; pVtab && pVtab->db!=db; pVtab=pVtab->pNext);
114704 sqlite3 *db = pVTab->db;
114706 assert( db );
114708 assert( db->magic==SQLITE_MAGIC_OPEN || db->magic==SQLITE_MAGIC_ZOMBIE );
114716 sqlite3DbFree(db, pVTab);
114724 ** Except, if argument db is not NULL, then the entry associated with
114725 ** connection db is left in the p->pVTable list.
114727 static VTable *vtabDisconnectAll(sqlite3 *db, Table *p){
114738 assert( db==0 || sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
114741 sqlite3 *db2 = pVTable->db;
114744 if( db2==db ){
114755 assert( !db || pRet );
114761 ** for table *p associated with database connection db from the linked
114763 ** used when closing database connection db to free all of its VTable
114767 SQLITE_PRIVATE void sqlite3VtabDisconnect(sqlite3 *db, Table *p){
114771 assert( sqlite3BtreeHoldsAllMutexes(db) );
114772 assert( sqlite3_mutex_held(db->mutex) );
114775 if( (*ppVTab)->db==db ){
114789 ** shared b-tree databases opened using connection db are held by the
114805 SQLITE_PRIVATE void sqlite3VtabUnlockList(sqlite3 *db){
114806 VTable *p = db->pDisconnect;
114807 db->pDisconnect = 0;
114809 assert( sqlite3BtreeHoldsAllMutexes(db) );
114810 assert( sqlite3_mutex_held(db->mutex) );
114813 sqlite3ExpirePreparedStatements(db);
114831 ** connection db is decremented immediately (which may lead to the
114836 SQLITE_PRIVATE void sqlite3VtabClear(sqlite3 *db, Table *p){
114837 if( !db || db->pnBytesFreed==0 ) vtabDisconnectAll(0, p);
114841 if( i!=1 ) sqlite3DbFree(db, p->azModuleArg[i]);
114843 sqlite3DbFree(db, p->azModuleArg);
114853 static void addModuleArgument(sqlite3 *db, Table *pTable, char *zArg){
114857 azModuleArg = sqlite3DbRealloc(db, pTable->azModuleArg, nBytes);
114861 sqlite3DbFree(db, pTable->azModuleArg[j]);
114863 sqlite3DbFree(db, zArg);
114864 sqlite3DbFree(db, pTable->azModuleArg);
114887 sqlite3 *db; /* Database connection */
114894 db = pParse->db;
114895 iDb = sqlite3SchemaToIndex(db, pTable->pSchema);
114900 addModuleArgument(db, pTable, sqlite3NameFromToken(db, pModuleName));
114901 addModuleArgument(db, pTable, 0);
114902 addModuleArgument(db, pTable, sqlite3DbStrDup(db, pTable->zName));
114918 pTable->azModuleArg[0], pParse->db->aDb[iDb].zName);
114932 sqlite3 *db = pParse->db;
114933 addModuleArgument(db, pParse->pNewTable, sqlite3DbStrNDup(db, z, n));
114943 sqlite3 *db = pParse->db; /* The database connection */
114956 if( !db->init.busy ){
114967 zStmt = sqlite3MPrintf(db, "CREATE VIRTUAL TABLE %T", &pParse->sNameToken);
114977 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
114982 db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
114988 sqlite3DbFree(db, zStmt);
114993 zWhere = sqlite3MPrintf(db, "name='%q' AND type='table'", pTab->zName);
115010 assert( sqlite3SchemaMutexHeld(db, 0, pSchema) );
115013 db->mallocFailed = 1;
115052 sqlite3 *db,
115069 for(pCtx=db->pVtabCtx; pCtx; pCtx=pCtx->pPrior){
115071 *pzErr = sqlite3MPrintf(db,
115078 zModuleName = sqlite3MPrintf(db, "%s", pTab->zName);
115083 pVTable = sqlite3DbMallocZero(db, sizeof(VTable));
115085 sqlite3DbFree(db, zModuleName);
115088 pVTable->db = db;
115091 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
115092 pTab->azModuleArg[1] = db->aDb[iDb].zName;
115095 assert( &db->pVtabCtx );
115099 sCtx.pPrior = db->pVtabCtx;
115101 db->pVtabCtx = &sCtx;
115102 rc = xConstruct(db, pMod->pAux, nArg, azArg, &pVTable->pVtab, &zErr);
115103 db->pVtabCtx = sCtx.pPrior;
115104 if( rc==SQLITE_NOMEM ) db->mallocFailed = 1;
115109 *pzErr = sqlite3MPrintf(db, "vtable constructor failed: %s", zModuleName);
115111 *pzErr = sqlite3MPrintf(db, "%s", zErr);
115114 sqlite3DbFree(db, pVTable);
115123 *pzErr = sqlite3MPrintf(db, zFormat, pTab->zName);
115175 sqlite3DbFree(db, zModuleName);
115187 sqlite3 *db = pParse->db;
115193 if( (pTab->tabFlags & TF_Virtual)==0 || sqlite3GetVTable(db, pTab) ){
115199 pMod = (Module*)sqlite3HashFind(&db->aModule, zMod);
115207 rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xConnect, &zErr);
115211 sqlite3DbFree(db, zErr);
115217 ** Grow the db->aVTrans[] array so that there is room for at least one
115220 static int growVTrans(sqlite3 *db){
115224 if( (db->nVTrans%ARRAY_INCR)==0 ){
115226 int nBytes = sizeof(sqlite3_vtab *) * (db->nVTrans + ARRAY_INCR);
115227 aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes);
115231 memset(&aVTrans[db->nVTrans], 0, sizeof(sqlite3_vtab *)*ARRAY_INCR);
115232 db->aVTrans = aVTrans;
115242 static void addToVTrans(sqlite3 *db, VTable *pVTab){
115244 db->aVTrans[db->nVTrans++] = pVTab;
115254 ** In this case the caller must call sqlite3DbFree(db, ) on *pzErr.
115256 SQLITE_PRIVATE int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab, char **pzErr){
115262 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
115267 pMod = (Module*)sqlite3HashFind(&db->aModule, zMod);
115274 *pzErr = sqlite3MPrintf(db, "no such module: %s", zMod);
115277 rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr);
115282 if( rc==SQLITE_OK && ALWAYS(sqlite3GetVTable(db, pTab)) ){
115283 rc = growVTrans(db);
115285 addToVTrans(db, sqlite3GetVTable(db, pTab));
115297 SQLITE_API int SQLITE_STDCALL sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){
115305 if( !sqlite3SafetyCheckOk(db) || zCreateTable==0 ){
115309 sqlite3_mutex_enter(db->mutex);
115310 pCtx = db->pVtabCtx;
115312 sqlite3Error(db, SQLITE_MISUSE);
115313 sqlite3_mutex_leave(db->mutex);
115319 pParse = sqlite3StackAllocZero(db, sizeof(*pParse));
115324 pParse->db = db;
115329 && !db->mallocFailed
115341 sqlite3ErrorWithMsg(db, SQLITE_ERROR, (zErr ? "%s" : 0), zErr);
115342 sqlite3DbFree(db, zErr);
115350 sqlite3DeleteTable(db, pParse->pNewTable);
115352 sqlite3StackFree(db, pParse);
115356 rc = sqlite3ApiExit(db, rc);
115357 sqlite3_mutex_leave(db->mutex);
115368 SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab){
115372 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
115381 p = vtabDisconnectAll(db, pTab);
115403 static void callFinaliser(sqlite3 *db, int offset){
115405 if( db->aVTrans ){
115406 for(i=0; i<db->nVTrans; i++){
115407 VTable *pVTab = db->aVTrans[i];
115417 sqlite3DbFree(db, db->aVTrans);
115418 db->nVTrans = 0;
115419 db->aVTrans = 0;
115430 SQLITE_PRIVATE int sqlite3VtabSync(sqlite3 *db, Vdbe *p){
115433 VTable **aVTrans = db->aVTrans;
115435 db->aVTrans = 0;
115436 for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
115444 db->aVTrans = aVTrans;
115452 SQLITE_PRIVATE int sqlite3VtabRollback(sqlite3 *db){
115453 callFinaliser(db, offsetof(sqlite3_module,xRollback));
115461 SQLITE_PRIVATE int sqlite3VtabCommit(sqlite3 *db){
115462 callFinaliser(db, offsetof(sqlite3_module,xCommit));
115474 SQLITE_PRIVATE int sqlite3VtabBegin(sqlite3 *db, VTable *pVTab){
115478 /* Special case: If db->aVTrans is NULL and db->nVTrans is greater
115483 if( sqlite3VtabInSync(db) ){
115495 for(i=0; i<db->nVTrans; i++){
115496 if( db->aVTrans[i]==pVTab ){
115503 rc = growVTrans(db);
115507 addToVTrans(db, pVTab);
115529 SQLITE_PRIVATE int sqlite3VtabSavepoint(sqlite3 *db, int op, int iSavepoint){
115534 if( db->aVTrans ){
115536 for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
115537 VTable *pVTab = db->aVTrans[i];
115576 sqlite3 *db, /* Database connection for reporting malloc problems */
115598 pVtab = sqlite3GetVTable(db, pTab)->pVtab;
115607 zLowerName = sqlite3DbStrDup(db, pDef->zName);
115613 sqlite3DbFree(db, zLowerName);
115621 pNew = sqlite3DbMallocZero(db, sizeof(*pNew)
115656 pToplevel->db->mallocFailed = 1;
115667 SQLITE_API int SQLITE_STDCALL sqlite3_vtab_on_conflict(sqlite3 *db){
115672 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
115676 assert( db->vtabOnConflict>=1 && db->vtabOnConflict<=5 );
115677 return (int)aMap[db->vtabOnConflict-1];
115685 SQLITE_API int SQLITE_CDECL sqlite3_vtab_config(sqlite3 *db, int op, ...){
115690 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
115692 sqlite3_mutex_enter(db->mutex);
115696 VtabCtx *p = db->pVtabCtx;
115711 if( rc!=SQLITE_OK ) sqlite3Error(db, rc);
115712 sqlite3_mutex_leave(db->mutex);
116007 #define TERM_DYNAMIC 0x01 /* Need to call sqlite3ExprDelete(db, pExpr) */
116342 static void whereOrInfoDelete(sqlite3 *db, WhereOrInfo *p){
116344 sqlite3DbFree(db, p);
116350 static void whereAndInfoDelete(sqlite3 *db, WhereAndInfo *p){
116352 sqlite3DbFree(db, p);
116362 sqlite3 *db = pWC->pWInfo->pParse->db;
116365 sqlite3ExprDelete(db, a->pExpr);
116368 whereOrInfoDelete(db, a->u.pOrInfo);
116370 whereAndInfoDelete(db, a->u.pAndInfo);
116374 sqlite3DbFree(db, pWC->a);
116384 ** the db->mallocFailed flag so that higher-level functions can detect it.
116403 sqlite3 *db = pWC->pWInfo->pParse->db;
116404 pWC->a = sqlite3DbMallocRaw(db, sizeof(pWC->a[0])*pWC->nSlot*2 );
116407 sqlite3ExprDelete(db, p);
116414 sqlite3DbFree(db, pOld);
116416 pWC->nSlot = sqlite3DbMallocSize(db, pWC->a)/sizeof(pWC->a[0]);
116677 if( pColl==0 ) pColl = pParse->db->pDfltColl;
116842 sqlite3 *db = pParse->db; /* Database connection */
116846 if( !sqlite3IsLikeFunction(db, pExpr, pnoCase, wc) ){
116886 pPrefix = sqlite3Expr(db, TK_STRING, z);
117008 sqlite3 *db; /* Database connection (for malloc) */
117030 db = pWC->pWInfo->pParse->db;
117031 pNew = sqlite3ExprDup(db, pOne->pExpr, 0);
117134 sqlite3 *db = pParse->db; /* Database connection */
117151 pTerm->u.pOrInfo = pOrInfo = sqlite3DbMallocZero(db, sizeof(*pOrInfo));
117158 if( db->mallocFailed ) return;
117171 pAndInfo = sqlite3DbMallocRaw(db, sizeof(*pAndInfo));
117185 testcase( db->mallocFailed );
117186 if( !db->mallocFailed ){
117345 pDup = sqlite3ExprDup(db, pOrTerm->pExpr->pRight, 0);
117350 pDup = sqlite3ExprDup(db, pLeft, 0);
117363 sqlite3ExprListDelete(db, pList);
117406 sqlite3 *db = pParse->db; /* Database connection */
117408 if( db->mallocFailed ){
117455 pDup = sqlite3ExprDup(db, pExpr, 0);
117456 if( db->mallocFailed ){
117457 sqlite3ExprDelete(db, pDup);
117468 && OptimizationEnabled(db, SQLITE_Transitive)
117514 sqlite3ExprDup(db, pExpr->pLeft, 0),
117515 sqlite3ExprDup(db, pList->a[i].pExpr, 0), 0);
117564 pStr2 = sqlite3ExprDup(db, pStr1, 0);
117570 if( noCase && !pParse->db->mallocFailed ){
117580 if( !db->mallocFailed ){
117597 pNewExpr1 = sqlite3ExprDup(db, pLeft, 0);
117605 pNewExpr2 = sqlite3ExprDup(db, pLeft, 0);
117641 0, sqlite3ExprDup(db, pRight, 0), 0);
117671 && OptimizationEnabled(db, SQLITE_Stat34)
117679 sqlite3ExprDup(db, pLeft, 0),
117936 pPartial = sqlite3ExprAnd(pParse->db, pPartial,
117937 sqlite3ExprDup(pParse->db, pExpr, 0));
117951 if( whereLoopResize(pParse->db, pLoop, nKeyCol+1) ){
117984 pIdx = sqlite3AllocateIndexObject(pParse->db, nKeyCol+1, 0, &zNotUsed);
118059 sqlite3ExprDelete(pParse->db, pPartial);
118115 pIdxInfo = sqlite3DbMallocZero(pParse->db, sizeof(*pIdxInfo)
118188 sqlite3_vtab *pVtab = sqlite3GetVTable(pParse->db, pTab)->pVtab;
118198 pParse->db->mallocFailed = 1;
118341 if( pParse->db->mallocFailed==0 ){
118348 || pParse->db->mallocFailed
118358 || pParse->db->mallocFailed );
118367 || pParse->db->mallocFailed );
118372 || pParse->db->mallocFailed );
118482 sqlite3 *db = pParse->db;
118508 rc = sqlite3Stat4Column(db, p->aSample[i].p, p->aSample[i].n, nEq, &pVal);
118937 assert( pParse->db->mallocFailed );
119025 sqlite3DbReallocOrFree(pParse->db, pLevel->u.in.aInLoop,
119124 zAff = sqlite3DbStrDup(pParse->db, sqlite3IndexAffinityStr(v, pIdx));
119126 pParse->db->mallocFailed = 1;
119281 sqlite3 *db = pParse->db; /* Database handle */
119298 sqlite3StrAccumInit(&str, db, zBuf, sizeof(zBuf), SQLITE_MAX_LENGTH);
119425 || pTerm->pWC->pWInfo->pParse->db->mallocFailed );
119450 sqlite3 *db; /* Database connection */
119461 db = pParse->db;
119885 sqlite3DbFree(db, zStartAff);
120017 pOrTab = sqlite3StackAllocRaw(db,
120080 pExpr = sqlite3ExprDup(db, pExpr, 0);
120081 pAndExpr = sqlite3ExprAnd(db, pAndExpr, pExpr);
120110 assert( pSubWInfo || pParse->nErr || db->mallocFailed );
120216 sqlite3ExprDelete(db, pAndExpr);
120222 if( pWInfo->nLevel>1 ) sqlite3StackFree(db, pOrTab);
120306 pEAlt = sqlite3StackAllocRaw(db, sizeof(*pEAlt));
120311 sqlite3StackFree(db, pEAlt);
120426 static void whereLoopClearUnion(sqlite3 *db, WhereLoop *p){
120433 sqlite3DbFree(db, p->u.btree.pIndex->zColAff);
120434 sqlite3DbFree(db, p->u.btree.pIndex);
120443 static void whereLoopClear(sqlite3 *db, WhereLoop *p){
120444 if( p->aLTerm!=p->aLTermSpace ) sqlite3DbFree(db, p->aLTerm);
120445 whereLoopClearUnion(db, p);
120452 static int whereLoopResize(sqlite3 *db, WhereLoop *p, int n){
120456 paNew = sqlite3DbMallocRaw(db, sizeof(p->aLTerm[0])*n);
120459 if( p->aLTerm!=p->aLTermSpace ) sqlite3DbFree(db, p->aLTerm);
120468 static int whereLoopXfer(sqlite3 *db, WhereLoop *pTo, WhereLoop *pFrom){
120469 whereLoopClearUnion(db, pTo);
120470 if( whereLoopResize(db, pTo, pFrom->nLTerm) ){
120487 static void whereLoopDelete(sqlite3 *db, WhereLoop *p){
120488 whereLoopClear(db, p);
120489 sqlite3DbFree(db, p);
120495 static void whereInfoFree(sqlite3 *db, WhereInfo *pWInfo){
120501 sqlite3DbFree(db, pLevel->u.in.aInLoop);
120508 whereLoopDelete(db, p);
120510 sqlite3DbFree(db, pWInfo);
120695 sqlite3 *db = pWInfo->pParse->db;
120751 *ppPrev = p = sqlite3DbMallocRaw(db, sizeof(WhereLoop));
120773 whereLoopDelete(db, pToDel);
120776 whereLoopXfer(db, p, pTemplate);
120890 sqlite3 *db = pParse->db; /* Database connection malloc context */
120908 if( db->mallocFailed ) return SQLITE_NOMEM;
120957 if( whereLoopResize(db, pNew, pNew->nLTerm+1) ) break; /* OOM */
121004 if( whereLoopResize(db, pNew, pNew->nLTerm+1) ) break; /* OOM */
121131 && (rc = whereLoopResize(db, pNew, pNew->nLTerm+1))==SQLITE_OK
121319 && (pWInfo->pParse->db->flags & SQLITE_AutoIndex)!=0
121416 && OptimizationEnabled(pWInfo->pParse->db, SQLITE_CoverIdxScan)
121465 sqlite3 *db;
121481 db = pParse->db;
121496 if( whereLoopResize(db, pNew, nConstraint) ){
121497 sqlite3DbFree(db, pIdxInfo);
121615 sqlite3DbFree(db, pIdxInfo);
121752 sqlite3 *db = pWInfo->pParse->db;
121777 if( rc || db->mallocFailed ) break;
121779 whereLoopClear(db, pNew);
121827 sqlite3 *db = pWInfo->pParse->db; /* Database connection */
121856 if( nLoop && OptimizationDisabled(db, SQLITE_OrderByIdxJoin) ) return 0;
121890 if( !pColl ) pColl = db->pDfltColl;
121893 if( !pColl ) pColl = db->pDfltColl;
121974 if( !pColl ) pColl = db->pDfltColl;
122136 sqlite3 *db; /* The database connection */
122155 db = pParse->db;
122178 pSpace = sqlite3DbMallocRaw(db, nSpace);
122403 sqlite3DbFree(db, pSpace);
122461 sqlite3DbFree(db, pSpace);
122657 sqlite3 *db; /* Database connection */
122662 db = pParse->db;
122672 if( OptimizationDisabled(db, SQLITE_DistinctOpt) ){
122700 pWInfo = sqlite3DbMallocZero(db, nByteWInfo + sizeof(WhereLoop));
122701 if( db->mallocFailed ){
122702 sqlite3DbFree(db, pWInfo);
122788 if( db->mallocFailed ){
122834 if( db->mallocFailed ) goto whereBeginError;
122837 if( db->mallocFailed ) goto whereBeginError;
122840 if( pWInfo->pOrderBy==0 && (db->flags & SQLITE_ReverseOrder)!=0 ){
122843 if( pParse->nErr || NEVER(db->mallocFailed) ){
122875 && OptimizationEnabled(db, SQLITE_OmitNoopJoin)
122931 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
122938 const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
123015 if( db->mallocFailed ) goto whereBeginError;
123031 if( db->mallocFailed ) goto whereBeginError;
123053 whereInfoFree(db, pWInfo);
123069 sqlite3 *db = pParse->db;
123158 if( pTabItem->viaCoroutine && !db->mallocFailed ){
123215 if( pIdx && !db->mallocFailed ){
123245 whereInfoFree(db, pWInfo);
123325 (mxSelect = pParse->db
123384 sqlite3 *db = pParse->db;
123387 sqlite3ExprDelete(db, pA->pRight);
124656 sqlite3SelectDelete(pParse->db, (yypminor->yy3));
124662 sqlite3ExprDelete(pParse->db, (yypminor->yy346).pExpr);
124677 sqlite3ExprListDelete(pParse->db, (yypminor->yy14));
124685 sqlite3SrcListDelete(pParse->db, (yypminor->yy65));
124691 sqlite3WithDelete(pParse->db, (yypminor->yy59));
124702 sqlite3ExprDelete(pParse->db, (yypminor->yy132));
124709 sqlite3IdListDelete(pParse->db, (yypminor->yy408));
124715 sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy473));
124720 sqlite3IdListDelete(pParse->db, (yypminor->yy378).b);
125400 pParse->db->lookaside.bEnabled = 0;
125433 sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy3);
125644 sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy3);
125654 sqlite3WithDelete(pParse->db, yymsp[-1].minor.yy59);
125680 sqlite3SelectDelete(pParse->db, yymsp[-2].minor.yy3);
125764 Expr *p = sqlite3Expr(pParse->db, TK_ALL, 0);
125780 {yygotominor.yy65 = sqlite3DbMallocZero(pParse->db, sizeof(*yygotominor.yy65));}
125823 sqlite3SrcListDelete(pParse->db, yymsp[-4].minor.yy65);
125837 {yygotominor.yy65 = sqlite3SrcListAppend(pParse->db,0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);}
125958 {yygotominor.yy408 = sqlite3IdListAppend(pParse->db,yymsp[-2].minor.yy408,&yymsp[0].minor.yy0);}
125961 {yygotominor.yy408 = sqlite3IdListAppend(pParse->db,0,&yymsp[0].minor.yy0);}
126031 if( yymsp[-1].minor.yy14 && yymsp[-1].minor.yy14->nExpr>pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] ){
126130 sqlite3ExprListDelete(pParse->db, pList);
126149 sqlite3ExprDelete(pParse->db, yymsp[-4].minor.yy346.pExpr);
126169 sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
126183 sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
126199 sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy3);
126213 sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy3);
126222 SrcList *pSrc = sqlite3SrcListAppend(pParse->db, 0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);
126229 sqlite3SrcListDelete(pParse->db, pSrc);
126244 sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy3);
126257 sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy14);
126258 sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy132);
126285 sqlite3SrcListAppend(pParse->db,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy14, yymsp[-10].minor.yy328,
126416 { yygotominor.yy473 = sqlite3TriggerUpdateStep(pParse->db, &yymsp[-4].minor.yy0, yymsp[-1].minor.yy14, yymsp[0].minor.yy132, yymsp[-5].minor.yy186); }
126419 {yygotominor.yy473 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy408, yymsp[0].minor.yy3, yymsp[-4].minor.yy186);}
126422 {yygotominor.yy473 = sqlite3TriggerDeleteStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[0].minor.yy132);}
126425 {yygotominor.yy473 = sqlite3TriggerSelectStep(pParse->db, yymsp[0].minor.yy3); }
126492 pParse->db->lookaside.bEnabled = 0;
127493 u8 enableLookaside; /* Saved value of db->lookaside.bEnabled */
127494 sqlite3 *db = pParse->db; /* The database connection */
127498 mxSqlLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH];
127499 if( db->nVdbeActive==0 ){
127500 db->u1.isInterrupted = 0;
127508 db->mallocFailed = 1;
127516 enableLookaside = db->lookaside.bEnabled;
127517 if( db->lookaside.pStart ) db->lookaside.bEnabled = 1;
127518 while( !db->mallocFailed && zSql[i]!=0 ){
127529 if( db->u1.isInterrupted ){
127557 if( zSql[i]==0 && pParse->rc==SQLITE_OK && db->mallocFailed==0 ){
127562 if( pParse->rc==SQLITE_OK && db->mallocFailed==0 ){
127574 db->lookaside.bEnabled = enableLookaside;
127575 if( db->mallocFailed ){
127579 sqlite3SetString(&pParse->zErrMsg, db, "%s", sqlite3ErrStr(pParse->rc));
127594 sqlite3DbFree(db, pParse->aTableLock);
127608 sqlite3DeleteTable(db, pParse->pNewTable);
127611 if( pParse->bFreeWith ) sqlite3WithDelete(db, pParse->pWith);
127612 sqlite3DeleteTrigger(db, pParse->pNewTrigger);
127613 for(i=pParse->nzVar-1; i>=0; i--) sqlite3DbFree(db, pParse->azVar[i]);
127614 sqlite3DbFree(db, pParse->azVar);
127618 sqlite3DbFree(db, p);
127623 sqlite3DeleteTable(db, p);
127963 SQLITE_PRIVATE int sqlite3Fts3Init(sqlite3 *db);
127995 SQLITE_PRIVATE int sqlite3RtreeInit(sqlite3 *db);
128027 SQLITE_PRIVATE int sqlite3IcuInit(sqlite3 *db);
128653 static int setupLookaside(sqlite3 *db, void *pBuf, int sz, int cnt){
128655 if( db->lookaside.nOut ){
128662 if( db->lookaside.bMalloced ){
128663 sqlite3_free(db->lookaside.pStart);
128682 db->lookaside.pStart = pStart;
128683 db->lookaside.pFree = 0;
128684 db->lookaside.sz = (u16)sz;
128691 p->pNext = db->lookaside.pFree;
128692 db->lookaside.pFree = p;
128695 db->lookaside.pEnd = p;
128696 db->lookaside.bEnabled = 1;
128697 db->lookaside.bMalloced = pBuf==0 ?1:0;
128699 db->lookaside.pStart = db;
128700 db->lookaside.pEnd = db;
128701 db->lookaside.bEnabled = 0;
128702 db->lookaside.bMalloced = 0;
128710 SQLITE_API sqlite3_mutex *SQLITE_STDCALL sqlite3_db_mutex(sqlite3 *db){
128712 if( !sqlite3SafetyCheckOk(db) ){
128717 return db->mutex;
128724 SQLITE_API int SQLITE_STDCALL sqlite3_db_release_memory(sqlite3 *db){
128728 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
128730 sqlite3_mutex_enter(db->mutex);
128731 sqlite3BtreeEnterAll(db);
128732 for(i=0; i<db->nDb; i++){
128733 Btree *pBt = db->aDb[i].pBt;
128739 sqlite3BtreeLeaveAll(db);
128740 sqlite3_mutex_leave(db->mutex);
128747 SQLITE_API int SQLITE_CDECL sqlite3_db_config(sqlite3 *db, int op, ...){
128756 rc = setupLookaside(db, pBuf, sz, cnt);
128773 int oldFlags = db->flags;
128775 db->flags |= aFlagOp[i].mask;
128777 db->flags &= ~aFlagOp[i].mask;
128779 if( oldFlags!=db->flags ){
128780 sqlite3ExpirePreparedStatements(db);
128783 *pRes = (db->flags & aFlagOp[i].mask)!=0;
128866 SQLITE_API sqlite_int64 SQLITE_STDCALL sqlite3_last_insert_rowid(sqlite3 *db){
128868 if( !sqlite3SafetyCheckOk(db) ){
128873 return db->lastRowid;
128879 SQLITE_API int SQLITE_STDCALL sqlite3_changes(sqlite3 *db){
128881 if( !sqlite3SafetyCheckOk(db) ){
128886 return db->nChange;
128892 SQLITE_API int SQLITE_STDCALL sqlite3_total_changes(sqlite3 *db){
128894 if( !sqlite3SafetyCheckOk(db) ){
128899 return db->nTotalChange;
128907 SQLITE_PRIVATE void sqlite3CloseSavepoints(sqlite3 *db){
128908 while( db->pSavepoint ){
128909 Savepoint *pTmp = db->pSavepoint;
128910 db->pSavepoint = pTmp->pNext;
128911 sqlite3DbFree(db, pTmp);
128913 db->nSavepoint = 0;
128914 db->nStatement = 0;
128915 db->isTransactionSavepoint = 0;
128924 static void functionDestroy(sqlite3 *db, FuncDef *p){
128930 sqlite3DbFree(db, pDestructor);
128937 ** db. This is called when db is being closed.
128939 static void disconnectAllVtab(sqlite3 *db){
128942 sqlite3BtreeEnterAll(db);
128943 for(i=0; i<db->nDb; i++){
128944 Schema *pSchema = db->aDb[i].pSchema;
128945 if( db->aDb[i].pSchema ){
128949 if( IsVirtual(pTab) ) sqlite3VtabDisconnect(db, pTab);
128953 sqlite3VtabUnlockList(db);
128954 sqlite3BtreeLeaveAll(db);
128956 UNUSED_PARAMETER(db);
128961 ** Return TRUE if database connection db has unfinalized prepared
128964 static int connectionIsBusy(sqlite3 *db){
128966 assert( sqlite3_mutex_held(db->mutex) );
128967 if( db->pVdbe ) return 1;
128968 for(j=0; j<db->nDb; j++){
128969 Btree *pBt = db->aDb[j].pBt;
128978 static int sqlite3Close(sqlite3 *db, int forceZombie){
128979 if( !db ){
128984 if( !sqlite3SafetyCheckSickOrOk(db) ){
128987 sqlite3_mutex_enter(db->mutex);
128990 disconnectAllVtab(db);
128994 ** tables in the db->aVTrans[] array. The following sqlite3VtabRollback()
128999 sqlite3VtabRollback(db);
129004 if( !forceZombie && connectionIsBusy(db) ){
129005 sqlite3ErrorWithMsg(db, SQLITE_BUSY, "unable to close due to unfinalized "
129007 sqlite3_mutex_leave(db->mutex);
129014 sqlite3GlobalConfig.xSqllog(sqlite3GlobalConfig.pSqllogArg, db, 0, 2);
129020 db->magic = SQLITE_MAGIC_ZOMBIE;
129021 sqlite3LeaveMutexAndCloseZombie(db);
129034 SQLITE_API int SQLITE_STDCALL sqlite3_close(sqlite3 *db){ return sqlite3Close(db,0); }
129035 SQLITE_API int SQLITE_STDCALL sqlite3_close_v2(sqlite3 *db){ return sqlite3Close(db,1); }
129039 ** Close the mutex on database connection db.
129041 ** Furthermore, if database connection db is a zombie (meaning that there
129042 ** has been a prior call to sqlite3_close(db) or sqlite3_close_v2(db)) and
129046 SQLITE_PRIVATE void sqlite3LeaveMutexAndCloseZombie(sqlite3 *db){
129054 if( db->magic!=SQLITE_MAGIC_ZOMBIE || connectionIsBusy(db) ){
129055 sqlite3_mutex_leave(db->mutex);
129069 sqlite3RollbackAll(db, SQLITE_OK);
129072 sqlite3CloseSavepoints(db);
129075 for(j=0; j<db->nDb; j++){
129076 struct Db *pDb = &db->aDb[j];
129086 if( db->aDb[1].pSchema ){
129087 sqlite3SchemaClear(db->aDb[1].pSchema);
129089 sqlite3VtabUnlockList(db);
129092 sqlite3CollapseDatabaseArray(db);
129093 assert( db->nDb<=2 );
129094 assert( db->aDb==db->aDbStatic );
129099 sqlite3ConnectionClosed(db);
129101 for(j=0; j<ArraySize(db->aFunc.a); j++){
129103 for(p=db->aFunc.a[j]; p; p=pHash){
129106 functionDestroy(db, p);
129108 sqlite3DbFree(db, p);
129113 for(i=sqliteHashFirst(&db->aCollSeq); i; i=sqliteHashNext(i)){
129121 sqlite3DbFree(db, pColl);
129123 sqlite3HashClear(&db->aCollSeq);
129125 for(i=sqliteHashFirst(&db->aModule); i; i=sqliteHashNext(i)){
129130 sqlite3DbFree(db, pMod);
129132 sqlite3HashClear(&db->aModule);
129135 sqlite3Error(db, SQLITE_OK); /* Deallocates any cached error strings. */
129136 sqlite3ValueFree(db->pErr);
129137 sqlite3CloseExtensions(db);
129139 sqlite3_free(db->auth.zAuthUser);
129140 sqlite3_free(db->auth.zAuthPW);
129143 db->magic = SQLITE_MAGIC_ERROR;
129151 sqlite3DbFree(db, db->aDb[1].pSchema);
129152 sqlite3_mutex_leave(db->mutex);
129153 db->magic = SQLITE_MAGIC_CLOSED;
129154 sqlite3_mutex_free(db->mutex);
129155 assert( db->lookaside.nOut==0 ); /* Fails on a lookaside memory leak */
129156 if( db->lookaside.bMalloced ){
129157 sqlite3_free(db->lookaside.pStart);
129159 sqlite3_free(db);
129169 SQLITE_PRIVATE void sqlite3RollbackAll(sqlite3 *db, int tripCode){
129173 assert( sqlite3_mutex_held(db->mutex) );
129182 sqlite3BtreeEnterAll(db);
129183 schemaChange = (db->flags & SQLITE_InternChanges)!=0 && db->init.busy==0;
129185 for(i=0; i<db->nDb; i++){
129186 Btree *p = db->aDb[i].pBt;
129194 sqlite3VtabRollback(db);
129197 if( (db->flags&SQLITE_InternChanges)!=0 && db->init.busy==0 ){
129198 sqlite3ExpirePreparedStatements(db);
129199 sqlite3ResetAllSchemasOfConnection(db);
129201 sqlite3BtreeLeaveAll(db);
129204 db->nDeferredCons = 0;
129205 db
129206 db->flags &= ~SQLITE_DeferFKs;
129209 if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){
129210 db->xRollbackCallback(db->pRollbackArg);
129390 sqlite3 *db = (sqlite3 *)ptr;
129391 int timeout = db->busyTimeout;
129406 sqlite3OsSleep(db->pVfs, delay*1000);
129409 sqlite3 *db = (sqlite3 *)ptr;
129414 sqlite3OsSleep(db->pVfs, 1000000);
129443 sqlite3 *db,
129448 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
129450 sqlite3_mutex_enter(db->mutex);
129451 db->busyHandler.xFunc = xBusy;
129452 db->busyHandler.pArg = pArg;
129453 db->busyHandler.nBusy = 0;
129454 db->busyTimeout = 0;
129455 sqlite3_mutex_leave(db->mutex);
129466 sqlite3 *db,
129472 if( !sqlite3SafetyCheckOk(db) ){
129477 sqlite3_mutex_enter(db->mutex);
129479 db->xProgress = xProgress;
129480 db->nProgressOps = (unsigned)nOps;
129481 db->pProgressArg = pArg;
129483 db->xProgress = 0;
129484 db->nProgressOps = 0;
129485 db->pProgressArg = 0;
129487 sqlite3_mutex_leave(db->mutex);
129496 SQLITE_API int SQLITE_STDCALL sqlite3_busy_timeout(sqlite3 *db, int ms){
129498 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
129501 sqlite3_busy_handler(db, sqliteDefaultBusyCallback, (void*)db);
129502 db->busyTimeout = ms;
129504 sqlite3_busy_handler(db, 0, 0);
129512 SQLITE_API void SQLITE_STDCALL sqlite3_interrupt(sqlite3 *db){
129514 if( !sqlite3SafetyCheckOk(db) ){
129519 db->u1.isInterrupted = 1;
129530 sqlite3 *db,
129544 assert( sqlite3_mutex_held(db->mutex) );
129570 rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF8|extraFlags,
129573 rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF16LE|extraFlags,
129590 p = sqlite3FindFunction(db, zFunctionName, nName, nArg, (u8)enc, 0);
129592 if( db->nVdbeActive ){
129593 sqlite3ErrorWithMsg(db, SQLITE_BUSY,
129595 assert( !db->mallocFailed );
129598 sqlite3ExpirePreparedStatements(db);
129602 p = sqlite3FindFunction(db, zFunctionName, nName, nArg, (u8)enc, 1);
129603 assert(p || db->mallocFailed);
129610 functionDestroy(db, p);
129630 sqlite3 *db,
129639 return sqlite3_create_function_v2(db, zFunc, nArg, enc, p, xFunc, xStep,
129644 sqlite3 *db,
129658 if( !sqlite3SafetyCheckOk(db) ){
129662 sqlite3_mutex_enter(db->mutex);
129664 pArg = (FuncDestructor *)sqlite3DbMallocZero(db, sizeof(FuncDestructor));
129672 rc = sqlite3CreateFunc(db, zFunc, nArg, enc, p, xFunc, xStep, xFinal, pArg);
129676 sqlite3DbFree(db, pArg);
129680 rc = sqlite3ApiExit(db, rc);
129681 sqlite3_mutex_leave(db->mutex);
129687 sqlite3 *db,
129700 if( !sqlite3SafetyCheckOk(db) || zFunctionName==0 ) return SQLITE_MISUSE_BKPT;
129702 sqlite3_mutex_enter(db->mutex);
129703 assert( !db->mallocFailed );
129704 zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1, SQLITE_UTF16NATIVE);
129705 rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal,0);
129706 sqlite3DbFree(db, zFunc8);
129707 rc = sqlite3ApiExit(db, rc);
129708 sqlite3_mutex_leave(db->mutex);
129727 sqlite3 *db,
129735 if( !sqlite3SafetyCheckOk(db) || zName==0 || nArg<-2 ){
129739 sqlite3_mutex_enter(db->mutex);
129740 if( sqlite3FindFunction(db, zName, nName, nArg, SQLITE_UTF8, 0)==0 ){
129741 rc = sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8,
129744 rc = sqlite3ApiExit(db, rc);
129745 sqlite3_mutex_leave(db->mutex);
129758 SQLITE_API void *SQLITE_STDCALL sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), void *pArg){
129762 if( !sqlite3SafetyCheckOk(db) ){
129767 sqlite3_mutex_enter(db->mutex);
129768 pOld = db->pTraceArg;
129769 db->xTrace = xTrace;
129770 db->pTraceArg = pArg;
129771 sqlite3_mutex_leave(db->mutex);
129783 sqlite3 *db,
129790 if( !sqlite3SafetyCheckOk(db) ){
129795 sqlite3_mutex_enter(db->mutex);
129796 pOld = db->pProfileArg;
129797 db->xProfile = xProfile;
129798 db->pProfileArg = pArg;
129799 sqlite3_mutex_leave(db->mutex);
129810 sqlite3 *db, /* Attach the hook to this database */
129817 if( !sqlite3SafetyCheckOk(db) ){
129822 sqlite3_mutex_enter(db->mutex);
129823 pOld = db->pCommitArg;
129824 db->xCommitCallback = xCallback;
129825 db->pCommitArg = pArg;
129826 sqlite3_mutex_leave(db->mutex);
129835 sqlite3 *db, /* Attach the hook to this database */
129842 if( !sqlite3SafetyCheckOk(db) ){
129847 sqlite3_mutex_enter(db->mutex);
129848 pRet = db->pUpdateArg;
129849 db->xUpdateCallback = xCallback;
129850 db->pUpdateArg = pArg;
129851 sqlite3_mutex_leave(db->mutex);
129860 sqlite3 *db, /* Attach the hook to this database */
129867 if( !sqlite3SafetyCheckOk(db) ){
129872 sqlite3_mutex_enter(db->mutex);
129873 pRet = db->pRollbackArg;
129874 db->xRollbackCallback = xCallback;
129875 db->pRollbackArg = pArg;
129876 sqlite3_mutex_leave(db->mutex);
129889 sqlite3 *db, /* Connection */
129895 sqlite3_wal_checkpoint(db, zDb);
129913 SQLITE_API int SQLITE_STDCALL sqlite3_wal_autocheckpoint(sqlite3 *db, int nFrame){
129915 UNUSED_PARAMETER(db);
129919 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
129922 sqlite3_wal_hook(db, sqlite3WalDefaultHook, SQLITE_INT_TO_PTR(nFrame));
129924 sqlite3_wal_hook(db, 0, 0);
129935 sqlite3 *db, /* Attach the hook to this db handle */
129942 if( !sqlite3SafetyCheckOk(db) ){
129947 sqlite3_mutex_enter(db->mutex);
129948 pRet = db->pWalArg;
129949 db->xWalCallback = xCallback;
129950 db->pWalArg = pArg;
129951 sqlite3_mutex_leave(db->mutex);
129962 sqlite3 *db, /* Database handle */
129972 int iDb = SQLITE_MAX_ATTACHED; /* sqlite3.aDb[] index of db to checkpoint */
129975 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
129992 sqlite3_mutex_enter(db->mutex);
129994 iDb = sqlite3FindDbName(db, zDb);
129998 sqlite3ErrorWithMsg(db, SQLITE_ERROR, "unknown database: %s", zDb);
130000 db->busyHandler.nBusy = 0;
130001 rc = sqlite3Checkpoint(db, iDb, eMode, pnLog, pnCkpt);
130002 sqlite3Error(db, rc);
130004 rc = sqlite3ApiExit(db, rc);
130005 sqlite3_mutex_leave(db->mutex);
130016 SQLITE_API int SQLITE_STDCALL sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb){
130019 return sqlite3_wal_checkpoint_v2(db,zDb,SQLITE_CHECKPOINT_PASSIVE,0,0);
130032 ** The mutex on database handle db should be held by the caller. The mutex
130042 SQLITE_PRIVATE int sqlite3Checkpoint(sqlite3 *db, int iDb, int eMode, int *pnLog, int *pnCkpt){
130047 assert( sqlite3_mutex_held(db->mutex) );
130051 for(i=0; i<db->nDb && rc==SQLITE_OK; i++){
130053 rc = sqlite3BtreeCheckpoint(db->aDb[i].pBt, eMode, pnLog, pnCkpt);
130070 ** The value returned depends on the value of db->temp_store (runtime
130075 ** SQLITE_TEMP_STORE db->temp_store Location of temporary database
130086 SQLITE_PRIVATE int sqlite3TempInMemory(const sqlite3 *db){
130088 return ( db->temp_store==2 );
130091 return ( db->temp_store!=1 );
130105 SQLITE_API const char *SQLITE_STDCALL sqlite3_errmsg(sqlite3 *db){
130107 if( !db ){
130110 if( !sqlite3SafetyCheckSickOrOk(db) ){
130113 sqlite3_mutex_enter(db->mutex);
130114 if( db->mallocFailed ){
130117 testcase( db->pErr==0 );
130118 z = (char*)sqlite3_value_text(db->pErr);
130119 assert( !db->mallocFailed );
130121 z = sqlite3ErrStr(db->errCode);
130124 sqlite3_mutex_leave(db->mutex);
130133 SQLITE_API const void *SQLITE_STDCALL sqlite3_errmsg16(sqlite3 *db){
130147 if( !db ){
130150 if( !sqlite3SafetyCheckSickOrOk(db) ){
130153 sqlite3_mutex_enter(db->mutex);
130154 if( db->mallocFailed ){
130157 z = sqlite3_value_text16(db->pErr);
130159 sqlite3ErrorWithMsg(db, db->errCode, sqlite3ErrStr(db->errCode));
130160 z = sqlite3_value_text16(db
130163 ** above. If this is the case, then the db->mallocFailed flag needs to
130167 db->mallocFailed = 0;
130169 sqlite3_mutex_leave(db->mutex);
130178 SQLITE_API int SQLITE_STDCALL sqlite3_errcode(sqlite3 *db){
130179 if( db && !sqlite3SafetyCheckSickOrOk(db) ){
130182 if( !db || db->mallocFailed ){
130185 return db->errCode & db->errMask;
130187 SQLITE_API int SQLITE_STDCALL sqlite3_extended_errcode(sqlite3 *db){
130188 if( db && !sqlite3SafetyCheckSickOrOk(db) ){
130191 if( !db || db->mallocFailed ){
130194 return db->errCode;
130207 ** Create a new collating function for database "db". The name is zName
130211 sqlite3* db,
130221 assert( sqlite3_mutex_held(db->mutex) );
130241 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0);
130243 if( db->nVdbeActive ){
130244 sqlite3ErrorWithMsg(db, SQLITE_BUSY,
130248 sqlite3ExpirePreparedStatements(db);
130257 CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName);
130271 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 1);
130277 sqlite3Error(db, SQLITE_OK);
130350 SQLITE_API int SQLITE_STDCALL sqlite3_limit(sqlite3 *db, int limitId, int newLimit){
130354 if( !sqlite3SafetyCheckOk(db) ){
130384 oldLimit = db->aLimit[limitId];
130389 db->aLimit[limitId] = newLimit;
130651 sqlite3 *db; /* Store allocated handle here */
130725 db = sqlite3MallocZero( sizeof(sqlite3) );
130726 if( db==0 ) goto opendb_out;
130728 db->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
130729 if( db->mutex==0 ){
130730 sqlite3_free(db);
130731 db = 0;
130735 sqlite3_mutex_enter(db->mutex);
130736 db->errMask = 0xff;
130737 db->nDb = 2;
130738 db->magic = SQLITE_MAGIC_BUSY;
130739 db->aDb = db->aDbStatic;
130741 assert( sizeof(db->aLimit)==sizeof(aHardLimit) );
130742 memcpy(db->aLimit, aHardLimit, sizeof(db->aLimit));
130743 db->aLimit[SQLITE_LIMIT_WORKER_THREADS] = SQLITE_DEFAULT_WORKER_THREADS;
130744 db->autoCommit = 1;
130745 db->nextAutovac = -1;
130746 db->szMmap = sqlite3GlobalConfig.szMmap;
130747 db->nextPagesize = 0;
130748 db->nMaxSorterMmap = 0x7FFFFFFF;
130749 db->flags |= SQLITE_ShortColNames | SQLITE_EnableTrigger | SQLITE_CacheSpill
130772 sqlite3HashInit(&db->aCollSeq);
130774 sqlite3HashInit(&db->aModule);
130784 createCollation(db, "BINARY", SQLITE_UTF8, 0, binCollFunc, 0);
130785 createCollation(db, "BINARY", SQLITE_UTF16BE, 0, binCollFunc, 0);
130786 createCollation(db, "BINARY", SQLITE_UTF16LE, 0, binCollFunc, 0);
130787 createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc, 0);
130788 createCollation(db, "RTRIM", SQLITE_UTF8, (void*)1, binCollFunc, 0);
130789 if( db->mallocFailed ){
130795 db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 0);
130796 assert( db->pDfltColl!=0 );
130799 db->openFlags = flags;
130800 rc = sqlite3ParseUri(zVfs, zFilename, &flags, &db->pVfs, &zOpen, &zErrMsg);
130802 if( rc==SQLITE_NOMEM ) db->mallocFailed = 1;
130803 sqlite3ErrorWithMsg(db, rc, zErrMsg ? "%s" : 0, zErrMsg);
130809 rc = sqlite3BtreeOpen(db->pVfs, zOpen, db, &db->aDb[0].pBt, 0,
130815 sqlite3Error(db, rc);
130818 sqlite3BtreeEnter(db->aDb[0].pBt);
130819 db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt);
130820 if( !db->mallocFailed ) ENC(db) = SCHEMA_ENC(db);
130821 sqlite3BtreeLeave(db->aDb[0].pBt);
130822 db->aDb[1].pSchema = sqlite3SchemaGet(db, 0);
130827 db->aDb[0].zName = "main";
130828 db->aDb[0].safety_level = 3;
130829 db->aDb[1].zName = "temp";
130830 db->aDb[1].safety_level = 1;
130832 db->magic = SQLITE_MAGIC_OPEN;
130833 if( db->mallocFailed ){
130841 sqlite3Error(db, SQLITE_OK);
130842 sqlite3RegisterBuiltinFunctions(db);
130847 rc = sqlite3_errcode(db);
130849 sqlite3AutoLoadExtensions(db);
130850 rc = sqlite3_errcode(db);
130857 if( !db->mallocFailed ){
130859 rc = sqlite3Fts1Init(db);
130864 if( !db->mallocFailed && rc==SQLITE_OK ){
130866 rc = sqlite3Fts2Init(db);
130871 if( !db->mallocFailed && rc==SQLITE_OK ){
130872 rc = sqlite3Fts3Init(db);
130877 if( !db->mallocFailed && rc==SQLITE_OK ){
130878 rc = sqlite3IcuInit(db);
130883 if( !db->mallocFailed && rc==SQLITE_OK){
130884 rc = sqlite3RtreeInit(db);
130889 if( !db->mallocFailed && rc==SQLITE_OK){
130891 rc = sqlite3_dbstat_register(db);
130900 db->dfltLockMode = SQLITE_DEFAULT_LOCKING_MODE;
130901 sqlite3PagerLockingMode(sqlite3BtreePager(db->aDb[0].pBt),
130905 if( rc ) sqlite3Error(db, rc);
130908 setupLookaside(db, 0, sqlite3GlobalConfig.szLookaside,
130911 sqlite3_wal_autocheckpoint(db, SQLITE_DEFAULT_WAL_AUTOCHECKPOINT);
130915 if( db ){
130916 assert( db->mutex!=0 || isThreadsafe==0
130918 sqlite3_mutex_leave(db->mutex);
130920 rc = sqlite3_errcode(db);
130921 assert( db!=0 || rc==SQLITE_NOMEM );
130923 sqlite3_close(db);
130924 db = 0;
130926 db->magic = SQLITE_MAGIC_SICK;
130928 *ppDb = db;
130931 /* Opening a db handle. Fourth parameter is passed 0. */
130933 sqlite3GlobalConfig.xSqllog(pArg, db, zFilename, 0);
130951 sqlite3 **ppDb, /* OUT: SQLite db handle */
130999 ** Register a new collation sequence with the database handle db.
131002 sqlite3* db,
131008 return sqlite3_create_collation_v2(db, zName, enc, pCtx, xCompare, 0);
131012 ** Register a new collation sequence with the database handle db.
131015 sqlite3* db,
131025 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
131027 sqlite3_mutex_enter(db->mutex);
131028 assert( !db->mallocFailed );
131029 rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel);
131030 rc = sqlite3ApiExit(db, rc);
131031 sqlite3_mutex_leave(db->mutex);
131037 ** Register a new collation sequence with the database handle db.
131040 sqlite3* db,
131050 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
131052 sqlite3_mutex_enter(db->mutex);
131053 assert( !db->mallocFailed );
131054 zName8 = sqlite3Utf16to8(db, zName, -1, SQLITE_UTF16NATIVE);
131056 rc = createCollation(db, zName8, (u8)enc, pCtx, xCompare, 0);
131057 sqlite3DbFree(db, zName8);
131059 rc = sqlite3ApiExit(db, rc);
131060 sqlite3_mutex_leave(db->mutex);
131067 ** db. Replace any previously installed collation sequence factory.
131070 sqlite3 *db,
131075 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
131077 sqlite3_mutex_enter(db->mutex);
131078 db->xCollNeeded = xCollNeeded;
131079 db->xCollNeeded16 = 0;
131080 db->pCollNeededArg = pCollNeededArg;
131081 sqlite3_mutex_leave(db->mutex);
131088 ** db. Replace any previously installed collation sequence factory.
131091 sqlite3 *db,
131096 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
131098 sqlite3_mutex_enter(db->mutex);
131099 db->xCollNeeded = 0;
131100 db->xCollNeeded16 = xCollNeeded16;
131101 db->pCollNeededArg = pCollNeededArg;
131102 sqlite3_mutex_leave(db->mutex);
131123 SQLITE_API int SQLITE_STDCALL sqlite3_get_autocommit(sqlite3 *db){
131125 if( !sqlite3SafetyCheckOk(db) ){
131130 return db->autoCommit;
131184 sqlite3 *db, /* Connection handle */
131207 if( !sqlite3SafetyCheckOk(db) || zTableName==0 ){
131213 sqlite3_mutex_enter(db->mutex);
131214 sqlite3BtreeEnterAll(db);
131215 rc = sqlite3Init(db, &zErrMsg);
131221 pTab = sqlite3FindTable(db, zTableName, zDbName);
131273 sqlite3BtreeLeaveAll(db);
131286 sqlite3DbFree(db, zErrMsg);
131287 zErrMsg = sqlite3MPrintf(db, "no such table column: %s.%s", zTableName,
131291 sqlite3ErrorWithMsg(db, rc, (zErrMsg?"%s":0), zErrMsg);
131292 sqlite3DbFree(db, zErrMsg);
131293 rc = sqlite3ApiExit(db, rc);
131294 sqlite3_mutex_leave(db->mutex);
131317 SQLITE_API int SQLITE_STDCALL sqlite3_extended_result_codes(sqlite3 *db, int onoff){
131319 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
131321 sqlite3_mutex_enter(db->mutex);
131322 db->errMask = onoff ? 0xffffffff : 0xff;
131323 sqlite3_mutex_leave(db->mutex);
131330 SQLITE_API int SQLITE_STDCALL sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){
131335 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
131337 sqlite3_mutex_enter(db->mutex);
131338 pBtree = sqlite3DbNameToBtree(db, zDbName);
131357 sqlite3_mutex_leave(db->mutex);
131543 /* sqlite3_test_control(SQLITE_TESTCTRL_RESERVE, sqlite3 *db, int N)
131546 ** connection db.
131549 sqlite3 *db = va_arg(ap, sqlite3*);
131551 sqlite3_mutex_enter(db->mutex);
131552 sqlite3BtreeSetPageSize(db->aDb[0].pBt, 0, x, 0);
131553 sqlite3_mutex_leave(db->mutex);
131557 /* sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS, sqlite3 *db, int N)
131567 sqlite3 *db = va_arg(ap, sqlite3*);
131568 db->dbOptFlags = (u16)(va_arg(ap, int) & 0xffff);
131645 /* sqlite3_test_control(SQLITE_TESTCTRL_SORTER_MMAP, db, nMax); */
131647 sqlite3 *db = va_arg(ap, sqlite3*);
131648 db->nMaxSorterMmap = va_arg(ap, int);
131662 /* sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, db, dbName, onOff, tnum);
131664 ** This test control is used to create imposter tables. "db" is a pointer
131679 sqlite3 *db = va_arg(ap, sqlite3*);
131680 sqlite3_mutex_enter(db->mutex);
131681 db->init.iDb = sqlite3FindDbName(db, va_arg(ap,const char*));
131682 db->init.busy = db->init.imposterTable = va_arg(ap,int);
131683 db->init.newTnum = va_arg(ap,int);
131684 if( db->init.busy==0 && db->init.newTnum>0 ){
131685 sqlite3ResetAllSchemasOfConnection(db);
131687 sqlite3_mutex_leave(db->mutex);
131747 SQLITE_PRIVATE Btree *sqlite3DbNameToBtree(sqlite3 *db, const char *zDbName){
131749 for(i=0; i<db->nDb; i++){
131750 if( db->aDb[i].pBt
131751 && (zDbName==0 || sqlite3StrICmp(zDbName, db->aDb[i].zName)==0)
131753 return db->aDb[i].pBt;
131763 SQLITE_API const char *SQLITE_STDCALL sqlite3_db_filename(sqlite3 *db, const char *zDbName){
131766 if( !sqlite3SafetyCheckOk(db) ){
131771 pBt = sqlite3DbNameToBtree(db, zDbName);
131779 SQLITE_API int SQLITE_STDCALL sqlite3_db_readonly(sqlite3 *db, const char *zDbName){
131782 if( !sqlite3SafetyCheckOk(db) ){
131787 pBt = sqlite3DbNameToBtree(db, zDbName);
131843 ** 3) If the argument db is not NULL, then none of the entries in the
131845 ** set to db. This is used when closing connection db.
131847 static void checkListProperties(sqlite3 *db){
131860 assert( db==0 || p->pUnlockConnection!=db );
131861 assert( db==0 || p->pBlockingConnection!=db );
131870 ** Remove connection db from the blocked connections list. If connection
131871 ** db is not currently a part of the list, this function is a no-op.
131873 static void removeFromBlockedList(sqlite3 *db){
131877 if( *pp==db ){
131885 ** Add connection db to the blocked connections list. It is assumed
131888 static void addToBlockedList(sqlite3 *db){
131893 *pp && (*pp)->xUnlockNotify!=db->xUnlockNotify;
131896 db->pNextBlocked = *pp;
131897 *pp = db;
131920 ** This is called after connection "db" has attempted some operation
131923 ** cache. pOther is found by looking at db->pBlockingConnection.
131928 ** If pOther is already blocked on db, then report SQLITE_LOCKED, to indicate
131935 ** on the same "db". If xNotify==0 then any prior callbacks are immediately
131939 sqlite3 *db,
131945 sqlite3_mutex_enter(db->mutex);
131949 removeFromBlockedList(db);
131950 db->pBlockingConnection = 0;
131951 db->pUnlockConnection = 0;
131952 db->xUnlockNotify = 0;
131953 db->pUnlockArg = 0;
131954 }else if( 0==db->pBlockingConnection ){
131963 for(p=db->pBlockingConnection; p && p!=db; p=p->pUnlockConnection){}
131967 db->pUnlockConnection = db->pBlockingConnection;
131968 db->xUnlockNotify = xNotify;
131969 db->pUnlockArg = pArg;
131970 removeFromBlockedList(db);
131971 addToBlockedList(db);
131976 assert( !db->mallocFailed );
131977 sqlite3ErrorWithMsg(db, rc, (rc?"database is deadlocked":0));
131978 sqlite3_mutex_leave(db->mutex);
131984 ** associated with connection db. The operation will return SQLITE_LOCKED
131988 SQLITE_PRIVATE void sqlite3ConnectionBlocked(sqlite3 *db, sqlite3 *pBlocker){
131990 if( db->pBlockingConnection==0 && db->pUnlockConnection==0 ){
131991 addToBlockedList(db);
131993 db->pBlockingConnection = pBlocker;
131999 ** the transaction opened by database db has just finished. Locks held
132000 ** by database connection db have been released.
132006 ** set to db, then set pBlockingConnection=0.
132009 ** set to db, then invoke the configured unlock-notify callback and
132016 SQLITE_PRIVATE void sqlite3ConnectionUnlocked(sqlite3 *db){
132032 if( p->pBlockingConnection==db ){
132037 if( p->pUnlockConnection==db ){
132064 ** is returned the transaction on connection db will still be
132115 SQLITE_PRIVATE void sqlite3ConnectionClosed(sqlite3 *db){
132116 sqlite3ConnectionUnlocked(db);
132118 removeFromBlockedList(db);
132119 checkListProperties(db);
132904 sqlite3 *db; /* The database connection */
133269 SQLITE_PRIVATE int sqlite3Fts3ExprInitTestInterface(sqlite3 *db);
133270 SQLITE_PRIVATE int sqlite3Fts3InitTerm(sqlite3 *db);
133278 SQLITE_PRIVATE int sqlite3Fts3InitAux(sqlite3 *db);
133542 sqlite3 *db, /* Database in which to run SQL */
133555 *pRc = sqlite3_exec(db, zSql, 0, 0, 0);
133567 sqlite3 *db = p->db; /* Database handle */
133571 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_content'", zDb, p->zName);
133573 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_segments'", zDb,p->zName);
133574 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_segdir'", zDb, p->zName);
133575 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_docsize'", zDb, p->zName);
133576 fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_stat'", zDb, p->zName);
133604 sqlite3_vtab_config(p->db, SQLITE_VTAB_CONSTRAINT_SUPPORT, 1);
133620 rc = sqlite3_declare_vtab(p->db, zSql);
133633 fts3DbExec(pRc, p->db,
133653 sqlite3 *db = p->db; /* The database connection */
133671 fts3DbExec(&rc, db,
133679 fts3DbExec(&rc, db,
133683 fts3DbExec(&rc, db,
133696 fts3DbExec(&rc, db,
133725 rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
134046 sqlite3 *db, /* Database handle */
134047 const char *zDb, /* Name of db (i.e. "main", "temp" etc.) */
134062 rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
134064 sqlite3Fts3ErrMsg(pzErr, "%s", sqlite3_errmsg(db));
134122 sqlite3 *db, /* The SQLite database connection */
134317 rc = fts3ContentColumns(db, argv[1], zContent,&aCol,&nCol,&nString,pzErr);
134370 p->db = db;
134498 sqlite3 *db, /* Database connection */
134505 return fts3InitVtab(0, db, pAux, argc, argv, ppVtab, pzErr);
134508 sqlite3 *db, /* Database connection */
134515 return fts3InitVtab(1, db, pAux, argc, argv, ppVtab, pzErr);
134713 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pCsr->pStmt, 0);
136250 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pCsr->pStmt, 0);
136390 int mxLevel = 0; /* Maximum relative level value in db */
136416 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
136710 sqlite3 *db = p->db; /* Database connection */
136729 fts3DbExec(&rc, db,
136736 fts3DbExec(&rc, db,
136742 fts3DbExec(&rc, db,
136747 fts3DbExec(&rc, db,
136751 fts3DbExec(&rc, db,
136867 SQLITE_PRIVATE int sqlite3Fts3Init(sqlite3 *db){
136886 rc = sqlite3Fts3InitTerm(db);
136890 rc = sqlite3Fts3InitAux(db);
136922 rc = sqlite3Fts3ExprInitTestInterface(db);
136932 && SQLITE_OK==(rc = sqlite3Fts3InitHashTable(db, pHash, "fts3_tokenizer"))
136934 && SQLITE_OK==(rc = sqlite3_overload_function(db, "snippet", -1))
136935 && SQLITE_OK==(rc = sqlite3_overload_function(db, "offsets", 1))
136936 && SQLITE_OK==(rc = sqlite3_overload_function(db, "matchinfo", 1))
136937 && SQLITE_OK==(rc = sqlite3_overload_function(db, "matchinfo", 2))
136938 && SQLITE_OK==(rc = sqlite3_overload_function(db, "optimize", 1))
136942 db, "fts1", &fts3Module, (void *)pHash, 0
136946 db, "fts2", &fts3Module, (void *)pHash, 0
136951 db, "fts3", &fts3Module, (void *)pHash, hashDestroy
136955 db, "fts4", &fts3Module, (void *)pHash, 0
136959 rc = sqlite3Fts3InitTok(db, (void *)pHash);
138087 ** the db. In this case the position-list is not populated at all.
138907 sqlite3 *db,
138912 return sqlite3Fts3Init(db);
138976 sqlite3 *db, /* Database connection */
138996 ** CREATE VIRTUAL TABLE xxx USING fts4aux(fts4-table-db, fts4-table);
139015 rc = sqlite3_declare_vtab(db, FTS3_AUX_SCHEMA);
139026 p->pFts3Tab->db = db;
139433 ** Register the fts3aux module with database connection db. Return SQLITE_OK
139436 SQLITE_PRIVATE int sqlite3Fts3InitAux(sqlite3 *db){
139464 rc = sqlite3_create_module(db, "fts4aux", &fts3aux_module, 0);
140559 sqlite3 *db,
140568 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
140665 sqlite3 *db = sqlite3_context_db_handle(context);
140674 rc = queryTestTokenizer(db,
140738 ** with database connection db.
140740 SQLITE_PRIVATE int sqlite3Fts3ExprInitTestInterface(sqlite3* db){
140742 db, "fts3_exprtest", -1, SQLITE_UTF8, 0, fts3ExprTest, 0, 0
140745 rc = sqlite3_create_function(db, "fts3_exprtest_rebalance",
142135 sqlite3 *db,
142143 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
142157 sqlite3 *db,
142166 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
142209 sqlite3 *db = (sqlite3 *)sqlite3_user_data(context);
142216 rc = queryTokenizer(db, "simple", &p2);
142219 rc = queryTokenizer(db, "nosuchtokenizer", &p2);
142222 assert( 0==strcmp(sqlite3_errmsg(db), "unknown tokenizer: nosuchtokenizer") );
142225 rc = registerTokenizer(db, "nosuchtokenizer", p1);
142227 rc = queryTokenizer(db, "nosuchtokenizer", &p2);
142237 ** Set up SQL objects in database db used to access the contents of
142254 sqlite3 *db,
142265 void *pdb = (void *)db;
142274 rc = sqlite3_create_function(db, zName, 1, any, p, scalarFunc, 0, 0);
142277 rc = sqlite3_create_function(db, zName, 2, any, p, scalarFunc, 0, 0);
142281 rc = sqlite3_create_function(db, zTest, -1, any, p, testFunc, 0, 0);
142284 rc = sqlite3_create_function(db, zTest2, 0, any, pdb, intTestFunc, 0, 0);
142692 sqlite3 *db, /* Database connection */
142706 rc = sqlite3_declare_vtab(db, FTS3_TOK_SCHEMA);
142952 ** Register the fts3tok module with database connection db. Return SQLITE_OK
142955 SQLITE_PRIVATE int sqlite3Fts3InitTok(sqlite3 *db, Fts3Hash *pHash){
142983 rc = sqlite3_create_module(db, "fts3tokenize", &fts3tok_module, (void*)pHash);
143322 ** of the oldest level in the db that contains at least ? segments. Or,
143398 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, NULL);
143999 *piDocid = sqlite3_last_insert_rowid(p->db);
144196 p->db, p->zDb, p->zSegmentsTbl, "block", iBlockid, 0, &p->pSegments
145104 ** blocks were written to the db). Otherwise, an SQLite error code is
145320 SegmentWriter *pWriter, /* SegmentWriter to flush to the db */
145327 sqlite3_int64 iLastLeaf; /* Largest leaf block id written to db */
146485 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
147622 ** Each input segment is either removed from the db completely (if all of
148160 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
148580 if( sqlite3_vtab_on_conflict(p->db)==SQLITE_REPLACE ){
148638 rc = sqlite3_exec(p->db, "SAVEPOINT fts3", 0, 0, 0);
148642 int rc2 = sqlite3_exec(p->db, "RELEASE fts3", 0, 0, 0);
148645 sqlite3_exec(p->db, "ROLLBACK TO fts3", 0, 0, 0);
148646 sqlite3_exec(p->db, "RELEASE fts3", 0, 0, 0);
151116 sqlite3 *db; /* Host database connection */
151666 pNode->iNode = sqlite3_last_insert_rowid(pRtree->db);
151759 sqlite3 *db,
151765 return rtreeInit(db, pAux, argc, argv, ppVtab, pzErr, 1);
151772 sqlite3 *db,
151778 return rtreeInit(db, pAux, argc, argv, ppVtab, pzErr, 0);
151833 rc = sqlite3_exec(pRtree->db, zCreate, 0, 0, 0);
153672 *piRowid = sqlite3_last_insert_rowid(pRtree->db);
153868 if( sqlite3_vtab_on_conflict(pRtree->db)==SQLITE_REPLACE ){
153936 rc = sqlite3_exec(pRtree->db, zSql, 0, 0, 0);
153947 static int rtreeQueryStat1(sqlite3 *db, Rtree *pRtree){
153958 rc = sqlite3_prepare_v2(db, zSql, -1, &p, 0);
154007 sqlite3 *db,
154034 pRtree->db = db;
154048 rc = sqlite3_exec(db, zCreate, 0, 0, 0);
154065 rc = rtreeQueryStat1(db, pRtree);
154069 rc = sqlite3_prepare_v2(db, zSql, -1, appStmt[i], 0);
154082 ** using database connection db. If successful, the integer value returned
154086 static int getIntFromStmt(sqlite3 *db, const char *zSql, int *piVal){
154090 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
154117 sqlite3 *db, /* Database handle */
154127 rc = getIntFromStmt(db, zSql, &iPageSize);
154134 *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db));
154141 rc = getIntFromStmt(db, zSql, &pRtree->iNodeSize);
154143 *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db));
154161 sqlite3 *db, /* Database connection */
154187 sqlite3_vtab_config(db, SQLITE_VTAB_CONSTRAINT_SUPPORT, 1);
154208 rc = getNodeSize(db, pRtree, isCreate, pzErr);
154215 if( (rc = rtreeSqlInit(pRtree, db, argv[1], argv[2], isCreate)) ){
154216 *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db));
154233 }else if( SQLITE_OK!=(rc = sqlite3_declare_vtab(db, zSql)) ){
154234 *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db));
154334 ** Register the r-tree module with database handle db. This creates the
154338 SQLITE_PRIVATE int sqlite3RtreeInit(sqlite3 *db){
154342 rc = sqlite3_create_function(db, "rtreenode", 2, utf8, 0, rtreenode, 0, 0);
154344 rc = sqlite3_create_function(db, "rtreedepth", 1, utf8, 0,rtreedepth, 0, 0);
154352 rc = sqlite3_create_module_v2(db, "rtree", &rtreeModule, c, 0);
154356 rc = sqlite3_create_module_v2(db, "rtree_i32", &rtreeModule, c, 0);
154418 sqlite3 *db, /* Register SQL function on this connection */
154432 return sqlite3_create_function_v2(db, zGeom, -1, SQLITE_ANY,
154442 sqlite3 *db, /* Register SQL function on this connection */
154457 return sqlite3_create_function_v2(db, zQueryFunc, -1, SQLITE_ANY,
154467 sqlite3 *db,
154472 return sqlite3RtreeInit(db);
154894 sqlite3 *db = (sqlite3 *)sqlite3_user_data(p);
154916 rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator,
154926 ** Register the ICU extension functions with database db.
154928 db){
154951 {"icu_load_collation", 2, SQLITE_UTF8, (void*)db, icuLoadCollation},
154960 db, p->zName, p->nArg, p->enc, p->pContext, p->xFunc, 0, 0
154972 sqlite3 *db,
154977 return sqlite3IcuInit(db);
155369 sqlite3 *db;
155381 sqlite3 *db,
155392 iDb = sqlite3FindDbName(db, argv[3]);
155400 rc = sqlite3_declare_vtab(db, VTAB_SCHEMA);
155409 pTab->db = db;
155474 " ORDER BY name", pTab->db->aDb[pTab->iDb].zName);
155478 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pStmt, 0);
155646 Btree *pBt = pTab->db->aDb[pTab->iDb].pBt;
155675 Btree *pBt = pTab->db->aDb[pTab->iDb].pBt;
155869 SQLITE_API int SQLITE_STDCALL sqlite3_dbstat_register(sqlite3 *db){
155892 return sqlite3_create_module(db, "dbstat", &dbstat_module, 0);
