Lines Matching defs:iDb
16717 #define OP_ReopenIdx 101 /* synopsis: root=P2 iDb=P3 */
16728 #define OP_OpenRead 112 /* synopsis: root=P2 iDb=P3 */
16729 #define OP_OpenWrite 113 /* synopsis: root=P2 iDb=P3 */
16763 #define OP_CreateBtree 147 /* synopsis: r[P2]=root iDb=P1 flags=P3 */
16785 #define OP_TableLock 169 /* synopsis: iDb=P1 root=P2 write=P3 */
17677 u8 iDb; /* Which db file is being initialized */
19687 int iDb; /* Index in sqlite3.aDb[] of database holding pTab */
20146 int iDb; /* 0 for main database. 1 for TEMP, 2.. for ATTACHed */
20973 SQLITE_PRIVATE void sqlite3OpenTable(Parse*, int iCur, int iDb, Table*, int);
21174 SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName);
23182 i8 iDb; /* Index of cursor database in db->aDb[] */
37281 /* 101 */ "ReopenIdx" OpHelp("root=P2 iDb=P3"),
37292 /* 112 */ "OpenRead" OpHelp("root=P2 iDb=P3"),
37293 /* 113 */ "OpenWrite" OpHelp("root=P2 iDb=P3"),
37327 /* 147 */ "CreateBtree" OpHelp("r[P2]=root iDb=P1 flags=P3"),
37349 /* 169 */ "TableLock" OpHelp("iDb=P1 root=P2 write=P3"),
53622 int iDb;
53640 iDb = sqlite3FindDbName(db, zSchema);
53642 if( iDb<0 ) return 0;
53655 pBt = db->aDb[iDb].pBt;
53716 int iDb;
53728 iDb = sqlite3FindDbName(db, zSchema);
53729 testcase( iDb==1 );
53730 if( iDb<2 && iDb!=0 ){
53742 db->init.iDb = (u8)iDb;
70474 ** db->aDb[iDb].pSchema structure. The mutexes required for schema
70478 ** (2) if iDb!=1, then the mutex on db->aDb[iDb].pBt.
70480 ** If pSchema is not NULL, then iDb is computed from pSchema and
70483 SQLITE_PRIVATE int sqlite3SchemaMutexHeld(sqlite3 *db, int iDb, Schema *pSchema){
70487 if( pSchema ) iDb = sqlite3SchemaToIndex(db, pSchema);
70488 assert( iDb>=0 && iDb<db->nDb );
70490 if( iDb==1 ) return 1;
70491 p = db->aDb[iDb].pBt;
73164 int iDb;
73165 for(iDb=db->nDb-1; iDb>=0; iDb--){
73166 Btree *pExisting = db->aDb[iDb].pBt;
74733 int iDb;
74734 for(iDb=0; ALWAYS(iDb<db->nDb); iDb++){
74735 if( db->aDb[iDb].pBt==p ) break;
74739 db->aDb[iDb].zDbSName,
85401 SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere, u16 p5){
85403 sqlite3VdbeAddOp4(p, OP_ParseSchema, iDb, 0, 0, zWhere, P4_DYNAMIC);
97242 int iDb;
97246 iDb = pOp->p1;
97249 assert( iDb>=0 && iDb<db->nDb );
97250 assert( db->aDb[iDb].pBt!=0 );
97251 assert( DbMaskTest(p->btreeMask, iDb) );
97253 sqlite3BtreeGetMeta(db->aDb[iDb].pBt, iCookie, (u32 *)&iMeta);
97307 ** Synopsis: root=P2 iDb=P3
97335 ** Synopsis: root=P2 iDb=P3
97357 ** Synopsis: root=P2 iDb=P3
97394 int iDb;
97404 assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */
97427 iDb = pOp->p3;
97428 assert( iDb>=0 && iDb<db->nDb );
97429 assert( DbMaskTest(p->btreeMask, iDb) );
97430 pDb = &db->aDb[iDb];
97436 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
97471 pCur->iDb = iDb;
98796 assert( pC->iDb>=0 );
98797 zDb = db->aDb[pC->iDb].zDbSName;
98957 assert( pC->iDb>=0 );
98959 zDb = db->aDb[pC->iDb].zDbSName;
99017 assert( pC->iDb>=0 );
99917 int iDb;
99929 iDb = pOp->p3;
99930 assert( DbMaskTest(p->btreeMask, iDb) );
99932 rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved);
99938 sqlite3RootPageMoved(db, iDb, iMoved, pOp->p1);
99940 assert( resetSchemaOnFault==0 || resetSchemaOnFault==iDb+1 );
99941 resetSchemaOnFault = iDb+1;
100011 ** Synopsis: r[P2]=root iDb=P1 flags=P3
100102 int iDb;
100112 for(iDb=0; iDb<db->nDb; iDb++){
100113 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
100117 iDb = pOp->p1;
100118 assert( iDb>=0 && iDb<db->nDb );
100119 assert( DbHasProperty(db, iDb, DB_SchemaLoaded)
100125 sqlite3SchemaClear(db->aDb[iDb].pSchema);
100127 rc = sqlite3InitOne(db, iDb, &p->zErrMsg, pOp->p5);
100135 initData.iDb = iDb;
100138 initData.mxPage = sqlite3BtreeLastPage(db->aDb[iDb].pBt);
100141 db->aDb[iDb].zDbSName, zSchema, pOp->p4.z);
101171 ** Synopsis: iDb=P1 root=P2 write=P3
102558 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
102561 sqlite3VdbeAddOp4Int(v, OP_Transaction, iDb, wrFlag,
102569 sqlite3VdbeUsesBtree(v, iDb);
102577 aOp[0].p1 = iDb;
102589 aOp[1].p3 = iDb;
105783 int iDb = pOp->p3;
105786 pSchema = db->aDb[iDb].pSchema;
105787 pCur->zSchema = db->aDb[iDb].zDbSName;
106981 ** pExpr->iDb Set the index in db->aDb[] of the database X
112161 int iDb; /* Database idx for pTab */
112171 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
112172 assert( iDb>=0 && iDb<SQLITE_MAX_DB );
112173 sqlite3CodeVerifySchema(pParse, iDb);
112174 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
112182 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
112266 sqlite3VdbeAddOp3(v, OP_OpenRead, iTab, pIdx->tnum, iDb);
116250 ** Generate code to reload the schema for database iDb. And, if iDb!=1, for
116253 static void renameReloadSchema(Parse *pParse, int iDb, u16 p5){
116256 sqlite3ChangeCookie(pParse, iDb);
116257 sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, iDb, 0, p5);
116258 if( iDb!=1 ) sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, 1, 0, p5);
116271 int iDb; /* Database that contains the table */
116272 char *zDb; /* Name of database iDb */
116287 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
116288 zDb = db->aDb[iDb].zDbSName;
116295 ** in database iDb. If so, this is an error.
116342 /* Begin a transaction for database iDb. Then modify the schema cookie
116363 , zDb, zDb, zTabName, zName, (iDb==1), zTabName
116398 if( iDb!=1 ){
116423 renameReloadSchema(pParse, iDb, INITFLAG_AlterRename);
116424 renameTestSchema(pParse, zDb, iDb==1, "after rename", 0);
116458 int iDb; /* Database number */
116476 iDb = sqlite3SchemaToIndex(db, pNew->pSchema);
116477 zDb = db->aDb[iDb].zDbSName;
116577 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT);
116578 sqlite3VdbeUsesBtree(v, iDb);
116582 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, 3);
116586 renameReloadSchema(pParse, iDb, INITFLAG_AlterAdd);
116628 int iDb;
116659 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
116690 pNew->pSchema = db->aDb[iDb].pSchema;
117291 db->init.iDb = bTemp ? 1 : sqlite3FindDbName(db, zDb);
117315 db->init.iDb = 0;
118299 int iDb; /* Index of db containing pTab in aDb[] */
118345 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
118346 assert( iDb>=0 );
118347 zDb = db->aDb[iDb].zDbSName;
118354 renameTestSchema(pParse, zDb, iDb==1, "", 0);
118355 renameFixQuotes(pParse, zDb, iDb==1);
118360 , zDb, iDb, iCol, pTab->zName
118364 renameReloadSchema(pParse, iDb, INITFLAG_AlterDrop);
118365 renameTestSchema(pParse, zDb, iDb==1, "after drop column", 1);
118378 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite);
118624 int iDb, /* The database we are looking in */
118656 pDb = &db->aDb[iDb];
118682 sqlite3TableLock(pParse, iDb, aRoot[i], 1, zTab);
118694 sqlite3VdbeAddOp2(v, OP_Clear, (int)aRoot[i], iDb);
118702 sqlite3VdbeAddOp4Int(v, OP_OpenWrite, iStatCur+i, (int)aRoot[i], iDb, 3);
119447 int iDb; /* Index of database containing pTab */
119481 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
119482 assert( iDb>=0 );
119483 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
119486 db->aDb[iDb].zDbSName ) ){
119507 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
119511 sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
119581 assert( iDb==sqlite3SchemaToIndex(db, pIdx->pSchema) );
119582 sqlite3VdbeAddOp3(v, OP_OpenRead, iIdxCur, pIdx->tnum, iDb);
119839 static void loadAnalysis(Parse *pParse, int iDb){
119842 sqlite3VdbeAddOp1(v, OP_LoadAnalysis, iDb);
119849 static void analyzeDatabase(Parse *pParse, int iDb){
119851 Schema *pSchema = db->aDb[iDb].pSchema; /* Schema of database iDb */
119857 sqlite3BeginWriteOperation(pParse, 0, iDb);
119860 openStatTable(pParse, iDb, iStatCur, 0, 0);
119863 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
119873 loadAnalysis(pParse, iDb);
119882 int iDb;
119887 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
119888 sqlite3BeginWriteOperation(pParse, 0, iDb);
119892 openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");
119894 openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
119897 loadAnalysis(pParse, iDb);
119914 int iDb;
119936 }else if( pName2->n==0 && (iDb = sqlite3FindDb(db, pName1))>=0 ){
119938 analyzeDatabase(pParse, iDb);
119941 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName);
119942 if( iDb>=0 ){
119943 zDb = pName2->n ? db->aDb[iDb].zDbSName : 0;
120403 SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
120408 Schema *pSchema = db->aDb[iDb].pSchema;
120411 assert( iDb>=0 && iDb<db->nDb );
120412 assert( db->aDb[iDb].pBt!=0 );
120415 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
120431 sInfo.zDatabase = db->aDb[iDb].zDbSName;
120446 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
120526 ** database iDb attached to handle db.
120528 SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName){
120530 sqlite3StrICmp(db->aDb[iDb].zDbSName, zName)==0
120531 || (iDb==0 && sqlite3StrICmp("main", zName)==0)
120547 ** new database, close the database on db->init.iDb and reopen it as an
120582 ** from sqlite3_deserialize() to close database db->init.iDb and
120594 pNew = &db->aDb[db->init.iDb];
120698 db->init.iDb = 0;
120717 int iDb = db->nDb - 1;
120718 assert( iDb>=2 );
120719 if( db->aDb[iDb].pBt ){
120720 sqlite3BtreeClose(db->aDb[iDb].pBt);
120721 db->aDb[iDb].pBt = 0;
120722 db->aDb[iDb].pSchema = 0;
120725 db->nDb = iDb;
120953 int iDb = sqlite3FindDbName(db, pFix->zDb);
120960 if( iDb!=sqlite3FindDbName(db, pItem->zDatabase) ){
120998 int iDb, /* This is the database that must be used */
121003 assert( db->nDb>iDb );
121005 pFix->zDb = db->aDb[iDb].zDbSName;
121006 pFix->pSchema = db->aDb[iDb].pSchema;
121009 pFix->bTemp = (iDb==1);
121204 int iDb /* Index of containing database. */
121207 char *zDb = db->aDb[iDb].zDbSName; /* Schema name of attached database */
121218 if( db->nDb>2 || iDb!=0 ) z = sqlite3_mprintf("%s.%z", zDb, z);
121245 int iDb; /* The index of the database the expression refers to */
121251 iDb = sqlite3SchemaToIndex(pParse->db, pSchema);
121252 if( iDb<0 ){
121281 assert( iDb>=0 && iDb<pParse->db->nDb );
121282 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
121400 int iDb; /* The database containing the table to be locked */
121409 ** The table to be locked has root page iTab and is found in database iDb.
121418 int iDb, /* Index of the database containing the table to lock */
121427 assert( iDb>=0 );
121432 if( p->iDb==iDb && p->iTab==iTab ){
121443 p->iDb = iDb;
121454 int iDb, /* Index of the database containing the table to lock */
121459 if( iDb==1 ) return;
121460 if( !sqlite3BtreeSharable(pParse->db->aDb[iDb].pBt) ) return;
121461 lockTable(pParse, iDb, iTab, isWriteLock, zName);
121475 int p1 = p->iDb;
121510 int iDb, i;
121579 iDb = 0;
121582 if( DbMaskTest(pParse->cookieMask, iDb)==0 ) continue;
121583 sqlite3VdbeUsesBtree(v, iDb);
121584 pSchema = db->aDb[iDb].pSchema;
121587 iDb, /* P1 */
121588 DbMaskTest(pParse->writeMask,iDb), /* P2 */
121595 }while( ++iDb<db->nDb );
121869 int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema);
121870 zDb = pParse->db->aDb[iDb].zDbSName;
121940 ** For the index called zIdxName which is found in the database iDb,
121945 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){
121949 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
121950 pHash = &db->aDb[iDb].pSchema->idxHash;
122001 ** Reset the schema for the database at index iDb. Also reset the
122003 ** Deferred resets may be run by calling with iDb<0.
122005 SQLITE_PRIVATE void sqlite3ResetOneSchema(sqlite3 *db, int iDb){
122007 assert( iDb<db->nDb );
122009 if( iDb>=0 ){
122010 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
122011 DbSetProperty(db, iDb, DB_ResetWanted);
122252 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){
122257 assert( iDb>=0 && iDb<db->nDb );
122259 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
122261 pDb = &db->aDb[iDb];
122292 ** Open the sqlite_schema table stored in database number iDb for
122295 SQLITE_PRIVATE void sqlite3OpenSchemaTable(Parse *p, int iDb){
122297 sqlite3TableLock(p, iDb, SCHEMA_ROOT, 1, LEGACY_SCHEMA_TABLE);
122298 sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, SCHEMA_ROOT, iDb, 5);
122361 int iDb; /* Database holding the object */
122371 iDb = sqlite3FindDb(db, pName1);
122372 if( iDb<0 ){
122377 assert( db->init.iDb==0 || db->init.busy || IN_SPECIAL_PARSE
122379 iDb = db->init.iDb;
122382 return iDb;
122592 int iDb; /* Database number to create the table in */
122597 iDb = db->init.iDb;
122598 zName = sqlite3DbStrDup(db, SCHEMA_TABLE(iDb));
122602 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
122603 if( iDb<0 ) return;
122604 if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){
122610 if( !OMIT_TEMPDB && isTemp ) iDb = 1;
122621 if( db->init.iDb==1 ) isTemp = 1;
122632 char *zDb = db->aDb[iDb].zDbSName;
122651 char *zDb = db->aDb[iDb].zDbSName;
122662 sqlite3CodeVerifySchema(pParse, iDb);
122682 pTable->pSchema = db->aDb[iDb].pSchema;
122706 sqlite3BeginWriteOperation(pParse, 1, iDb);
122720 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT);
122721 sqlite3VdbeUsesBtree(v, iDb);
122725 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, fileFormat);
122726 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, ENC(db));
122746 sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, reg2, BTREE_INTKEY);
122748 sqlite3OpenSchemaTable(pParse, iDb);
123107 int isInit = db->init.busy && db->init.iDb!=1;
123283 && !sqlite3BtreeIsReadonly(db->aDb[db->init.iDb].pBt)
123416 SQLITE_PRIVATE void sqlite3ChangeCookie(Parse *pParse, int iDb){
123419 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
123420 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION,
123421 (int)(1+(unsigned)db->aDb[iDb].pSchema->schema_cookie));
124001 int iDb; /* Database in which the table lives */
124089 iDb = sqlite3SchemaToIndex(db, p->pSchema);
124210 sqlite3VdbeAddOp3(v, OP_OpenWrite, iCsr, pParse->regRoot, iDb);
124259 db->aDb[iDb].zDbSName,
124268 sqlite3ChangeCookie(pParse, iDb);
124275 Db *pDb = &db->aDb[iDb];
124276 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
124287 sqlite3VdbeAddParseSchemaOp(v, iDb,
124295 db->aDb[iDb].zDbSName, p->zName), P4_DYNAMIC);
124304 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
124321 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
124358 int iDb;
124382 iDb = sqlite3SchemaToIndex(db, p->pSchema);
124383 sqlite3FixInit(&sFix, pParse, iDb, "view", pName);
124591 ** root-page of a table or index in database iDb has changed from iFrom
124606 SQLITE_PRIVATE void sqlite3RootPageMoved(sqlite3 *db, int iDb, Pgno iFrom, Pgno iTo){
124611 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
124612 pDb = &db->aDb[iDb];
124631 ** Write code to erase the table with root-page iTable from database iDb.
124636 static void destroyRootPage(Parse *pParse, int iTable, int iDb){
124640 sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
124655 pParse->db->aDb[iDb].zDbSName, iTable, r1, r1);
124703 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
124704 assert( iDb>=0 && iDb<pParse->db->nDb );
124705 destroyRootPage(pParse, iLargest, iDb);
124717 int iDb, /* The database number */
124722 const char *zDbName = pParse->db->aDb[iDb].zDbSName;
124738 SQLITE_PRIVATE void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){
124742 Db *pDb = &db->aDb[iDb];
124746 sqlite3BeginWriteOperation(pParse, 1, iDb);
124799 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
124802 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
124803 sqlite3ChangeCookie(pParse, iDb);
124804 sqliteViewResetAll(db, iDb);
124850 int iDb;
124870 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
124871 assert( iDb>=0 && iDb<db->nDb );
124882 const char *zTab = SCHEMA_TABLE(iDb);
124883 const char *zDb = db->aDb[iDb].zDbSName;
124889 if( !OMIT_TEMPDB && iDb==1 ){
124900 if( !OMIT_TEMPDB && iDb==1 ){
124938 sqlite3BeginWriteOperation(pParse, 1, iDb);
124940 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
124943 sqlite3CodeDropTable(pParse, pTab, iDb, isView);
125134 int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
125138 db->aDb[iDb].zDbSName ) ){
125144 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
125163 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
125173 if( memRootPage<0 ) sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb);
125174 sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, (int)tnum, iDb,
125310 int iDb; /* Index of the database that is being written */
125343 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
125344 if( iDb<0 ) goto exit_create_index;
125355 iDb = 1;
125360 sqlite3FixInit(&sFix, pParse, iDb, "index", pName);
125369 if( iDb==1 && db->aDb[iDb].pSchema!=pTab->pSchema ){
125381 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
125383 pDb = &db->aDb[iDb];
125441 sqlite3CodeVerifySchema(pParse, iDb);
125469 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
125473 if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX;
125531 pIndex->pSchema = db->aDb[iDb].pSchema;
125538 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
125781 sqlite3BeginWriteOperation(pParse, 1, iDb);
125790 sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, iMem, BTREE_BLOBKEY);
125812 db->aDb[iDb].zDbSName,
125825 sqlite3ChangeCookie(pParse, iDb);
125826 sqlite3VdbeAddParseSchemaOp(v, iDb,
125949 int iDb;
125975 iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
125980 const char *zDb = db->aDb[iDb].zDbSName;
125981 const char *zTab = SCHEMA_TABLE(iDb);
125985 if( !OMIT_TEMPDB && iDb==1 ) code = SQLITE_DROP_TEMP_INDEX;
125995 sqlite3BeginWriteOperation(pParse, 1, iDb);
125998 db->aDb[iDb].zDbSName, pIndex->zName
126000 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
126001 sqlite3ChangeCookie(pParse, iDb);
126002 destroyRootPage(pParse, pIndex->tnum, iDb);
126003 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
126608 ** for database iDb. The code to actually verify the schema cookie
126612 static void sqlite3CodeVerifySchemaAtToplevel(Parse *pToplevel, int iDb){
126613 assert( iDb>=0 && iDb<pToplevel->db->nDb );
126614 assert( pToplevel->db->aDb[iDb].pBt!=0 || iDb==1 );
126615 assert( iDb<SQLITE_MAX_DB );
126616 assert( sqlite3SchemaMutexHeld(pToplevel->db, iDb, 0) );
126617 if( DbMaskTest(pToplevel->cookieMask, iDb)==0 ){
126618 DbMaskSet(pToplevel->cookieMask, iDb);
126619 if( !OMIT_TEMPDB && iDb==1 ){
126624 SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
126625 sqlite3CodeVerifySchemaAtToplevel(sqlite3ParseToplevel(pParse), iDb);
126657 SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
126659 sqlite3CodeVerifySchemaAtToplevel(pToplevel, iDb);
126660 DbMaskSet(pToplevel->writeMask, iDb);
126809 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
126810 sqlite3BeginWriteOperation(pParse, 0, iDb);
126826 int iDb; /* The database index number */
126832 for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
126862 int iDb; /* The database index number */
126888 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName);
126889 if( iDb<0 ) return;
126892 zDb = pName2->n ? db->aDb[iDb].zDbSName : 0;
126902 iDb = sqlite3SchemaToIndex(db, pIndex->pTable->pSchema);
126903 sqlite3BeginWriteOperation(pParse, 0, iDb);
127770 int iDb = sqlite3SchemaToIndex(db, pView->pSchema);
127776 pFrom->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zDbSName);
127922 int iDb; /* Database number */
128006 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
128007 assert( iDb<db->nDb );
128009 db->aDb[iDb].zDbSName);
128037 sqlite3BeginWriteOperation(pParse, bComplex, iDb);
128095 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
128097 sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt ? memCnt : -1,
128103 sqlite3VdbeAddOp3(v, OP_Clear, pIdx->tnum, iDb, memCnt ? memCnt : -1);
128105 sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);
131730 int iDb, /* Index of database housing pTab */
131792 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);
131802 sqlite3VdbeAddOp3(v, OP_OpenRead, iCur, pIdx->tnum, iDb);
132112 SQLITE_PRIVATE void sqlite3FkClearTriggerCache(sqlite3 *db, int iDb){
132114 Hash *pHash = &db->aDb[iDb].pSchema->tblHash;
132306 int iDb; /* Index of database containing pTab */
132317 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
132318 zDb = db->aDb[iDb].zDbSName;
132390 rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
132399 sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
132406 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regOld, -1, bIgnore);
132417 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regNew, +1, bIgnore);
132735 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
132747 pSrc->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zDbSName);
132922 int iDb, /* The database index in sqlite3.aDb[] */
132932 sqlite3TableLock(pParse, iDb, pTab->tnum,
132936 sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nNVCol);
132942 sqlite3VdbeAddOp3(v, opcode, iCur, pPk->tnum, iDb);
133117 ** Return non-zero if the table pTab in database iDb or any of its indices
133119 ** a statement of the form "INSERT INTO <iDb, pTab> SELECT ..." can
133122 static int readsTable(Parse *p, int iDb, Table *pTab){
133133 if( pOp->opcode==OP_OpenRead && pOp->p3==iDb ){
133278 ** which is in database iDb. Return the register number for the register
133301 int iDb, /* Index of the database holding pTab */
133305 assert( pParse->db->aDb[iDb].pSchema!=0 );
133311 Table *pSeqTab = pParse->db->aDb[iDb].pSchema->pSeqTab;
133336 pInfo->iDb = iDb;
133380 pDb = &db->aDb[p->iDb];
133383 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead);
133440 Db *pDb = &db->aDb[p->iDb];
133448 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
133793 int iDb; /* Index of database holding TABLE */
133842 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
133843 assert( iDb<db->nDb );
133845 db->aDb[iDb].zDbSName) ){
133893 sqlite3BeginWriteOperation(pParse, pSelect || pTrigger, iDb);
133908 && xferOptimization(pParse, pTab, pSelect, onError, iDb)
133919 regAutoinc = autoIncBegin(pParse, iDb, pTab);
134043 if( pTrigger || readsTable(pParse, iDb, pTab) ){
135754 int iDb;
135770 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
135777 sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op);
135779 sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
135790 sqlite3VdbeAddOp3(v, op, iIdxCur, pIdx->tnum, iDb);
138961 ** Set the safety_level and pager flags for pager iDb. Or if iDb<0
139145 int iDb; /* Database index for <database> */
139156 /* Interpret the [schema.] part of the pragma statement. iDb is the
139158 iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId);
139159 if( iDb<0 ) return;
139160 pDb = &db->aDb[iDb];
139165 if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){
139275 sqlite3VdbeUsesBtree(v, iDb);
139281 aOp[0].p1 = iDb;
139282 aOp[1].p1 = iDb;
139286 sqlite3BeginWriteOperation(pParse, 0, iDb);
139287 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_DEFAULT_CACHE_SIZE, size);
139288 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
139374 sqlite3CodeVerifySchema(pParse, iDb);
139377 sqlite3VdbeAddOp2(v, OP_Pagecount, iDb, iReg);
139385 sqlite3VdbeAddOp3(v, OP_MaxPgcnt, iDb, iReg, (int)x);
139469 iDb = 0;
139473 if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
139544 aOp[0].p1 = iDb;
139545 aOp[1].p1 = iDb;
139547 aOp[4].p1 = iDb;
139549 sqlite3VdbeUsesBtree(v, iDb);
139567 sqlite3BeginWriteOperation(pParse, 0, iDb);
139569 addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb); VdbeCoverage(v);
139591 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
139625 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
139662 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
139669 if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
139847 }else if( iDb!=1 ){
140057 sqlite3CodeVerifySchema(pParse, iDb);
140269 k = sqliteHashFirst(&db->aDb[iDb].pSchema->tblHash);
140279 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
140280 zDb = db->aDb[iDb].zDbSName;
140281 sqlite3CodeVerifySchema(pParse, iDb);
140282 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
140284 sqlite3OpenTable(pParse, 0, iDb, pTab, OP_OpenRead);
140291 sqlite3TableLock(pParse, iDb, pParent->tnum, 0, pParent->zName);
140295 sqlite3OpenTable(pParse, i, iDb, pParent, OP_OpenRead);
140297 sqlite3VdbeAddOp3(v, OP_OpenRead, i, pIdx->tnum, iDb);
140412 ** then iDb is set to the index of the database identified by <db>.
140413 ** In this case, the integrity of database iDb only is verified by
140417 ** "PRAGMA quick_check"), then iDb is set to 0. In this case, set iDb
140420 assert( iDb>=0 );
140421 assert( iDb==0 || pId2->z );
140422 if( pId2->z==0 ) iDb = -1;
140436 iDb>=0 ? db->aDb[iDb].zDbSName : 0);
140449 if( iDb>=0 && i!=iDb ) continue;
141023 sqlite3VdbeUsesBtree(v, iDb);
141034 aOp[0].p1 = iDb;
141035 aOp[1].p1 = iDb;
141055 aOp[0].p1 = iDb;
141056 aOp[1].p1 = iDb;
141091 int iBt = (pId2->z?iDb:SQLITE_MAX_DB);
141242 for(iDbLast = zDb?iDb:db->nDb-1; iDb<=iDbLast; iDb++){
141243 if( iDb==1 ) continue;
141244 sqlite3CodeVerifySchema(pParse, iDb);
141245 pSchema = db->aDb[iDb].pSchema;
141286 sqlite3BeginWriteOperation(pParse, 0, iDb);
141293 sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
141307 db->aDb[iDb].zDbSName, pTab->zName);
141901 int iDb = pData->iDb;
141914 assert( iDb>=0 && iDb<db->nDb );
141931 u8 saved_iDb = db->init.iDb;
141936 db->init.iDb = iDb;
141950 db->init.iDb = saved_iDb;
141954 assert( iDb==1 );
141976 pIndex = sqlite3FindIndex(db, argv[1], db->aDb[iDb].zDbSName);
141996 ** database file is given by iDb. iDb==0 is used for the main
141997 ** database. iDb==1 should never be used. iDb>=2 is used for
142001 SQLITE_PRIVATE int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFlags){
142016 assert( iDb>=0 && iDb<db->nDb );
142017 assert( db->aDb[iDb].pSchema );
142019 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
142029 azArg[1] = zSchemaTabName = SCHEMA_TABLE(iDb);
142036 initData.iDb = iDb;
142051 pDb = &db->aDb[iDb];
142053 assert( iDb==1 );
142103 if( iDb==0 && (db->mDbFlags & DBFLAG_EncodingFixed)==0 ){
142164 if( iDb==0 && meta[BTREE_FILE_FORMAT-1]>=4 ){
142176 db->aDb[iDb].zDbSName, zSchemaTabName);
142192 sqlite3AnalysisLoad(db, iDb);
142196 assert( pDb == &(db->aDb[iDb]) );
142200 pDb = &db->aDb[iDb];
142213 DbSetProperty(db, iDb, DB_SchemaLoaded);
142232 sqlite3ResetOneSchema(db, iDb);
142303 int iDb;
142309 for(iDb=0; iDb<db->nDb; iDb++){
142311 Btree *pBt = db->aDb[iDb].pBt; /* Btree database to read cookie from */
142331 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
142332 if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){
142333 if( DbHasProperty(db, iDb, DB_SchemaLoaded) ) pParse->rc = SQLITE_SCHEMA;
142334 sqlite3ResetOneSchema(db, iDb);
142345 ** Convert a schema pointer into the iDb index that indicates
144592 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
144593 sqlite3OpenTable(pParse, pSort->aDefer[i].iCsr, iDb, pTab, OP_OpenRead);
144881 int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
144882 zOrigDb = pNC->pParse->db->aDb[iDb].zDbSName;
149059 int iDb; /* Schema index for this data src */
149078 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
149079 zSchemaName = iDb>=0 ? db->aDb[iDb].zDbSName : "*";
151321 const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
151328 sqlite3CodeVerifySchema(pParse, iDb);
151329 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
151358 sqlite3VdbeAddOp4Int(v, OP_OpenRead, iCsr, (int)iRoot, iDb, 1);
151831 int iDb; /* The database to store the trigger in */
151845 iDb = 1;
151849 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
151850 if( iDb<0 ){
151866 if( db->init.busy && iDb!=1 ){
151872 ** then set iDb to 1 to create the trigger in the temporary database.
151879 iDb = 1;
151885 sqlite3FixInit(&sFix, pParse, iDb, "trigger", pName);
151913 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
151915 if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),zName) ){
151920 sqlite3CodeVerifySchema(pParse, iDb);
151978 pTrigger->pSchema = db->aDb[iDb].pSchema;
152007 if( db->init.iDb==1 ){
152036 int iDb; /* Database containing the trigger */
152042 iDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
152049 sqlite3FixInit(&sFix, pParse, iDb, "trigger", &nameToken);
152091 sqlite3BeginWriteOperation(pParse, 0, iDb);
152097 db->aDb[iDb].zDbSName, zName,
152100 sqlite3ChangeCookie(pParse, iDb);
152101 sqlite3VdbeAddParseSchemaOp(v, iDb,
152107 Hash *pHash = &db->aDb[iDb].pSchema->trigHash;
152108 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
152387 int iDb;
152389 iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema);
152390 assert( iDb>=0 && iDb<db->nDb );
152392 assert( (pTable && pTable->pSchema==pTrigger->pSchema) || iDb==1 );
152396 const char *zDb = db->aDb[iDb].zDbSName;
152397 const char *zTab = SCHEMA_TABLE(iDb);
152398 if( iDb==1 ) code = SQLITE_DROP_TEMP_TRIGGER;
152411 db->aDb[iDb].zDbSName, pTrigger->zName
152413 sqlite3ChangeCookie(pParse, iDb);
152414 sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
152421 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){
152425 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
152426 pHash = &(db->aDb[iDb].pSchema->trigHash);
153593 int iDb; /* Database containing the table being updated */
153637 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
153789 db->aDb[iDb].zDbSName);
153877 sqlite3BeginWriteOperation(pParse, pTrigger || hasFK, iDb);
155083 int iDb = 0;
155090 iDb = sqlite3TwoPartName(pParse, pNm, pNm, &pNm);
155091 if( iDb<0 ) goto build_vacuum_end;
155098 iDb = sqlite3FindDb(pParse->db, pNm);
155099 if( iDb<0 ) iDb = 0;
155102 if( iDb!=1 ){
155108 sqlite3VdbeAddOp2(v, OP_Vacuum, iDb, iIntoReg);
155109 sqlite3VdbeUsesBtree(v, iDb);
155122 int iDb, /* Which attached DB to vacuum */
155177 zDbMain = db->aDb[iDb].zDbSName;
155178 pMain = db->aDb[iDb].pBt;
155216 pgflags = db->aDb[iDb].safety_level | (db->flags & PAGER_FLAGS_MASK);
155220 sqlite3BtreeSetCacheSize(pTemp, db->aDb[iDb].pSchema->cache_size);
155257 db->init.iDb = nDb; /* force new CREATE statements into vacuum_db */
155271 db->init.iDb = 0;
155359 db->init.iDb = 0;
155813 int iDb = sqlite3SchemaToIndex(db, pTable->pSchema);
155814 assert( iDb>=0 ); /* The database the table is being created in */
155816 pTable->u.vtab.azArg[0], pParse->db->aDb[iDb].zDbSName);
155858 int iDb;
155878 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
155883 db->aDb[iDb].zDbSName,
155890 sqlite3ChangeCookie(pParse, iDb);
155894 sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere, 0);
155899 sqlite3VdbeAddOp2(v, OP_VCreate, iDb, iReg);
155962 int iDb;
155993 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
155994 pTab->u.vtab.azArg[1] = db->aDb[iDb].zDbSName;
156155 ** of the virtual table named zTab in database iDb.
156161 SQLITE_PRIVATE int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab, char **pzErr){
156167 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
156309 ** of the virtual table named zTab in database iDb. This occurs
156314 SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab){
156318 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
168761 int iDb; /* Index of database containing table/index */
168766 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
168789 sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op);
168820 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
168864 sqlite3VdbeAddOp3(v, op, iIndexCur, pIx->tnum, iDb);
168893 if( iDb>=0 ) sqlite3CodeVerifySchema(pParse, iDb);
169173 int iDb = sqlite3SchemaToIndex(db, pIx->pSchema);
169174 sqlite3VdbeAddOp3(v, OP_ReopenIdx, pLevel->iIdxCur, pIx->tnum, iDb);
181079 int iDb, nDb;
181089 nDb = iDb = sqlite3FindDbName(db, zSchema);
181090 if( iDb<0 ) nDb--;
181092 iDb = 0;
181095 for(; iDb<=nDb; iDb++){
181096 Btree *pBt = db->aDb[iDb].pBt;
182276 int iDb; /* Schema to checkpoint */
182298 iDb = sqlite3FindDbName(db, zDb);
182300 iDb = SQLITE_MAX_DB; /* This means process all schemas */
182302 if( iDb<0 ){
182307 rc = sqlite3Checkpoint(db, iDb, eMode, pnLog, pnCkpt);
182337 ** Run a checkpoint on database iDb. This is a no-op if database iDb is
182349 ** If iDb is passed SQLITE_MAX_DB then all attached databases are
182356 SQLITE_PRIVATE int sqlite3Checkpoint(sqlite3 *db, int iDb, int eMode, int *pnLog, int *pnCkpt){
182364 testcase( iDb==SQLITE_MAX_ATTACHED ); /* See forum post a006d86f72 */
182365 testcase( iDb==SQLITE_MAX_DB );
182368 if( i==iDb || iDb==SQLITE_MAX_DB ){
184276 int iDb;
184278 iDb = sqlite3FindDbName(db, va_arg(ap,const char*));
184279 if( iDb>=0 ){
184280 db->init.iDb = iDb;
184628 int iDb = zDbName ? sqlite3FindDbName(db, zDbName) : 0;
184629 return iDb<0 ? 0 : db->aDb[iDb].pBt;
184703 int iDb = sqlite3FindDbName(db, zDb);
184704 if( iDb==0 || iDb>1 ){
184705 Btree *pBt = db->aDb[iDb].pBt;
184738 int iDb;
184739 iDb = sqlite3FindDbName(db, zDb);
184740 if( iDb==0 || iDb>1 ){
184741 Btree *pBt = db->aDb[iDb].pBt;
184782 int iDb;
184791 iDb = sqlite3FindDbName(db, zDb);
184792 if( iDb==0 || iDb>1 ){
184793 Btree *pBt = db->aDb[iDb].pBt;
223662 int iDb; /* Schema used for this query */
223685 int iDb; /* Index of database to analyze */
223704 int iDb;
223710 iDb = sqlite3FindDb(db, &nm);
223711 if( iDb<0 ){
223716 iDb = 0;
223729 pTab->iDb = iDb;
223838 pCsr->iDb = pTab->iDb;
224051 Btree *pBt = pTab->db->aDb[pTab->iDb].pBt;
224114 Btree *pBt = pTab->db->aDb[pCsr->iDb].pBt;
224294 pCsr->iDb = sqlite3FindDbName(pTab->db, zDbase);
224295 if( pCsr->iDb<0 ){
224296 pCsr->iDb = 0;
224301 pCsr->iDb = pTab->iDb;
224320 pTab->db->aDb[pCsr->iDb].zDbSName);
224391 int iDb = pCsr->iDb;
224392 sqlite3_result_text(ctx, db->aDb[iDb].zDbSName, -1, SQLITE_STATIC);
224494 int iDb; /* Index of database to analyze */
224690 pCsr->iDb = sqlite3FindDbName(db, zSchema);
224691 if( pCsr->iDb<0 ) return SQLITE_OK;
224693 pCsr->iDb = 0;
224695 pBt = db->aDb[pCsr->iDb].pBt;
224747 sqlite3_result_text(ctx, db->aDb[pCsr->iDb].zDbSName, -1, SQLITE_STATIC);
224772 int iDb;
224794 iDb = ALWAYS(zSchema) ? sqlite3FindDbName(pTab->db, zSchema) : -1;
224795 if( NEVER(iDb<0) ){
224799 pBt = pTab->db->aDb[iDb].pBt;