Lines Matching refs:iDb
16332 u8 iDb; /* Which db file is being initialized */ member
17922 int iDb; /* Index in sqlite3.aDb[] of database holding pTab */ member
18299 int iDb; /* 0 for main database. 1 for TEMP, 2.. for ATTACHed */ member
18903 SQLITE_PRIVATE void sqlite3OpenTable(Parse*, int iCur, int iDb, Table*, int);
20012 i8 iDb; /* Index of cursor database in db->aDb[] (or -1) */ member
47193 int iDb;
47211 iDb = sqlite3FindDbName(db, zSchema);
47213 if( iDb<0 ) return 0;
47224 pBt = db->aDb[iDb].pBt;
47277 int iDb;
47289 iDb = sqlite3FindDbName(db, zSchema);
47290 if( iDb<0 ){
47298 db->init.iDb = (u8)iDb;
63129 SQLITE_PRIVATE int sqlite3SchemaMutexHeld(sqlite3 *db, int iDb, Schema *pSchema){
63132 if( pSchema ) iDb = sqlite3SchemaToIndex(db, pSchema);
63133 assert( iDb>=0 && iDb<db->nDb );
63135 if( iDb==1 ) return 1;
63136 p = db->aDb[iDb].pBt;
65606 int iDb;
65607 for(iDb=db->nDb-1; iDb>=0; iDb--){
65608 Btree *pExisting = db->aDb[iDb].pBt;
76728 SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere){
76730 sqlite3VdbeAddOp4(p, OP_ParseSchema, iDb, 0, 0, zWhere, P4_DYNAMIC);
83715 int iDb, /* Database the cursor belongs to, or -1 */
83758 pCx->iDb = iDb;
86934 int iDb;
86938 iDb = pOp->p1;
86941 assert( iDb>=0 && iDb<db->nDb );
86942 assert( db->aDb[iDb].pBt!=0 );
86943 assert( DbMaskTest(p->btreeMask, iDb) );
86945 sqlite3BtreeGetMeta(db->aDb[iDb].pBt, iCookie, (u32 *)&iMeta);
87080 int iDb;
87090 assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */
87111 iDb = pOp->p3;
87112 assert( iDb>=0 && iDb<db->nDb );
87113 assert( DbMaskTest(p->btreeMask, iDb) );
87114 pDb = &db->aDb[iDb];
87120 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
87153 pCur = allocateCursor(p, pOp->p1, nField, iDb, CURTYPE_BTREE);
88196 assert( pC->iDb>=0 );
88197 zDb = db->aDb[pC->iDb].zDbSName;
88315 assert( pC->iDb>=0 );
88317 zDb = db->aDb[pC->iDb].zDbSName;
88373 assert( pC->iDb>=0 );
89180 int iDb;
89192 iDb = pOp->p3;
89193 assert( DbMaskTest(p->btreeMask, iDb) );
89195 rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved);
89201 sqlite3RootPageMoved(db, iDb, iMoved, pOp->p1);
89203 assert( resetSchemaOnFault==0 || resetSchemaOnFault==iDb+1 );
89204 resetSchemaOnFault = iDb+1;
89327 int iDb;
89337 for(iDb=0; iDb<db->nDb; iDb++){
89338 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
89342 iDb = pOp->p1;
89343 assert( iDb>=0 && iDb<db->nDb );
89344 assert( DbHasProperty(db, iDb, DB_SchemaLoaded) );
89348 sqlite3SchemaClear(db->aDb[iDb].pSchema);
89350 rc = sqlite3InitOne(db, iDb, &p->zErrMsg, INITFLAG_AlterTable);
89358 initData.iDb = iDb;
89363 db->aDb[iDb].zDbSName, zMaster, pOp->p4.z);
91484 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
91487 sqlite3VdbeAddOp4Int(v, OP_Transaction, iDb, wrFlag,
91495 sqlite3VdbeUsesBtree(v, iDb);
91503 aOp[0].p1 = iDb;
91515 aOp[1].p3 = iDb;
99291 i16 iDb; /* Database idx for pTab */
99301 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
99302 sqlite3CodeVerifySchema(pParse, iDb);
99303 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
99311 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
99396 sqlite3VdbeAddOp3(v, OP_OpenRead, iTab, pIdx->tnum, iDb);
102427 static void renameReloadSchema(Parse *pParse, int iDb){
102430 sqlite3ChangeCookie(pParse, iDb);
102431 sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, iDb, 0);
102432 if( iDb!=1 ) sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, 1, 0);
102445 int iDb; /* Database that contains the table */
102463 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
102464 zDb = db->aDb[iDb].zDbSName;
102537 , zDb, MASTER_NAME, zDb, zTabName, zName, (iDb==1), zTabName
102571 if( iDb!=1 ){
102596 renameReloadSchema(pParse, iDb);
102597 renameTestSchema(pParse, zDb, iDb==1);
102616 int iDb; /* Database number */
102632 iDb = sqlite3SchemaToIndex(db, pNew->pSchema);
102633 zDb = db->aDb[iDb].zDbSName;
102725 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT);
102726 sqlite3VdbeUsesBtree(v, iDb);
102730 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, 3);
102735 renameReloadSchema(pParse, iDb);
102756 int iDb;
102785 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
102815 pNew->pSchema = db->aDb[iDb].pSchema;
103299 db->init.iDb = bTemp ? 1 : sqlite3FindDbName(db, zDb);
103331 db->init.iDb = 0;
104166 int iDb, /* The database we are looking in */
104197 pDb = &db->aDb[iDb];
104223 sqlite3TableLock(pParse, iDb, aRoot[i], 1, zTab);
104235 sqlite3VdbeAddOp2(v, OP_Clear, aRoot[i], iDb);
104243 sqlite3VdbeAddOp4Int(v, OP_OpenWrite, iStatCur+i, aRoot[i], iDb, 3);
104987 int iDb; /* Index of database containing pTab */
105018 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
105019 assert( iDb>=0 );
105020 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
105023 db->aDb[iDb].zDbSName ) ){
105044 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
105048 sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
105113 assert( iDb==sqlite3SchemaToIndex(db, pIdx->pSchema) );
105114 sqlite3VdbeAddOp3(v, OP_OpenRead, iIdxCur, pIdx->tnum, iDb);
105316 static void loadAnalysis(Parse *pParse, int iDb){
105319 sqlite3VdbeAddOp1(v, OP_LoadAnalysis, iDb);
105326 static void analyzeDatabase(Parse *pParse, int iDb){
105328 Schema *pSchema = db->aDb[iDb].pSchema; /* Schema of database iDb */
105334 sqlite3BeginWriteOperation(pParse, 0, iDb);
105337 openStatTable(pParse, iDb, iStatCur, 0, 0);
105340 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
105345 loadAnalysis(pParse, iDb);
105354 int iDb;
105359 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
105360 sqlite3BeginWriteOperation(pParse, 0, iDb);
105364 openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");
105366 openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
105369 loadAnalysis(pParse, iDb);
105386 int iDb;
105408 }else if( pName2->n==0 && (iDb = sqlite3FindDb(db, pName1))>=0 ){
105410 analyzeDatabase(pParse, iDb);
105413 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName);
105414 if( iDb>=0 ){
105415 zDb = pName2->n ? db->aDb[iDb].zDbSName : 0;
105861 SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
105866 Schema *pSchema = db->aDb[iDb].pSchema;
105868 assert( iDb>=0 && iDb<db->nDb );
105869 assert( db->aDb[iDb].pBt!=0 );
105872 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
105888 sInfo.zDatabase = db->aDb[iDb].zDbSName;
105901 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
106030 pNew = &db->aDb[db->init.iDb];
106166 db->init.iDb = 0;
106185 int iDb = db->nDb - 1;
106186 assert( iDb>=2 );
106187 if( db->aDb[iDb].pBt ){
106188 sqlite3BtreeClose(db->aDb[iDb].pBt);
106189 db->aDb[iDb].pBt = 0;
106190 db->aDb[iDb].pSchema = 0;
106193 db->nDb = iDb;
106388 int iDb, /* This is the database that must be used */
106395 assert( db->nDb>iDb );
106397 pFix->zDb = db->aDb[iDb].zDbSName;
106398 pFix->pSchema = db->aDb[iDb].pSchema;
106401 pFix->bVarOnly = (iDb==1);
106673 int iDb /* Index of containing database. */
106676 char *zDb = db->aDb[iDb].zDbSName; /* Schema name of attached database */
106687 if( db->nDb>2 || iDb!=0 ) z = sqlite3_mprintf("%s.%z", zDb, z);
106715 int iDb; /* The index of the database the expression refers to */
106721 iDb = sqlite3SchemaToIndex(pParse->db, pSchema);
106722 if( iDb<0 ){
106751 assert( iDb>=0 && iDb<db->nDb );
106752 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
106874 int iDb; /* The database containing the table to be locked */
106892 int iDb, /* Index of the database containing the table to lock */
106901 assert( iDb>=0 );
106903 if( iDb==1 ) return;
106904 if( !sqlite3BtreeSharable(pParse->db->aDb[iDb].pBt) ) return;
106907 if( p->iDb==iDb && p->iTab==iTab ){
106918 p->iDb = iDb;
106941 int p1 = p->iDb;
107014 int iDb, i;
107017 for(iDb=0; iDb<db->nDb; iDb++){
107019 if( DbMaskTest(pParse->cookieMask, iDb)==0 ) continue;
107020 sqlite3VdbeUsesBtree(v, iDb);
107021 pSchema = db->aDb[iDb].pSchema;
107024 iDb, /* P1 */
107025 DbMaskTest(pParse->writeMask,iDb), /* P2 */
107252 int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema);
107253 zDb = pParse->db->aDb[iDb].zDbSName;
107312 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){
107316 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
107317 pHash = &db->aDb[iDb].pSchema->idxHash;
107372 SQLITE_PRIVATE void sqlite3ResetOneSchema(sqlite3 *db, int iDb){
107374 assert( iDb<db->nDb );
107376 if( iDb>=0 ){
107377 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
107378 DbSetProperty(db, iDb, DB_ResetWanted);
107516 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){
107521 assert( iDb>=0 && iDb<db->nDb );
107523 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
107525 pDb = &db->aDb[iDb];
107559 SQLITE_PRIVATE void sqlite3OpenMasterTable(Parse *p, int iDb){
107561 sqlite3TableLock(p, iDb, MASTER_ROOT, 1, MASTER_NAME);
107562 sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, MASTER_ROOT, iDb, 5);
107625 int iDb; /* Database holding the object */
107635 iDb = sqlite3FindDb(db, pName1);
107636 if( iDb<0 ){
107641 assert( db->init.iDb==0 || db->init.busy || IN_RENAME_OBJECT
107643 iDb = db->init.iDb;
107646 return iDb;
107730 int iDb; /* Database number to create the table in */
107735 iDb = db->init.iDb;
107736 zName = sqlite3DbStrDup(db, SCHEMA_TABLE(iDb));
107740 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
107741 if( iDb<0 ) return;
107742 if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){
107748 if( !OMIT_TEMPDB && isTemp ) iDb = 1;
107759 if( db->init.iDb==1 ) isTemp = 1;
107770 char *zDb = db->aDb[iDb].zDbSName;
107789 char *zDb = db->aDb[iDb].zDbSName;
107799 sqlite3CodeVerifySchema(pParse, iDb);
107818 pTable->pSchema = db->aDb[iDb].pSchema;
107834 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
107853 sqlite3BeginWriteOperation(pParse, 1, iDb);
107867 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT);
107868 sqlite3VdbeUsesBtree(v, iDb);
107872 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, fileFormat);
107873 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, ENC(db));
107892 sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, reg2, BTREE_INTKEY);
107894 sqlite3OpenMasterTable(pParse, iDb);
108284 && !sqlite3BtreeIsReadonly(db->aDb[db->init.iDb].pBt)
108387 SQLITE_PRIVATE void sqlite3ChangeCookie(Parse *pParse, int iDb){
108390 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
108391 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION,
108392 (int)(1+(unsigned)db->aDb[iDb].pSchema->schema_cookie));
108809 int iDb; /* Database in which the table lives */
108861 iDb = sqlite3SchemaToIndex(db, p->pSchema);
108937 sqlite3VdbeAddOp3(v, OP_OpenWrite, 1, pParse->regRoot, iDb);
108987 db->aDb[iDb].zDbSName, MASTER_NAME,
108996 sqlite3ChangeCookie(pParse, iDb);
109003 Db *pDb = &db->aDb[iDb];
109004 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
109015 sqlite3VdbeAddParseSchemaOp(v, iDb,
109025 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
109070 int iDb;
109081 iDb = sqlite3SchemaToIndex(db, p->pSchema);
109082 sqlite3FixInit(&sFix, pParse, iDb, "view", pName);
109302 SQLITE_PRIVATE void sqlite3RootPageMoved(sqlite3 *db, int iDb, int iFrom, int iTo){
109307 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
109308 pDb = &db->aDb[iDb];
109332 static void destroyRootPage(Parse *pParse, int iTable, int iDb){
109336 sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
109350 pParse->db->aDb[iDb].zDbSName, MASTER_NAME, iTable, r1, r1);
109398 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
109399 assert( iDb>=0 && iDb<pParse->db->nDb );
109400 destroyRootPage(pParse, iLargest, iDb);
109412 int iDb, /* The database number */
109417 const char *zDbName = pParse->db->aDb[iDb].zDbSName;
109433 SQLITE_PRIVATE void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){
109437 Db *pDb = &db->aDb[iDb];
109441 sqlite3BeginWriteOperation(pParse, 1, iDb);
109493 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
109496 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
109497 sqlite3ChangeCookie(pParse, iDb);
109498 sqliteViewResetAll(db, iDb);
109509 int iDb;
109526 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
109527 assert( iDb>=0 && iDb<db->nDb );
109538 const char *zTab = SCHEMA_TABLE(iDb);
109539 const char *zDb = db->aDb[iDb].zDbSName;
109545 if( !OMIT_TEMPDB && iDb==1 ){
109556 if( !OMIT_TEMPDB && iDb==1 ){
109595 sqlite3BeginWriteOperation(pParse, 1, iDb);
109597 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
109600 sqlite3CodeDropTable(pParse, pTab, iDb, isView);
109787 int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
109791 db->aDb[iDb].zDbSName ) ){
109797 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
109816 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
109826 if( memRootPage<0 ) sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb);
109827 sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, tnum, iDb,
109925 int iDb; /* Index of the database that is being written */
109953 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
109954 if( iDb<0 ) goto exit_create_index;
109965 iDb = 1;
109970 sqlite3FixInit(&sFix, pParse, iDb, "index", pName);
109979 if( iDb==1 && db->aDb[iDb].pSchema!=pTab->pSchema ){
109991 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
109993 pDb = &db->aDb[iDb];
110055 sqlite3CodeVerifySchema(pParse, iDb);
110082 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
110086 if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX;
110143 pIndex->pSchema = db->aDb[iDb].pSchema;
110150 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
110384 sqlite3BeginWriteOperation(pParse, 1, iDb);
110393 sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, iMem, BTREE_BLOBKEY);
110414 db->aDb[iDb].zDbSName, MASTER_NAME,
110427 sqlite3ChangeCookie(pParse, iDb);
110428 sqlite3VdbeAddParseSchemaOp(v, iDb,
110527 int iDb;
110552 iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
110557 const char *zDb = db->aDb[iDb].zDbSName;
110558 const char *zTab = SCHEMA_TABLE(iDb);
110562 if( !OMIT_TEMPDB && iDb ) code = SQLITE_DROP_TEMP_INDEX;
110572 sqlite3BeginWriteOperation(pParse, 1, iDb);
110575 db->aDb[iDb].zDbSName, MASTER_NAME, pIndex->zName
110577 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
110578 sqlite3ChangeCookie(pParse, iDb);
110579 destroyRootPage(pParse, pIndex->tnum, iDb);
110580 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
111123 SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
111126 assert( iDb>=0 && iDb<pParse->db->nDb );
111127 assert( pParse->db->aDb[iDb].pBt!=0 || iDb==1 );
111128 assert( iDb<SQLITE_MAX_ATTACHED+2 );
111129 assert( sqlite3SchemaMutexHeld(pParse->db, iDb, 0) );
111130 if( DbMaskTest(pToplevel->cookieMask, iDb)==0 ){
111131 DbMaskSet(pToplevel->cookieMask, iDb);
111132 if( !OMIT_TEMPDB && iDb==1 ){
111166 SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
111168 sqlite3CodeVerifySchema(pParse, iDb);
111169 DbMaskSet(pToplevel->writeMask, iDb);
111316 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
111317 sqlite3BeginWriteOperation(pParse, 0, iDb);
111333 int iDb; /* The database index number */
111339 for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
111369 int iDb; /* The database index number */
111395 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName);
111396 if( iDb<0 ) return;
111399 zDb = db->aDb[iDb].zDbSName;
111409 sqlite3BeginWriteOperation(pParse, 0, iDb);
112141 int iDb = sqlite3SchemaToIndex(db, pView->pSchema);
112147 pFrom->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zDbSName);
112280 int iDb; /* Database number */
112355 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
112356 assert( iDb<db->nDb );
112358 db->aDb[iDb].zDbSName);
112386 sqlite3BeginWriteOperation(pParse, bComplex, iDb);
112443 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
112445 sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt ? memCnt : -1,
112450 sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);
115339 int iDb, /* Index of database housing pTab */
115400 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);
115411 sqlite3VdbeAddOp3(v, OP_OpenRead, iCur, pIdx->tnum, iDb);
115894 int iDb; /* Index of database containing pTab */
115904 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
115905 zDb = db->aDb[iDb].zDbSName;
115975 rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
115984 sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
115991 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regOld, -1, bIgnore);
116002 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regNew, +1, bIgnore);
116482 int iDb, /* The database index in sqlite3.aDb[] */
116490 sqlite3TableLock(pParse, iDb, pTab->tnum,
116493 sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nCol);
116499 sqlite3VdbeAddOp3(v, opcode, iCur, pPk->tnum, iDb);
116619 static int readsTable(Parse *p, int iDb, Table *pTab){
116630 if( pOp->opcode==OP_OpenRead && pOp->p3==iDb ){
116679 int iDb, /* Index of the database holding pTab */
116683 assert( pParse->db->aDb[iDb].pSchema!=0 );
116689 Table *pSeqTab = pParse->db->aDb[iDb].pSchema->pSeqTab;
116712 pInfo->iDb = iDb;
116756 pDb = &db->aDb[p->iDb];
116759 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead);
116816 Db *pDb = &db->aDb[p->iDb];
116824 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
116979 int iDb; /* Index of database holding TABLE */
117025 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
117026 assert( iDb<db->nDb );
117028 db->aDb[iDb].zDbSName) ){
117068 sqlite3BeginWriteOperation(pParse, pSelect || pTrigger, iDb);
117080 if( pColumn==0 && xferOptimization(pParse, pTab, pSelect, onError, iDb) ){
117090 regAutoinc = autoIncBegin(pParse, iDb, pTab);
117179 if( pTrigger || readsTable(pParse, iDb, pTab) ){
118451 int iDb;
118464 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
118471 sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op);
118473 sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
118484 sqlite3VdbeAddOp3(v, op, iIdxCur, pIdx->tnum, iDb);
121532 int iDb; /* Database index for <database> */
121545 iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId);
121546 if( iDb<0 ) return;
121547 pDb = &db->aDb[iDb];
121552 if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){
121658 sqlite3VdbeUsesBtree(v, iDb);
121664 aOp[0].p1 = iDb;
121665 aOp[1].p1 = iDb;
121669 sqlite3BeginWriteOperation(pParse, 0, iDb);
121670 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_DEFAULT_CACHE_SIZE, size);
121671 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
121756 sqlite3CodeVerifySchema(pParse, iDb);
121759 sqlite3VdbeAddOp2(v, OP_Pagecount, iDb, iReg);
121761 sqlite3VdbeAddOp3(v, OP_MaxPgcnt, iDb, iReg,
121841 iDb = 0;
121845 if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
121916 aOp[0].p1 = iDb;
121917 aOp[1].p1 = iDb;
121919 aOp[4].p1 = iDb;
121921 sqlite3VdbeUsesBtree(v, iDb);
121939 sqlite3BeginWriteOperation(pParse, 0, iDb);
121941 addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb); VdbeCoverage(v);
121963 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
121997 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
122034 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
122041 if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
122213 }else if( iDb!=1 ){
122320 sqlite3CodeVerifySchema(pParse, iDb);
122523 k = sqliteHashFirst(&db->aDb[iDb].pSchema->tblHash);
122656 assert( iDb>=0 );
122657 assert( iDb==0 || pId2->z );
122658 if( pId2->z==0 ) iDb = -1;
122682 if( iDb>=0 && i!=iDb ) continue;
122997 sqlite3VdbeUsesBtree(v, iDb);
123008 aOp[0].p1 = iDb;
123009 aOp[1].p1 = iDb;
123023 aOp[0].p1 = iDb;
123024 aOp[1].p1 = iDb;
123059 int iBt = (pId2->z?iDb:SQLITE_MAX_ATTACHED);
123179 for(iDbLast = zDb?iDb:db->nDb-1; iDb<=iDbLast; iDb++){
123180 if( iDb==1 ) continue;
123181 sqlite3CodeVerifySchema(pParse, iDb);
123182 pSchema = db->aDb[iDb].pSchema;
123200 sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
123206 db->aDb[iDb].zDbSName, pTab->zName);
123764 int iDb = pData->iDb;
123769 DbClearProperty(db, iDb, DB_Empty);
123776 assert( iDb>=0 && iDb<db->nDb );
123787 u8 saved_iDb = db->init.iDb;
123792 db->init.iDb = iDb;
123798 db->init.iDb = saved_iDb;
123802 assert( iDb==1 );
123823 pIndex = sqlite3FindIndex(db, argv[0], db->aDb[iDb].zDbSName);
123843 SQLITE_PRIVATE int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFlags){
123857 assert( iDb>=0 && iDb<db->nDb );
123858 assert( db->aDb[iDb].pSchema );
123860 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
123869 azArg[0] = zMasterName = SCHEMA_TABLE(iDb);
123875 initData.iDb = iDb;
123888 pDb = &db->aDb[iDb];
123890 assert( iDb==1 );
123940 if( iDb==0 ){
123960 DbSetProperty(db, iDb, DB_Empty);
123996 if( iDb==0 && meta[BTREE_FILE_FORMAT-1]>=4 ){
124007 db->aDb[iDb].zDbSName, zMasterName);
124023 sqlite3AnalysisLoad(db, iDb);
124040 DbSetProperty(db, iDb, DB_SchemaLoaded);
124059 sqlite3ResetOneSchema(db, iDb);
124131 int iDb;
124137 for(iDb=0; iDb<db->nDb; iDb++){
124139 Btree *pBt = db->aDb[iDb].pBt; /* Btree database to read cookie from */
124158 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
124159 if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){
124160 sqlite3ResetOneSchema(db, iDb);
126069 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
126070 sqlite3OpenTable(pParse, pSort->aDefer[i].iCsr, iDb, pTab, OP_OpenRead);
126343 int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
126344 zOrigDb = pNC->pParse->db->aDb[iDb].zDbSName;
129603 int iDb;
129613 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
129614 zSchemaName = iDb>=0 ? db->aDb[iDb].zDbSName : "*";
131100 const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
131107 sqlite3CodeVerifySchema(pParse, iDb);
131108 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
131135 sqlite3VdbeAddOp4Int(v, OP_OpenRead, iCsr, iRoot, iDb, 1);
131542 int iDb; /* The database to store the trigger in */
131556 iDb = 1;
131560 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
131561 if( iDb<0 ){
131577 if( db->init.busy && iDb!=1 ){
131590 iDb = 1;
131596 sqlite3FixInit(&sFix, pParse, iDb, "trigger", pName);
131603 if( db->init.iDb==1 ){
131627 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
131629 if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),zName) ){
131634 sqlite3CodeVerifySchema(pParse, iDb);
131691 pTrigger->pSchema = db->aDb[iDb].pSchema;
131732 int iDb; /* Database containing the trigger */
131738 iDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
131745 sqlite3FixInit(&sFix, pParse, iDb, "trigger", &nameToken);
131770 sqlite3BeginWriteOperation(pParse, 0, iDb);
131775 db->aDb[iDb].zDbSName, MASTER_NAME, zName,
131778 sqlite3ChangeCookie(pParse, iDb);
131779 sqlite3VdbeAddParseSchemaOp(v, iDb,
131785 Hash *pHash = &db->aDb[iDb].pSchema->trigHash;
131786 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
132055 int iDb;
132057 iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema);
132058 assert( iDb>=0 && iDb<db->nDb );
132061 assert( pTable->pSchema==pTrigger->pSchema || iDb==1 );
132065 const char *zDb = db->aDb[iDb].zDbSName;
132066 const char *zTab = SCHEMA_TABLE(iDb);
132067 if( iDb==1 ) code = SQLITE_DROP_TEMP_TRIGGER;
132081 db->aDb[iDb].zDbSName, MASTER_NAME, pTrigger->zName
132083 sqlite3ChangeCookie(pParse, iDb);
132084 sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
132091 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){
132095 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
132096 pHash = &(db->aDb[iDb].pSchema->trigHash);
132175 int iDb; /* Index of the database to use */
132182 iDb = sqlite3SchemaToIndex(db, pStep->pTrig->pSchema);
132183 if( iDb==0 || iDb>=2 ){
132185 assert( iDb<db->nDb );
132186 zDb = db->aDb[iDb].zDbSName;
132806 int iDb; /* Database containing the table being updated */
132847 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
132963 db->aDb[iDb].zDbSName);
133024 sqlite3BeginWriteOperation(pParse, pTrigger || hasFK, iDb);
133987 int iDb = 0;
133993 iDb = sqlite3TwoPartName(pParse, pNm, pNm, &pNm);
133994 if( iDb<0 ) goto build_vacuum_end;
134001 iDb = sqlite3FindDb(pParse->db, pNm);
134002 if( iDb<0 ) iDb = 0;
134005 if( iDb!=1 ){
134011 sqlite3VdbeAddOp2(v, OP_Vacuum, iDb, iIntoReg);
134012 sqlite3VdbeUsesBtree(v, iDb);
134025 int iDb, /* Which attached DB to vacuum */
134079 zDbMain = db->aDb[iDb].zDbSName;
134080 pMain = db->aDb[iDb].pBt;
134123 sqlite3CodecGetKey(db, iDb, (void**)&zKey, &nKey);
134128 sqlite3BtreeSetCacheSize(pTemp, db->aDb[iDb].pSchema->cache_size);
134163 db->init.iDb = nDb; /* force new CREATE statements into vacuum_db */
134177 db->init.iDb = 0;
134264 db->init.iDb = 0;
134660 int iDb = sqlite3SchemaToIndex(db, pTable->pSchema);
134661 assert( iDb>=0 ); /* The database the table is being created in */
134663 pTable->azModuleArg[0], pParse->db->aDb[iDb].zDbSName);
134704 int iDb;
134722 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
134727 db->aDb[iDb].zDbSName, MASTER_NAME,
134735 sqlite3ChangeCookie(pParse, iDb);
134739 sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere);
134743 sqlite3VdbeAddOp2(v, OP_VCreate, iDb, iReg);
134810 int iDb;
134837 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
134838 pTab->azModuleArg[1] = db->aDb[iDb].zDbSName;
134998 SQLITE_PRIVATE int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab, char **pzErr){
135004 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
135124 SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab){
135128 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
144991 int iDb; /* Index of database containing table/index */
144996 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
145017 sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op);
145041 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
145076 sqlite3VdbeAddOp3(v, op, iIndexCur, pIx->tnum, iDb);
145103 if( iDb>=0 ) sqlite3CodeVerifySchema(pParse, iDb);
156876 int iDb = SQLITE_MAX_ATTACHED; /* sqlite3.aDb[] index of db to checkpoint */
156898 iDb = sqlite3FindDbName(db, zDb);
156900 if( iDb<0 ){
156905 rc = sqlite3Checkpoint(db, iDb, eMode, pnLog, pnCkpt);
156954 SQLITE_PRIVATE int sqlite3Checkpoint(sqlite3 *db, int iDb, int eMode, int *pnLog, int *pnCkpt){
156964 if( i==iDb || iDb==SQLITE_MAX_ATTACHED ){
158697 db->init.iDb = sqlite3FindDbName(db, va_arg(ap,const char*));
158780 int iDb = zDbName ? sqlite3FindDbName(db, zDbName) : 0;
158781 return iDb<0 ? 0 : db->aDb[iDb].pBt;
158837 int iDb = sqlite3FindDbName(db, zDb);
158838 if( iDb==0 || iDb>1 ){
158839 Btree *pBt = db->aDb[iDb].pBt;
158872 int iDb;
158873 iDb = sqlite3FindDbName(db, zDb);
158874 if( iDb==0 || iDb>1 ){
158875 Btree *pBt = db->aDb[iDb].pBt;
158915 int iDb;
158925 iDb = sqlite3FindDbName(db, zDb);
158926 if( iDb==0 || iDb>1 ){
158927 Btree *pBt = db->aDb[iDb].pBt;
193990 int iDb; /* Schema used for this query */
194011 int iDb; /* Index of database to analyze */
194030 int iDb;
194035 iDb = sqlite3FindDb(db, &nm);
194036 if( iDb<0 ){
194041 iDb = 0;
194053 pTab->iDb = iDb;
194129 pCsr->iDb = pTab->iDb;
194316 Btree *pBt = pTab->db->aDb[pTab->iDb].pBt;
194345 Btree *pBt = pTab->db->aDb[pCsr->iDb].pBt;
194493 pCsr->iDb = sqlite3FindDbName(pTab->db, zDbase);
194494 if( pCsr->iDb<0 ){
194500 pCsr->iDb = pTab->iDb;
194510 " ORDER BY name", pTab->db->aDb[pCsr->iDb].zDbSName);
194563 int iDb = pCsr->iDb;
194564 sqlite3_result_text(ctx, db->aDb[iDb].zDbSName, -1, SQLITE_STATIC);
194661 int iDb; /* Index of database to analyze */
194848 pCsr->iDb = sqlite3FindDbName(db, zSchema);
194849 if( pCsr->iDb<0 ) return SQLITE_OK;
194851 pCsr->iDb = 0;
194853 pBt = db->aDb[pCsr->iDb].pBt;
194899 sqlite3_result_text(ctx, db->aDb[pCsr->iDb].zDbSName, -1, SQLITE_STATIC);
194924 int iDb;
194943 iDb = zSchema ? sqlite3FindDbName(pTab->db, zSchema) : -1;
194944 if( iDb<0 ){
194948 pBt = pTab->db->aDb[iDb].pBt;
