Lines Matching refs:iDb
18074 u8 iDb; /* Which db file is being initialized */ member
20150 int iDb; /* Index in sqlite3.aDb[] of database holding pTab */ member
20614 int iDb; /* 0 for main database. 1 for TEMP, 2.. for ATTACHed */ member
21442 SQLITE_PRIVATE void sqlite3OpenTable(Parse*, int iCur, int iDb, Table*, int);
21646 SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName);
23662 i8 iDb; /* Index of cursor database in db->aDb[] */ member
54571 int iDb; local
54589 iDb = sqlite3FindDbName(db, zSchema);
54591 if( iDb<0 ) return 0;
54604 pBt = db->aDb[iDb].pBt;
54665 int iDb; local
54677 iDb = sqlite3FindDbName(db, zSchema);
54678 testcase( iDb==1 );
54679 if( iDb<2 && iDb!=0 ){
54691 db->init.iDb = (u8)iDb;
71493 SQLITE_PRIVATE int sqlite3SchemaMutexHeld(sqlite3 *db, int iDb, Schema *pSchema){
71497 if( pSchema ) iDb = sqlite3SchemaToIndex(db, pSchema);
71498 assert( iDb>=0 && iDb<db->nDb );
71500 if( iDb==1 ) return 1;
71501 p = db->aDb[iDb].pBt;
74180 int iDb; local
74181 for(iDb=db->nDb-1; iDb>=0; iDb--){
74182 Btree *pExisting = db->aDb[iDb].pBt;
75756 int iDb; local
75757 for(iDb=0; ALWAYS(iDb<db->nDb); iDb++){
75758 if( db->aDb[iDb].pBt==p ) break;
75762 db->aDb[iDb].zDbSName,
86457 SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere, u16 p5){
86459 sqlite3VdbeAddOp4(p, OP_ParseSchema, iDb, 0, 0, zWhere, P4_DYNAMIC);
98500 int iDb;
98504 iDb = pOp->p1;
98507 assert( iDb>=0 && iDb<db->nDb );
98508 assert( db->aDb[iDb].pBt!=0 );
98509 assert( DbMaskTest(p->btreeMask, iDb) );
98511 sqlite3BtreeGetMeta(db->aDb[iDb].pBt, iCookie, (u32 *)&iMeta);
98652 int iDb;
98662 assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */
98685 iDb = pOp->p3;
98686 assert( iDb>=0 && iDb<db->nDb );
98687 assert( DbMaskTest(p->btreeMask, iDb) );
98688 pDb = &db->aDb[iDb];
98694 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
98729 pCur->iDb = iDb;
100060 assert( pC->iDb>=0 );
100061 zDb = db->aDb[pC->iDb].zDbSName;
100221 assert( pC->iDb>=0 );
100223 zDb = db->aDb[pC->iDb].zDbSName;
100281 assert( pC->iDb>=0 );
101181 int iDb;
101193 iDb = pOp->p3;
101194 assert( DbMaskTest(p->btreeMask, iDb) );
101196 rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved);
101202 sqlite3RootPageMoved(db, iDb, iMoved, pOp->p1);
101204 assert( resetSchemaOnFault==0 || resetSchemaOnFault==iDb+1 );
101205 resetSchemaOnFault = iDb+1;
101366 int iDb;
101376 for(iDb=0; iDb<db->nDb; iDb++){
101377 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
101381 iDb = pOp->p1;
101382 assert( iDb>=0 && iDb<db->nDb );
101383 assert( DbHasProperty(db, iDb, DB_SchemaLoaded)
101389 sqlite3SchemaClear(db->aDb[iDb].pSchema);
101391 rc = sqlite3InitOne(db, iDb, &p->zErrMsg, pOp->p5);
101399 initData.iDb = iDb;
101402 initData.mxPage = sqlite3BtreeLastPage(db->aDb[iDb].pBt);
101405 db->aDb[iDb].zDbSName, zSchema, pOp->p4.z);
103713 int iDb;
103760 || ((iDb = sqlite3SchemaToIndex(db, pTab->pSchema))==1 &&
103773 pBlob->zDb = db->aDb[iDb].zDbSName;
103859 sqlite3VdbeAddOp4Int(v, OP_Transaction, iDb, wrFlag,
103867 sqlite3VdbeUsesBtree(v, iDb);
103875 aOp[0].p1 = iDb;
103887 aOp[1].p3 = iDb;
107091 int iDb = pOp->p3;
107094 pSchema = db->aDb[iDb].pSchema;
107095 pCur->zSchema = db->aDb[iDb].zDbSName;
113525 int iDb; /* Database idx for pTab */
113535 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
113536 assert( iDb>=0 && iDb<SQLITE_MAX_DB );
113537 sqlite3CodeVerifySchema(pParse, iDb);
113538 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
113546 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
113631 sqlite3VdbeAddOp3(v, OP_OpenRead, iTab, pIdx->tnum, iDb);
117879 static void renameReloadSchema(Parse *pParse, int iDb, u16 p5){
117882 sqlite3ChangeCookie(pParse, iDb);
117883 sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, iDb, 0, p5);
117884 if( iDb!=1 ) sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, 1, 0, p5);
117897 int iDb; /* Database that contains the table */
117913 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
117914 zDb = db->aDb[iDb].zDbSName;
117989 , zDb, zDb, zTabName, zName, (iDb==1), zTabName
118024 if( iDb!=1 ){
118049 renameReloadSchema(pParse, iDb, INITFLAG_AlterRename);
118050 renameTestSchema(pParse, zDb, iDb==1, "after rename", 0);
118084 int iDb; /* Database number */
118102 iDb = sqlite3SchemaToIndex(db, pNew->pSchema);
118103 zDb = db->aDb[iDb].zDbSName;
118203 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT);
118204 sqlite3VdbeUsesBtree(v, iDb);
118208 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, 3);
118212 renameReloadSchema(pParse, iDb, INITFLAG_AlterAdd);
118254 int iDb;
118285 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
118316 pNew->pSchema = db->aDb[iDb].pSchema;
118917 db->init.iDb = 1;
118919 int iDb = sqlite3FindDbName(db, zDb);
118920 assert( iDb>=0 && iDb<=0xff );
118921 db->init.iDb = (u8)iDb;
118950 db->init.iDb = 0;
119943 int iDb; /* Index of db containing pTab in aDb[] */
119989 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
119990 assert( iDb>=0 );
119991 zDb = db->aDb[iDb].zDbSName;
119998 renameTestSchema(pParse, zDb, iDb==1, "", 0);
119999 renameFixQuotes(pParse, zDb, iDb==1);
120004 , zDb, iDb, iCol, pTab->zName
120008 renameReloadSchema(pParse, iDb, INITFLAG_AlterDrop);
120009 renameTestSchema(pParse, zDb, iDb==1, "after drop column", 1);
120022 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite);
120268 int iDb, /* The database we are looking in */
120300 pDb = &db->aDb[iDb];
120327 sqlite3TableLock(pParse, iDb, aRoot[i], 1, zTab);
120339 sqlite3VdbeAddOp2(v, OP_Clear, (int)aRoot[i], iDb);
120347 sqlite3VdbeAddOp4Int(v, OP_OpenWrite, iStatCur+i, (int)aRoot[i], iDb, 3);
121092 int iDb; /* Index of database containing pTab */
121126 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
121127 assert( iDb>=0 );
121128 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
121131 db->aDb[iDb].zDbSName ) ){
121152 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
121156 sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
121226 assert( iDb==sqlite3SchemaToIndex(db, pIdx->pSchema) );
121227 sqlite3VdbeAddOp3(v, OP_OpenRead, iIdxCur, pIdx->tnum, iDb);
121484 static void loadAnalysis(Parse *pParse, int iDb){
121487 sqlite3VdbeAddOp1(v, OP_LoadAnalysis, iDb);
121494 static void analyzeDatabase(Parse *pParse, int iDb){
121496 Schema *pSchema = db->aDb[iDb].pSchema; /* Schema of database iDb */
121502 sqlite3BeginWriteOperation(pParse, 0, iDb);
121505 openStatTable(pParse, iDb, iStatCur, 0, 0);
121508 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
121518 loadAnalysis(pParse, iDb);
121527 int iDb;
121532 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
121533 sqlite3BeginWriteOperation(pParse, 0, iDb);
121537 openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");
121539 openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
121542 loadAnalysis(pParse, iDb);
121559 int iDb;
121581 }else if( pName2->n==0 && (iDb = sqlite3FindDb(db, pName1))>=0 ){
121583 analyzeDatabase(pParse, iDb);
121586 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName);
121587 if( iDb>=0 ){
121588 zDb = pName2->n ? db->aDb[iDb].zDbSName : 0;
122042 SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
122047 Schema *pSchema = db->aDb[iDb].pSchema;
122050 assert( iDb>=0 && iDb<db->nDb );
122051 assert( db->aDb[iDb].pBt!=0 );
122054 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
122070 sInfo.zDatabase = db->aDb[iDb].zDbSName;
122085 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
122167 SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName){
122169 sqlite3StrICmp(db->aDb[iDb].zDbSName, zName)==0
122170 || (iDb==0 && sqlite3StrICmp("main", zName)==0)
122233 pNew = &db->aDb[db->init.iDb];
122343 db->init.iDb = 0;
122360 int iDb = db->nDb - 1;
122361 assert( iDb>=2 );
122362 if( db->aDb[iDb].pBt ){
122363 sqlite3BtreeClose(db->aDb[iDb].pBt);
122364 db->aDb[iDb].pBt = 0;
122365 db->aDb[iDb].pSchema = 0;
122368 db->nDb = iDb;
122596 int iDb = sqlite3FindDbName(db, pFix->zDb);
122603 if( iDb!=sqlite3FindDbName(db, pItem->u4.zDatabase) ){
122642 int iDb, /* This is the database that must be used */
122647 assert( db->nDb>iDb );
122649 pFix->zDb = db->aDb[iDb].zDbSName;
122650 pFix->pSchema = db->aDb[iDb].pSchema;
122653 pFix->bTemp = (iDb==1);
122848 int iDb /* Index of containing database. */
122851 char *zDb = db->aDb[iDb].zDbSName; /* Schema name of attached database */
122858 if( db->nDb>2 || iDb!=0 ) z = sqlite3_mprintf("%s.%z", zDb, z);
122885 int iDb; /* The index of the database the expression refers to */
122891 iDb = sqlite3SchemaToIndex(pParse->db, pSchema);
122892 if( iDb<0 ){
122921 assert( iDb>=0 && iDb<pParse->db->nDb );
122922 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
123036 int iDb; /* The database containing the table to be locked */
123054 int iDb, /* Index of the database containing the table to lock */
123063 assert( iDb>=0 );
123068 if( p->iDb==iDb && p->iTab==iTab ){
123080 p->iDb = iDb;
123091 int iDb, /* Index of the database containing the table to lock */
123096 if( iDb==1 ) return;
123097 if( !sqlite3BtreeSharable(pParse->db->aDb[iDb].pBt) ) return;
123098 lockTable(pParse, iDb, iTab, isWriteLock, zName);
123112 int p1 = p->iDb;
123147 int iDb, i;
123207 iDb = 0;
123210 if( DbMaskTest(pParse->cookieMask, iDb)==0 ) continue;
123211 sqlite3VdbeUsesBtree(v, iDb);
123212 pSchema = db->aDb[iDb].pSchema;
123215 iDb, /* P1 */
123216 DbMaskTest(pParse->writeMask,iDb), /* P2 */
123223 }while( ++iDb<db->nDb );
123481 int iDb = sqlite3SchemaToIndex(pParse->db, p->u4.pSchema);
123482 zDb = pParse->db->aDb[iDb].zDbSName;
123558 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){
123562 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
123563 pHash = &db->aDb[iDb].pSchema->idxHash;
123618 SQLITE_PRIVATE void sqlite3ResetOneSchema(sqlite3 *db, int iDb){
123620 assert( iDb<db->nDb );
123622 if( iDb>=0 ){
123623 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
123624 DbSetProperty(db, iDb, DB_ResetWanted);
123865 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){
123870 assert( iDb>=0 && iDb<db->nDb );
123872 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
123874 pDb = &db->aDb[iDb];
123908 SQLITE_PRIVATE void sqlite3OpenSchemaTable(Parse *p, int iDb){
123910 sqlite3TableLock(p, iDb, SCHEMA_ROOT, 1, LEGACY_SCHEMA_TABLE);
123911 sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, SCHEMA_ROOT, iDb, 5);
123974 int iDb; /* Database holding the object */
123984 iDb = sqlite3FindDb(db, pName1);
123985 if( iDb<0 ){
123990 assert( db->init.iDb==0 || db->init.busy || IN_SPECIAL_PARSE
123992 iDb = db->init.iDb;
123995 return iDb;
124211 int iDb; /* Database number to create the table in */
124216 iDb = db->init.iDb;
124217 zName = sqlite3DbStrDup(db, SCHEMA_TABLE(iDb));
124221 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
124222 if( iDb<0 ) return;
124223 if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){
124229 if( !OMIT_TEMPDB && isTemp ) iDb = 1;
124240 if( db->init.iDb==1 ) isTemp = 1;
124251 char *zDb = db->aDb[iDb].zDbSName;
124270 char *zDb = db->aDb[iDb].zDbSName;
124281 sqlite3CodeVerifySchema(pParse, iDb);
124301 pTable->pSchema = db->aDb[iDb].pSchema;
124325 sqlite3BeginWriteOperation(pParse, 1, iDb);
124340 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT);
124341 sqlite3VdbeUsesBtree(v, iDb);
124345 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, fileFormat);
124346 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, ENC(db));
124366 sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, reg2, BTREE_INTKEY);
124368 sqlite3OpenSchemaTable(pParse, iDb);
124729 int isInit = db->init.busy && db->init.iDb!=1;
124901 && !sqlite3BtreeIsReadonly(db->aDb[db->init.iDb].pBt)
125036 SQLITE_PRIVATE void sqlite3ChangeCookie(Parse *pParse, int iDb){
125039 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
125040 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION,
125041 (int)(1+(unsigned)db->aDb[iDb].pSchema->schema_cookie));
125633 int iDb; /* Database in which the table lives */
125721 iDb = sqlite3SchemaToIndex(db, p->pSchema);
125843 sqlite3VdbeAddOp3(v, OP_OpenWrite, iCsr, pParse->u1.cr.regRoot, iDb);
125893 db->aDb[iDb].zDbSName,
125902 sqlite3ChangeCookie(pParse, iDb);
125909 Db *pDb = &db->aDb[iDb];
125910 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
125921 sqlite3VdbeAddParseSchemaOp(v, iDb,
125929 db->aDb[iDb].zDbSName, p->zName), P4_DYNAMIC);
125938 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
125955 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
125992 int iDb;
126016 iDb = sqlite3SchemaToIndex(db, p->pSchema);
126017 sqlite3FixInit(&sFix, pParse, iDb, "view", pName);
126240 SQLITE_PRIVATE void sqlite3RootPageMoved(sqlite3 *db, int iDb, Pgno iFrom, Pgno iTo){
126245 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
126246 pDb = &db->aDb[iDb];
126270 static void destroyRootPage(Parse *pParse, int iTable, int iDb){
126274 sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
126289 pParse->db->aDb[iDb].zDbSName, iTable, r1, r1);
126337 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
126338 assert( iDb>=0 && iDb<pParse->db->nDb );
126339 destroyRootPage(pParse, iLargest, iDb);
126351 int iDb, /* The database number */
126356 const char *zDbName = pParse->db->aDb[iDb].zDbSName;
126372 SQLITE_PRIVATE void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){
126376 Db *pDb = &db->aDb[iDb];
126380 sqlite3BeginWriteOperation(pParse, 1, iDb);
126433 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
126436 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
126437 sqlite3ChangeCookie(pParse, iDb);
126438 sqliteViewResetAll(db, iDb);
126484 int iDb;
126506 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
126507 assert( iDb>=0 && iDb<db->nDb );
126518 const char *zTab = SCHEMA_TABLE(iDb);
126519 const char *zDb = db->aDb[iDb].zDbSName;
126525 if( !OMIT_TEMPDB && iDb==1 ){
126536 if( !OMIT_TEMPDB && iDb==1 ){
126574 sqlite3BeginWriteOperation(pParse, 1, iDb);
126576 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
126579 sqlite3CodeDropTable(pParse, pTab, iDb, isView);
126770 int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
126774 db->aDb[iDb].zDbSName ) ){
126780 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
126799 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
126809 if( memRootPage<0 ) sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb);
126810 sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, (int)tnum, iDb,
126948 int iDb; /* Index of the database that is being written */
126981 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
126982 if( iDb<0 ) goto exit_create_index;
126993 iDb = 1;
126998 sqlite3FixInit(&sFix, pParse, iDb, "index", pName);
127007 if( iDb==1 && db->aDb[iDb].pSchema!=pTab->pSchema ){
127019 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
127021 pDb = &db->aDb[iDb];
127076 sqlite3CodeVerifySchema(pParse, iDb);
127104 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
127108 if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX;
127166 pIndex->pSchema = db->aDb[iDb].pSchema;
127173 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
127416 sqlite3BeginWriteOperation(pParse, 1, iDb);
127425 sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, iMem, BTREE_BLOBKEY);
127447 db->aDb[iDb].zDbSName,
127460 sqlite3ChangeCookie(pParse, iDb);
127461 sqlite3VdbeAddParseSchemaOp(v, iDb,
127584 int iDb;
127612 iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
127617 const char *zDb = db->aDb[iDb].zDbSName;
127618 const char *zTab = SCHEMA_TABLE(iDb);
127622 if( !OMIT_TEMPDB && iDb==1 ) code = SQLITE_DROP_TEMP_INDEX;
127632 sqlite3BeginWriteOperation(pParse, 1, iDb);
127635 db->aDb[iDb].zDbSName, pIndex->zName
127637 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
127638 sqlite3ChangeCookie(pParse, iDb);
127639 destroyRootPage(pParse, pIndex->tnum, iDb);
127640 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
128336 static void sqlite3CodeVerifySchemaAtToplevel(Parse *pToplevel, int iDb){
128337 assert( iDb>=0 && iDb<pToplevel->db->nDb );
128338 assert( pToplevel->db->aDb[iDb].pBt!=0 || iDb==1 );
128339 assert( iDb<SQLITE_MAX_DB );
128340 assert( sqlite3SchemaMutexHeld(pToplevel->db, iDb, 0) );
128341 if( DbMaskTest(pToplevel->cookieMask, iDb)==0 ){
128342 DbMaskSet(pToplevel->cookieMask, iDb);
128343 if( !OMIT_TEMPDB && iDb==1 ){
128348 SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
128349 sqlite3CodeVerifySchemaAtToplevel(sqlite3ParseToplevel(pParse), iDb);
128381 SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
128383 sqlite3CodeVerifySchemaAtToplevel(pToplevel, iDb);
128384 DbMaskSet(pToplevel->writeMask, iDb);
128533 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
128534 sqlite3BeginWriteOperation(pParse, 0, iDb);
128550 int iDb; /* The database index number */
128556 for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
128586 int iDb; /* The database index number */
128612 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName);
128613 if( iDb<0 ) return;
128616 zDb = pName2->n ? db->aDb[iDb].zDbSName : 0;
128626 iDb = sqlite3SchemaToIndex(db, pIndex->pTable->pSchema);
128627 sqlite3BeginWriteOperation(pParse, 0, iDb);
129500 int iDb = sqlite3SchemaToIndex(db, pView->pSchema);
129507 pFrom->a[0].u4.zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zDbSName);
129653 int iDb; /* Database number */
129737 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
129738 assert( iDb<db->nDb );
129740 db->aDb[iDb].zDbSName);
129768 sqlite3BeginWriteOperation(pParse, bComplex, iDb);
129826 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
129828 sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt ? memCnt : -1,
129834 sqlite3VdbeAddOp3(v, OP_Clear, pIdx->tnum, iDb, memCnt ? memCnt : -1);
129836 sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);
133649 int iDb, /* Index of database housing pTab */
133711 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);
133721 sqlite3VdbeAddOp3(v, OP_OpenRead, iCur, pIdx->tnum, iDb);
134031 SQLITE_PRIVATE void sqlite3FkClearTriggerCache(sqlite3 *db, int iDb){
134033 Hash *pHash = &db->aDb[iDb].pSchema->tblHash;
134225 int iDb; /* Index of database containing pTab */
134236 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
134237 zDb = db->aDb[iDb].zDbSName;
134309 rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
134318 sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
134325 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regOld, -1, bIgnore);
134336 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regNew, +1, bIgnore);
134654 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
134668 pSrc->a[0].u4.zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zDbSName);
134843 int iDb, /* The database index in sqlite3.aDb[] */
134853 sqlite3TableLock(pParse, iDb, pTab->tnum,
134857 sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nNVCol);
134863 sqlite3VdbeAddOp3(v, opcode, iCur, pPk->tnum, iDb);
135043 static int readsTable(Parse *p, int iDb, Table *pTab){
135054 if( pOp->opcode==OP_OpenRead && pOp->p3==iDb ){
135222 int iDb, /* Index of the database holding pTab */
135226 assert( pParse->db->aDb[iDb].pSchema!=0 );
135232 Table *pSeqTab = pParse->db->aDb[iDb].pSchema->pSeqTab;
135257 pInfo->iDb = iDb;
135301 pDb = &db->aDb[p->iDb];
135304 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead);
135361 Db *pDb = &db->aDb[p->iDb];
135369 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
135728 int iDb; /* Index of database holding TABLE */
135778 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
135779 assert( iDb<db->nDb );
135781 db->aDb[iDb].zDbSName) ){
135829 sqlite3BeginWriteOperation(pParse, pSelect || pTrigger, iDb);
135844 && xferOptimization(pParse, pTab, pSelect, onError, iDb)
135855 regAutoinc = autoIncBegin(pParse, iDb, pTab);
135978 if( pTrigger || readsTable(pParse, iDb, pTab) ){
137692 int iDb;
137708 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
137715 sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op);
137717 sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
137728 sqlite3VdbeAddOp3(v, op, iIdxCur, pIdx->tnum, iDb);
141089 int iDb; /* Database index for <database> */
141102 iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId);
141103 if( iDb<0 ) return;
141104 pDb = &db->aDb[iDb];
141109 if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){
141219 sqlite3VdbeUsesBtree(v, iDb);
141225 aOp[0].p1 = iDb;
141226 aOp[1].p1 = iDb;
141230 sqlite3BeginWriteOperation(pParse, 0, iDb);
141231 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_DEFAULT_CACHE_SIZE, size);
141232 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
141318 sqlite3CodeVerifySchema(pParse, iDb);
141321 sqlite3VdbeAddOp2(v, OP_Pagecount, iDb, iReg);
141329 sqlite3VdbeAddOp3(v, OP_MaxPgcnt, iDb, iReg, (int)x);
141413 iDb = 0;
141417 if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
141488 aOp[0].p1 = iDb;
141489 aOp[1].p1 = iDb;
141491 aOp[4].p1 = iDb;
141493 sqlite3VdbeUsesBtree(v, iDb);
141511 sqlite3BeginWriteOperation(pParse, 0, iDb);
141513 addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb); VdbeCoverage(v);
141535 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
141569 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
141606 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
141613 if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
141791 }else if( iDb!=1 ){
141999 sqlite3CodeVerifySchema(pParse, iDb);
142211 k = sqliteHashFirst(&db->aDb[iDb].pSchema->tblHash);
142221 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
142222 zDb = db->aDb[iDb].zDbSName;
142223 sqlite3CodeVerifySchema(pParse, iDb);
142224 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
142226 sqlite3OpenTable(pParse, 0, iDb, pTab, OP_OpenRead);
142233 sqlite3TableLock(pParse, iDb, pParent->tnum, 0, pParent->zName);
142237 sqlite3OpenTable(pParse, i, iDb, pParent, OP_OpenRead);
142239 sqlite3VdbeAddOp3(v, OP_OpenRead, i, pIdx->tnum, iDb);
142362 assert( iDb>=0 );
142363 assert( iDb==0 || pId2->z );
142364 if( pId2->z==0 ) iDb = -1;
142378 iDb>=0 ? db->aDb[iDb].zDbSName : 0);
142391 if( iDb>=0 && i!=iDb ) continue;
142966 sqlite3VdbeUsesBtree(v, iDb);
142977 aOp[0].p1 = iDb;
142978 aOp[1].p1 = iDb;
142998 aOp[0].p1 = iDb;
142999 aOp[1].p1 = iDb;
143034 int iBt = (pId2->z?iDb:SQLITE_MAX_DB);
143185 for(iDbLast = zDb?iDb:db->nDb-1; iDb<=iDbLast; iDb++){
143186 if( iDb==1 ) continue;
143187 sqlite3CodeVerifySchema(pParse, iDb);
143188 pSchema = db->aDb[iDb].pSchema;
143229 sqlite3BeginWriteOperation(pParse, 0, iDb);
143236 sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
143250 db->aDb[iDb].zDbSName, pTab->zName);
143844 int iDb = pData->iDb;
143857 assert( iDb>=0 && iDb<db->nDb );
143874 u8 saved_iDb = db->init.iDb;
143879 db->init.iDb = iDb;
143893 db->init.iDb = saved_iDb;
143897 assert( iDb==1 );
143919 pIndex = sqlite3FindIndex(db, argv[1], db->aDb[iDb].zDbSName);
143944 SQLITE_PRIVATE int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFlags){
143959 assert( iDb>=0 && iDb<db->nDb );
143960 assert( db->aDb[iDb].pSchema );
143962 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
143972 azArg[1] = zSchemaTabName = SCHEMA_TABLE(iDb);
143979 initData.iDb = iDb;
143994 pDb = &db->aDb[iDb];
143996 assert( iDb==1 );
144046 if( iDb==0 && (db->mDbFlags & DBFLAG_EncodingFixed)==0 ){
144100 if( iDb==0 && meta[BTREE_FILE_FORMAT-1]>=4 ){
144112 db->aDb[iDb].zDbSName, zSchemaTabName);
144128 sqlite3AnalysisLoad(db, iDb);
144132 assert( pDb == &(db->aDb[iDb]) );
144136 pDb = &db->aDb[iDb];
144149 DbSetProperty(db, iDb, DB_SchemaLoaded);
144168 sqlite3ResetOneSchema(db, iDb);
144239 int iDb;
144245 for(iDb=0; iDb<db->nDb; iDb++){
144247 Btree *pBt = db->aDb[iDb].pBt; /* Btree database to read cookie from */
144267 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
144268 if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){
144269 if( DbHasProperty(db, iDb, DB_SchemaLoaded) ) pParse->rc = SQLITE_SCHEMA;
144270 sqlite3ResetOneSchema(db, iDb);
146579 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
146580 sqlite3OpenTable(pParse, pSort->aDefer[i].iCsr, iDb, pTab, OP_OpenRead);
146872 int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
146873 zOrigDb = pNC->pParse->db->aDb[iDb].zDbSName;
151092 int iDb; /* Schema index for this data src */
151112 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
151113 zSchemaName = iDb>=0 ? db->aDb[iDb].zDbSName : "*";
152655 int iDb = sqlite3SchemaToIndex(pParse->db, pItem->u4.pSchema);
152656 zDb = db->aDb[iDb].zDbSName;
153469 const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
153476 sqlite3CodeVerifySchema(pParse, iDb);
153477 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
153506 sqlite3VdbeAddOp4Int(v, OP_OpenRead, iCsr, (int)iRoot, iDb, 1);
153983 int iDb; /* The database to store the trigger in */
153997 iDb = 1;
154001 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
154002 if( iDb<0 ){
154018 if( db->init.busy && iDb!=1 ){
154033 iDb = 1;
154039 sqlite3FixInit(&sFix, pParse, iDb, "trigger", pName);
154067 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
154069 if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),zName) ){
154074 sqlite3CodeVerifySchema(pParse, iDb);
154132 pTrigger->pSchema = db->aDb[iDb].pSchema;
154161 if( db->init.iDb==1 ){
154190 int iDb; /* Database containing the trigger */
154196 iDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
154203 sqlite3FixInit(&sFix, pParse, iDb, "trigger", &nameToken);
154245 sqlite3BeginWriteOperation(pParse, 0, iDb);
154251 db->aDb[iDb].zDbSName, zName,
154254 sqlite3ChangeCookie(pParse, iDb);
154255 sqlite3VdbeAddParseSchemaOp(v, iDb,
154261 Hash *pHash = &db->aDb[iDb].pSchema->trigHash;
154262 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
154542 int iDb;
154544 iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema);
154545 assert( iDb>=0 && iDb<db->nDb );
154547 assert( (pTable && pTable->pSchema==pTrigger->pSchema) || iDb==1 );
154551 const char *zDb = db->aDb[iDb].zDbSName;
154552 const char *zTab = SCHEMA_TABLE(iDb);
154553 if( iDb==1 ) code = SQLITE_DROP_TEMP_TRIGGER;
154566 db->aDb[iDb].zDbSName, pTrigger->zName
154568 sqlite3ChangeCookie(pParse, iDb);
154569 sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
154576 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){
154580 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
154581 pHash = &(db->aDb[iDb].pSchema->trigHash);
155755 int iDb; /* Database containing the table being updated */
155799 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
155945 db->aDb[iDb].zDbSName);
156033 sqlite3BeginWriteOperation(pParse, pTrigger || hasFK, iDb);
157239 int iDb = 0;
157246 iDb = sqlite3TwoPartName(pParse, pNm, pNm, &pNm);
157247 if( iDb<0 ) goto build_vacuum_end;
157254 iDb = sqlite3FindDb(pParse->db, pNm);
157255 if( iDb<0 ) iDb = 0;
157258 if( iDb!=1 ){
157264 sqlite3VdbeAddOp2(v, OP_Vacuum, iDb, iIntoReg);
157265 sqlite3VdbeUsesBtree(v, iDb);
157278 int iDb, /* Which attached DB to vacuum */
157336 zDbMain = db->aDb[iDb].zDbSName;
157337 pMain = db->aDb[iDb].pBt;
157377 pgflags = db->aDb[iDb].safety_level | (db->flags & PAGER_FLAGS_MASK);
157381 sqlite3BtreeSetCacheSize(pTemp, db->aDb[iDb].pSchema->cache_size);
157418 db->init.iDb = nDb; /* force new CREATE statements into vacuum_db */
157432 db->init.iDb = 0;
157520 db->init.iDb = 0;
157974 int iDb = sqlite3SchemaToIndex(db, pTable->pSchema);
157975 assert( iDb>=0 ); /* The database the table is being created in */
157977 pTable->u.vtab.azArg[0], pParse->db->aDb[iDb].zDbSName);
158019 int iDb;
158039 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
158045 db->aDb[iDb].zDbSName,
158052 sqlite3ChangeCookie(pParse, iDb);
158056 sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere, 0);
158061 sqlite3VdbeAddOp2(v, OP_VCreate, iDb, iReg);
158124 int iDb;
158155 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
158156 pTab->u.vtab.azArg[1] = db->aDb[iDb].zDbSName;
158323 SQLITE_PRIVATE int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab, char **pzErr){
158329 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
158479 SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab){
158483 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
171546 int iDb; /* Index of database containing table/index */
171551 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
171574 sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op);
171605 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
171649 sqlite3VdbeAddOp3(v, op, iIndexCur, pIx->tnum, iDb);
171678 if( iDb>=0 ) sqlite3CodeVerifySchema(pParse, iDb);
171965 int iDb = sqlite3SchemaToIndex(db, pIx->pSchema);
171966 sqlite3VdbeAddOp3(v, OP_ReopenIdx, pLevel->iIdxCur, pIx->tnum, iDb);
183950 int iDb, nDb;
183960 nDb = iDb = sqlite3FindDbName(db, zSchema);
183961 if( iDb<0 ) nDb--;
183963 iDb = 0;
183966 for(; iDb<=nDb; iDb++){
183967 Btree *pBt = db->aDb[iDb].pBt;
184494 int iDb;
184506 for(iDb=0; iDb<db->nDb; iDb++){
184507 Btree *pBt = db->aDb[iDb].pBt;
185184 int iDb; /* Schema to checkpoint */
185206 iDb = sqlite3FindDbName(db, zDb);
185208 iDb = SQLITE_MAX_DB; /* This means process all schemas */
185210 if( iDb<0 ){
185215 rc = sqlite3Checkpoint(db, iDb, eMode, pnLog, pnCkpt);
185264 SQLITE_PRIVATE int sqlite3Checkpoint(sqlite3 *db, int iDb, int eMode, int *pnLog, int *pnCkpt){
185272 testcase( iDb==SQLITE_MAX_ATTACHED ); /* See forum post a006d86f72 */
185273 testcase( iDb==SQLITE_MAX_DB );
185276 if( i==iDb || iDb==SQLITE_MAX_DB ){
187196 int iDb;
187198 iDb = sqlite3FindDbName(db, va_arg(ap,const char*));
187199 if( iDb>=0 ){
187200 db->init.iDb = iDb;
187530 int iDb = zDbName ? sqlite3FindDbName(db, zDbName) : 0;
187531 return iDb<0 ? 0 : db->aDb[iDb].pBt;
187605 int iDb = sqlite3FindDbName(db, zDb);
187606 if( iDb==0 || iDb>1 ){
187607 Btree *pBt = db->aDb[iDb].pBt;
187644 int iDb;
187645 iDb = sqlite3FindDbName(db, zDb);
187646 if( iDb==0 || iDb>1 ){
187647 Btree *pBt = db->aDb[iDb].pBt;
187688 int iDb;
187697 iDb = sqlite3FindDbName(db, zDb);
187698 if( iDb==0 || iDb>1 ){
187699 Btree *pBt = db->aDb[iDb].pBt;
226846 int iDb; /* Schema used for this query */
226869 int iDb; /* Index of database to analyze */
226888 int iDb;
226894 iDb = sqlite3FindDb(db, &nm);
226895 if( iDb<0 ){
226900 iDb = 0;
226913 pTab->iDb = iDb;
227023 pCsr->iDb = pTab->iDb;
227236 Btree *pBt = pTab->db->aDb[pTab->iDb].pBt;
227299 Btree *pBt = pTab->db->aDb[pCsr->iDb].pBt;
227479 pCsr->iDb = sqlite3FindDbName(pTab->db, zDbase);
227480 if( pCsr->iDb<0 ){
227481 pCsr->iDb = 0;
227486 pCsr->iDb = pTab->iDb;
227505 pTab->db->aDb[pCsr->iDb].zDbSName);
227576 int iDb = pCsr->iDb;
227577 sqlite3_result_text(ctx, db->aDb[iDb].zDbSName, -1, SQLITE_STATIC);
227685 int iDb; /* Index of database to analyze */
227882 pCsr->iDb = sqlite3FindDbName(db, zSchema);
227883 if( pCsr->iDb<0 ) return SQLITE_OK;
227885 pCsr->iDb = 0;
227887 pBt = db->aDb[pCsr->iDb].pBt;
227939 sqlite3_result_text(ctx, db->aDb[pCsr->iDb].zDbSName, -1, SQLITE_STATIC);
227981 int iDb;
228008 iDb = 0;
228011 iDb = sqlite3FindDbName(pTab->db, zSchema);
228012 if( iDb<0 ){
228017 pBt = pTab->db->aDb[iDb].pBt;
228029 pTab->iDbTrunc = iDb;