Lines Matching refs:pBt
14604 SQLITE_PRIVATE int sqlite3BtreeSetVersion(Btree *pBt, int iVersion);
14606 SQLITE_PRIVATE int sqlite3BtreeIsReadonly(Btree *pBt);
16124 Btree *pBt; /* The B*Tree structure for this database file */ member
20788 Btree *pBt = db->aDb[i].pBt; in sqlite3_db_status() local
20789 if( pBt ){ in sqlite3_db_status()
20790 Pager *pPager = sqlite3BtreePager(pBt); in sqlite3_db_status()
20793 nByte = nByte / sqlite3BtreeConnectionCount(pBt); in sqlite3_db_status()
20886 if( db->aDb[i].pBt ){ in sqlite3_db_status()
20887 Pager *pPager = sqlite3BtreePager(db->aDb[i].pBt); in sqlite3_db_status()
23285 void **pBt; in sqlite3MemMalloc() local
23299 pBt = (void**)&z[mem.nTitle]; in sqlite3MemMalloc()
23300 pHdr = (struct MemBlockHdr*)&pBt[mem.nBacktrace]; in sqlite3MemMalloc()
23316 memcpy(pBt, &aAddr[1], pHdr->nBacktrace*sizeof(void*)); in sqlite3MemMalloc()
23317 assert(pBt[0]); in sqlite3MemMalloc()
23344 void **pBt; in sqlite3MemFree() local
23349 pBt = (void**)pHdr; in sqlite3MemFree()
23350 pBt -= pHdr->nBacktraceSlots; in sqlite3MemFree()
23366 z = (char*)pBt; in sqlite3MemFree()
23507 void **pBt = (void**)pHdr; in sqlite3MemdebugSync() local
23508 pBt -= pHdr->nBacktraceSlots; in sqlite3MemdebugSync()
23509 mem.xBacktrace((int)pHdr->iSize, pHdr->nBacktrace-1, &pBt[1]); in sqlite3MemdebugSync()
23520 void **pBt; in sqlite3MemdebugDump() local
23535 pBt = (void**)pHdr; in sqlite3MemdebugDump()
23536 pBt -= pHdr->nBacktraceSlots; in sqlite3MemdebugDump()
23537 backtrace_symbols_fd(pBt, pHdr->nBacktrace, fileno(out)); in sqlite3MemdebugDump()
47194 Btree *pBt;
47224 pBt = db->aDb[iDb].pBt;
47225 if( pBt==0 ) return 0;
47226 szPage = sqlite3BtreeGetPageSize(pBt);
47243 Pager *pPager = sqlite3BtreePager(pBt);
62403 #define MX_CELL_SIZE(pBt) ((int)(pBt->pageSize-8))
62410 #define MX_CELL(pBt) ((pBt->pageSize-8)/6)
62476 BtShared *pBt; /* Pointer to BtShared that this page is part of */
62527 BtShared *pBt; /* Sharable content of this btree */
62702 #define BTCURSOR_FIRST_UNINIT pBt /* Name of first uninitialized field */
62703 BtShared *pBt; /* The BtShared this cursor points to */
62766 # define PENDING_BYTE_PAGE(pBt) PAGER_MJ_PGNO(pBt)
62783 #define PTRMAP_PAGENO(pBt, pgno) ptrmapPageno(pBt, pgno)
62785 #define PTRMAP_ISPAGE(pBt, pgno) (PTRMAP_PAGENO((pBt),(pgno))==(pgno))
62828 assert( p->pBt->inTransaction!=TRANS_NONE || p->pBt->nTransaction==0 ); \
62829 assert( p->pBt->inTransaction>=p->inTrans );
62840 #define ISAUTOVACUUM (pBt->autoVacuum)
62858 BtShared *pBt; /* The tree being checked out */
62906 assert( sqlite3_mutex_notheld(p->pBt->mutex) );
62909 sqlite3_mutex_enter(p->pBt->mutex);
62910 p->pBt->db = p->db;
62919 BtShared *pBt = p->pBt;
62921 assert( sqlite3_mutex_held(pBt->mutex) );
62923 assert( p->db==pBt->db );
62925 sqlite3_mutex_leave(pBt->mutex);
62953 assert( p->pNext==0 || p->pNext->pBt>p->pBt );
62954 assert( p->pPrev==0 || p->pPrev->pBt<p->pBt );
62968 assert( (p->locked==0 && p->sharable) || p->pBt->db==p->db );
62989 if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){
62990 p->pBt->db = p->db;
63002 assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt );
63040 assert( p->sharable==0 || p->locked==0 || p->db==p->pBt->db );
63041 assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->pBt->mutex) );
63069 p = db->aDb[i].pBt;
63085 p = db->aDb[i].pBt;
63107 p = db->aDb[i].pBt;
63109 (p->wantToLock==0 || !sqlite3_mutex_held(p->pBt->mutex)) ){
63136 p = db->aDb[iDb].pBt;
63154 p->pBt->db = p->db;
63159 Btree *p = db->aDb[i].pBt;
63161 p->pBt->db = p->db;
63317 (int)p->pgno, sqlite3PagerFilename(p->pBt->pPager, 0)
63362 Schema *pSchema = (Schema *)pBtree->pBt->pSchema;
63410 for(pLock=pBtree->pBt->pLock; pLock; pLock=pLock->pNext){
63445 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
63464 BtShared *pBt = p->pBt;
63476 assert( eLock==READ_LOCK || (p==pBt->pWriter && p->inTrans==TRANS_WRITE) );
63477 assert( eLock==READ_LOCK || pBt->inTransaction==TRANS_WRITE );
63487 if( pBt->pWriter!=p && (pBt->btsFlags & BTS_EXCLUSIVE)!=0 ){
63488 sqlite3ConnectionBlocked(p->db, pBt->pWriter->db);
63492 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
63507 assert( p==pBt->pWriter );
63508 pBt->btsFlags |= BTS_PENDING;
63536 BtShared *pBt = p->pBt;
63556 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
63573 pLock->pNext = pBt->pLock;
63574 pBt->pLock = pLock;
63600 BtShared *pBt = p->pBt;
63601 BtLock **ppIter = &pBt->pLock;
63609 assert( (pBt->btsFlags & BTS_EXCLUSIVE)==0 || pBt->pWriter==pLock->pBtree );
63622 assert( (pBt->btsFlags & BTS_PENDING)==0 || pBt->pWriter );
63623 if( pBt->pWriter==p ){
63624 pBt->pWriter = 0;
63625 pBt->btsFlags &= ~(BTS_EXCLUSIVE|BTS_PENDING);
63626 }else if( pBt->nTransaction==2 ){
63636 pBt->btsFlags &= ~BTS_PENDING;
63644 BtShared *pBt = p->pBt;
63645 if( pBt->pWriter==p ){
63647 pBt->pWriter = 0;
63648 pBt->btsFlags &= ~(BTS_EXCLUSIVE|BTS_PENDING);
63649 for(pLock=pBt->pLock; pLock; pLock=pLock->pNext){
63669 return sqlite3_mutex_held(p->pBt->mutex);
63682 return (p->pBtree->db==p->pBt->db);
63696 static void invalidateAllOverflowCache(BtShared *pBt){
63698 assert( sqlite3_mutex_held(pBt->mutex) );
63699 for(p=pBt->pCursor; p; p=p->pNext){
63728 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
63778 static int btreeSetHasContent(BtShared *pBt, Pgno pgno){
63780 if( !pBt->pHasContent ){
63781 assert( pgno<=pBt->nPage );
63782 pBt->pHasContent = sqlite3BitvecCreate(pBt->nPage);
63783 if( !pBt->pHasContent ){
63787 if( rc==SQLITE_OK && pgno<=sqlite3BitvecSize(pBt->pHasContent) ){
63788 rc = sqlite3BitvecSet(pBt->pHasContent, pgno);
63800 static int btreeGetHasContent(BtShared *pBt, Pgno pgno){
63801 Bitvec *p = pBt->pHasContent;
63809 static void btreeClearHasContent(BtShared *pBt){
63810 sqlite3BitvecDestroy(pBt->pHasContent);
63811 pBt->pHasContent = 0;
63930 static int saveAllCursors(BtShared *pBt, Pgno iRoot, BtCursor *pExcept){
63932 assert( sqlite3_mutex_held(pBt->mutex) );
63933 assert( pExcept==0 || pExcept->pBt==pBt );
63934 for(p=pBt->pCursor; p; p=p->pNext){
64145 static Pgno ptrmapPageno(BtShared *pBt, Pgno pgno){
64148 assert( sqlite3_mutex_held(pBt->mutex) );
64150 nPagesPerMapPage = (pBt->usableSize/5)+1;
64153 if( ret==PENDING_BYTE_PAGE(pBt) ){
64169 static void ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent, int *pRC){
64178 assert( sqlite3_mutex_held(pBt->mutex) );
64180 assert( 0==PTRMAP_ISPAGE(pBt, PENDING_BYTE_PAGE(pBt)) );
64182 assert( pBt->autoVacuum );
64187 iPtrmap = PTRMAP_PAGENO(pBt, key);
64188 rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage, 0);
64205 assert( offset <= (int)pBt->usableSize-5 );
64228 static int ptrmapGet(BtShared *pBt, Pgno key, u8 *pEType, Pgno *pPgno){
64235 assert( sqlite3_mutex_held(pBt->mutex) );
64237 iPtrmap = PTRMAP_PAGENO(pBt, key);
64238 rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage, 0);
64249 assert( offset <= (int)pBt->usableSize-5 );
64307 surplus = minLocal + (pInfo->nPayload - minLocal)%(pPage->pBt->usableSize-4);
64337 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
64358 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
64425 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
64511 nSize = minLocal + (nSize - minLocal) % (pPage->pBt->usableSize - 4);
64573 ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, pRC);
64607 assert( pPage->pBt!=0 );
64608 assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE );
64610 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
64618 usableSize = pPage->pBt->usableSize;
64690 temp = sqlite3PagerTempSpace(pPage->pBt->pPager);
64733 int maxPC = pPg->pBt->usableSize - nByte; /* Max address for a usable slot */
64803 assert( pPage->pBt );
64804 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
64808 assert( nByte < (int)(pPage->pBt->usableSize-8) );
64819 assert( top<=(int)pPage->pBt->usableSize ); /* Prevent by getAndInitPage() */
64821 if( top==0 && pPage->pBt->usableSize==65536 ){
64868 assert( top+nByte <= (int)pPage->pBt->usableSize );
64896 assert( pPage->pBt!=0 );
64899 assert( CORRUPT_DB || iEnd <= pPage->pBt->usableSize );
64900 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
64902 assert( iStart<=pPage->pBt->usableSize-4 );
64919 if( iFreeBlk>pPage->pBt->usableSize-4 ){
64934 if( iEnd > pPage->pBt->usableSize ){
64969 if( pPage->pBt->btsFlags & BTS_FAST_SECURE ){
64993 BtShared *pBt; /* A copy of pPage->pBt */
64996 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
65001 pBt = pPage->pBt;
65018 pPage->maxLocal = pBt->maxLeaf;
65019 pPage->minLocal = pBt->minLeaf;
65030 pPage->maxLocal = pBt->maxLocal;
65031 pPage->minLocal = pBt->minLocal;
65037 pPage->max1bytePayload = pBt->max1bytePayload;
65055 assert( pPage->pBt!=0 );
65056 assert( pPage->pBt->db!=0 );
65057 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
65064 usableSize = pPage->pBt->usableSize;
65138 usableSize = pPage->pBt->usableSize;
65170 BtShared *pBt; /* The main btree structure */
65172 assert( pPage->pBt!=0 );
65173 assert( pPage->pBt->db!=0 );
65174 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
65180 pBt = pPage->pBt;
65187 assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
65188 pPage->maskPage = (u16)(pBt->pageSize - 1);
65192 pPage->aDataEnd = pPage->aData + pBt->usableSize;
65197 if( pPage->nCell>MX_CELL(pBt) ){
65201 testcase( pPage->nCell==MX_CELL(pBt) );
65207 || get2byteNotZero(&data[5])==(int)pBt->usableSize
65211 if( pBt->db->flags & SQLITE_CellSizeCk ){
65223 BtShared *pBt = pPage->pBt;
65231 assert( sqlite3_mutex_held(pBt->mutex) );
65232 if( pBt->btsFlags & BTS_FAST_SECURE ){
65233 memset(&data[hdr], 0, pBt->usableSize - hdr);
65239 put2byte(&data[hdr+5], pBt->usableSize);
65240 pPage->nFree = (u16)(pBt->usableSize - first);
65243 pPage->aDataEnd = &data[pBt->usableSize];
65247 assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
65248 pPage->maskPage = (u16)(pBt->pageSize - 1);
65258 static MemPage *btreePageFromDbPage(DbPage *pDbPage, Pgno pgno, BtShared *pBt){
65263 pPage->pBt = pBt;
65283 BtShared *pBt, /* The btree */
65292 assert( sqlite3_mutex_held(pBt->mutex) );
65293 rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, flags);
65295 *ppPage = btreePageFromDbPage(pDbPage, pgno, pBt);
65304 static MemPage *btreePageLookup(BtShared *pBt, Pgno pgno){
65306 assert( sqlite3_mutex_held(pBt->mutex) );
65307 pDbPage = sqlite3PagerLookup(pBt->pPager, pgno);
65309 return btreePageFromDbPage(pDbPage, pgno, pBt);
65318 static Pgno btreePagecount(BtShared *pBt){
65319 return pBt->nPage;
65323 assert( ((p->pBt->nPage)&0x80000000)==0 );
65324 return btreePagecount(p->pBt);
65341 BtShared *pBt, /* The database file */
65349 assert( sqlite3_mutex_held(pBt->mutex) );
65354 if( pgno>btreePagecount(pBt) ){
65358 rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, bReadOnly);
65364 btreePageFromDbPage(pDbPage, pgno, pBt);
65401 assert( pPage->pBt );
65405 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
65414 assert( pPage->pBt );
65418 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
65432 BtShared *pBt, /* The btree */
65437 int rc = btreeGetPage(pBt, pgno, ppPage, flags);
65465 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
65483 BtShared *pBt = (BtShared*)pArg;
65484 assert( pBt->db );
65485 assert( sqlite3_mutex_held(pBt->db->mutex) );
65486 return sqlite3InvokeBusyHandler(&pBt->db->busyHandler,
65487 sqlite3PagerFile(pBt->pPager));
65519 BtShared *pBt = 0; /* Shared part of btree structure */
65602 for(pBt=GLOBAL(BtShared*,sqlite3SharedCacheList); pBt; pBt=pBt->pNext){
65603 assert( pBt->nRef>0 );
65604 if( 0==strcmp(zFullPathname, sqlite3PagerFilename(pBt->pPager, 0))
65605 && sqlite3PagerVfs(pBt->pPager)==pVfs ){
65608 Btree *pExisting = db->aDb[iDb].pBt;
65609 if( pExisting && pExisting->pBt==pBt ){
65617 p->pBt = pBt;
65618 pBt->nRef++;
65637 if( pBt==0 ){
65649 pBt = sqlite3MallocZero( sizeof(*pBt) );
65650 if( pBt==0 ){
65654 rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename,
65657 sqlite3PagerSetMmapLimit(pBt->pPager, db->szMmap);
65658 rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader);
65663 pBt->openFlags = (u8)flags;
65664 pBt->db = db;
65665 sqlite3PagerSetBusyHandler(pBt->pPager, btreeInvokeBusyHandler, pBt);
65666 p->pBt = pBt;
65668 pBt->pCursor = 0;
65669 pBt->pPage1 = 0;
65670 if( sqlite3PagerIsreadonly(pBt->pPager) ) pBt->btsFlags |= BTS_READ_ONLY;
65672 pBt->btsFlags |= BTS_SECURE_DELETE;
65674 pBt->btsFlags |= BTS_OVERWRITE;
65679 pBt->pageSize = (zDbHeader[16]<<8) | (zDbHeader[17]<<16);
65680 if( pBt->pageSize<512 || pBt->pageSize>SQLITE_MAX_PAGE_SIZE
65681 || ((pBt->pageSize-1)&pBt->pageSize)!=0 ){
65682 pBt->pageSize = 0;
65691 pBt->autoVacuum = (SQLITE_DEFAULT_AUTOVACUUM ? 1 : 0);
65692 pBt->incrVacuum = (SQLITE_DEFAULT_AUTOVACUUM==2 ? 1 : 0);
65701 pBt->btsFlags |= BTS_PAGESIZE_FIXED;
65703 pBt->autoVacuum = (get4byte(&zDbHeader[36 + 4*4])?1:0);
65704 pBt->incrVacuum = (get4byte(&zDbHeader[36 + 7*4])?1:0);
65707 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
65709 pBt->usableSize = pBt->pageSize - nReserve;
65710 assert( (pBt->pageSize & 7)==0 ); /* 8-byte alignment of pageSize */
65715 pBt->nRef = 1;
65720 pBt->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_FAST);
65721 if( pBt->mutex==0 ){
65727 pBt->pNext = GLOBAL(BtShared*,sqlite3SharedCacheList);
65728 GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt;
65743 if( (pSib = db->aDb[i].pBt)!=0 && pSib->sharable ){
65745 if( (uptr)p->pBt<(uptr)pSib->pBt ){
65750 while( pSib->pNext && (uptr)pSib->pNext->pBt<(uptr)p->pBt ){
65769 if( pBt && pBt->pPager ){
65770 sqlite3PagerClose(pBt->pPager, 0);
65772 sqlite3_free(pBt);
65783 sqlite3PagerSetCachesize(p->pBt->pPager, SQLITE_DEFAULT_CACHE_SIZE);
65786 pFile = sqlite3PagerFile(pBt->pPager);
65788 sqlite3OsFileControlHint(pFile, SQLITE_FCNTL_PDB, (void*)&pBt->db);
65805 static int removeFromSharingList(BtShared *pBt){
65811 assert( sqlite3_mutex_notheld(pBt->mutex) );
65814 pBt->nRef--;
65815 if( pBt->nRef<=0 ){
65816 if( GLOBAL(BtShared*,sqlite3SharedCacheList)==pBt ){
65817 GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt->pNext;
65820 while( ALWAYS(pList) && pList->pNext!=pBt ){
65824 pList->pNext = pBt->pNext;
65828 sqlite3_mutex_free(pBt->mutex);
65844 static void allocateTempSpace(BtShared *pBt){
65845 if( !pBt->pTmpSpace ){
65846 pBt->pTmpSpace = sqlite3PageMalloc( pBt->pageSize );
65863 if( pBt->pTmpSpace ){
65864 memset(pBt->pTmpSpace, 0, 8);
65865 pBt->pTmpSpace += 4;
65873 static void freeTempSpace(BtShared *pBt){
65874 if( pBt->pTmpSpace ){
65875 pBt->pTmpSpace -= 4;
65876 sqlite3PageFree(pBt->pTmpSpace);
65877 pBt->pTmpSpace = 0;
65885 BtShared *pBt = p->pBt;
65891 pCur = pBt->pCursor;
65912 if( !p->sharable || removeFromSharingList(pBt) ){
65918 assert( !pBt->pCursor );
65919 sqlite3PagerClose(pBt->pPager, p->db);
65920 if( pBt->xFreeSchema && pBt->pSchema ){
65921 pBt->xFreeSchema(pBt->pSchema);
65923 sqlite3DbFree(0, pBt->pSchema);
65924 freeTempSpace(pBt);
65925 sqlite3_free(pBt);
65947 BtShared *pBt = p->pBt;
65950 sqlite3PagerSetCachesize(pBt->pPager, mxPage);
65966 BtShared *pBt = p->pBt;
65970 res = sqlite3PagerSetSpillsize(pBt->pPager, mxPage);
65981 BtShared *pBt = p->pBt;
65984 sqlite3PagerSetMmapLimit(pBt->pPager, szMmap);
66003 BtShared *pBt = p->pBt;
66006 sqlite3PagerSetFlags(pBt->pPager, pgFlags);
66034 BtShared *pBt = p->pBt;
66038 if( nReserve>pBt->optimalReserve ) pBt->optimalReserve = (u8)nReserve;
66040 if( pBt->btsFlags & BTS_PAGESIZE_FIXED ){
66045 nReserve = pBt->pageSize - pBt->usableSize;
66051 assert( !pBt->pCursor );
66052 pBt->pageSize = (u32)pageSize;
66053 freeTempSpace(pBt);
66055 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
66056 pBt->usableSize = pBt->pageSize - (u16)nReserve;
66057 if( iFix ) pBt->btsFlags |= BTS_PAGESIZE_FIXED;
66066 return p->pBt->pageSize;
66082 assert( sqlite3_mutex_held(p->pBt->mutex) );
66083 n = p->pBt->pageSize - p->pBt->usableSize;
66101 if( n<p->pBt->optimalReserve ) n = p->pBt->optimalReserve;
66116 n = sqlite3PagerMaxPageCount(p->pBt->pPager, mxPage);
66146 p->pBt->btsFlags &= ~BTS_FAST_SECURE;
66147 p->pBt->btsFlags |= BTS_SECURE_DELETE*newFlag;
66149 b = (p->pBt->btsFlags & BTS_FAST_SECURE)/BTS_SECURE_DELETE;
66164 BtShared *pBt = p->pBt;
66169 if( (pBt->btsFlags & BTS_PAGESIZE_FIXED)!=0 && (av ?1:0)!=pBt->autoVacuum ){
66172 pBt->autoVacuum = av ?1:0;
66173 pBt->incrVacuum = av==2 ?1:0;
66191 (!p->pBt->autoVacuum)?BTREE_AUTOVACUUM_NONE:
66192 (!p->pBt->incrVacuum)?BTREE_AUTOVACUUM_FULL:
66208 static void setDefaultSyncFlag(BtShared *pBt, u8 safety_level){
66211 if( (db=pBt->db)!=0 && (pDb=db->aDb)!=0 ){
66212 while( pDb->pBt==0 || pDb->pBt->pBt!=pBt ){ pDb++; }
66218 sqlite3PagerSetFlags(pBt->pPager,
66224 # define setDefaultSyncFlag(pBt,safety_level)
66240 static int lockBtree(BtShared *pBt){
66247 assert( sqlite3_mutex_held(pBt->mutex) );
66248 assert( pBt->pPage1==0 );
66249 rc = sqlite3PagerSharedLock(pBt->pPager);
66251 rc = btreeGetPage(pBt, 1, &pPage1, 0);
66258 sqlite3PagerPagecount(pBt->pPager, (int*)&nPageFile);
66262 if( (pBt->db->flags & SQLITE_ResetDatabase)!=0 ){
66279 pBt->btsFlags |= BTS_READ_ONLY;
66286 pBt->btsFlags |= BTS_READ_ONLY;
66300 if( page1[19]==2 && (pBt->btsFlags & BTS_NO_WAL)==0 ){
66302 rc = sqlite3PagerOpenWal(pBt->pPager, &isOpen);
66306 setDefaultSyncFlag(pBt, SQLITE_DEFAULT_WAL_SYNCHRONOUS+1);
66314 setDefaultSyncFlag(pBt, SQLITE_DEFAULT_SYNCHRONOUS+1);
66339 pBt->btsFlags |= BTS_PAGESIZE_FIXED;
66349 if( (u32)pageSize!=pBt->pageSize ){
66357 pBt->usableSize = usableSize;
66358 pBt->pageSize = pageSize;
66359 freeTempSpace(pBt);
66360 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize,
66364 if( sqlite3WritableSchema(pBt->db)==0 && nPage>nPageFile ){
66374 pBt->pageSize = pageSize;
66375 pBt->usableSize = usableSize;
66377 pBt->autoVacuum = (get4byte(&page1[36 + 4*4])?1:0);
66378 pBt->incrVacuum = (get4byte(&page1[36 + 7*4])?1:0);
66395 pBt->maxLocal = (u16)((pBt->usableSize-12)*64/255 - 23);
66396 pBt->minLocal = (u16)((pBt->usableSize-12)*32/255 - 23);
66397 pBt->maxLeaf = (u16)(pBt->usableSize - 35);
66398 pBt->minLeaf = (u16)((pBt->usableSize-12)*32/255 - 23);
66399 if( pBt->maxLocal>127 ){
66400 pBt->max1bytePayload = 127;
66402 pBt->max1bytePayload = (u8)pBt->maxLocal;
66404 assert( pBt->maxLeaf + 23 <= MX_CELL_SIZE(pBt) );
66405 pBt->pPage1 = pPage1;
66406 pBt->nPage = nPage;
66411 pBt->pPage1 = 0;
66428 static int countValidCursors(BtShared *pBt, int wrOnly){
66431 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
66447 static void unlockBtreeIfUnused(BtShared *pBt){
66448 assert( sqlite3_mutex_held(pBt->mutex) );
66449 assert( countValidCursors(pBt,0)==0 || pBt->inTransaction>TRANS_NONE );
66450 if( pBt->inTransaction==TRANS_NONE && pBt->pPage1!=0 ){
66451 MemPage *pPage1 = pBt->pPage1;
66453 assert( sqlite3PagerRefcount(pBt->pPager)==1 );
66454 pBt->pPage1 = 0;
66464 static int newDatabase(BtShared *pBt){
66469 assert( sqlite3_mutex_held(pBt->mutex) );
66470 if( pBt->nPage>0 ){
66473 pP1 = pBt->pPage1;
66480 data[16] = (u8)((pBt->pageSize>>8)&0xff);
66481 data[17] = (u8)((pBt->pageSize>>16)&0xff);
66484 assert( pBt->usableSize<=pBt->pageSize && pBt->usableSize+255>=pBt->pageSize);
66485 data[20] = (u8)(pBt->pageSize - pBt->usableSize);
66491 pBt->btsFlags |= BTS_PAGESIZE_FIXED;
66493 assert( pBt->autoVacuum==1 || pBt->autoVacuum==0 );
66494 assert( pBt->incrVacuum==1 || pBt->incrVacuum==0 );
66495 put4byte(&data[36 + 4*4], pBt->autoVacuum);
66496 put4byte(&data[36 + 7*4], pBt->incrVacuum);
66498 pBt->nPage = 1;
66511 p->pBt->nPage = 0;
66512 rc = newDatabase(p->pBt);
66553 BtShared *pBt = p->pBt;
66566 assert( pBt->inTransaction==TRANS_WRITE || IfNotOmitAV(pBt->bDoTruncate)==0 );
66569 && sqlite3PagerIsreadonly(pBt->pPager)==0
66571 pBt->btsFlags &= ~BTS_READ_ONLY;
66575 if( (pBt->btsFlags & BTS_READ_ONLY)!=0 && wrflag ){
66587 if( (wrflag && pBt->inTransaction==TRANS_WRITE)
66588 || (pBt->btsFlags & BTS_PENDING)!=0
66590 pBlock = pBt->pWriter->db;
66593 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
66614 pBt->btsFlags &= ~BTS_INITIALLY_EMPTY;
66615 if( pBt->nPage==0 ) pBt->btsFlags |= BTS_INITIALLY_EMPTY;
66624 while( pBt->pPage1==0 && SQLITE_OK==(rc = lockBtree(pBt)) );
66627 if( (pBt->btsFlags & BTS_READ_ONLY)!=0 ){
66630 rc = sqlite3PagerBegin(pBt->pPager,wrflag>1,sqlite3TempInMemory(p->db));
66632 rc = newDatabase(pBt);
66633 }else if( rc==SQLITE_BUSY_SNAPSHOT && pBt->inTransaction==TRANS_NONE ){
66643 unlockBtreeIfUnused(pBt);
66645 }while( (rc&0xFF)==SQLITE_BUSY && pBt->inTransaction==TRANS_NONE &&
66646 btreeInvokeBusyHandler(pBt) );
66647 sqlite3PagerResetLockTimeout(pBt->pPager);
66651 pBt->nTransaction++;
66656 p->lock.pNext = pBt->pLock;
66657 pBt->pLock = &p->lock;
66662 if( p->inTrans>pBt->inTransaction ){
66663 pBt->inTransaction = p->inTrans;
66666 MemPage *pPage1 = pBt->pPage1;
66668 assert( !pBt->pWriter );
66669 pBt->pWriter = p;
66670 pBt->btsFlags &= ~BTS_EXCLUSIVE;
66671 if( wrflag>1 ) pBt->btsFlags |= BTS_EXCLUSIVE;
66680 if( pBt->nPage!=get4byte(&pPage1->aData[28]) ){
66683 put4byte(&pPage1->aData[28], pBt->nPage);
66692 *pSchemaVersion = get4byte(&pBt->pPage1->aData[40]);
66699 rc = sqlite3PagerOpenSavepoint(pBt->pPager, p->db->nSavepoint);
66719 BtShared *pBt = pPage->pBt;
66722 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
66734 ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
66740 ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
66761 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
66784 if( pCell+info.nSize > pPage->aData+pPage->pBt->usableSize ){
66822 BtShared *pBt, /* Btree */
66831 Pager *pPager = pBt->pPager;
66836 assert( sqlite3_mutex_held(pBt->mutex) );
66837 assert( pDbPage->pBt==pBt );
66865 ptrmapPut(pBt, nextOvfl, PTRMAP_OVERFLOW2, iFreePage, &rc);
66877 rc = btreeGetPage(pBt, iPtrPage, &pPtrPage, 0);
66889 ptrmapPut(pBt, iFreePage, eType, iPtrPage, &rc);
66915 static int incrVacuumStep(BtShared *pBt, Pgno nFin, Pgno iLastPg, int bCommit){
66919 assert( sqlite3_mutex_held(pBt->mutex) );
66922 if( !PTRMAP_ISPAGE(pBt, iLastPg) && iLastPg!=PENDING_BYTE_PAGE(pBt) ){
66926 nFreeList = get4byte(&pBt->pPage1->aData[36]);
66931 rc = ptrmapGet(pBt, iLastPg, &eType, &iPtrPage);
66948 rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, iLastPg, BTALLOC_EXACT);
66961 rc = btreeGetPage(pBt, iLastPg, &pLastPg, 0);
66979 rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, iNear, eMode);
66988 rc = relocatePage(pBt, pLastPg, eType, iPtrPage, iFreePg, bCommit);
66999 }while( iLastPg==PENDING_BYTE_PAGE(pBt) || PTRMAP_ISPAGE(pBt, iLastPg) );
67000 pBt->bDoTruncate = 1;
67001 pBt->nPage = iLastPg;
67011 static Pgno finalDbSize(BtShared *pBt, Pgno nOrig, Pgno nFree){
67016 nEntry = pBt->usableSize/5;
67017 nPtrmap = (nFree-nOrig+PTRMAP_PAGENO(pBt, nOrig)+nEntry)/nEntry;
67019 if( nOrig>PENDING_BYTE_PAGE(pBt) && nFin<PENDING_BYTE_PAGE(pBt) ){
67022 while( PTRMAP_ISPAGE(pBt, nFin) || nFin==PENDING_BYTE_PAGE(pBt) ){
67039 BtShared *pBt = p->pBt;
67042 assert( pBt->inTransaction==TRANS_WRITE && p->inTrans==TRANS_WRITE );
67043 if( !pBt->autoVacuum ){
67046 Pgno nOrig = btreePagecount(pBt);
67047 Pgno nFree = get4byte(&pBt->pPage1->aData[36]);
67048 Pgno nFin = finalDbSize(pBt, nOrig, nFree);
67053 rc = saveAllCursors(pBt, 0, 0);
67055 invalidateAllOverflowCache(pBt);
67056 rc = incrVacuumStep(pBt, nFin, nOrig, 0);
67059 rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
67060 put4byte(&pBt->pPage1->aData[28], pBt->nPage);
67079 static int autoVacuumCommit(BtShared *pBt){
67081 Pager *pPager = pBt->pPager;
67084 assert( sqlite3_mutex_held(pBt->mutex) );
67085 invalidateAllOverflowCache(pBt);
67086 assert(pBt->autoVacuum);
67087 if( !pBt->incrVacuum ){
67093 nOrig = btreePagecount(pBt);
67094 if( PTRMAP_ISPAGE(pBt, nOrig) || nOrig==PENDING_BYTE_PAGE(pBt) ){
67102 nFree = get4byte(&pBt->pPage1->aData[36]);
67103 nFin = finalDbSize(pBt, nOrig, nFree);
67106 rc = saveAllCursors(pBt, 0, 0);
67109 rc = incrVacuumStep(pBt, nFin, iFree, 1);
67112 rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
67113 put4byte(&pBt->pPage1->aData[32], 0);
67114 put4byte(&pBt->pPage1->aData[36], 0);
67115 put4byte(&pBt->pPage1->aData[28], nFin);
67116 pBt->bDoTruncate = 1;
67117 pBt->nPage = nFin;
67161 BtShared *pBt = p->pBt;
67164 if( pBt->autoVacuum ){
67165 rc = autoVacuumCommit(pBt);
67171 if( pBt->bDoTruncate ){
67172 sqlite3PagerTruncateImage(pBt->pPager, pBt->nPage);
67175 rc = sqlite3PagerCommitPhaseOne(pBt->pPager, zMaster, 0);
67186 BtShared *pBt = p->pBt;
67191 pBt->bDoTruncate = 0;
67206 pBt->nTransaction--;
67207 if( 0==pBt->nTransaction ){
67208 pBt->inTransaction = TRANS_NONE;
67215 unlockBtreeIfUnused(pBt);
67258 BtShared *pBt = p->pBt;
67259 assert( pBt->inTransaction==TRANS_WRITE );
67260 assert( pBt->nTransaction>0 );
67261 rc = sqlite3PagerCommitPhaseTwo(pBt->pPager);
67267 pBt->inTransaction = TRANS_READ;
67268 btreeClearHasContent(pBt);
67323 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
67357 BtShared *pBt = p->pBt;
67364 rc = tripCode = saveAllCursors(pBt, 0, 0);
67379 assert( TRANS_WRITE==pBt->inTransaction );
67380 rc2 = sqlite3PagerRollback(pBt->pPager);
67388 if( btreeGetPage(pBt, 1, &pPage1, 0)==SQLITE_OK ){
67391 if( nPage==0 ) sqlite3PagerPagecount(pBt->pPager, &nPage);
67392 testcase( pBt->nPage!=nPage );
67393 pBt->nPage = nPage;
67396 assert( countValidCursors(pBt, 1)==0 );
67397 pBt->inTransaction = TRANS_READ;
67398 btreeClearHasContent(pBt);
67426 BtShared *pBt = p->pBt;
67429 assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
67432 assert( pBt->inTransaction==TRANS_WRITE );
67438 rc = sqlite3PagerOpenSavepoint(pBt->pPager, iStatement);
67458 BtShared *pBt = p->pBt;
67463 rc = saveAllCursors(pBt, 0, 0);
67466 rc = sqlite3PagerSavepoint(pBt->pPager, op, iSavepoint);
67469 if( iSavepoint<0 && (pBt->btsFlags & BTS_INITIALLY_EMPTY)!=0 ){
67470 pBt->nPage = 0;
67472 rc = newDatabase(pBt);
67473 pBt->nPage = get4byte(28 + pBt->pPage1->aData);
67478 assert( pBt->nPage>0 );
67534 BtShared *pBt = p->pBt; /* Shared b-tree handle */
67553 assert( pBt->pPage1 && pBt->pPage1->aData );
67554 assert( wrFlag==0 || (pBt->btsFlags & BTS_READ_ONLY)==0 );
67557 allocateTempSpace(pBt);
67558 if( pBt->pTmpSpace==0 ) return SQLITE_NOMEM_BKPT;
67560 if( iTable==1 && btreePagecount(pBt)==0 ){
67571 pCur->pBt = pBt;
67576 for(pX=pBt->pCursor; pX; pX=pX->pNext){
67582 pCur->pNext = pBt->pCursor;
67583 pBt->pCursor = pCur;
67636 BtShared *pBt = pCur->pBt;
67638 assert( pBt->pCursor!=0 );
67639 if( pBt->pCursor==pCur ){
67640 pBt->pCursor = pCur->pNext;
67642 BtCursor *pPrev = pBt->pCursor;
67652 unlockBtreeIfUnused(pBt);
67734 return (i64)pCur->pBt->pageSize*((i64)pCur->pPage->pgno - 1) +
67771 return pCur->pBt->pageSize * (sqlite3_int64)pCur->pBt->nPage;
67794 BtShared *pBt, /* The database file */
67803 assert( sqlite3_mutex_held(pBt->mutex) );
67813 if( pBt->autoVacuum ){
67818 while( PTRMAP_ISPAGE(pBt, iGuess) || iGuess==PENDING_BYTE_PAGE(pBt) ){
67822 if( iGuess<=btreePagecount(pBt) ){
67823 rc = ptrmapGet(pBt, iGuess, &eType, &pgno);
67834 rc = btreeGetPage(pBt, ovfl, &pPage, (ppPage==0) ? PAGER_GET_READONLY : 0);
67922 BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */
67938 if( (uptr)(aPayload - pPage->aData) > (pBt->usableSize - pCur->info.nLocal) ){
67963 const u32 ovflSize = pBt->usableSize - 4; /* Bytes content per ovfl page */
68019 assert( pCur->pBtree->db==pBt->db );
68023 rc = getOverflowPage(pBt, nextPage, 0, &nextPage);
68051 && sqlite3PagerDirectReadOk(pBt->pPager, nextPage) /* (3,4,5) */
68054 sqlite3_file *fd = sqlite3PagerFile(pBt->pPager);
68059 rc = sqlite3OsRead(fd, aWrite, a+4, (i64)pBt->pageSize*(nextPage-1));
68067 rc = sqlite3PagerGet(pBt->pPager, nextPage, &pDbPage,
68222 BtShared *pBt = pCur->pBt;
68237 return getAndInitPage(pBt, newPgno, &pCur->pPage, pCur, pCur->curPagerFlags);
68343 rc = getAndInitPage(pCur->pBtree->pBt, pCur->pgnoRoot, &pCur->pPage,
68713 if( nCell<2 || nCell/pCur->pBt->usableSize>pCur->pBt->nPage ){
69034 BtShared *pBt, /* The btree */
69048 assert( sqlite3_mutex_held(pBt->mutex) );
69049 assert( eMode==BTALLOC_ANY || (nearby>0 && IfNotOmitAV(pBt->autoVacuum)) );
69050 pPage1 = pBt->pPage1;
69051 mxPage = btreePagecount(pBt);
69074 assert( pBt->autoVacuum );
69075 rc = ptrmapGet(pBt, nearby, &eType, 0);
69115 rc = btreeGetUnusedPage(pBt, iTrunk, &pTrunk, 0);
69140 }else if( k>(u32)(pBt->usableSize/4 - 2) ){
69180 rc = btreeGetUnusedPage(pBt, iNewTrunk, &pNewTrunk, 0);
69259 noContent = !btreeGetHasContent(pBt, *pPgno)? PAGER_GET_NOCONTENT : 0;
69260 rc = btreeGetUnusedPage(pBt, *pPgno, ppPage, noContent);
69293 int bNoContent = (0==IfNotOmitAV(pBt->bDoTruncate))? PAGER_GET_NOCONTENT:0;
69295 rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
69297 pBt->nPage++;
69298 if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ) pBt->nPage++;
69301 if( pBt->autoVacuum && PTRMAP_ISPAGE(pBt, pBt->nPage) ){
69307 TRACE(("ALLOCATE: %d from end of file (pointer-map page)\n", pBt->nPage));
69308 assert( pBt->nPage!=PENDING_BYTE_PAGE(pBt) );
69309 rc = btreeGetUnusedPage(pBt, pBt->nPage, &pPg, bNoContent);
69315 pBt->nPage++;
69316 if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ){ pBt->nPage++; }
69319 put4byte(28 + (u8*)pBt->pPage1->aData, pBt->nPage);
69320 *pPgno = pBt->nPage;
69322 assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
69323 rc = btreeGetUnusedPage(pBt, *pPgno, ppPage, bNoContent);
69333 assert( CORRUPT_DB || *pPgno!=PENDING_BYTE_PAGE(pBt) );
69355 static int freePage2(BtShared *pBt, MemPage *pMemPage, Pgno iPage){
69358 MemPage *pPage1 = pBt->pPage1; /* Local reference to page 1 */
69363 assert( sqlite3_mutex_held(pBt->mutex) );
69367 if( iPage<2 || iPage>pBt->nPage ){
69374 pPage = btreePageLookup(pBt, iPage);
69383 if( pBt->btsFlags & BTS_SECURE_DELETE ){
69387 if( (!pPage && ((rc = btreeGetPage(pBt, iPage, &pPage, 0))!=0) )
69392 memset(pPage->aData, 0, pPage->pBt->pageSize);
69399 ptrmapPut(pBt, iPage, PTRMAP_FREEPAGE, 0, &rc);
69414 rc = btreeGetPage(pBt, iTrunk, &pTrunk, 0);
69420 assert( pBt->usableSize>32 );
69421 if( nLeaf > (u32)pBt->usableSize/4 - 2 ){
69425 if( nLeaf < (u32)pBt->usableSize/4 - 8 ){
69449 if( pPage && (pBt->btsFlags & BTS_SECURE_DELETE)==0 ){
69452 rc = btreeSetHasContent(pBt, iPage);
69465 if( pPage==0 && SQLITE_OK!=(rc = btreeGetPage(pBt, iPage, &pPage, 0)) ){
69487 *pRC = freePage2(pPage->pBt, pPage, pPage->pgno);
69500 BtShared *pBt;
69506 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
69518 pBt = pPage->pBt;
69519 assert( pBt->usableSize > 4 );
69520 ovflPageSize = pBt->usableSize - 4;
69528 if( ovflPgno<2 || ovflPgno>btreePagecount(pBt) ){
69535 rc = getOverflowPage(pBt, ovflPgno, &pOvfl, &iNext);
69539 if( ( pOvfl || ((pOvfl = btreePageLookup(pBt, ovflPgno))!=0) )
69554 rc = freePage2(pBt, pOvfl, ovflPgno);
69591 BtShared *pBt;
69595 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
69599 assert( pCell<pPage->aData || pCell>=&pPage->aData[pPage->pBt->pageSize]
69639 n = mn + (nPayload - mn) % (pPage->pBt->usableSize - 4);
69648 pBt = pPage->pBt;
69684 assert( pPayload<pPage->aData || pPayload>=&pPage->aData[pBt->pageSize]
69705 if( pBt->autoVacuum ){
69709 PTRMAP_ISPAGE(pBt, pgnoOvfl) || pgnoOvfl==PENDING_BYTE_PAGE(pBt)
69713 rc = allocateBtreePage(pBt, &pOvfl, &pgnoOvfl, pgnoOvfl, 0);
69725 if( pBt->autoVacuum && rc==SQLITE_OK ){
69727 ptrmapPut(pBt, pgnoOvfl, eType, pgnoPtrmap, &rc);
69744 assert( pPrior<pPage->aData || pPrior>=&pPage->aData[pBt->pageSize]
69753 spaceLeft = pBt->usableSize - 4;
69779 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
69786 testcase( pc+sz==pPage->pBt->usableSize );
69787 if( pc+sz > pPage->pBt->usableSize ){
69800 put2byte(&data[hdr+5], pPage->pBt->usableSize);
69801 pPage->nFree = pPage->pBt->usableSize - pPage->hdrOffset
69840 assert( MX_CELL(pPage->pBt)<=10921 );
69841 assert( pPage->nCell<=MX_CELL(pPage->pBt) || CORRUPT_DB );
69844 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
69890 assert( idx+sz <= (int)pPage->pBt->usableSize );
69911 if( pPage->pBt->autoVacuum ){
70069 const int usableSize = pPg->pBt->usableSize;
70075 u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager);
70223 u8 * const pEnd = &aData[pPg->pBt->usableSize];
70291 u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager);
70292 memcpy(pTmp, aData, pPg->pBt->usableSize);
70360 if( SQLITE_WITHIN(pCell, aData, &aData[pPg->pBt->usableSize]) ){
70401 BtShared *const pBt = pPage->pBt; /* B-Tree Database */
70406 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
70418 rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0);
70442 pNew->nFree = pBt->usableSize - pNew->cellOffset - 2 - szCell;
70454 ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno, &rc);
70508 BtShared *pBt = pPage->pBt;
70519 ptrmapGet(pBt, ovfl, &e, &n);
70524 ptrmapGet(pBt, child, &e, &n);
70530 ptrmapGet(pBt, child, &e, &n);
70557 BtShared * const pBt = pFrom->pBt;
70568 assert( get2byte(&aFrom[iFromHdr+5]) <= (int)pBt->usableSize );
70572 memcpy(&aTo[iData], &aFrom[iData], pBt->usableSize-iData);
70644 BtShared *pBt; /* The whole database */
70676 pBt = pParent->pBt;
70677 assert( sqlite3_mutex_held(pBt->mutex) );
70726 rc = getAndInitPage(pBt, pgno, &apOld[i], 0, 0);
70762 if( pBt->btsFlags & BTS_FAST_SECURE ){
70766 if( (iOff+szNew[i])>(int)pBt->usableSize ){
70781 nMaxCells = nOld*(MX_CELL(pBt) + ArraySize(pParent->apOvfl));
70790 + pBt->pageSize; /* aSpace1 */
70792 assert( szScratch<=7*(int)pBt->pageSize );
70884 assert( sz<=pBt->maxLocal+23 );
70885 assert( iSpace1 <= (int)pBt->pageSize );
70927 usableSpace = pBt->usableSize - 12 + leafCorrection;
71061 rc = allocateBtreePage(pBt, &pNew, &pgno, (bBulk ? 1 : pgno), 0);
71070 ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno, &rc);
71116 sqlite3PagerRekey(apNew[iBest]->pDbPage, pBt->nPage+iBest+1, 0);
71194 ptrmapPut(pBt, get4byte(pCell), PTRMAP_BTREE, pNew->pgno, &rc);
71250 assert( sz<=pBt->maxLocal+23 );
71251 assert( iOvflSpace <= (int)pBt->pageSize );
71354 ptrmapPut(pBt, key, PTRMAP_BTREE, apNew[i]->pgno, &rc);
71418 BtShared *pBt = pRoot->pBt; /* The BTree */
71421 assert( sqlite3_mutex_held(pBt->mutex) );
71429 rc = allocateBtreePage(pBt,&pChild,&pgnoChild,pRoot->pgno,0);
71432 ptrmapPut(pBt, pgnoChild, PTRMAP_BTREE, pRoot->pgno, &rc);
71473 const int nMin = pCur->pBt->usableSize * 2 / 3;
71560 u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
71645 BtShared *pBt; /* Btree */
71663 pBt = pPage->pBt;
71664 ovflPageSize = pBt->usableSize - 4;
71666 rc = btreeGetPage(pBt, ovflPgno, &pPage, 0);
71729 BtShared *pBt = p->pBt;
71742 && pBt->inTransaction==TRANS_WRITE
71743 && (pBt->btsFlags & BTS_READ_ONLY)==0 );
71765 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
71871 newCell = pBt->pTmpSpace;
71876 assert( szNew <= MX_CELL_SIZE(pBt) );
71992 BtShared *pBt = p->pBt;
72003 assert( pBt->inTransaction==TRANS_WRITE );
72004 assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
72032 || (pPage->nFree+cellSizePtr(pPage,pCell)+2)>(int)(pBt->usableSize*2/3)
72060 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
72102 assert( MX_CELL_SIZE(pBt) >= nCell );
72103 pTmp = pBt->pTmpSpace;
72175 BtShared *pBt = p->pBt;
72182 assert( pBt->inTransaction==TRANS_WRITE );
72183 assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
72186 rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0);
72191 if( pBt->autoVacuum ){
72200 invalidateAllOverflowCache(pBt);
72212 while( pgnoRoot==PTRMAP_PAGENO(pBt, pgnoRoot) ||
72213 pgnoRoot==PENDING_BYTE_PAGE(pBt) ){
72223 rc = allocateBtreePage(pBt, &pPageMove, &pgnoMove, pgnoRoot, BTALLOC_EXACT);
72241 rc = saveAllCursors(pBt, 0, 0);
72248 rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0);
72252 rc = ptrmapGet(pBt, pgnoRoot, &eType, &iPtrPage);
72262 rc = relocatePage(pBt, pRoot, eType, iPtrPage, pgnoMove, 0);
72269 rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0);
72283 ptrmapPut(pBt, pgnoRoot, PTRMAP_ROOTPAGE, 0, &rc);
72293 assert( sqlite3PagerIswriteable(pBt->pPage1->pDbPage) );
72301 rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0);
72313 assert( (pBt->openFlags & BTREE_SINGLE)==0 || pgnoRoot==2 );
72330 BtShared *pBt, /* The BTree that contains the table */
72342 assert( sqlite3_mutex_held(pBt->mutex) );
72343 if( pgno>btreePagecount(pBt) ){
72346 rc = getAndInitPage(pBt, pgno, &pPage, 0, 0);
72357 rc = clearDatabasePage(pBt, get4byte(pCell), 1, pnChange);
72364 rc = clearDatabasePage(pBt, get4byte(&pPage->aData[hdr+8]), 1, pnChange);
72398 BtShared *pBt = p->pBt;
72402 rc = saveAllCursors(pBt, (Pgno)iTable, 0);
72409 rc = clearDatabasePage(pBt, (Pgno)iTable, 0, pnChange);
72447 BtShared *pBt = p->pBt;
72452 if( iTable>btreePagecount(pBt) ){
72456 rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0);
72470 if( pBt->autoVacuum ){
72490 rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0);
72494 rc = relocatePage(pBt, pMove, PTRMAP_ROOTPAGE, 0, iTable, 0);
72500 rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0);
72515 while( maxRootPgno==PENDING_BYTE_PAGE(pBt)
72516 || PTRMAP_ISPAGE(pBt, maxRootPgno) ){
72519 assert( maxRootPgno!=PENDING_BYTE_PAGE(pBt) );
72559 BtShared *pBt = p->pBt;
72564 assert( pBt->pPage1 );
72568 *pMeta = sqlite3PagerDataVersion(pBt->pPager) + p->iDataVersion;
72570 *pMeta = get4byte(&pBt->pPage1->aData[36 + idx*4]);
72577 pBt->btsFlags |= BTS_READ_ONLY;
72589 BtShared *pBt = p->pBt;
72595 assert( pBt->pPage1!=0 );
72596 pP1 = pBt->pPage1->aData;
72597 rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
72602 assert( pBt->autoVacuum || iMeta==0 );
72604 pBt->incrVacuum = (u8)iMeta;
72692 return p->pBt->pPager;
72780 rc = ptrmapGet(pCheck->pBt, iChild, &ePtrmapType, &iPtrmapParent);
72821 if( pCheck->pBt->autoVacuum ){
72825 if( n>pCheck->pBt->usableSize/4-2 ){
72833 if( pCheck->pBt->autoVacuum ){
72848 if( pCheck->pBt->autoVacuum && N>0 ){
72953 BtShared *pBt; /* The BtShared object that owns pPage */
72966 pBt = pCheck->pBt;
72967 usableSize = pBt->usableSize;
72972 if( (rc = btreeGetPage(pBt, (Pgno)iPage, &pPage, 0))!=0 ){
73016 if( pBt->autoVacuum ){
73071 if( pBt->autoVacuum ){
73082 if( pBt->autoVacuum ){
73211 BtShared *pBt = p->pBt;
73212 u64 savedDbFlags = pBt->db->flags;
73217 assert( p->inTrans>TRANS_NONE && pBt->inTransaction>TRANS_NONE );
73218 VVA_ONLY( nRef = sqlite3PagerRefcount(pBt->pPager) );
73220 sCheck.pBt = pBt;
73221 sCheck.pPager = pBt->pPager;
73222 sCheck.nPage = btreePagecount(sCheck.pBt);
73242 sCheck.heap = (u32*)sqlite3PageMalloc( pBt->pageSize );
73248 i = PENDING_BYTE_PAGE(pBt);
73254 checkList(&sCheck, 1, get4byte(&pBt->pPage1->aData[32]),
73255 get4byte(&pBt->pPage1->aData[36]));
73261 if( pBt->autoVacuum ){
73265 mxInHdr = get4byte(&pBt->pPage1->aData[52]);
73272 }else if( get4byte(&pBt->pPage1->aData[64])!=0 ){
73278 testcase( pBt->db->flags & SQLITE_CellSizeCk );
73279 pBt->db->flags &= ~(u64)SQLITE_CellSizeCk;
73284 if( pBt->autoVacuum && aRoot[i]>1 ){
73290 pBt->db->flags = savedDbFlags;
73304 (PTRMAP_PAGENO(pBt, i)!=i || !pBt->autoVacuum) ){
73308 (PTRMAP_PAGENO(pBt, i)==i && pBt->autoVacuum) ){
73326 assert( nRef==sqlite3PagerRefcount(pBt->pPager) );
73340 assert( p->pBt->pPager!=0 );
73341 return sqlite3PagerFilename(p->pBt->pPager, 1);
73353 assert( p->pBt->pPager!=0 );
73354 return sqlite3PagerJournalname(p->pBt->pPager);
73377 BtShared *pBt = p->pBt;
73379 if( pBt->inTransaction!=TRANS_NONE ){
73382 rc = sqlite3PagerCheckpoint(pBt->pPager, p->db, eMode, pnLog, pnCkpt);
73426 BtShared *pBt = p->pBt;
73428 if( !pBt->pSchema && nBytes ){
73429 pBt->pSchema = sqlite3DbMallocZero(0, nBytes);
73430 pBt->xFreeSchema = xFree;
73433 return pBt->pSchema;
73511 VVA_ONLY(rc =) saveAllCursors(pCsr->pBt, pCsr->pgnoRoot, pCsr);
73524 assert( (pCsr->pBt->btsFlags & BTS_READ_ONLY)==0
73525 && pCsr->pBt->inTransaction==TRANS_WRITE );
73548 BtShared *pBt = pBtree->pBt;
73556 pBt->btsFlags &= ~BTS_NO_WAL;
73557 if( iVersion==1 ) pBt->btsFlags |= BTS_NO_WAL;
73561 u8 *aData = pBt->pPage1->aData;
73565 rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
73574 pBt->btsFlags &= ~BTS_NO_WAL;
73590 return (p->pBt->btsFlags & BTS_READ_ONLY)!=0;
73613 return p->pBt->nRef;
73724 return pDb->aDb[i].pBt;
73869 assert( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) );
73906 if( iDest==PENDING_BYTE_PAGE(p->pDest->pBt) ) continue;
73992 if( p->pDestDb && p->pSrc->pBt->inTransaction==TRANS_WRITE ){
74041 if( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ){
74101 if( nDestTruncate==(int)PENDING_BYTE_PAGE(p->pDest->pBt) ){
74129 nDestTruncate==(int)(PENDING_BYTE_PAGE(p->pDest->pBt)-1)
74141 if( iPg!=PENDING_BYTE_PAGE(p->pDest->pBt) ){
74315 assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
74351 assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
74407 pTo->pBt->btsFlags &= ~BTS_PAGESIZE_FIXED;
77922 if( i!=1 && sqlite3BtreeSharable(p->db->aDb[i].pBt) ){
77959 if( i!=1 && DbMaskTest(p->lockMask,i) && ALWAYS(aDb[i].pBt!=0) ){
77960 sqlite3BtreeEnter(aDb[i].pBt);
77979 if( i!=1 && DbMaskTest(p->lockMask,i) && ALWAYS(aDb[i].pBt!=0) ){
77980 sqlite3BtreeLeave(aDb[i].pBt);
78785 Btree *pBt = db->aDb[i].pBt;
78786 if( sqlite3BtreeIsInTrans(pBt) ){
78800 sqlite3BtreeEnter(pBt);
78801 pPager = sqlite3BtreePager(pBt);
78810 sqlite3BtreeLeave(pBt);
78834 if( 0==sqlite3Strlen30(sqlite3BtreeGetFilename(db->aDb[0].pBt))
78838 Btree *pBt = db->aDb[i].pBt;
78839 if( pBt ){
78840 rc = sqlite3BtreeCommitPhaseOne(pBt, 0);
78850 Btree *pBt = db->aDb[i].pBt;
78851 if( pBt ){
78852 rc = sqlite3BtreeCommitPhaseTwo(pBt, 0);
78868 char const *zMainFile = sqlite3BtreeGetFilename(db->aDb[0].pBt);
78919 Btree *pBt = db->aDb[i].pBt;
78920 if( sqlite3BtreeIsInTrans(pBt) ){
78921 char const *zFile = sqlite3BtreeGetJournalname(pBt);
78960 Btree *pBt = db->aDb[i].pBt;
78961 if( pBt ){
78962 rc = sqlite3BtreeCommitPhaseOne(pBt, zMaster);
78993 Btree *pBt = db->aDb[i].pBt;
78994 if( pBt ){
78995 sqlite3BtreeCommitPhaseTwo(pBt, 1);
79062 Btree *pBt = db->aDb[i].pBt;
79063 if( pBt ){
79065 rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_ROLLBACK, iSavepoint);
79068 rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_RELEASE, iSavepoint);
81823 Btree *pBt = db->aDb[i].pBt;
81824 if( pBt ){
81826 sqlite3BtreeEnter(pBt);
81827 nEntry = sqlite3PagerWalCallback(sqlite3BtreePager(pBt));
81828 sqlite3BtreeLeave(pBt);
86681 rc = sqlite3BtreeTripAllCursors(db->aDb[ii].pBt,
86690 rc = sqlite3BtreeSavepoint(db->aDb[ii].pBt, p1, iSavepoint);
86837 Btree *pBt;
86848 pBt = db->aDb[pOp->p1].pBt;
86850 if( pBt ){
86851 rc = sqlite3BtreeBeginTrans(pBt, pOp->p2, &iMeta);
86866 assert( sqlite3BtreeIsInTrans(pBt) );
86875 rc = sqlite3BtreeBeginStmt(pBt, p->iStatement);
86942 assert( db->aDb[iDb].pBt!=0 );
86945 sqlite3BtreeGetMeta(db->aDb[iDb].pBt, iCookie, (u32 *)&iMeta);
86970 assert( pDb->pBt!=0 );
86973 rc = sqlite3BtreeUpdateMeta(pDb->pBt, pOp->p2, pOp->p3);
87115 pX = pDb->pBt;
89195 rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved);
89237 db->aDb[pOp->p2].pBt, pOp->p1, (pOp->p3 ? &nChange : 0)
89297 assert( pDb->pBt!=0 );
89298 rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, pOp->p3);
89338 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
89491 z = sqlite3BtreeIntegrityCheck(db->aDb[pOp->p5].pBt, &aRoot[1], nRoot,
90199 Btree *pBt; /* Btree to change journal mode of */
90220 pBt = db->aDb[pOp->p1].pBt;
90221 pPager = sqlite3BtreePager(pBt);
90270 assert( sqlite3BtreeIsInTrans(pBt)==0 );
90272 rc = sqlite3BtreeSetVersion(pBt, (eNew==PAGER_JOURNALMODE_WAL ? 2 : 1));
90318 Btree *pBt;
90323 pBt = db->aDb[pOp->p1].pBt;
90324 rc = sqlite3BtreeIncrVacuum(pBt);
90384 rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock);
90799 pOut->u.i = sqlite3BtreeLastPage(db->aDb[pOp->p1].pBt);
90816 Btree *pBt;
90819 pBt = db->aDb[pOp->p1].pBt;
90822 newMax = sqlite3BtreeLastPage(pBt);
90825 pOut->u.i = sqlite3BtreeMaxPageCount(pBt, newMax);
92698 pSorter->pgsz = pgsz = sqlite3BtreeGetPageSize(db->aDb[0].pBt);
105869 assert( db->aDb[iDb].pBt!=0 );
106031 if( pNew->pBt ) sqlite3BtreeClose(pNew->pBt);
106032 pNew->pBt = 0;
106034 rc = sqlite3BtreeOpen(pVfs, "x\0", db, &pNew->pBt, 0, SQLITE_OPEN_MAIN_DB);
106088 rc = sqlite3BtreeOpen(pVfs, zPath, db, &pNew->pBt, 0, flags);
106098 pNew->pSchema = sqlite3SchemaGet(db, pNew->pBt);
106106 sqlite3BtreeEnter(pNew->pBt);
106107 pPager = sqlite3BtreePager(pNew->pBt);
106109 sqlite3BtreeSecureDelete(pNew->pBt,
106110 sqlite3BtreeSecureDelete(db->aDb[0].pBt,-1) );
106112 sqlite3BtreeSetPagerFlags(pNew->pBt,
106115 sqlite3BtreeLeave(pNew->pBt);
106149 if( nKey || sqlite3BtreeGetOptimalReserve(db->aDb[0].pBt)>0 ){
106187 if( db->aDb[iDb].pBt ){
106188 sqlite3BtreeClose(db->aDb[iDb].pBt);
106189 db->aDb[iDb].pBt = 0;
106240 if( pDb->pBt==0 ) continue;
106252 if( sqlite3BtreeIsInReadTrans(pDb->pBt) || sqlite3BtreeIsInBackup(pDb->pBt) ){
106257 sqlite3BtreeClose(pDb->pBt);
106258 pDb->pBt = 0;
106904 if( !sqlite3BtreeSharable(pParse->db->aDb[iDb].pBt) ) return;
107349 if( pDb->pBt==0 ){
108284 && !sqlite3BtreeIsReadonly(db->aDb[db->init.iDb].pBt)
111090 if( db->aDb[1].pBt==0 && !pParse->explain ){
111092 Btree *pBt;
111100 rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pBt, 0, flags);
111107 db->aDb[1].pBt = pBt;
111109 if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, -1, 0) ){
111127 assert( pParse->db->aDb[iDb].pBt!=0 || iDb==1 );
111147 if( pDb->pBt && (!zDb || 0==sqlite3StrICmp(zDb, pDb->zDbSName)) ){
112003 SQLITE_PRIVATE Schema *sqlite3SchemaGet(sqlite3 *db, Btree *pBt){
112005 if( pBt ){
112006 p = (Schema *)sqlite3BtreeSchema(pBt, sizeof(Schema), sqlite3SchemaClear);
121324 if( db->aDb[1].pBt!=0 ){
121325 if( !db->autoCommit || sqlite3BtreeIsInReadTrans(db->aDb[1].pBt) ){
121330 sqlite3BtreeClose(db->aDb[1].pBt);
121331 db->aDb[1].pBt = 0;
121413 if( pDb->pBt ){
121414 sqlite3BtreeSetPagerFlags(pDb->pBt,
121673 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
121690 Btree *pBt = pDb->pBt;
121691 assert( pBt!=0 );
121693 int size = ALWAYS(pBt) ? sqlite3BtreeGetPageSize(pBt) : 0;
121700 if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize,-1,0) ){
121716 Btree *pBt = pDb->pBt;
121718 assert( pBt!=0 );
121729 sqlite3BtreeSecureDelete(db->aDb[ii].pBt, b);
121732 b = sqlite3BtreeSecureDelete(pBt, b);
121796 pPager = sqlite3BtreePager(db->aDb[ii].pBt);
121801 pPager = sqlite3BtreePager(pDb->pBt);
121845 if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
121861 Pager *pPager = sqlite3BtreePager(pDb->pBt);
121883 Btree *pBt = pDb->pBt;
121884 assert( pBt!=0 );
121886 returnSingleInt(v, sqlite3BtreeGetAutoVacuum(pBt));
121896 rc = sqlite3BtreeSetAutoVacuum(pBt, eAuto);
121969 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
122001 sqlite3BtreeSetSpillSize(pDb->pBt,0));
122005 sqlite3BtreeSetSpillSize(pDb->pBt, size);
122041 if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
122042 sqlite3BtreeSetMmapLimit(db->aDb[ii].pBt, sz);
122171 Pager *pPager = sqlite3BtreePager(pDb->pBt);
122178 Pager *pPager = sqlite3BtreePager(pDb->pBt);
122404 if( db->aDb[i].pBt==0 ) continue;
122409 sqlite3BtreeGetFilename(db->aDb[i].pBt));
123288 Btree *pBt;
123292 pBt = db->aDb[i].pBt;
123293 if( pBt==0 || sqlite3BtreePager(pBt)==0 ){
123860 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
123889 if( pDb->pBt==0 ){
123899 sqlite3BtreeEnter(pDb->pBt);
123900 if( !sqlite3BtreeIsInReadTrans(pDb->pBt) ){
123901 rc = sqlite3BtreeBeginTrans(pDb->pBt, 0, 0);
123927 sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);
123972 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
124050 sqlite3BtreeCommit(pDb->pBt);
124052 sqlite3BtreeLeave(pDb->pBt);
124080 assert( sqlite3BtreeHoldsMutex(db->aDb[0].pBt) );
124091 assert( i==1 || sqlite3BtreeHoldsMutex(db->aDb[i].pBt) );
124139 Btree *pBt = db->aDb[iDb].pBt; /* Btree database to read cookie from */
124140 if( pBt==0 ) continue;
124145 if( !sqlite3BtreeIsInReadTrans(pBt) ){
124146 rc = sqlite3BtreeBeginTrans(pBt, 0, 0);
124157 sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&cookie);
124166 sqlite3BtreeCommit(pBt);
124275 Btree *pBt = db->aDb[i].pBt;
124276 if( pBt ){
124277 assert( sqlite3BtreeHoldsMutex(pBt) );
124278 rc = sqlite3BtreeSchemaLocked(pBt);
134080 pMain = db->aDb[iDb].pBt;
134104 pTemp = pDb->pBt;
134282 sqlite3BtreeClose(pDb->pBt);
134283 pDb->pBt = 0;
155384 Btree *pBt = db->aDb[i].pBt;
155385 if( pBt ){
155386 Pager *pPager = sqlite3BtreePager(pBt);
155410 Btree *pBt = db->aDb[i].pBt;
155411 if( pBt && sqlite3BtreeIsInTrans(pBt) ){
155412 Pager *pPager = sqlite3BtreePager(pBt);
155697 Btree *pBt = db->aDb[j].pBt;
155698 if( pBt && sqlite3BtreeIsInBackup(pBt) ) return 1;
155808 if( pDb->pBt ){
155809 sqlite3BtreeClose(pDb->pBt);
155810 pDb->pBt = 0;
155917 Btree *p = db->aDb[i].pBt;
156965 rc = sqlite3BtreeCheckpoint(db->aDb[i].pBt, eMode, pnLog, pnCkpt);
157788 rc = sqlite3BtreeOpen(db->pVfs, zOpen, db, &db->aDb[0].pBt, 0,
157797 sqlite3BtreeEnter(db->aDb[0].pBt);
157798 db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt);
157800 sqlite3BtreeLeave(db->aDb[0].pBt);
157906 sqlite3PagerLockingMode(sqlite3BtreePager(db->aDb[0].pBt),
158581 sqlite3BtreeSetPageSize(db->aDb[0].pBt, 0, x, 0);
158781 return iDb<0 ? 0 : db->aDb[iDb].pBt;
158789 Btree *pBt;
158796 pBt = sqlite3DbNameToBtree(db, zDbName);
158797 return pBt ? sqlite3BtreeGetFilename(pBt) : 0;
158805 Btree *pBt;
158812 pBt = sqlite3DbNameToBtree(db, zDbName);
158813 return pBt ? sqlite3BtreeIsReadonly(pBt) : -1;
158839 Btree *pBt = db->aDb[iDb].pBt;
158840 if( 0==sqlite3BtreeIsInTrans(pBt) ){
158841 rc = sqlite3BtreeBeginTrans(pBt, 0, 0);
158843 rc = sqlite3PagerSnapshotGet(sqlite3BtreePager(pBt), ppSnapshot);
158875 Btree *pBt = db->aDb[iDb].pBt;
158876 if( sqlite3BtreeIsInTrans(pBt)==0 ){
158877 Pager *pPager = sqlite3BtreePager(pBt);
158879 if( sqlite3BtreeIsInReadTrans(pBt) ){
158884 rc = sqlite3BtreeCommit(pBt);
158894 rc = sqlite3BtreeBeginTrans(pBt, 0, 0);
158927 Btree *pBt = db->aDb[iDb].pBt;
158928 if( 0==sqlite3BtreeIsInReadTrans(pBt) ){
158929 rc = sqlite3BtreeBeginTrans(pBt, 0, 0);
158931 rc = sqlite3PagerSnapshotRecover(sqlite3BtreePager(pBt));
158932 sqlite3BtreeCommit(pBt);
194201 static int statDecodePage(Btree *pBt, StatPage *p){
194224 szPage = sqlite3BtreeGetPageSize(pBt);
194244 sqlite3BtreeEnter(pBt);
194245 nUsable = szPage - sqlite3BtreeGetReserveNoMutex(pBt);
194246 sqlite3BtreeLeave(pBt);
194289 rc = sqlite3PagerGet(sqlite3BtreePager(pBt), iPrev, &pPg, 0);
194316 Btree *pBt = pTab->db->aDb[pTab->iDb].pBt;
194317 Pager *pPager = sqlite3BtreePager(pBt);
194322 pCsr->szPage = sqlite3BtreeGetPageSize(pBt);
194345 Btree *pBt = pTab->db->aDb[pCsr->iDb].pBt;
194346 Pager *pPager = sqlite3BtreePager(pBt);
194381 sqlite3BtreeEnter(pBt);
194382 nUsable = sqlite3BtreeGetPageSize(pBt) -
194383 sqlite3BtreeGetReserveNoMutex(pBt);
194384 sqlite3BtreeLeave(pBt);
194443 rc = statDecodePage(pBt, p);
194838 Btree *pBt;
194853 pBt = db->aDb[pCsr->iDb].pBt;
194854 if( pBt==0 ) return SQLITE_OK;
194855 pCsr->pPager = sqlite3BtreePager(pBt);
194856 pCsr->szPage = sqlite3BtreeGetPageSize(pBt);
194857 pCsr->mxPgno = sqlite3BtreeLastPage(pBt);
194925 Btree *pBt;
194948 pBt = pTab->db->aDb[iDb].pBt;
194949 if( pgno<1 || pBt==0 || pgno>(int)sqlite3BtreeLastPage(pBt) ){
194953 szPage = sqlite3BtreeGetPageSize(pBt);
194960 pPager = sqlite3BtreePager(pBt);
194988 Btree *pBt = db->aDb[i].pBt;
194989 if( pBt ) sqlite3BtreeBeginTrans(pBt, 1, 0);
