Lines Matching defs:iDb
9472 int iDb; /* When back is being initialized */
9910 ** database file. If Table.iDb is the index of the database table backend
10766 int iDb; /* Index in sqlite3.aDb[] of database holding pTab */
11068 int iDb; /* 0 for main database. 1 for TEMP, 2.. for ATTACHed */
11390 SQLITE_PRIVATE void sqlite3OpenTable(Parse*, int iCur, int iDb, Table*, int);
12594 int iDb; /* Index of cursor database in db->aDb[] (or -1) */
48211 ** db->aDb[iDb].pSchema structure. The mutexes required for schema
48215 ** (2) if iDb!=1, then the mutex on db->aDb[iDb].pBt.
48217 ** If pSchema is not NULL, then iDb is computed from pSchema and
48220 SQLITE_PRIVATE int sqlite3SchemaMutexHeld(sqlite3 *db, int iDb, Schema *pSchema){
48223 if( pSchema ) iDb = sqlite3SchemaToIndex(db, pSchema);
48224 assert( iDb>=0 && iDb<db->nDb );
48226 if( iDb==1 ) return 1;
48227 p = db->aDb[iDb].pBt;
50043 int iDb;
50044 for(iDb=db->nDb-1; iDb>=0; iDb--){
50045 Btree *pExisting = db->aDb[iDb].pBt;
58509 SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere){
58511 int addr = sqlite3VdbeAddOp3(p, OP_ParseSchema, iDb, 0, 0);
63205 int iDb, /* When database the cursor belongs to, or -1 */
63243 pCx->iDb = iDb;
63815 int iDb;
63830 int iDb;
63965 int iDb;
63976 int iDb;
66464 int iDb;
66468 u.at.iDb = pOp->p1;
66471 assert( u.at.iDb>=0 && u.at.iDb<db->nDb );
66472 assert( db->aDb[u.at.iDb].pBt!=0 );
66473 assert( (p->btreeMask & (((yDbMask)1)<<u.at.iDb))!=0 );
66475 sqlite3BtreeGetMeta(db->aDb[u.at.iDb].pBt, u.at.iCookie, (u32 *)&u.at.iMeta);
66637 int iDb;
66652 u.aw.iDb = pOp->p3;
66653 assert( u.aw.iDb>=0 && u.aw.iDb<db->nDb );
66654 assert( (p->btreeMask & (((yDbMask)1)<<u.aw.iDb))!=0 );
66655 u.aw.pDb = &db->aDb[u.aw.iDb];
66660 assert( sqlite3SchemaMutexHeld(db, u.aw.iDb, 0) );
66692 u.aw.pCur = allocateCursor(p, pOp->p1, u.aw.nField, u.aw.iDb, 1);
67593 u.bg.zDb = db->aDb[u.bg.pC->iDb].zName;
67598 assert( u.bg.pC->iDb>=0 );
67661 const char *zDb = db->aDb[u.bh.pC->iDb].zName;
67664 assert( u.bh.pC->iDb>=0 );
68273 int iDb;
68290 u.bu.iDb = pOp->p3;
68292 assert( (p->btreeMask & (((yDbMask)1)<<u.bu.iDb))!=0 );
68293 rc = sqlite3BtreeDropTable(db->aDb[u.bu.iDb].pBt, pOp->p1, &u.bu.iMoved);
68298 sqlite3RootPageMoved(db, u.bu.iDb, u.bu.iMoved, pOp->p1);
68300 assert( resetSchemaOnFault==0 || resetSchemaOnFault==u.bu.iDb+1 );
68301 resetSchemaOnFault = u.bu.iDb+1;
68403 int iDb;
68414 for(u.bx.iDb=0; u.bx.iDb<db->nDb; u.bx.iDb++){
68415 assert( u.bx.iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[u.bx.iDb].pBt) );
68419 u.bx.iDb = pOp->p1;
68420 assert( u.bx.iDb>=0 && u.bx.iDb<db->nDb );
68421 assert( DbHasProperty(db, u.bx.iDb, DB_SchemaLoaded) );
68423 u.bx.zMaster = SCHEMA_TABLE(u.bx.iDb);
68425 u.bx.initData.iDb = pOp->p1;
68429 db->aDb[u.bx.iDb].zName, u.bx.zMaster, pOp->p4.z);
70064 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
70070 sqlite3VdbeChangeP1(v, 0, iDb);
70074 sqlite3VdbeChangeP1(v, 1, iDb);
70079 sqlite3VdbeUsesBtree(v, iDb);
70085 sqlite3VdbeChangeP1(v, 2, iDb);
70095 sqlite3VdbeChangeP3(v, 3 + flags, iDb);
71907 ** pExpr->iDb Set the index in db->aDb[] of the database X
71963 int iDb;
71968 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
71979 if( zDb!=0 && sqlite3StrICmp(db->aDb[iDb].zName, zDb)!=0 ){
74469 int iDb; /* Database idx for pTab */
74472 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
74473 sqlite3CodeVerifySchema(pParse, iDb);
74474 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
74487 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
74518 sqlite3VdbeAddOp4(v, OP_OpenRead, iTab, pIdx->tnum, iDb,
77112 int iDb; /* Index of database containing pTab */
77120 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
77121 assert( iDb>=0 );
77127 assert( iTrigDb==iDb || iTrigDb==1 );
77133 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
77138 sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere);
77175 int iDb; /* Database that contains the table */
77176 char *zDb; /* Name of database iDb */
77196 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
77197 zDb = db->aDb[iDb].zName;
77205 ** in database iDb. If so, this is an error.
77249 /* Begin a transaction and code the VerifyCookie for database iDb.
77258 sqlite3BeginWriteOperation(pParse, pVTab!=0, iDb);
77259 sqlite3ChangeCookie(pParse, iDb);
77288 "WHERE %s;", zDb, SCHEMA_TABLE(iDb), zTabName, zName, zWhere);
77312 zDb, SCHEMA_TABLE(iDb), zName, zName, zName,
77371 SQLITE_PRIVATE void sqlite3MinimumFileFormat(Parse *pParse, int iDb, int minFormat){
77381 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT);
77382 sqlite3VdbeUsesBtree(v, iDb);
77385 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, r2);
77403 int iDb; /* Database number */
77417 iDb = sqlite3SchemaToIndex(db, pNew->pSchema);
77418 zDb = db->aDb[iDb].zName;
77492 zDb, SCHEMA_TABLE(iDb), pNew->addColOffset, zCol, pNew->addColOffset+1,
77503 sqlite3MinimumFileFormat(pParse, iDb, pDflt ? 3 : 2);
77528 int iDb;
77557 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
77589 pNew->pSchema = db->aDb[iDb].pSchema;
77594 sqlite3BeginWriteOperation(pParse, 0, iDb);
77597 sqlite3ChangeCookie(pParse, iDb);
77640 int iDb, /* The database we are looking in */
77665 pDb = &db->aDb[iDb];
77685 sqlite3TableLock(pParse, iDb, aRoot[i], 1, zTab);
77692 sqlite3VdbeAddOp2(v, OP_Clear, aRoot[i], iDb);
77699 sqlite3VdbeAddOp3(v, OP_OpenWrite, iStatCur+i, aRoot[i], iDb);
77724 int iDb; /* Index of database containing pTab */
77755 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
77756 assert( iDb>=0 );
77757 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
77760 db->aDb[iDb].zName ) ){
77766 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
77782 assert( iDb==sqlite3SchemaToIndex(db, pIdx->pSchema) );
77783 sqlite3VdbeAddOp4(v, OP_OpenRead, iIdxCur, pIdx->tnum, iDb,
77955 sqlite3VdbeAddOp3(v, OP_OpenRead, iIdxCur, pTab->tnum, iDb);
77977 static void loadAnalysis(Parse *pParse, int iDb){
77980 sqlite3VdbeAddOp1(v, OP_LoadAnalysis, iDb);
77987 static void analyzeDatabase(Parse *pParse, int iDb){
77989 Schema *pSchema = db->aDb[iDb].pSchema; /* Schema of database iDb */
77994 sqlite3BeginWriteOperation(pParse, 0, iDb);
77997 openStatTable(pParse, iDb, iStatCur, 0, 0);
77999 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
78004 loadAnalysis(pParse, iDb);
78013 int iDb;
78018 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
78019 sqlite3BeginWriteOperation(pParse, 0, iDb);
78023 openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");
78025 openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
78028 loadAnalysis(pParse, iDb);
78045 int iDb;
78068 iDb = sqlite3FindDb(db, pName1);
78069 if( iDb>=0 ){
78070 analyzeDatabase(pParse, iDb);
78084 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName);
78085 if( iDb>=0 ){
78086 zDb = db->aDb[iDb].zName;
78206 SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
78212 assert( iDb>=0 && iDb<db->nDb );
78213 assert( db->aDb[iDb].pBt!=0 );
78216 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
78217 for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){
78226 sInfo.zDatabase = db->aDb[iDb].zName;
78538 int iDb = db->nDb - 1;
78539 assert( iDb>=2 );
78540 if( db->aDb[iDb].pBt ){
78541 sqlite3BtreeClose(db->aDb[iDb].pBt);
78542 db->aDb[iDb].pBt = 0;
78543 db->aDb[iDb].pSchema = 0;
78546 db->nDb = iDb;
78752 int iDb, /* This is the database that must be used */
78758 if( NEVER(iDb<0) || iDb==1 ) return 0;
78760 assert( db->nDb>iDb );
78762 pFix->zDb = db->aDb[iDb].zName;
78990 int iDb /* Index of containing database. */
78993 char *zDb = db->aDb[iDb].zName; /* Name of attached database */
78998 if( db->nDb>2 || iDb!=0 ){
79029 int iDb; /* The index of the database the expression refers to */
79033 iDb = sqlite3SchemaToIndex(pParse->db, pSchema);
79034 if( iDb<0 ){
79064 assert( iDb>=0 && iDb<db->nDb );
79065 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
79178 int iDb; /* The database containing the table to be locked */
79187 ** The table to be locked has root page iTab and is found in database iDb.
79196 int iDb, /* Index of the database containing the table to lock */
79205 assert( iDb>=0 );
79209 if( p->iDb==iDb && p->iTab==iTab ){
79220 p->iDb = iDb;
79243 int p1 = p->iDb;
79288 int iDb;
79290 for(iDb=0, mask=1; iDb<db->nDb; mask<<=1, iDb++){
79292 sqlite3VdbeUsesBtree(v, iDb);
79293 sqlite3VdbeAddOp2(v,OP_Transaction, iDb, (mask & pParse->writeMask)!=0);
79295 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
79297 iDb, pParse->cookieValue[iDb],
79298 db->aDb[iDb].pSchema->iGeneration);
79500 ** For the index called zIdxName which is found in the database iDb,
79505 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){
79510 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
79511 pHash = &db->aDb[iDb].pSchema->idxHash;
79539 ** If iDb<0 then reset the internal schema tables for all database
79540 ** files. If iDb>=0 then reset the internal schema for only the
79543 SQLITE_PRIVATE void sqlite3ResetInternalSchema(sqlite3 *db, int iDb){
79545 assert( iDb<db->nDb );
79547 if( iDb>=0 ){
79548 /* Case 1: Reset the single schema identified by iDb */
79549 Db *pDb = &db->aDb[iDb];
79550 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
79558 if( iDb!=1 ){
79567 assert( iDb<0 );
79688 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){
79693 assert( iDb>=0 && iDb<db->nDb );
79695 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
79697 pDb = &db->aDb[iDb];
79729 ** Open the sqlite_master table stored in database number iDb for
79732 SQLITE_PRIVATE void sqlite3OpenMasterTable(Parse *p, int iDb){
79734 sqlite3TableLock(p, iDb, MASTER_ROOT, 1, SCHEMA_TABLE(iDb));
79735 sqlite3VdbeAddOp3(v, OP_OpenWrite, 0, MASTER_ROOT, iDb);
79800 int iDb; /* Database holding the object */
79810 iDb = sqlite3FindDb(db, pName1);
79811 if( iDb<0 ){
79817 assert( db->init.iDb==0 || db->init.busy );
79818 iDb = db->init.iDb;
79821 return iDb;
79870 int iDb; /* Database number to create the table in */
79886 ** pName2) that stores the unqualified table name. The variable iDb is
79890 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
79891 if( iDb<0 ) return;
79892 if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){
79898 if( !OMIT_TEMPDB && isTemp ) iDb = 1;
79906 if( db->init.iDb==1 ) isTemp = 1;
79911 char *zDb = db->aDb[iDb].zName;
79942 char *zDb = db->aDb[iDb].zName;
79952 sqlite3CodeVerifySchema(pParse, iDb);
79971 pTable->pSchema = db->aDb[iDb].pSchema;
79983 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
80000 sqlite3BeginWriteOperation(pParse, 0, iDb);
80014 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT);
80015 sqlite3VdbeUsesBtree(v, iDb);
80020 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, reg3);
80022 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, reg3);
80040 sqlite3VdbeAddOp2(v, OP_CreateTable, iDb, reg2);
80042 sqlite3OpenMasterTable(pParse, iDb);
80440 SQLITE_PRIVATE void sqlite3ChangeCookie(Parse *pParse, int iDb){
80444 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
80445 sqlite3VdbeAddOp2(v, OP_Integer, db->aDb[iDb].pSchema->schema_cookie+1, r1);
80446 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION, r1);
80599 int iDb;
80609 iDb = sqlite3SchemaToIndex(db, p->pSchema);
80694 sqlite3VdbeAddOp3(v, OP_OpenWrite, 1, pParse->regRoot, iDb);
80730 db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
80739 sqlite3ChangeCookie(pParse, iDb);
80746 Db *pDb = &db->aDb[iDb];
80747 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
80758 sqlite3VdbeAddParseSchemaOp(v, iDb,
80768 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
80814 int iDb;
80829 iDb = sqlite3SchemaToIndex(db, p->pSchema);
80830 if( sqlite3FixInit(&sFix, pParse, iDb, "view", pName)
80993 ** root-page of a table or index in database iDb has changed from iFrom
81008 SQLITE_PRIVATE void sqlite3RootPageMoved(sqlite3 *db, int iDb, int iFrom, int iTo){
81013 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
81014 pDb = &db->aDb[iDb];
81033 ** Write code to erase the table with root-page iTable from database iDb.
81038 static void destroyRootPage(Parse *pParse, int iTable, int iDb){
81041 sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
81055 pParse->db->aDb[iDb].zName, SCHEMA_TABLE(iDb), iTable, r1, r1);
81069 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
81070 destroyRootPage(pParse, pTab->tnum, iDb);
81072 destroyRootPage(pParse, pIdx->tnum, iDb);
81111 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
81112 destroyRootPage(pParse, iLargest, iDb);
81125 int iDb, /* The database number */
81131 const char *zDbName = pParse->db->aDb[iDb].zName;
81150 int iDb;
81166 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
81167 assert( iDb>=0 && iDb<db->nDb );
81178 const char *zTab = SCHEMA_TABLE(iDb);
81179 const char *zDb = db->aDb[iDb].zName;
81185 if( !OMIT_TEMPDB && iDb==1 ){
81196 if( !OMIT_TEMPDB && iDb==1 ){
81235 Db *pDb = &db->aDb[iDb];
81236 sqlite3BeginWriteOperation(pParse, 1, iDb);
81280 pDb->zName, SCHEMA_TABLE(iDb), pTab->zName);
81281 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
81290 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
81292 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
81293 sqlite3ChangeCookie(pParse, iDb);
81295 sqliteViewResetAll(db, iDb);
81472 int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
81476 db->aDb[iDb].zName ) ){
81482 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
81490 sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb);
81493 sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, tnum, iDb,
81507 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
81602 int iDb; /* Index of the database that is being written */
81628 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
81629 if( iDb<0 ) goto exit_create_index;
81639 iDb = 1;
81644 if( sqlite3FixInit(&sFix, pParse, iDb, "index", pName) &&
81654 assert( db->aDb[iDb].pSchema==pTab->pSchema );
81659 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
81661 pDb = &db->aDb[iDb];
81713 sqlite3CodeVerifySchema(pParse, iDb);
81732 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
81736 if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX;
81799 pIndex->pSchema = db->aDb[iDb].pSchema;
81800 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
81971 sqlite3BeginWriteOperation(pParse, 1, iDb);
81972 sqlite3VdbeAddOp2(v, OP_CreateIndex, iDb, iMem);
81994 db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
82007 sqlite3ChangeCookie(pParse, iDb);
82008 sqlite3VdbeAddParseSchemaOp(v, iDb,
82092 int iDb;
82117 iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
82122 const char *zDb = db->aDb[iDb].zName;
82123 const char *zTab = SCHEMA_TABLE(iDb);
82127 if( !OMIT_TEMPDB && iDb ) code = SQLITE_DROP_TEMP_INDEX;
82137 sqlite3BeginWriteOperation(pParse, 1, iDb);
82140 db->aDb[iDb].zName, SCHEMA_TABLE(iDb), pIndex->zName
82142 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
82143 sqlite3ChangeCookie(pParse, iDb);
82144 destroyRootPage(pParse, pIndex->tnum, iDb);
82145 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
82661 ** If iDb<0 then code the OP_Goto only - don't set flag to verify the
82665 SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
82673 if( iDb>=0 ){
82677 assert( iDb<db->nDb );
82678 assert( db->aDb[iDb].pBt!=0 || iDb==1 );
82679 assert( iDb<SQLITE_MAX_ATTACHED+2 );
82680 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
82681 mask = ((yDbMask)1)<<iDb;
82684 pToplevel->cookieValue[iDb] = db->aDb[iDb].pSchema->schema_cookie;
82685 if( !OMIT_TEMPDB && iDb==1 ){
82720 SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
82722 sqlite3CodeVerifySchema(pParse, iDb);
82723 pToplevel->writeMask |= ((yDbMask)1)<<iDb;
82802 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
82803 sqlite3BeginWriteOperation(pParse, 0, iDb);
82818 int iDb; /* The database index number */
82824 for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
82854 int iDb; /* The database index number */
82880 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName);
82881 if( iDb<0 ) return;
82884 zDb = db->aDb[iDb].zName;
82894 sqlite3BeginWriteOperation(pParse, 0, iDb);
83637 int iDb; /* Database number */
83685 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
83686 assert( iDb<db->nDb );
83687 zDb = db->aDb[iDb].zName;
83716 sqlite3BeginWriteOperation(pParse, 1, iDb);
83753 sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt,
83757 sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);
85976 int iDb, /* Index of database housing pTab */
86028 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);
86040 sqlite3VdbeAddOp3(v, OP_OpenRead, iCur, pIdx->tnum, iDb);
86363 int iDb; /* Index of database containing pTab */
86373 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
86374 zDb = db->aDb[iDb].zName;
86436 rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
86445 sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
86452 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regOld, -1,isIgnore);
86457 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regNew, +1,isIgnore);
86903 int iDb, /* The database index in sqlite3.aDb[] */
86911 sqlite3TableLock(p, iDb, pTab->tnum, (opcode==OP_OpenWrite)?1:0, pTab->zName);
86912 sqlite3VdbeAddOp3(v, opcode, iCur, pTab->tnum, iDb);
87010 ** Return non-zero if the table pTab in database iDb or any of its indices
87013 ** a statement of the form "INSERT INTO <iDb, pTab> SELECT ..." can
87016 static int readsTable(Parse *p, int iStartAddr, int iDb, Table *pTab){
87027 if( pOp->opcode==OP_OpenRead && pOp->p3==iDb ){
87053 ** which is in database iDb. Return the register number for the register
87073 int iDb, /* Index of the database holding pTab */
87089 pInfo->iDb = iDb;
87118 pDb = &db->aDb[p->iDb];
87121 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead);
87165 Db *pDb = &db->aDb[p->iDb];
87172 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
87339 int iDb; /* Index of database holding TABLE */
87374 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
87375 assert( iDb<db->nDb );
87376 pDb = &db->aDb[iDb];
87420 sqlite3BeginWriteOperation(pParse, pSelect || pTrigger, iDb);
87432 if( pColumn==0 && xferOptimization(pParse, pTab, pSelect, onError, iDb) ){
87442 regAutoinc = autoIncBegin(pParse, iDb, pTab);
87509 if( pTrigger || readsTable(pParse, addrSelect, iDb, pTab) ){
88371 int iDb;
88376 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
88379 sqlite3OpenTable(pParse, baseCur, iDb, pTab, op);
88383 sqlite3VdbeAddOp4(v, op, i+baseCur, pIdx->tnum, iDb,
90273 int iDb; /* Database index for <database> */
90281 /* Interpret the [database.] part of the pragma statement. iDb is the
90283 iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId);
90284 if( iDb<0 ) return;
90285 pDb = &db->aDb[iDb];
90290 if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){
90338 sqlite3VdbeUsesBtree(v, iDb);
90344 sqlite3VdbeChangeP1(v, addr, iDb);
90345 sqlite3VdbeChangeP1(v, addr+1, iDb);
90349 sqlite3BeginWriteOperation(pParse, 0, iDb);
90351 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_DEFAULT_CACHE_SIZE, 1);
90352 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
90427 sqlite3CodeVerifySchema(pParse, iDb);
90430 sqlite3VdbeAddOp2(v, OP_Pagecount, iDb, iReg);
90432 sqlite3VdbeAddOp3(v, OP_MaxPgcnt, iDb, iReg, sqlite3Atoi(zRight));
90522 iDb = 0;
90526 if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
90602 sqlite3VdbeChangeP1(v, iAddr, iDb);
90603 sqlite3VdbeChangeP1(v, iAddr+1, iDb);
90606 sqlite3VdbeChangeP1(v, iAddr+5, iDb);
90607 sqlite3VdbeUsesBtree(v, iDb);
90628 sqlite3BeginWriteOperation(pParse, 0, iDb);
90630 addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb);
90655 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
91076 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
91287 sqlite3VdbeUsesBtree(v, iDb);
91308 sqlite3VdbeChangeP1(v, addr, iDb);
91310 sqlite3VdbeChangeP1(v, addr+2, iDb);
91320 sqlite3VdbeChangeP1(v, addr, iDb);
91321 sqlite3VdbeChangeP1(v, addr+1, iDb);
91356 int iBt = (pId2->z?iDb:SQLITE_MAX_ATTACHED);
91542 int iDb = pData->iDb;
91547 DbClearProperty(db, iDb, DB_Empty);
91553 assert( iDb>=0 && iDb<db->nDb );
91568 db->init.iDb = iDb;
91574 db->init.iDb = 0;
91577 assert( iDb==1 );
91598 pIndex = sqlite3FindIndex(db, argv[0], db->aDb[iDb].zName);
91616 ** database file is given by iDb. iDb==0 is used for the main
91617 ** database. iDb==1 should never be used. iDb>=2 is used for
91621 static int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg){
91660 assert( iDb>=0 && iDb<db->nDb );
91661 assert( db->aDb[iDb].pSchema );
91663 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
91669 if( !OMIT_TEMPDB && iDb==1 ){
91674 zMasterName = SCHEMA_TABLE(iDb);
91682 initData.iDb = iDb;
91690 pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName);
91697 pDb = &db->aDb[iDb];
91699 if( !OMIT_TEMPDB && ALWAYS(iDb==1) ){
91746 if( iDb==0 ){
91763 DbSetProperty(db, iDb, DB_Empty);
91795 if( iDb==0 && meta[BTREE_FILE_FORMAT-1]>=4 ){
91806 db->aDb[iDb].zName, zMasterName);
91822 sqlite3AnalysisLoad(db, iDb);
91839 DbSetProperty(db, iDb, DB_SchemaLoaded);
91933 int iDb;
91939 for(iDb=0; iDb<db->nDb; iDb++){
91941 Btree *pBt = db->aDb[iDb].pBt; /* Btree database to read cookie from */
91960 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
91961 if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){
91962 sqlite3ResetInternalSchema(db, iDb);
91974 ** Convert a schema pointer into the iDb index that indicates
93436 int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
93437 zOriginDb = pNC->pParse->db->aDb[iDb].zName;
96690 const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
96697 sqlite3CodeVerifySchema(pParse, iDb);
96698 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
96724 sqlite3VdbeAddOp3(v, OP_OpenRead, iCsr, iRoot, iDb);
97230 int iDb; /* The database to store the trigger in */
97245 iDb = 1;
97249 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
97250 if( iDb<0 ){
97266 if( db->init.busy && iDb!=1 ){
97272 ** then set iDb to 1 to create the trigger in the temporary database.
97279 iDb = 1;
97285 if( sqlite3FixInit(&sFix, pParse, iDb, "trigger", pName) &&
97292 if( db->init.iDb==1 ){
97316 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
97317 if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),
97323 sqlite3CodeVerifySchema(pParse, iDb);
97380 pTrigger->pSchema = db->aDb[iDb].pSchema;
97414 int iDb; /* Database containing the trigger */
97420 iDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
97428 if( sqlite3FixInit(&sFix, pParse, iDb, "trigger", &nameToken)
97443 sqlite3BeginWriteOperation(pParse, 0, iDb);
97447 db->aDb[iDb].zName, SCHEMA_TABLE(iDb), zName,
97450 sqlite3ChangeCookie(pParse, iDb);
97451 sqlite3VdbeAddParseSchemaOp(v, iDb,
97457 Hash *pHash = &db->aDb[iDb].pSchema->trigHash;
97458 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
97680 int iDb;
97682 iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema);
97683 assert( iDb>=0 && iDb<db->nDb );
97686 assert( pTable->pSchema==pTrigger->pSchema || iDb==1 );
97690 const char *zDb = db->aDb[iDb].zName;
97691 const char *zTab = SCHEMA_TABLE(iDb);
97692 if( iDb==1 ) code = SQLITE_DROP_TEMP_TRIGGER;
97717 sqlite3BeginWriteOperation(pParse, 0, iDb);
97718 sqlite3OpenMasterTable(pParse, iDb);
97722 sqlite3ChangeCookie(pParse, iDb);
97724 sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
97734 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){
97738 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
97739 pHash = &(db->aDb[iDb].pSchema->trigHash);
97817 int iDb; /* Index of the database to use */
97824 iDb = sqlite3SchemaToIndex(pParse->db, pStep->pTrig->pSchema);
97825 if( iDb==0 || iDb>=2 ){
97827 assert( iDb<pParse->db->nDb );
97828 pSrc->a[pSrc->nSrc-1].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zName);
98373 int iDb; /* Database containing the table being updated */
98403 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
98482 pTab->aCol[j].zName, db->aDb[iDb].zName);
98524 sqlite3BeginWriteOperation(pParse, 1, iDb);
98605 if( !okOnePass ) sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite);
98620 sqlite3VdbeAddOp4(v, OP_OpenWrite, iCur+i+1, pIdx->tnum, iDb,
99560 int iDb; /* The database the table is being created in */
99570 iDb = sqlite3SchemaToIndex(db, pTable->pSchema);
99571 assert( iDb>=0 );
99576 addModuleArgument(db, pTable, sqlite3DbStrDup(db, db->aDb[iDb].zName));
99588 pTable->azModuleArg[0], pParse->db->aDb[iDb].zName);
99629 int iDb;
99646 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
99651 db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
99659 sqlite3ChangeCookie(pParse, iDb);
99663 sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere);
99664 sqlite3VdbeAddOp4(v, OP_VCreate, iDb, 0, 0,
99891 ** of the virtual table named zTab in database iDb.
99897 SQLITE_PRIVATE int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab, char **pzErr){
99903 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
99996 ** of the virtual table named zTab in database iDb. This occurs
100001 SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab){
100005 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
105281 int iDb; /* Index of database containing table/index */
105287 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
105301 sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op);
105313 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
105326 sqlite3VdbeAddOp4(v, OP_OpenRead, iIdxCur, pIx->tnum, iDb,
105330 sqlite3CodeVerifySchema(pParse, iDb);
111552 int iDb = SQLITE_MAX_ATTACHED; /* sqlite3.aDb[] index of db to checkpoint */
111567 iDb = sqlite3FindDbName(db, zDb);
111569 if( iDb<0 ){
111573 rc = sqlite3Checkpoint(db, iDb, eMode, pnLog, pnCkpt);
111594 ** Run a checkpoint on database iDb. This is a no-op if database iDb is
111606 ** If iDb is passed SQLITE_MAX_ATTACHED, then all attached databases are
111612 SQLITE_PRIVATE int sqlite3Checkpoint(sqlite3 *db, int iDb, int eMode, int *pnLog, int *pnCkpt){
111622 if( i==iDb || iDb==SQLITE_MAX_ATTACHED ){
112809 int iDb;
112812 iDb = 0;
112814 for(iDb=0; iDb<db->nDb; iDb++){
112815 if( strcmp(db->aDb[iDb].zName, zDbName)==0 ) break;
112818 if( iDb<db->nDb ){
112819 Btree *pBtree = db->aDb[iDb].pBt;