Lines Matching defs:iDb
16112 #define OP_ReopenIdx 101 /* synopsis: root=P2 iDb=P3 */
16123 #define OP_OpenRead 112 /* synopsis: root=P2 iDb=P3 */
16124 #define OP_OpenWrite 113 /* synopsis: root=P2 iDb=P3 */
16158 #define OP_CreateBtree 147 /* synopsis: r[P2]=root iDb=P1 flags=P3 */
16180 #define OP_TableLock 169 /* synopsis: iDb=P1 root=P2 write=P3 */
17049 u8 iDb; /* Which db file is being initialized */
19008 int iDb; /* Index in sqlite3.aDb[] of database holding pTab */
19434 int iDb; /* 0 for main database. 1 for TEMP, 2.. for ATTACHed */
20209 SQLITE_PRIVATE void sqlite3OpenTable(Parse*, int iCur, int iDb, Table*, int);
20411 SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName);
22486 i8 iDb; /* Index of cursor database in db->aDb[] */
35703 /* 101 */ "ReopenIdx" OpHelp("root=P2 iDb=P3"),
35714 /* 112 */ "OpenRead" OpHelp("root=P2 iDb=P3"),
35715 /* 113 */ "OpenWrite" OpHelp("root=P2 iDb=P3"),
35749 /* 147 */ "CreateBtree" OpHelp("r[P2]=root iDb=P1 flags=P3"),
35771 /* 169 */ "TableLock" OpHelp("iDb=P1 root=P2 write=P3"),
52028 int iDb;
52046 iDb = sqlite3FindDbName(db, zSchema);
52048 if( iDb<0 ) return 0;
52061 pBt = db->aDb[iDb].pBt;
52114 int iDb;
52126 iDb = sqlite3FindDbName(db, zSchema);
52127 testcase( iDb==1 );
52128 if( iDb<2 && iDb!=0 ){
52140 db->init.iDb = (u8)iDb;
68525 ** db->aDb[iDb].pSchema structure. The mutexes required for schema
68529 ** (2) if iDb!=1, then the mutex on db->aDb[iDb].pBt.
68531 ** If pSchema is not NULL, then iDb is computed from pSchema and
68534 SQLITE_PRIVATE int sqlite3SchemaMutexHeld(sqlite3 *db, int iDb, Schema *pSchema){
68538 if( pSchema ) iDb = sqlite3SchemaToIndex(db, pSchema);
68539 assert( iDb>=0 && iDb<db->nDb );
68541 if( iDb==1 ) return 1;
68542 p = db->aDb[iDb].pBt;
71169 int iDb;
71170 for(iDb=db->nDb-1; iDb>=0; iDb--){
71171 Btree *pExisting = db->aDb[iDb].pBt;
72708 int iDb;
72709 for(iDb=0; ALWAYS(iDb<db->nDb); iDb++){
72710 if( db->aDb[iDb].pBt==p ) break;
72714 db->aDb[iDb].zDbSName,
83018 SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere, u16 p5){
83020 sqlite3VdbeAddOp4(p, OP_ParseSchema, iDb, 0, 0, zWhere, P4_DYNAMIC);
94374 int iDb;
94378 iDb = pOp->p1;
94381 assert( iDb>=0 && iDb<db->nDb );
94382 assert( db->aDb[iDb].pBt!=0 );
94383 assert( DbMaskTest(p->btreeMask, iDb) );
94385 sqlite3BtreeGetMeta(db->aDb[iDb].pBt, iCookie, (u32 *)&iMeta);
94439 ** Synopsis: root=P2 iDb=P3
94467 ** Synopsis: root=P2 iDb=P3
94489 ** Synopsis: root=P2 iDb=P3
94526 int iDb;
94536 assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */
94559 iDb = pOp->p3;
94560 assert( iDb>=0 && iDb<db->nDb );
94561 assert( DbMaskTest(p->btreeMask, iDb) );
94562 pDb = &db->aDb[iDb];
94568 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
94603 pCur->iDb = iDb;
95926 assert( pC->iDb>=0 );
95927 zDb = db->aDb[pC->iDb].zDbSName;
96077 assert( pC->iDb>=0 );
96079 zDb = db->aDb[pC->iDb].zDbSName;
96136 assert( pC->iDb>=0 );
97020 int iDb;
97032 iDb = pOp->p3;
97033 assert( DbMaskTest(p->btreeMask, iDb) );
97035 rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved);
97041 sqlite3RootPageMoved(db, iDb, iMoved, pOp->p1);
97043 assert( resetSchemaOnFault==0 || resetSchemaOnFault==iDb+1 );
97044 resetSchemaOnFault = iDb+1;
97114 ** Synopsis: r[P2]=root iDb=P1 flags=P3
97164 int iDb;
97174 for(iDb=0; iDb<db->nDb; iDb++){
97175 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
97179 iDb = pOp->p1;
97180 assert( iDb>=0 && iDb<db->nDb );
97181 assert( DbHasProperty(db, iDb, DB_SchemaLoaded)
97187 sqlite3SchemaClear(db->aDb[iDb].pSchema);
97189 rc = sqlite3InitOne(db, iDb, &p->zErrMsg, pOp->p5);
97197 initData.iDb = iDb;
97200 initData.mxPage = sqlite3BtreeLastPage(db->aDb[iDb].pBt);
97203 db->aDb[iDb].zDbSName, zSchema, pOp->p4.z);
98247 ** Synopsis: iDb=P1 root=P2 write=P3
99533 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
99536 sqlite3VdbeAddOp4Int(v, OP_Transaction, iDb, wrFlag,
99544 sqlite3VdbeUsesBtree(v, iDb);
99552 aOp[0].p1 = iDb;
99564 aOp[1].p3 = iDb;
102753 int iDb = pOp->p3;
102756 pSchema = db->aDb[iDb].pSchema;
102757 pCur->zSchema = db->aDb[iDb].zDbSName;
103886 ** pExpr->iDb Set the index in db->aDb[] of the database X
108593 int iDb; /* Database idx for pTab */
108603 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
108604 assert( iDb>=0 && iDb<SQLITE_MAX_DB );
108605 sqlite3CodeVerifySchema(pParse, iDb);
108606 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
108614 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
108699 sqlite3VdbeAddOp3(v, OP_OpenRead, iTab, pIdx->tnum, iDb);
112434 ** Generate code to reload the schema for database iDb. And, if iDb!=1, for
112437 static void renameReloadSchema(Parse *pParse, int iDb, u16 p5){
112440 sqlite3ChangeCookie(pParse, iDb);
112441 sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, iDb, 0, p5);
112442 if( iDb!=1 ) sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, 1, 0, p5);
112455 int iDb; /* Database that contains the table */
112456 char *zDb; /* Name of database iDb */
112471 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
112472 zDb = db->aDb[iDb].zDbSName;
112479 ** in database iDb. If so, this is an error.
112526 /* Begin a transaction for database iDb. Then modify the schema cookie
112547 , zDb, zDb, zTabName, zName, (iDb==1), zTabName
112582 if( iDb!=1 ){
112607 renameReloadSchema(pParse, iDb, INITFLAG_AlterRename);
112608 renameTestSchema(pParse, zDb, iDb==1, "after rename", 0);
112642 int iDb; /* Database number */
112660 iDb = sqlite3SchemaToIndex(db, pNew->pSchema);
112661 zDb = db->aDb[iDb].zDbSName;
112761 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT);
112762 sqlite3VdbeUsesBtree(v, iDb);
112766 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, 3);
112770 renameReloadSchema(pParse, iDb, INITFLAG_AlterAdd);
112807 int iDb;
112838 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
112869 pNew->pSchema = db->aDb[iDb].pSchema;
113469 db->init.iDb = bTemp ? 1 : sqlite3FindDbName(db, zDb);
113493 db->init.iDb = 0;
114454 int iDb; /* Index of db containing pTab in aDb[] */
114500 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
114501 assert( iDb>=0 );
114502 zDb = db->aDb[iDb].zDbSName;
114509 renameTestSchema(pParse, zDb, iDb==1, "", 0);
114510 renameFixQuotes(pParse, zDb, iDb==1);
114515 , zDb, iDb, iCol, pTab->zName
114519 renameReloadSchema(pParse, iDb, INITFLAG_AlterDrop);
114520 renameTestSchema(pParse, zDb, iDb==1, "after drop column", 1);
114533 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite);
114774 int iDb, /* The database we are looking in */
114806 pDb = &db->aDb[iDb];
114832 sqlite3TableLock(pParse, iDb, aRoot[i], 1, zTab);
114844 sqlite3VdbeAddOp2(v, OP_Clear, (int)aRoot[i], iDb);
114852 sqlite3VdbeAddOp4Int(v, OP_OpenWrite, iStatCur+i, (int)aRoot[i], iDb, 3);
115591 int iDb; /* Index of database containing pTab */
115621 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
115622 assert( iDb>=0 );
115623 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
115626 db->aDb[iDb].zDbSName ) ){
115647 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
115651 sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
115716 assert( iDb==sqlite3SchemaToIndex(db, pIdx->pSchema) );
115717 sqlite3VdbeAddOp3(v, OP_OpenRead, iIdxCur, pIdx->tnum, iDb);
115938 static void loadAnalysis(Parse *pParse, int iDb){
115941 sqlite3VdbeAddOp1(v, OP_LoadAnalysis, iDb);
115948 static void analyzeDatabase(Parse *pParse, int iDb){
115950 Schema *pSchema = db->aDb[iDb].pSchema; /* Schema of database iDb */
115956 sqlite3BeginWriteOperation(pParse, 0, iDb);
115959 openStatTable(pParse, iDb, iStatCur, 0, 0);
115962 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
115967 loadAnalysis(pParse, iDb);
115976 int iDb;
115981 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
115982 sqlite3BeginWriteOperation(pParse, 0, iDb);
115986 openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");
115988 openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
115991 loadAnalysis(pParse, iDb);
116008 int iDb;
116030 }else if( pName2->n==0 && (iDb = sqlite3FindDb(db, pName1))>=0 ){
116032 analyzeDatabase(pParse, iDb);
116035 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName);
116036 if( iDb>=0 ){
116037 zDb = pName2->n ? db->aDb[iDb].zDbSName : 0;
116473 SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
116478 Schema *pSchema = db->aDb[iDb].pSchema;
116481 assert( iDb>=0 && iDb<db->nDb );
116482 assert( db->aDb[iDb].pBt!=0 );
116485 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
116501 sInfo.zDatabase = db->aDb[iDb].zDbSName;
116516 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
116596 ** database iDb attached to handle db.
116598 SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName){
116600 sqlite3StrICmp(db->aDb[iDb].zDbSName, zName)==0
116601 || (iDb==0 && sqlite3StrICmp("main", zName)==0)
116617 ** new database, close the database on db->init.iDb and reopen it as an
116652 ** from sqlite3_deserialize() to close database db->init.iDb and
116656 pNew = &db->aDb[db->init.iDb];
116790 db->init.iDb = 0;
116809 int iDb = db->nDb - 1;
116810 assert( iDb>=2 );
116811 if( db->aDb[iDb].pBt ){
116812 sqlite3BtreeClose(db->aDb[iDb].pBt);
116813 db->aDb[iDb].pBt = 0;
116814 db->aDb[iDb].pSchema = 0;
116817 db->nDb = iDb;
117043 int iDb = sqlite3FindDbName(db, pFix->zDb);
117050 if( iDb!=sqlite3FindDbName(db, pItem->zDatabase) ){
117088 int iDb, /* This is the database that must be used */
117093 assert( db->nDb>iDb );
117095 pFix->zDb = db->aDb[iDb].zDbSName;
117096 pFix->pSchema = db->aDb[iDb].pSchema;
117099 pFix->bTemp = (iDb==1);
117294 int iDb /* Index of containing database. */
117297 char *zDb = db->aDb[iDb].zDbSName; /* Schema name of attached database */
117308 if( db->nDb>2 || iDb!=0 ) z = sqlite3_mprintf("%s.%z", zDb, z);
117335 int iDb; /* The index of the database the expression refers to */
117341 iDb = sqlite3SchemaToIndex(pParse->db, pSchema);
117342 if( iDb<0 ){
117371 assert( iDb>=0 && iDb<pParse->db->nDb );
117372 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
117490 int iDb; /* The database containing the table to be locked */
117499 ** The table to be locked has root page iTab and is found in database iDb.
117508 int iDb, /* Index of the database containing the table to lock */
117517 assert( iDb>=0 );
117522 if( p->iDb==iDb && p->iTab==iTab ){
117533 p->iDb = iDb;
117544 int iDb, /* Index of the database containing the table to lock */
117549 if( iDb==1 ) return;
117550 if( !sqlite3BtreeSharable(pParse->db->aDb[iDb].pBt) ) return;
117551 lockTable(pParse, iDb, iTab, isWriteLock, zName);
117565 int p1 = p->iDb;
117600 int iDb, i;
117669 iDb = 0;
117672 if( DbMaskTest(pParse->cookieMask, iDb)==0 ) continue;
117673 sqlite3VdbeUsesBtree(v, iDb);
117674 pSchema = db->aDb[iDb].pSchema;
117677 iDb, /* P1 */
117678 DbMaskTest(pParse->writeMask,iDb), /* P2 */
117685 }while( ++iDb<db->nDb );
117961 int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema);
117962 zDb = pParse->db->aDb[iDb].zDbSName;
118032 ** For the index called zIdxName which is found in the database iDb,
118037 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){
118041 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
118042 pHash = &db->aDb[iDb].pSchema->idxHash;
118093 ** Reset the schema for the database at index iDb. Also reset the
118095 ** Deferred resets may be run by calling with iDb<0.
118097 SQLITE_PRIVATE void sqlite3ResetOneSchema(sqlite3 *db, int iDb){
118099 assert( iDb<db->nDb );
118101 if( iDb>=0 ){
118102 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
118103 DbSetProperty(db, iDb, DB_ResetWanted);
118341 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){
118346 assert( iDb>=0 && iDb<db->nDb );
118348 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
118350 pDb = &db->aDb[iDb];
118364 db->mDropSchemaName = sqlite3_malloc(strlen(db->aDb[iDb].zDbSName) + 1);
118366 memcpy(db->mDropSchemaName, db->aDb[iDb].zDbSName, strlen(db->aDb[iDb].zDbSName) + 1);
118397 ** Open the sqlite_schema table stored in database number iDb for
118400 SQLITE_PRIVATE void sqlite3OpenSchemaTable(Parse *p, int iDb){
118402 sqlite3TableLock(p, iDb, SCHEMA_ROOT, 1, LEGACY_SCHEMA_TABLE);
118403 sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, SCHEMA_ROOT, iDb, 5);
118466 int iDb; /* Database holding the object */
118476 iDb = sqlite3FindDb(db, pName1);
118477 if( iDb<0 ){
118482 assert( db->init.iDb==0 || db->init.busy || IN_SPECIAL_PARSE
118484 iDb = db->init.iDb;
118487 return iDb;
118697 int iDb; /* Database number to create the table in */
118702 iDb = db->init.iDb;
118703 zName = sqlite3DbStrDup(db, SCHEMA_TABLE(iDb));
118707 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
118708 if( iDb<0 ) return;
118709 if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){
118715 if( !OMIT_TEMPDB && isTemp ) iDb = 1;
118726 if( db->init.iDb==1 ) isTemp = 1;
118737 char *zDb = db->aDb[iDb].zDbSName;
118756 char *zDb = db->aDb[iDb].zDbSName;
118767 sqlite3CodeVerifySchema(pParse, iDb);
118787 pTable->pSchema = db->aDb[iDb].pSchema;
118811 sqlite3BeginWriteOperation(pParse, 1, iDb);
118825 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT);
118826 sqlite3VdbeUsesBtree(v, iDb);
118830 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, fileFormat);
118831 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, ENC(db));
118851 sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, reg2, BTREE_INTKEY);
118853 sqlite3OpenSchemaTable(pParse, iDb);
119215 int isInit = db->init.busy && db->init.iDb!=1;
119391 && !sqlite3BtreeIsReadonly(db->aDb[db->init.iDb].pBt)
119516 SQLITE_PRIVATE void sqlite3ChangeCookie(Parse *pParse, int iDb){
119519 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
119520 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION,
119521 (int)(1+(unsigned)db->aDb[iDb].pSchema->schema_cookie));
120097 int iDb; /* Database in which the table lives */
120185 iDb = sqlite3SchemaToIndex(db, p->pSchema);
120305 sqlite3VdbeAddOp3(v, OP_OpenWrite, 1, pParse->regRoot, iDb);
120355 db->aDb[iDb].zDbSName,
120364 sqlite3ChangeCookie(pParse, iDb);
120371 Db *pDb = &db->aDb[iDb];
120372 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
120383 sqlite3VdbeAddParseSchemaOp(v, iDb,
120392 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
120409 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
120446 int iDb;
120467 iDb = sqlite3SchemaToIndex(db, p->pSchema);
120468 sqlite3FixInit(&sFix, pParse, iDb, "view", pName);
120676 ** root-page of a table or index in database iDb has changed from iFrom
120691 SQLITE_PRIVATE void sqlite3RootPageMoved(sqlite3 *db, int iDb, Pgno iFrom, Pgno iTo){
120696 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
120697 pDb = &db->aDb[iDb];
120716 ** Write code to erase the table with root-page iTable from database iDb.
120721 static void destroyRootPage(Parse *pParse, int iTable, int iDb){
120725 sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
120740 pParse->db->aDb[iDb].zDbSName, iTable, r1, r1);
120788 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
120789 assert( iDb>=0 && iDb<pParse->db->nDb );
120790 destroyRootPage(pParse, iLargest, iDb);
120802 int iDb, /* The database number */
120807 const char *zDbName = pParse->db->aDb[iDb].zDbSName;
120823 SQLITE_PRIVATE void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){
120827 Db *pDb = &db->aDb[iDb];
120831 sqlite3BeginWriteOperation(pParse, 1, iDb);
120884 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
120887 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
120888 sqlite3ChangeCookie(pParse, iDb);
120889 sqliteViewResetAll(db, iDb);
120935 int iDb;
120955 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
120956 assert( iDb>=0 && iDb<db->nDb );
120967 const char *zTab = SCHEMA_TABLE(iDb);
120968 const char *zDb = db->aDb[iDb].zDbSName;
120974 if( !OMIT_TEMPDB && iDb==1 ){
120985 if( !OMIT_TEMPDB && iDb==1 ){
121023 sqlite3BeginWriteOperation(pParse, 1, iDb);
121025 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
121028 sqlite3CodeDropTable(pParse, pTab, iDb, isView);
121219 int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
121223 db->aDb[iDb].zDbSName ) ){
121229 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
121248 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
121258 if( memRootPage<0 ) sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb);
121259 sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, (int)tnum, iDb,
121395 int iDb; /* Index of the database that is being written */
121428 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
121429 if( iDb<0 ) goto exit_create_index;
121440 iDb = 1;
121445 sqlite3FixInit(&sFix, pParse, iDb, "index", pName);
121454 if( iDb==1 && db->aDb[iDb].pSchema!=pTab->pSchema ){
121466 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
121468 pDb = &db->aDb[iDb];
121526 sqlite3CodeVerifySchema(pParse, iDb);
121554 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
121558 if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX;
121616 pIndex->pSchema = db->aDb[iDb].pSchema;
121623 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
121866 sqlite3BeginWriteOperation(pParse, 1, iDb);
121875 sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, iMem, BTREE_BLOBKEY);
121897 db->aDb[iDb].zDbSName,
121910 sqlite3ChangeCookie(pParse, iDb);
121911 sqlite3VdbeAddParseSchemaOp(v, iDb,
122034 int iDb;
122060 iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
122065 const char *zDb = db->aDb[iDb].zDbSName;
122066 const char *zTab = SCHEMA_TABLE(iDb);
122070 if( !OMIT_TEMPDB && iDb==1 ) code = SQLITE_DROP_TEMP_INDEX;
122080 sqlite3BeginWriteOperation(pParse, 1, iDb);
122083 db->aDb[iDb].zDbSName, pIndex->zName
122085 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
122086 sqlite3ChangeCookie(pParse, iDb);
122087 destroyRootPage(pParse, pIndex->tnum, iDb);
122088 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
122693 ** for database iDb. The code to actually verify the schema cookie
122697 static void sqlite3CodeVerifySchemaAtToplevel(Parse *pToplevel, int iDb){
122698 assert( iDb>=0 && iDb<pToplevel->db->nDb );
122699 assert( pToplevel->db->aDb[iDb].pBt!=0 || iDb==1 );
122700 assert( iDb<SQLITE_MAX_DB );
122701 assert( sqlite3SchemaMutexHeld(pToplevel->db, iDb, 0) );
122702 if( DbMaskTest(pToplevel->cookieMask, iDb)==0 ){
122703 DbMaskSet(pToplevel->cookieMask, iDb);
122704 if( !OMIT_TEMPDB && iDb==1 ){
122709 SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
122710 sqlite3CodeVerifySchemaAtToplevel(sqlite3ParseToplevel(pParse), iDb);
122742 SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
122744 sqlite3CodeVerifySchemaAtToplevel(pToplevel, iDb);
122745 DbMaskSet(pToplevel->writeMask, iDb);
122894 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
122895 sqlite3BeginWriteOperation(pParse, 0, iDb);
122911 int iDb; /* The database index number */
122917 for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
122947 int iDb; /* The database index number */
122973 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName);
122974 if( iDb<0 ) return;
122977 zDb = db->aDb[iDb].zDbSName;
122987 sqlite3BeginWriteOperation(pParse, 0, iDb);
123847 int iDb = sqlite3SchemaToIndex(db, pView->pSchema);
123853 pFrom->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zDbSName);
123993 int iDb; /* Database number */
124077 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
124078 assert( iDb<db->nDb );
124080 db->aDb[iDb].zDbSName);
124108 sqlite3BeginWriteOperation(pParse, bComplex, iDb);
124166 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
124168 sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt ? memCnt : -1,
124174 sqlite3VdbeAddOp3(v, OP_Clear, pIdx->tnum, iDb, memCnt ? memCnt : -1);
124176 sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);
127446 int iDb, /* Index of database housing pTab */
127508 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);
127518 sqlite3VdbeAddOp3(v, OP_OpenRead, iCur, pIdx->tnum, iDb);
127828 SQLITE_PRIVATE void sqlite3FkClearTriggerCache(sqlite3 *db, int iDb){
127830 Hash *pHash = &db->aDb[iDb].pSchema->tblHash;
128021 int iDb; /* Index of database containing pTab */
128032 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
128033 zDb = db->aDb[iDb].zDbSName;
128105 rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
128114 sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
128121 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regOld, -1, bIgnore);
128132 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regNew, +1, bIgnore);
128443 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
128450 tDb.z = db->aDb[iDb].zDbSName;
128631 int iDb, /* The database index in sqlite3.aDb[] */
128640 sqlite3TableLock(pParse, iDb, pTab->tnum,
128643 sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nNVCol);
128649 sqlite3VdbeAddOp3(v, opcode, iCur, pPk->tnum, iDb);
128822 ** Return non-zero if the table pTab in database iDb or any of its indices
128824 ** a statement of the form "INSERT INTO <iDb, pTab> SELECT ..." can
128827 static int readsTable(Parse *p, int iDb, Table *pTab){
128838 if( pOp->opcode==OP_OpenRead && pOp->p3==iDb ){
128983 ** which is in database iDb. Return the register number for the register
129006 int iDb, /* Index of the database holding pTab */
129010 assert( pParse->db->aDb[iDb].pSchema!=0 );
129016 Table *pSeqTab = pParse->db->aDb[iDb].pSchema->pSeqTab;
129041 pInfo->iDb = iDb;
129085 pDb = &db->aDb[p->iDb];
129088 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead);
129145 Db *pDb = &db->aDb[p->iDb];
129153 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
129308 int iDb; /* Index of database holding TABLE */
129357 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
129358 assert( iDb<db->nDb );
129360 db->aDb[iDb].zDbSName) ){
129408 sqlite3BeginWriteOperation(pParse, pSelect || pTrigger, iDb);
129423 && xferOptimization(pParse, pTab, pSelect, onError, iDb)
129434 regAutoinc = autoIncBegin(pParse, iDb, pTab);
129543 if( pTrigger || readsTable(pParse, iDb, pTab) ){
131253 int iDb;
131267 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
131274 sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op);
131276 sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
131287 sqlite3VdbeAddOp3(v, op, iIdxCur, pIdx->tnum, iDb);
134447 ** Set the safety_level and pager flags for pager iDb. Or if iDb<0
134631 int iDb; /* Database index for <database> */
134648 /* Interpret the [schema.] part of the pragma statement. iDb is the
134650 iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId);
134651 if( iDb<0 ) return;
134652 pDb = &db->aDb[iDb];
134657 if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){
134715 if(sqlite3CodecPragma(db, iDb, pParse, zLeft, zRight)) {
134776 sqlite3VdbeUsesBtree(v, iDb);
134782 aOp[0].p1 = iDb;
134783 aOp[1].p1 = iDb;
134787 sqlite3BeginWriteOperation(pParse, 0, iDb);
134788 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_DEFAULT_CACHE_SIZE, size);
134789 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
134875 sqlite3CodeVerifySchema(pParse, iDb);
134878 sqlite3VdbeAddOp2(v, OP_Pagecount, iDb, iReg);
134886 sqlite3VdbeAddOp3(v, OP_MaxPgcnt, iDb, iReg, (int)x);
134970 iDb = 0;
134974 if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
135045 aOp[0].p1 = iDb;
135046 aOp[1].p1 = iDb;
135048 aOp[4].p1 = iDb;
135050 sqlite3VdbeUsesBtree(v, iDb);
135068 sqlite3BeginWriteOperation(pParse, 0, iDb);
135070 addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb); VdbeCoverage(v);
135092 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
135126 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
135163 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
135170 if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
135348 }else if( iDb!=1 ){
135554 sqlite3CodeVerifySchema(pParse, iDb);
135766 k = sqliteHashFirst(&db->aDb[iDb].pSchema->tblHash);
135776 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
135777 zDb = db->aDb[iDb].zDbSName;
135778 sqlite3CodeVerifySchema(pParse, iDb);
135779 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
135781 sqlite3OpenTable(pParse, 0, iDb, pTab, OP_OpenRead);
135788 sqlite3TableLock(pParse, iDb, pParent->tnum, 0, pParent->zName);
135792 sqlite3OpenTable(pParse, i, iDb, pParent, OP_OpenRead);
135794 sqlite3VdbeAddOp3(v, OP_OpenRead, i, pIdx->tnum, iDb);
135909 ** then iDb is set to the index of the database identified by <db>.
135910 ** In this case, the integrity of database iDb only is verified by
135914 ** "PRAGMA quick_check"), then iDb is set to 0. In this case, set iDb
135917 assert( iDb>=0 );
135918 assert( iDb==0 || pId2->z );
135919 if( pId2->z==0 ) iDb = -1;
135933 iDb>=0 ? db->aDb[iDb].zDbSName : 0);
135947 if( iDb>=0 && i!=iDb ) continue;
136410 sqlite3VdbeUsesBtree(v, iDb);
136421 aOp[0].p1 = iDb;
136422 aOp[1].p1 = iDb;
136442 aOp[0].p1 = iDb;
136443 aOp[1].p1 = iDb;
136478 int iBt = (pId2->z?iDb:SQLITE_MAX_DB);
136598 for(iDbLast = zDb?iDb:db->nDb-1; iDb<=iDbLast; iDb++){
136599 if( iDb==1 ) continue;
136600 sqlite3CodeVerifySchema(pParse, iDb);
136601 pSchema = db->aDb[iDb].pSchema;
136619 sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
136625 db->aDb[iDb].zDbSName, pTab->zName);
137241 int iDb = pData->iDb;
137254 assert( iDb>=0 && iDb<db->nDb );
137271 u8 saved_iDb = db->init.iDb;
137276 db->init.iDb = iDb;
137290 db->init.iDb = saved_iDb;
137294 assert( iDb==1 );
137316 pIndex = sqlite3FindIndex(db, argv[1], db->aDb[iDb].zDbSName);
137336 ** database file is given by iDb. iDb==0 is used for the main
137337 ** database. iDb==1 should never be used. iDb>=2 is used for
137341 SQLITE_PRIVATE int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFlags){
137356 assert( iDb>=0 && iDb<db->nDb );
137357 assert( db->aDb[iDb].pSchema );
137359 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
137369 azArg[1] = zSchemaTabName = SCHEMA_TABLE(iDb);
137376 initData.iDb = iDb;
137391 pDb = &db->aDb[iDb];
137393 assert( iDb==1 );
137443 if( iDb==0 && (db->mDbFlags & DBFLAG_EncodingFixed)==0 ){
137497 if( iDb==0 && meta[BTREE_FILE_FORMAT-1]>=4 ){
137509 db->aDb[iDb].zDbSName, zSchemaTabName);
137525 sqlite3AnalysisLoad(db, iDb);
137529 assert( pDb == &(db->aDb[iDb]) );
137533 pDb = &db->aDb[iDb];
137546 DbSetProperty(db, iDb, DB_SchemaLoaded);
137565 sqlite3ResetOneSchema(db, iDb);
137636 int iDb;
137642 for(iDb=0; iDb<db->nDb; iDb++){
137644 Btree *pBt = db->aDb[iDb].pBt; /* Btree database to read cookie from */
137664 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
137665 if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){
137666 sqlite3ResetOneSchema(db, iDb);
137678 ** Convert a schema pointer into the iDb index that indicates
139900 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
139901 sqlite3OpenTable(pParse, pSort->aDefer[i].iCsr, iDb, pTab, OP_OpenRead);
140204 int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
140205 zOrigDb = pNC->pParse->db->aDb[iDb].zDbSName;
144165 int iDb; /* Schema index for this data src */
144183 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
144184 zSchemaName = iDb>=0 ? db->aDb[iDb].zDbSName : "*";
145977 const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
145984 sqlite3CodeVerifySchema(pParse, iDb);
145985 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
146014 sqlite3VdbeAddOp4Int(v, OP_OpenRead, iCsr, (int)iRoot, iDb, 1);
146481 int iDb; /* The database to store the trigger in */
146495 iDb = 1;
146499 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
146500 if( iDb<0 ){
146516 if( db->init.busy && iDb!=1 ){
146522 ** then set iDb to 1 to create the trigger in the temporary database.
146529 iDb = 1;
146535 sqlite3FixInit(&sFix, pParse, iDb, "trigger", pName);
146559 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
146561 if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),zName) ){
146566 sqlite3CodeVerifySchema(pParse, iDb);
146623 pTrigger->pSchema = db->aDb[iDb].pSchema;
146652 if( db->init.iDb==1 ){
146681 int iDb; /* Database containing the trigger */
146687 iDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
146694 sqlite3FixInit(&sFix, pParse, iDb, "trigger", &nameToken);
146736 sqlite3BeginWriteOperation(pParse, 0, iDb);
146742 db->aDb[iDb].zDbSName, zName,
146745 sqlite3ChangeCookie(pParse, iDb);
146746 sqlite3VdbeAddParseSchemaOp(v, iDb,
146752 Hash *pHash = &db->aDb[iDb].pSchema->trigHash;
146753 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
147032 int iDb;
147034 iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema);
147035 assert( iDb>=0 && iDb<db->nDb );
147037 assert( (pTable && pTable->pSchema==pTrigger->pSchema) || iDb==1 );
147041 const char *zDb = db->aDb[iDb].zDbSName;
147042 const char *zTab = SCHEMA_TABLE(iDb);
147043 if( iDb==1 ) code = SQLITE_DROP_TEMP_TRIGGER;
147056 db->aDb[iDb].zDbSName, pTrigger->zName
147058 sqlite3ChangeCookie(pParse, iDb);
147059 sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
147066 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){
147070 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
147071 pHash = &(db->aDb[iDb].pSchema->trigHash);
148159 int iDb; /* Database containing the table being updated */
148203 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
148355 db->aDb[iDb].zDbSName);
148443 sqlite3BeginWriteOperation(pParse, pTrigger || hasFK, iDb);
149617 int iDb = 0;
149624 iDb = sqlite3TwoPartName(pParse, pNm, pNm, &pNm);
149625 if( iDb<0 ) goto build_vacuum_end;
149632 iDb = sqlite3FindDb(pParse->db, pNm);
149633 if( iDb<0 ) iDb = 0;
149636 if( iDb!=1 ){
149642 sqlite3VdbeAddOp2(v, OP_Vacuum, iDb, iIntoReg);
149643 sqlite3VdbeUsesBtree(v, iDb);
149656 int iDb, /* Which attached DB to vacuum */
149711 zDbMain = db->aDb[iDb].zDbSName;
149712 pMain = db->aDb[iDb].pBt;
149750 pgflags = db->aDb[iDb].safety_level | (db->flags & PAGER_FLAGS_MASK);
149759 sqlite3CodecGetKey(db, iDb, (void**)&zKey, &nKey);
149764 sqlite3BtreeSetCacheSize(pTemp, db->aDb[iDb].pSchema->cache_size);
149801 db->init.iDb = nDb; /* force new CREATE statements into vacuum_db */
149815 db->init.iDb = 0;
149903 db->init.iDb = 0;
150358 int iDb = sqlite3SchemaToIndex(db, pTable->pSchema);
150359 assert( iDb>=0 ); /* The database the table is being created in */
150361 pTable->u.vtab.azArg[0], pParse->db->aDb[iDb].zDbSName);
150403 int iDb;
150423 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
150428 db->aDb[iDb].zDbSName,
150435 sqlite3ChangeCookie(pParse, iDb);
150439 sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere, 0);
150444 sqlite3VdbeAddOp2(v, OP_VCreate, iDb, iReg);
150507 int iDb;
150538 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
150539 pTab->u.vtab.azArg[1] = db->aDb[iDb].zDbSName;
150696 ** of the virtual table named zTab in database iDb.
150702 SQLITE_PRIVATE int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab, char **pzErr){
150708 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
150832 ** of the virtual table named zTab in database iDb. This occurs
150837 SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab){
150841 pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
162541 int iDb; /* Index of database containing table/index */
162546 iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
162569 sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op);
162600 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
162639 sqlite3VdbeAddOp3(v, op, iIndexCur, pIx->tnum, iDb);
162668 if( iDb>=0 ) sqlite3CodeVerifySchema(pParse, iDb);
162955 int iDb = sqlite3SchemaToIndex(db, pIx->pSchema);
162956 sqlite3VdbeAddOp3(v, OP_ReopenIdx, pLevel->iIdxCur, pIx->tnum, iDb);
174687 int iDb, nDb;
174697 nDb = iDb = sqlite3FindDbName(db, zSchema);
174698 if( iDb<0 ) nDb--;
174700 iDb = 0;
174703 for(; iDb<=nDb; iDb++){
174704 Btree *pBt = db->aDb[iDb].pBt;
175860 int iDb; /* Schema to checkpoint */
175882 iDb = sqlite3FindDbName(db, zDb);
175884 iDb = SQLITE_MAX_DB; /* This means process all schemas */
175886 if( iDb<0 ){
175891 rc = sqlite3Checkpoint(db, iDb, eMode, pnLog, pnCkpt);
175921 ** Run a checkpoint on database iDb. This is a no-op if database iDb is
175933 ** If iDb is passed SQLITE_MAX_DB then all attached databases are
175940 SQLITE_PRIVATE int sqlite3Checkpoint(sqlite3 *db, int iDb, int eMode, int *pnLog, int *pnCkpt){
175948 testcase( iDb==SQLITE_MAX_ATTACHED ); /* See forum post a006d86f72 */
175949 testcase( iDb==SQLITE_MAX_DB );
175952 if( i==iDb || iDb==SQLITE_MAX_DB ){
177814 int iDb;
177816 iDb = sqlite3FindDbName(db, va_arg(ap,const char*));
177817 if( iDb>=0 ){
177818 db->init.iDb = iDb;
178127 int iDb = zDbName ? sqlite3FindDbName(db, zDbName) : 0;
178128 return iDb<0 ? 0 : db->aDb[iDb].pBt;
178202 int iDb = sqlite3FindDbName(db, zDb);
178203 if( iDb==0 || iDb>1 ){
178204 Btree *pBt = db->aDb[iDb].pBt;
178237 int iDb;
178238 iDb = sqlite3FindDbName(db, zDb);
178239 if( iDb==0 || iDb>1 ){
178240 Btree *pBt = db->aDb[iDb].pBt;
178281 int iDb;
178290 iDb = sqlite3FindDbName(db, zDb);
178291 if( iDb==0 || iDb>1 ){
178292 Btree *pBt = db->aDb[iDb].pBt;
214307 int iDb; /* Schema used for this query */
214330 int iDb; /* Index of database to analyze */
214349 int iDb;
214354 iDb = sqlite3FindDb(db, &nm);
214355 if( iDb<0 ){
214360 iDb = 0;
214373 pTab->iDb = iDb;
214481 pCsr->iDb = pTab->iDb;
214694 Btree *pBt = pTab->db->aDb[pTab->iDb].pBt;
214757 Btree *pBt = pTab->db->aDb[pCsr->iDb].pBt;
214935 pCsr->iDb = sqlite3FindDbName(pTab->db, zDbase);
214936 if( pCsr->iDb<0 ){
214937 pCsr->iDb = 0;
214942 pCsr->iDb = pTab->iDb;
214961 pTab->db->aDb[pCsr->iDb].zDbSName);
215032 int iDb = pCsr->iDb;
215033 sqlite3_result_text(ctx, db->aDb[iDb].zDbSName, -1, SQLITE_STATIC);
215134 int iDb; /* Index of database to analyze */
215323 pCsr->iDb = sqlite3FindDbName(db, zSchema);
215324 if( pCsr->iDb<0 ) return SQLITE_OK;
215326 pCsr->iDb = 0;
215328 pBt = db->aDb[pCsr->iDb].pBt;
215380 sqlite3_result_text(ctx, db->aDb[pCsr->iDb].zDbSName, -1, SQLITE_STATIC);
215405 int iDb;
215424 iDb = zSchema ? sqlite3FindDbName(pTab->db, zSchema) : -1;
215425 if( iDb<0 ){
215429 pBt = pTab->db->aDb[iDb].pBt;
245786 int iDb = sqlite3CodecGetDbIndex(db, zDb);
245787 return sqlite3CodecAttach(db, iDb, pKey, nKey);
245798 int iDb = sqlite3CodecGetDbIndex(db, zDb);
245799 Btree *p = db->aDb[iDb].pBt;
245872 int sqlite3CodecPragma(sqlite3 *db, int iDb, Parse *parse, const char *zLeft, const char *zRight){
245873 Btree *p = db->aDb[iDb].pBt;