Lines Matching defs:pBt
9026 SQLITE_PRIVATE int sqlite3BtreeSetVersion(Btree *pBt, int iVersion);
9028 SQLITE_PRIVATE int sqlite3BtreeIsReadonly(Btree *pBt);
10321 Btree *pBt; /* The B*Tree structure for this database file */
13923 Btree *pBt; /* Separate file holding temporary table */
14475 Btree *pBt = db->aDb[i].pBt;
14476 if( pBt ){
14477 Pager *pPager = sqlite3BtreePager(pBt);
14566 if( db->aDb[i].pBt ){
14567 Pager *pPager = sqlite3BtreePager(db->aDb[i].pBt);
16816 void **pBt;
16830 pBt = (void**)&z[mem.nTitle];
16831 pHdr = (struct MemBlockHdr*)&pBt[mem.nBacktrace];
16847 memcpy(pBt, &aAddr[1], pHdr->nBacktrace*sizeof(void*));
16848 assert(pBt[0]);
16875 void **pBt;
16880 pBt = (void**)pHdr;
16881 pBt -= pHdr->nBacktraceSlots;
16897 z = (char*)pBt;
17038 void **pBt = (void**)pHdr;
17039 pBt -= pHdr->nBacktraceSlots;
17040 mem.xBacktrace((int)pHdr->iSize, pHdr->nBacktrace-1, &pBt[1]);
17051 void **pBt;
17066 pBt = (void**)pHdr;
17067 pBt -= pHdr->nBacktraceSlots;
17068 backtrace_symbols_fd(pBt, pHdr->nBacktrace, fileno(out));
50837 #define MX_CELL_SIZE(pBt) ((int)(pBt->pageSize-8))
50844 #define MX_CELL(pBt) ((pBt->pageSize-8)/6)
50886 ** stored in MemPage.pBt->mutex.
50906 BtShared *pBt; /* Pointer to BtShared that this page is part of */
50955 ** The pBt pointer itself may not be changed while there exists cursors
50962 BtShared *pBt; /* Sharable content of this btree */
50964 u8 sharable; /* True if we can share pBt with another db */
50965 u8 locked; /* True if db currently has pBt locked */
51107 ** found at self->pBt->mutex.
51111 BtShared *pBt; /* The BtShared this cursor points to */
51177 # define PENDING_BYTE_PAGE(pBt) PAGER_MJ_PGNO(pBt)
51194 #define PTRMAP_PAGENO(pBt, pgno) ptrmapPageno(pBt, pgno)
51196 #define PTRMAP_ISPAGE(pBt, pgno) (PTRMAP_PAGENO((pBt),(pgno))==(pgno))
51239 assert( p->pBt->inTransaction!=TRANS_NONE || p->pBt->nTransaction==0 ); \
51240 assert( p->pBt->inTransaction>=p->inTrans );
51251 #define ISAUTOVACUUM (pBt->autoVacuum)
51269 BtShared *pBt; /* The tree being checked out */
51270 Pager *pPager; /* The associated pager. Also accessible by pBt->pPager */
51299 assert( sqlite3_mutex_notheld(p->pBt->mutex) );
51302 sqlite3_mutex_enter(p->pBt->mutex);
51303 p->pBt->db = p->db;
51312 BtShared *pBt = p->pBt;
51314 assert( sqlite3_mutex_held(pBt->mutex) );
51316 assert( p->db==pBt->db );
51318 sqlite3_mutex_leave(pBt->mutex);
51343 ** Btree.pBt value. All elements of the list should belong to
51345 assert( p->pNext==0 || p->pNext->pBt>p->pBt );
51346 assert( p->pPrev==0 || p->pPrev->pBt<p->pBt );
51360 assert( (p->locked==0 && p->sharable) || p->pBt->db==p->db );
51370 if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){
51371 p->pBt->db = p->db;
51383 assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt );
51419 assert( p->sharable==0 || p->locked==0 || p->db==p->pBt->db );
51420 assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->pBt->mutex) );
51462 p = db->aDb[i].pBt;
51471 p = db->aDb[i].pBt;
51498 p = db->aDb[i].pBt;
51500 (p->wantToLock==0 || !sqlite3_mutex_held(p->pBt->mutex)) ){
51515 ** (2) if iDb!=1, then the mutex on db->aDb[iDb].pBt.
51527 p = db->aDb[iDb].pBt;
51545 p->pBt->db = p->db;
51550 Btree *p = db->aDb[i].pBt;
51552 p->pBt->db = p->db;
51705 Schema *pSchema = (Schema *)pBtree->pBt->pSchema;
51747 for(pLock=pBtree->pBt->pLock; pLock; pLock=pLock->pNext){
51782 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
51801 BtShared *pBt = p->pBt;
51813 assert( eLock==READ_LOCK || (p==pBt->pWriter && p->inTrans==TRANS_WRITE) );
51814 assert( eLock==READ_LOCK || pBt->inTransaction==TRANS_WRITE );
51824 if( pBt->pWriter!=p && (pBt->btsFlags & BTS_EXCLUSIVE)!=0 ){
51825 sqlite3ConnectionBlocked(p->db, pBt->pWriter->db);
51829 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
51844 assert( p==pBt->pWriter );
51845 pBt->btsFlags |= BTS_PENDING;
51873 BtShared *pBt = p->pBt;
51893 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
51910 pLock->pNext = pBt->pLock;
51911 pBt->pLock = pLock;
51937 BtShared *pBt = p->pBt;
51938 BtLock **ppIter = &pBt->pLock;
51946 assert( (pBt->btsFlags & BTS_EXCLUSIVE)==0 || pBt->pWriter==pLock->pBtree );
51959 assert( (pBt->btsFlags & BTS_PENDING)==0 || pBt->pWriter );
51960 if( pBt->pWriter==p ){
51961 pBt->pWriter = 0;
51962 pBt->btsFlags &= ~(BTS_EXCLUSIVE|BTS_PENDING);
51963 }else if( pBt->nTransaction==2 ){
51973 pBt->btsFlags &= ~BTS_PENDING;
51981 BtShared *pBt = p->pBt;
51982 if( pBt->pWriter==p ){
51984 pBt->pWriter = 0;
51985 pBt->btsFlags &= ~(BTS_EXCLUSIVE|BTS_PENDING);
51986 for(pLock=pBt->pLock; pLock; pLock=pLock->pNext){
52004 return sqlite3_mutex_held(p->pBt->mutex);
52010 ** on the shared btree structure pBt.
52016 ** on the shared btree structure pBt.
52018 static void invalidateAllOverflowCache(BtShared *pBt){
52020 assert( sqlite3_mutex_held(pBt->mutex) );
52021 for(p=pBt->pCursor; p; p=p->pNext){
52046 BtShared *pBt = pBtree->pBt;
52048 for(p=pBt->pCursor; p; p=p->pNext){
52095 static int btreeSetHasContent(BtShared *pBt, Pgno pgno){
52097 if( !pBt->pHasContent ){
52098 assert( pgno<=pBt->nPage );
52099 pBt->pHasContent = sqlite3BitvecCreate(pBt->nPage);
52100 if( !pBt->pHasContent ){
52104 if( rc==SQLITE_OK && pgno<=sqlite3BitvecSize(pBt->pHasContent) ){
52105 rc = sqlite3BitvecSet(pBt->pHasContent, pgno);
52117 static int btreeGetHasContent(BtShared *pBt, Pgno pgno){
52118 Bitvec *p = pBt->pHasContent;
52126 static void btreeClearHasContent(BtShared *pBt){
52127 sqlite3BitvecDestroy(pBt->pHasContent);
52128 pBt->pHasContent = 0;
52196 static int saveAllCursors(BtShared *pBt, Pgno iRoot, BtCursor *pExcept){
52198 assert( sqlite3_mutex_held(pBt->mutex) );
52199 assert( pExcept==0 || pExcept->pBt==pBt );
52200 for(p=pBt->pCursor; p; p=p->pNext){
52342 static Pgno ptrmapPageno(BtShared *pBt, Pgno pgno){
52345 assert( sqlite3_mutex_held(pBt->mutex) );
52347 nPagesPerMapPage = (pBt->usableSize/5)+1;
52350 if( ret==PENDING_BYTE_PAGE(pBt) ){
52366 static void ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent, int *pRC){
52375 assert( sqlite3_mutex_held(pBt->mutex) );
52377 assert( 0==PTRMAP_ISPAGE(pBt, PENDING_BYTE_PAGE(pBt)) );
52379 assert( pBt->autoVacuum );
52384 iPtrmap = PTRMAP_PAGENO(pBt, key);
52385 rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage);
52395 assert( offset <= (int)pBt->usableSize-5 );
52418 static int ptrmapGet(BtShared *pBt, Pgno key, u8 *pEType, Pgno *pPgno){
52425 assert( sqlite3_mutex_held(pBt->mutex) );
52427 iPtrmap = PTRMAP_PAGENO(pBt, key);
52428 rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage);
52439 assert( offset <= (int)pBt->usableSize-5 );
52473 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
52504 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
52551 surplus = minLocal + (nPayload - minLocal)%(pPage->pBt->usableSize - 4);
52613 nSize = minLocal + (nSize - minLocal) % (pPage->pBt->usableSize - 4);
52654 ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, pRC);
52682 assert( pPage->pBt!=0 );
52683 assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE );
52685 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
52686 temp = sqlite3PagerTempSpace(pPage->pBt->pPager);
52692 usableSize = pPage->pBt->usableSize;
52766 assert( pPage->pBt );
52767 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
52771 usableSize = pPage->pBt->usableSize;
52842 assert( top+nByte <= (int)pPage->pBt->usableSize );
52860 assert( pPage->pBt!=0 );
52863 assert( (start + size) <= (int)pPage->pBt->usableSize );
52864 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
52867 if( pPage->pBt->btsFlags & BTS_SECURE_DELETE ){
52884 iLast = pPage->pBt->usableSize - 4;
52906 assert( pbegin <= (int)pPage->pBt->usableSize-4 );
52949 BtShared *pBt; /* A copy of pPage->pBt */
52952 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
52956 pBt = pPage->pBt;
52960 pPage->maxLocal = pBt->maxLeaf;
52961 pPage->minLocal = pBt->minLeaf;
52965 pPage->maxLocal = pBt->maxLocal;
52966 pPage->minLocal = pBt->minLocal;
52970 pPage->max1bytePayload = pBt->max1bytePayload;
52985 assert( pPage->pBt!=0 );
52986 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
52995 BtShared *pBt; /* The main btree structure */
53003 pBt = pPage->pBt;
53008 assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
53009 pPage->maskPage = (u16)(pBt->pageSize - 1);
53011 usableSize = pBt->usableSize;
53017 if( pPage->nCell>MX_CELL(pBt) ){
53021 testcase( pPage->nCell==MX_CELL(pBt) );
53097 BtShared *pBt = pPage->pBt;
53105 assert( sqlite3_mutex_held(pBt->mutex) );
53106 if( pBt->btsFlags & BTS_SECURE_DELETE ){
53107 memset(&data[hdr], 0, pBt->usableSize - hdr);
53113 put2byte(&data[hdr+5], pBt->usableSize);
53114 pPage->nFree = (u16)(pBt->usableSize - first);
53117 pPage->aDataEnd = &data[pBt->usableSize];
53120 assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
53121 pPage->maskPage = (u16)(pBt->pageSize - 1);
53131 static MemPage *btreePageFromDbPage(DbPage *pDbPage, Pgno pgno, BtShared *pBt){
53135 pPage->pBt = pBt;
53142 ** Get a page from the pager. Initialize the MemPage.pBt and
53153 BtShared *pBt, /* The btree */
53162 assert( sqlite3_mutex_held(pBt->mutex) );
53163 rc = sqlite3PagerAcquire(pBt->pPager, pgno, (DbPage**)&pDbPage, flags);
53165 *ppPage = btreePageFromDbPage(pDbPage, pgno, pBt);
53171 ** already in the pager cache return NULL. Initialize the MemPage.pBt and
53174 static MemPage *btreePageLookup(BtShared *pBt, Pgno pgno){
53176 assert( sqlite3_mutex_held(pBt->mutex) );
53177 pDbPage = sqlite3PagerLookup(pBt->pPager, pgno);
53179 return btreePageFromDbPage(pDbPage, pgno, pBt);
53188 static Pgno btreePagecount(BtShared *pBt){
53189 return pBt->nPage;
53193 assert( ((p->pBt->nPage)&0x8000000)==0 );
53194 return btreePagecount(p->pBt);
53206 BtShared *pBt, /* The database file */
53212 assert( sqlite3_mutex_held(pBt->mutex) );
53215 if( pgno>btreePagecount(pBt) ){
53218 rc = btreeGetPage(pBt, pgno, ppPage, bReadonly);
53239 assert( pPage->pBt );
53243 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
53261 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
53279 BtShared *pBt = (BtShared*)pArg;
53280 assert( pBt->db );
53281 assert( sqlite3_mutex_held(pBt->db->mutex) );
53282 return sqlite3InvokeBusyHandler(&pBt->db->busyHandler);
53314 BtShared *pBt = 0; /* Shared part of btree structure */
53395 for(pBt=GLOBAL(BtShared*,sqlite3SharedCacheList); pBt; pBt=pBt->pNext){
53396 assert( pBt->nRef>0 );
53397 if( 0==strcmp(zFullPathname, sqlite3PagerFilename(pBt->pPager, 0))
53398 && sqlite3PagerVfs(pBt->pPager)==pVfs ){
53401 Btree *pExisting = db->aDb[iDb].pBt;
53402 if( pExisting && pExisting->pBt==pBt ){
53410 p->pBt = pBt;
53411 pBt->nRef++;
53430 if( pBt==0 ){
53442 pBt = sqlite3MallocZero( sizeof(*pBt) );
53443 if( pBt==0 ){
53447 rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename,
53450 sqlite3PagerSetMmapLimit(pBt->pPager, db->szMmap);
53451 rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader);
53456 pBt->openFlags = (u8)flags;
53457 pBt->db = db;
53458 sqlite3PagerSetBusyhandler(pBt->pPager, btreeInvokeBusyHandler, pBt);
53459 p->pBt = pBt;
53461 pBt->pCursor = 0;
53462 pBt->pPage1 = 0;
53463 if( sqlite3PagerIsreadonly(pBt->pPager) ) pBt->btsFlags |= BTS_READ_ONLY;
53465 pBt->btsFlags |= BTS_SECURE_DELETE;
53467 pBt->pageSize = (zDbHeader[16]<<8) | (zDbHeader[17]<<16);
53468 if( pBt->pageSize<512 || pBt->pageSize>SQLITE_MAX_PAGE_SIZE
53469 || ((pBt->pageSize-1)&pBt->pageSize)!=0 ){
53470 pBt->pageSize = 0;
53479 pBt->autoVacuum = (SQLITE_DEFAULT_AUTOVACUUM ? 1 : 0);
53480 pBt->incrVacuum = (SQLITE_DEFAULT_AUTOVACUUM==2 ? 1 : 0);
53486 pBt->btsFlags |= BTS_PAGESIZE_FIXED;
53488 pBt->autoVacuum = (get4byte(&zDbHeader[36 + 4*4])?1:0);
53489 pBt->incrVacuum = (get4byte(&zDbHeader[36 + 7*4])?1:0);
53492 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
53494 pBt->usableSize = pBt->pageSize - nReserve;
53495 assert( (pBt->pageSize & 7)==0 ); /* 8-byte alignment of pageSize */
53502 pBt->nRef = 1;
53505 pBt->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_FAST);
53506 if( pBt->mutex==0 ){
53513 pBt->pNext = GLOBAL(BtShared*,sqlite3SharedCacheList);
53514 GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt;
53523 ** The list is kept in ascending order by pBt address.
53529 if( (pSib = db->aDb[i].pBt)!=0 && pSib->sharable ){
53531 if( p->pBt<pSib->pBt ){
53536 while( pSib->pNext && pSib->pNext->pBt<p->pBt ){
53555 if( pBt && pBt->pPager ){
53556 sqlite3PagerClose(pBt->pPager);
53558 sqlite3_free(pBt);
53567 sqlite3PagerSetCachesize(p->pBt->pPager, SQLITE_DEFAULT_CACHE_SIZE);
53583 static int removeFromSharingList(BtShared *pBt){
53589 assert( sqlite3_mutex_notheld(pBt->mutex) );
53592 pBt->nRef--;
53593 if( pBt->nRef<=0 ){
53594 if( GLOBAL(BtShared*,sqlite3SharedCacheList)==pBt ){
53595 GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt->pNext;
53598 while( ALWAYS(pList) && pList->pNext!=pBt ){
53602 pList->pNext = pBt->pNext;
53606 sqlite3_mutex_free(pBt->mutex);
53618 ** Make sure pBt->pTmpSpace points to an allocation of
53619 ** MX_CELL_SIZE(pBt) bytes.
53621 static void allocateTempSpace(BtShared *pBt){
53622 if( !pBt->pTmpSpace ){
53623 pBt->pTmpSpace = sqlite3PageMalloc( pBt->pageSize );
53625 /* One of the uses of pBt->pTmpSpace is to format cells before
53635 if( pBt->pTmpSpace ) memset(pBt->pTmpSpace, 0, 4);
53640 ** Free the pBt->pTmpSpace allocation
53642 static void freeTempSpace(BtShared *pBt){
53643 sqlite3PageFree( pBt->pTmpSpace);
53644 pBt->pTmpSpace = 0;
53651 BtShared *pBt = p->pBt;
53657 pCur = pBt->pCursor;
53678 if( !p->sharable || removeFromSharingList(pBt) ){
53679 /* The pBt is no longer on the sharing list, so we can access
53684 assert( !pBt->pCursor );
53685 sqlite3PagerClose(pBt->pPager);
53686 if( pBt->xFreeSchema && pBt->pSchema ){
53687 pBt->xFreeSchema(pBt->pSchema);
53689 sqlite3DbFree(0, pBt->pSchema);
53690 freeTempSpace(pBt);
53691 sqlite3_free(pBt);
53721 BtShared *pBt = p->pBt;
53724 sqlite3PagerSetCachesize(pBt->pPager, mxPage);
53735 BtShared *pBt = p->pBt;
53738 sqlite3PagerSetMmapLimit(pBt->pPager, szMmap);
53757 BtShared *pBt = p->pBt;
53760 sqlite3PagerSetFlags(pBt->pPager, pgFlags);
53771 BtShared *pBt = p->pBt;
53775 assert( pBt && pBt->pPager );
53776 rc = sqlite3PagerNosync(pBt->pPager);
53803 BtShared *pBt = p->pBt;
53806 if( pBt->btsFlags & BTS_PAGESIZE_FIXED ){
53811 nReserve = pBt->pageSize - pBt->usableSize;
53817 assert( !pBt->pPage1 && !pBt->pCursor );
53818 pBt->pageSize = (u32)pageSize;
53819 freeTempSpace(pBt);
53821 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
53822 pBt->usableSize = pBt->pageSize - (u16)nReserve;
53823 if( iFix ) pBt->btsFlags |= BTS_PAGESIZE_FIXED;
53832 return p->pBt->pageSize;
53848 assert( sqlite3_mutex_held(p->pBt->mutex) );
53849 return p->pBt->pageSize - p->pBt->usableSize;
53862 n = p->pBt->pageSize - p->pBt->usableSize;
53875 n = sqlite3PagerMaxPageCount(p->pBt->pPager, mxPage);
53890 p->pBt->btsFlags &= ~BTS_SECURE_DELETE;
53891 if( newFlag ) p->pBt->btsFlags |= BTS_SECURE_DELETE;
53893 b = (p->pBt->btsFlags & BTS_SECURE_DELETE)!=0;
53909 BtShared *pBt = p->pBt;
53914 if( (pBt->btsFlags & BTS_PAGESIZE_FIXED)!=0 && (av ?1:0)!=pBt->autoVacuum ){
53917 pBt->autoVacuum = av ?1:0;
53918 pBt->incrVacuum = av==2 ?1:0;
53936 (!p->pBt->autoVacuum)?BTREE_AUTOVACUUM_NONE:
53937 (!p->pBt->incrVacuum)?BTREE_AUTOVACUUM_FULL:
53955 static int lockBtree(BtShared *pBt){
53962 assert( sqlite3_mutex_held(pBt->mutex) );
53963 assert( pBt->pPage1==0 );
53964 rc = sqlite3PagerSharedLock(pBt->pPager);
53966 rc = btreeGetPage(pBt, 1, &pPage1, 0);
53973 sqlite3PagerPagecount(pBt->pPager, &nPageFile);
53988 pBt->btsFlags |= BTS_READ_ONLY;
53995 pBt->btsFlags |= BTS_READ_ONLY;
54009 if( page1[19]==2 && (pBt->btsFlags & BTS_NO_WAL)==0 ){
54011 rc = sqlite3PagerOpenWal(pBt->pPager, &isOpen);
54039 if( (u32)pageSize!=pBt->pageSize ){
54042 ** actually pageSize. Unlock the database, leave pBt->pPage1 at
54047 pBt->usableSize = usableSize;
54048 pBt->pageSize = pageSize;
54049 freeTempSpace(pBt);
54050 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize,
54054 if( (pBt->db->flags & SQLITE_RecoveryMode)==0 && nPage>nPageFile ){
54061 pBt->pageSize = pageSize;
54062 pBt->usableSize = usableSize;
54064 pBt->autoVacuum = (get4byte(&page1[36 + 4*4])?1:0);
54065 pBt->incrVacuum = (get4byte(&page1[36 + 7*4])?1:0);
54082 pBt->maxLocal = (u16)((pBt->usableSize-12)*64/255 - 23);
54083 pBt->minLocal = (u16)((pBt->usableSize-12)*32/255 - 23);
54084 pBt->maxLeaf = (u16)(pBt->usableSize - 35);
54085 pBt->minLeaf = (u16)((pBt->usableSize-12)*32/255 - 23);
54086 if( pBt->maxLocal>127 ){
54087 pBt->max1bytePayload = 127;
54089 pBt->max1bytePayload = (u8)pBt->maxLocal;
54091 assert( pBt->maxLeaf + 23 <= MX_CELL_SIZE(pBt) );
54092 pBt->pPage1 = pPage1;
54093 pBt->nPage = nPage;
54098 pBt->pPage1 = 0;
54104 ** Return the number of cursors open on pBt. This is for use
54115 static int countValidCursors(BtShared *pBt, int wrOnly){
54118 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
54134 static void unlockBtreeIfUnused(BtShared *pBt){
54135 assert( sqlite3_mutex_held(pBt->mutex) );
54136 assert( countValidCursors(pBt,0)==0 || pBt->inTransaction>TRANS_NONE );
54137 if( pBt->inTransaction==TRANS_NONE && pBt->pPage1!=0 ){
54138 assert( pBt->pPage1->aData );
54139 assert( sqlite3PagerRefcount(pBt->pPager)==1 );
54140 assert( pBt->pPage1->aData );
54141 releasePage(pBt->pPage1);
54142 pBt->pPage1 = 0;
54147 ** If pBt points to an empty file then convert that empty file
54151 static int newDatabase(BtShared *pBt){
54156 assert( sqlite3_mutex_held(pBt->mutex) );
54157 if( pBt->nPage>0 ){
54160 pP1 = pBt->pPage1;
54167 data[16] = (u8)((pBt->pageSize>>8)&0xff);
54168 data[17] = (u8)((pBt->pageSize>>16)&0xff);
54171 assert( pBt->usableSize<=pBt->pageSize && pBt->usableSize+255>=pBt->pageSize);
54172 data[20] = (u8)(pBt->pageSize - pBt->usableSize);
54178 pBt->btsFlags |= BTS_PAGESIZE_FIXED;
54180 assert( pBt->autoVacuum==1 || pBt->autoVacuum==0 );
54181 assert( pBt->incrVacuum==1 || pBt->incrVacuum==0 );
54182 put4byte(&data[36 + 4*4], pBt->autoVacuum);
54183 put4byte(&data[36 + 7*4], pBt->incrVacuum);
54185 pBt->nPage = 1;
54198 p->pBt->nPage = 0;
54199 rc = newDatabase(p->pBt);
54241 BtShared *pBt = p->pBt;
54254 assert( pBt->inTransaction==TRANS_WRITE || IfNotOmitAV(pBt->bDoTruncate)==0 );
54257 if( (pBt->btsFlags & BTS_READ_ONLY)!=0 && wrflag ){
54267 if( (wrflag && pBt->inTransaction==TRANS_WRITE)
54268 || (pBt->btsFlags & BTS_PENDING)!=0
54270 pBlock = pBt->pWriter->db;
54273 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
54293 pBt->btsFlags &= ~BTS_INITIALLY_EMPTY;
54294 if( pBt->nPage==0 ) pBt->btsFlags |= BTS_INITIALLY_EMPTY;
54296 /* Call lockBtree() until either pBt->pPage1 is populated or
54298 ** may return SQLITE_OK but leave pBt->pPage1 set to 0 if after
54300 ** file is not pBt->pageSize. In this case lockBtree() will update
54301 ** pBt->pageSize to the page-size of the file on disk.
54303 while( pBt->pPage1==0 && SQLITE_OK==(rc = lockBtree(pBt)) );
54306 if( (pBt->btsFlags & BTS_READ_ONLY)!=0 ){
54309 rc = sqlite3PagerBegin(pBt->pPager,wrflag>1,sqlite3TempInMemory(p->db));
54311 rc = newDatabase(pBt);
54317 unlockBtreeIfUnused(pBt);
54319 }while( (rc&0xFF)==SQLITE_BUSY && pBt->inTransaction==TRANS_NONE &&
54320 btreeInvokeBusyHandler(pBt) );
54324 pBt->nTransaction++;
54329 p->lock.pNext = pBt->pLock;
54330 pBt->pLock = &p->lock;
54335 if( p->inTrans>pBt->inTransaction ){
54336 pBt->inTransaction = p->inTrans;
54339 MemPage *pPage1 = pBt->pPage1;
54341 assert( !pBt->pWriter );
54342 pBt->pWriter = p;
54343 pBt->btsFlags &= ~BTS_EXCLUSIVE;
54344 if( wrflag>1 ) pBt->btsFlags |= BTS_EXCLUSIVE;
54353 if( pBt->nPage!=get4byte(&pPage1->aData[28]) ){
54356 put4byte(&pPage1->aData[28], pBt->nPage);
54369 rc = sqlite3PagerOpenSavepoint(pBt->pPager, p->db->nSavepoint);
54388 BtShared *pBt = pPage->pBt;
54392 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
54406 ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
54412 ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
54435 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
54495 BtShared *pBt, /* Btree */
54504 Pager *pPager = pBt->pPager;
54509 assert( sqlite3_mutex_held(pBt->mutex) );
54510 assert( pDbPage->pBt==pBt );
54537 ptrmapPut(pBt, nextOvfl, PTRMAP_OVERFLOW2, iFreePage, &rc);
54549 rc = btreeGetPage(pBt, iPtrPage, &pPtrPage, 0);
54561 ptrmapPut(pBt, iFreePage, eType, iPtrPage, &rc);
54587 static int incrVacuumStep(BtShared *pBt, Pgno nFin, Pgno iLastPg, int bCommit){
54591 assert( sqlite3_mutex_held(pBt->mutex) );
54594 if( !PTRMAP_ISPAGE(pBt, iLastPg) && iLastPg!=PENDING_BYTE_PAGE(pBt) ){
54598 nFreeList = get4byte(&pBt->pPage1->aData[36]);
54603 rc = ptrmapGet(pBt, iLastPg, &eType, &iPtrPage);
54620 rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, iLastPg, BTALLOC_EXACT);
54633 rc = btreeGetPage(pBt, iLastPg, &pLastPg, 0);
54651 rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, iNear, eMode);
54660 rc = relocatePage(pBt, pLastPg, eType, iPtrPage, iFreePg, bCommit);
54671 }while( iLastPg==PENDING_BYTE_PAGE(pBt) || PTRMAP_ISPAGE(pBt, iLastPg) );
54672 pBt->bDoTruncate = 1;
54673 pBt->nPage = iLastPg;
54683 static Pgno finalDbSize(BtShared *pBt, Pgno nOrig, Pgno nFree){
54688 nEntry = pBt->usableSize/5;
54689 nPtrmap = (nFree-nOrig+PTRMAP_PAGENO(pBt, nOrig)+nEntry)/nEntry;
54691 if( nOrig>PENDING_BYTE_PAGE(pBt) && nFin<PENDING_BYTE_PAGE(pBt) ){
54694 while( PTRMAP_ISPAGE(pBt, nFin) || nFin==PENDING_BYTE_PAGE(pBt) ){
54711 BtShared *pBt = p->pBt;
54714 assert( pBt->inTransaction==TRANS_WRITE && p->inTrans==TRANS_WRITE );
54715 if( !pBt->autoVacuum ){
54718 Pgno nOrig = btreePagecount(pBt);
54719 Pgno nFree = get4byte(&pBt->pPage1->aData[36]);
54720 Pgno nFin = finalDbSize(pBt, nOrig, nFree);
54725 rc = saveAllCursors(pBt, 0, 0);
54727 invalidateAllOverflowCache(pBt);
54728 rc = incrVacuumStep(pBt, nFin, nOrig, 0);
54731 rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
54732 put4byte(&pBt->pPage1->aData[28], pBt->nPage);
54751 static int autoVacuumCommit(BtShared *pBt){
54753 Pager *pPager = pBt->pPager;
54756 assert( sqlite3_mutex_held(pBt->mutex) );
54757 invalidateAllOverflowCache(pBt);
54758 assert(pBt->autoVacuum);
54759 if( !pBt->incrVacuum ){
54765 nOrig = btreePagecount(pBt);
54766 if( PTRMAP_ISPAGE(pBt, nOrig) || nOrig==PENDING_BYTE_PAGE(pBt) ){
54774 nFree = get4byte(&pBt->pPage1->aData[36]);
54775 nFin = finalDbSize(pBt, nOrig, nFree);
54778 rc = saveAllCursors(pBt, 0, 0);
54781 rc = incrVacuumStep(pBt, nFin, iFree, 1);
54784 rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
54785 put4byte(&pBt->pPage1->aData[32], 0);
54786 put4byte(&pBt->pPage1->aData[36], 0);
54787 put4byte(&pBt->pPage1->aData[28], nFin);
54788 pBt->bDoTruncate = 1;
54789 pBt->nPage = nFin;
54817 ** This call is a no-op if no write-transaction is currently active on pBt.
54819 ** Otherwise, sync the database file for the btree pBt. zMaster points to
54833 BtShared *pBt = p->pBt;
54836 if( pBt->autoVacuum ){
54837 rc = autoVacuumCommit(pBt);
54843 if( pBt->bDoTruncate ){
54844 sqlite3PagerTruncateImage(pBt->pPager, pBt->nPage);
54847 rc = sqlite3PagerCommitPhaseOne(pBt->pPager, zMaster, 0);
54858 BtShared *pBt = p->pBt;
54863 pBt->bDoTruncate = 0;
54878 pBt->nTransaction--;
54879 if( 0==pBt->nTransaction ){
54880 pBt->inTransaction = TRANS_NONE;
54887 unlockBtreeIfUnused(pBt);
54930 BtShared *pBt = p->pBt;
54931 assert( pBt->inTransaction==TRANS_WRITE );
54932 assert( pBt->nTransaction>0 );
54933 rc = sqlite3PagerCommitPhaseTwo(pBt->pPager);
54938 pBt->inTransaction = TRANS_READ;
54939 btreeClearHasContent(pBt);
54982 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
55006 BtShared *pBt = p->pBt;
55011 rc = tripCode = saveAllCursors(pBt, 0, 0);
55023 assert( TRANS_WRITE==pBt->inTransaction );
55024 rc2 = sqlite3PagerRollback(pBt->pPager);
55032 if( btreeGetPage(pBt, 1, &pPage1, 0)==SQLITE_OK ){
55035 if( nPage==0 ) sqlite3PagerPagecount(pBt->pPager, &nPage);
55036 testcase( pBt->nPage!=nPage );
55037 pBt->nPage = nPage;
55040 assert( countValidCursors(pBt, 1)==0 );
55041 pBt->inTransaction = TRANS_READ;
55042 btreeClearHasContent(pBt);
55070 BtShared *pBt = p->pBt;
55073 assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
55076 assert( pBt->inTransaction==TRANS_WRITE );
55082 rc = sqlite3PagerOpenSavepoint(pBt->pPager, iStatement);
55102 BtShared *pBt = p->pBt;
55106 rc = sqlite3PagerSavepoint(pBt->pPager, op, iSavepoint);
55108 if( iSavepoint<0 && (pBt->btsFlags & BTS_INITIALLY_EMPTY)!=0 ){
55109 pBt->nPage = 0;
55111 rc = newDatabase(pBt);
55112 pBt->nPage = get4byte(28 + pBt->pPage1->aData);
55117 assert( pBt->nPage>0 );
55163 BtShared *pBt = p->pBt; /* Shared b-tree handle */
55178 assert( pBt->pPage1 && pBt->pPage1->aData );
55180 if( NEVER(wrFlag && (pBt->btsFlags & BTS_READ_ONLY)!=0) ){
55183 if( iTable==1 && btreePagecount(pBt)==0 ){
55194 pCur->pBt = pBt;
55197 pCur->pNext = pBt->pCursor;
55201 pBt->pCursor = pCur;
55251 BtShared *pBt = pCur->pBt;
55257 pBt->pCursor = pCur->pNext;
55265 unlockBtreeIfUnused(pBt);
55397 BtShared *pBt, /* The database file */
55406 assert( sqlite3_mutex_held(pBt->mutex) );
55416 if( pBt->autoVacuum ){
55421 while( PTRMAP_ISPAGE(pBt, iGuess) || iGuess==PENDING_BYTE_PAGE(pBt) ){
55425 if( iGuess<=btreePagecount(pBt) ){
55426 rc = ptrmapGet(pBt, iGuess, &eType, &pgno);
55437 rc = btreeGetPage(pBt, ovfl, &pPage, (ppPage==0) ? PAGER_GET_READONLY : 0);
55527 BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */
55546 || &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize]
55567 const u32 ovflSize = pBt->usableSize - 4; /* Bytes content per ovfl page */
55632 rc = getOverflowPage(pBt, nextPage, 0, &nextPage);
55664 && pBt->inTransaction==TRANS_READ /* (4) */
55665 && (fd = sqlite3PagerFile(pBt->pPager))->pMethods /* (3) */
55666 && pBt
55671 rc = sqlite3OsRead(fd, aWrite, a+4, (i64)pBt->pageSize*(nextPage-1));
55679 rc = sqlite3PagerAcquire(pBt->pPager, nextPage, &pDbPage,
55820 BtShared *pBt = pCur->pBt;
55829 rc = getAndInitPage(pBt, newPgno, &pNewPage,
55941 rc = getAndInitPage(pCur->pBtree->pBt, pCur->pgnoRoot, &pCur->apPage[0],
56551 BtShared *pBt, /* The btree */
56565 assert( sqlite3_mutex_held(pBt->mutex) );
56566 assert( eMode==BTALLOC_ANY || (nearby>0 && IfNotOmitAV(pBt->autoVacuum)) );
56567 pPage1 = pBt->pPage1;
56568 mxPage = btreePagecount(pBt);
56588 assert( pBt->autoVacuum );
56589 rc = ptrmapGet(pBt, nearby, &eType, 0);
56623 rc = btreeGetPage(pBt, iTrunk, &pTrunk, 0);
56647 }else if( k>(u32)(pBt->usableSize/4 - 2) ){
56687 rc = btreeGetPage(pBt, iNewTrunk, &pNewTrunk, 0);
56766 noContent = !btreeGetHasContent(pBt, *pPgno) ? PAGER_GET_NOCONTENT : 0;
56767 rc = btreeGetPage(pBt, *pPgno, ppPage, noContent);
56799 int bNoContent = (0==IfNotOmitAV(pBt->bDoTruncate)) ? PAGER_GET_NOCONTENT : 0;
56801 rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
56803 pBt->nPage++;
56804 if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ) pBt->nPage++;
56807 if( pBt->autoVacuum && PTRMAP_ISPAGE(pBt, pBt->nPage) ){
56813 TRACE(("ALLOCATE: %d from end of file (pointer-map page)\n", pBt->nPage));
56814 assert( pBt->nPage!=PENDING_BYTE_PAGE(pBt) );
56815 rc = btreeGetPage(pBt, pBt->nPage, &pPg, bNoContent);
56821 pBt->nPage++;
56822 if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ){ pBt->nPage++; }
56825 put4byte(28 + (u8*)pBt->pPage1->aData, pBt->nPage);
56826 *pPgno = pBt->nPage;
56828 assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
56829 rc = btreeGetPage(pBt, *pPgno, ppPage, bNoContent);
56838 assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
56869 static int freePage2(BtShared *pBt, MemPage *pMemPage, Pgno iPage){
56872 MemPage *pPage1 = pBt->pPage1; /* Local reference to page 1 */
56877 assert( sqlite3_mutex_held(pBt->mutex) );
56885 pPage = btreePageLookup(pBt, iPage);
56894 if( pBt->btsFlags & BTS_SECURE_DELETE ){
56898 if( (!pPage && ((rc = btreeGetPage(pBt, iPage, &pPage, 0))!=0) )
56903 memset(pPage->aData, 0, pPage->pBt->pageSize);
56910 ptrmapPut(pBt, iPage, PTRMAP_FREEPAGE, 0, &rc);
56925 rc = btreeGetPage(pBt, iTrunk, &pTrunk, 0);
56931 assert( pBt->usableSize>32 );
56932 if( nLeaf > (u32)pBt->usableSize/4 - 2 ){
56936 if( nLeaf < (u32)pBt->usableSize/4 - 8 ){
56955 if( pPage && (pBt->btsFlags & BTS_SECURE_DELETE)==0 ){
56958 rc = btreeSetHasContent(pBt, iPage);
56971 if( pPage==0 && SQLITE_OK!=(rc = btreeGetPage(pBt, iPage, &pPage, 0)) ){
56993 *pRC = freePage2(pPage->pBt, pPage, pPage->pgno);
57001 BtShared *pBt = pPage->pBt;
57008 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
57017 assert( pBt->usableSize > 4 );
57018 ovflPageSize = pBt->usableSize - 4;
57024 if( ovflPgno<2 || ovflPgno>btreePagecount(pBt) ){
57031 rc = getOverflowPage(pBt, ovflPgno, &pOvfl, &iNext);
57035 if( ( pOvfl || ((pOvfl = btreePageLookup(pBt, ovflPgno))!=0) )
57050 rc = freePage2(pBt, pOvfl, ovflPgno);
57090 BtShared *pBt = pPage->pBt;
57095 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
57099 assert( pCell<pPage->aData || pCell>=&pPage->aData[pBt->pageSize]
57141 if( pBt->autoVacuum ){
57145 PTRMAP_ISPAGE(pBt, pgnoOvfl) || pgnoOvfl==PENDING_BYTE_PAGE(pBt)
57149 rc = allocateBtreePage(pBt, &pOvfl, &pgnoOvfl, pgnoOvfl, 0);
57161 if( pBt->autoVacuum && rc==SQLITE_OK ){
57163 ptrmapPut(pBt, pgnoOvfl, eType, pgnoPtrmap, &rc);
57180 assert( pPrior<pPage->aData || pPrior>=&pPage->aData[pBt->pageSize]
57189 spaceLeft = pBt->usableSize - 4;
57200 assert( pPayload<pPage->aData || pPayload>=&pPage->aData[pBt->pageSize]
57244 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
57250 testcase( pc+sz==pPage->pBt->usableSize );
57251 if( pc < (u32)get2byte(&data[hdr+5]) || pc+sz > pPage->pBt->usableSize ){
57303 assert( MX_CELL(pPage->pBt)<=10921 );
57304 assert( pPage->nCell<=MX_CELL(pPage->pBt) || CORRUPT_DB );
57307 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
57342 assert( idx+sz <= (int)pPage->pBt->usableSize );
57353 if( pPage->pBt->autoVacuum ){
57378 const int nUsable = pPage->pBt->usableSize; /* Usable size of page */
57381 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
57382 assert( nCell>=0 && nCell<=(int)MX_CELL(pPage->pBt)
57383 && (int)MX_CELL(pPage->pBt)<=10921);
57446 BtShared *const pBt = pPage->pBt; /* B-Tree Database */
57451 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
57462 rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0);
57486 ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno, &rc);
57538 BtShared *pBt = pPage->pBt;
57549 ptrmapGet(pBt, ovfl, &e, &n);
57554 ptrmapGet(pBt, child, &e, &n);
57560 ptrmapGet(pBt, child, &e, &n);
57587 BtShared * const pBt = pFrom->pBt;
57598 assert( get2byte(&aFrom[iFromHdr+5]) <= (int)pBt->usableSize );
57602 memcpy(&aTo[iData], &aFrom[iData], pBt->usableSize-iData);
57676 BtShared *pBt; /* The whole database */
57704 pBt = pParent->pBt;
57705 assert( sqlite3_mutex_held(pBt->mutex) );
57758 rc = getAndInitPage(pBt, pgno, &apOld[i], 0);
57788 if( pBt->btsFlags & BTS_SECURE_DELETE ){
57792 if( (iOff+szNew[i])>(int)pBt->usableSize ){
57812 k = pBt->pageSize + ROUND8(sizeof(MemPage));
57816 + pBt->pageSize /* aSpace1 */
57852 MemPage *pOld = apCopy[i] = (MemPage*)&aSpace1[pBt->pageSize + k*i];
57855 memcpy(pOld->aData, apOld[i]->aData, pBt->pageSize);
57883 assert( sz<=pBt->maxLocal+23 );
57884 assert( iSpace1 <= (int)pBt->pageSize );
57922 usableSpace = pBt->usableSize - 12 + leafCorrection;
58008 rc = allocateBtreePage(pBt, &pNew, &pgno, (bBulk ? 1 : pgno), 0);
58015 ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno, &rc);
58135 assert( sz<=pBt->maxLocal+23 );
58136 assert( iOvflSpace <= (int)pBt->pageSize );
58256 ptrmapPut(pBt, get4byte(apCell[i]), PTRMAP_BTREE, pNew->pgno, &rc);
58267 ptrmapPut(pBt, key, PTRMAP_BTREE, apNew[i]->pgno, &rc);
58327 BtShared *pBt = pRoot->pBt; /* The BTree */
58330 assert( sqlite3_mutex_held(pBt->mutex) );
58338 rc = allocateBtreePage(pBt,&pChild,&pgnoChild,pRoot->pgno,0);
58341 ptrmapPut(pBt, pgnoChild, PTRMAP_BTREE, pRoot->pgno, &rc);
58382 const int nMin = pCur->pBt->usableSize * 2 / 3;
58461 u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
58529 BtShared *pBt = p->pBt;
58539 assert( (pCur->curFlags & BTCF_WriteFlag)!=0 && pBt->inTransaction==TRANS_WRITE
58540 && (pBt->btsFlags & BTS_READ_ONLY)==0 );
58561 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
58591 allocateTempSpace(pBt);
58592 newCell = pBt->pTmpSpace;
58597 assert( szNew <= MX_CELL_SIZE(pBt) );
58667 BtShared *pBt = p->pBt;
58675 assert( pBt->inTransaction==TRANS_WRITE );
58676 assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
58710 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
58738 assert( MX_CELL_SIZE(pBt) >= nCell );
58740 allocateTempSpace(pBt);
58741 pTmp = pBt->pTmpSpace;
58790 BtShared *pBt = p->pBt;
58797 assert( pBt->inTransaction==TRANS_WRITE );
58798 assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
58801 rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0);
58806 if( pBt->autoVacuum ){
58815 invalidateAllOverflowCache(pBt);
58827 while( pgnoRoot==PTRMAP_PAGENO(pBt, pgnoRoot) ||
58828 pgnoRoot==PENDING_BYTE_PAGE(pBt) ){
58837 rc = allocateBtreePage(pBt, &pPageMove, &pgnoMove, pgnoRoot, BTALLOC_EXACT);
58855 rc = saveAllCursors(pBt, 0, 0);
58862 rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0);
58866 rc = ptrmapGet(pBt, pgnoRoot, &eType, &iPtrPage);
58876 rc = relocatePage(pBt, pRoot, eType, iPtrPage, pgnoMove, 0);
58883 rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0);
58897 ptrmapPut(pBt, pgnoRoot, PTRMAP_ROOTPAGE, 0, &rc);
58907 assert( sqlite3PagerIswriteable(pBt->pPage1->pDbPage) );
58915 rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0);
58927 assert( (pBt->openFlags & BTREE_SINGLE)==0 || pgnoRoot==2 );
58944 BtShared *pBt, /* The BTree that contains the table */
58955 assert( sqlite3_mutex_held(pBt->mutex) );
58956 if( pgno>btreePagecount(pBt) ){
58960 rc = getAndInitPage(pBt, pgno, &pPage, 0);
58966 rc = clearDatabasePage(pBt, get4byte(pCell), 1, pnChange);
58973 rc = clearDatabasePage(pBt, get4byte(&pPage->aData[hdr+8]), 1, pnChange);
59005 BtShared *pBt = p->pBt;
59009 rc = saveAllCursors(pBt, (Pgno)iTable, 0);
59016 rc = clearDatabasePage(pBt, (Pgno)iTable, 0, pnChange);
59054 BtShared *pBt = p->pBt;
59067 if( NEVER(pBt->pCursor) ){
59068 sqlite3ConnectionBlocked(p->db, pBt->pCursor->pBtree->db);
59072 rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0);
59087 if( pBt->autoVacuum ){
59107 rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0);
59111 rc = relocatePage(pBt, pMove, PTRMAP_ROOTPAGE, 0, iTable, 0);
59117 rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0);
59132 while( maxRootPgno==PENDING_BYTE_PAGE(pBt)
59133 || PTRMAP_ISPAGE(pBt, maxRootPgno) ){
59136 assert( maxRootPgno!=PENDING_BYTE_PAGE(pBt) );
59177 BtShared *pBt = p->pBt;
59182 assert( pBt->pPage1 );
59185 *pMeta = get4byte(&pBt->pPage1->aData[36 + idx*4]);
59191 pBt->btsFlags |= BTS_READ_ONLY;
59203 BtShared *pBt = p->pBt;
59209 assert( pBt->pPage1!=0 );
59210 pP1 = pBt->pPage1->aData;
59211 rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
59216 assert( pBt->autoVacuum || iMeta==0 );
59218 pBt->incrVacuum = (u8)iMeta;
59306 return p->pBt->pPager;
59397 rc = ptrmapGet(pCheck->pBt, iChild, &ePtrmapType, &iPtrmapParent);
59444 if( pCheck->pBt->autoVacuum ){
59448 if( n>(int)pCheck->pBt->usableSize/4-2 ){
59456 if( pCheck->pBt->autoVacuum ){
59471 if( pCheck->pBt->autoVacuum && N>0 ){
59514 BtShared *pBt;
59525 pBt = pCheck->pBt;
59526 usableSize = pBt->usableSize;
59529 if( (rc = btreeGetPage(pBt, (Pgno)iPage, &pPage, 0))!=0 ){
59574 && (&pCell[info.iOverflow]<=&pPage->aData[pBt->usableSize])
59579 if( pBt->autoVacuum ){
59591 if( pBt->autoVacuum ){
59608 if( pBt->autoVacuum ){
59655 hit = sqlite3PageMalloc( pBt->pageSize );
59736 BtShared *pBt = p->pBt;
59740 assert( p->inTrans>TRANS_NONE && pBt->inTransaction>TRANS_NONE );
59741 nRef = sqlite3PagerRefcount(pBt->pPager);
59742 sCheck.pBt = pBt;
59743 sCheck.pPager = pBt->pPager;
59744 sCheck.nPage = btreePagecount(sCheck.pBt);
59760 i = PENDING_BYTE_PAGE(pBt);
59767 checkList(&sCheck, 1, get4byte(&pBt->pPage1->aData[32]),
59768 get4byte(&pBt->pPage1->aData[36]), "Main freelist: ");
59775 if( pBt->autoVacuum && aRoot[i]>1 ){
59794 (PTRMAP_PAGENO(pBt, i)!=i || !pBt->autoVacuum) ){
59798 (PTRMAP_PAGENO(pBt, i)==i && pBt->autoVacuum) ){
59808 if( NEVER(nRef != sqlite3PagerRefcount(pBt->pPager)) ){
59811 nRef, sqlite3PagerRefcount(pBt->pPager)
59838 assert( p->pBt->pPager!=0 );
59839 return sqlite3PagerFilename(p->pBt->pPager, 1);
59851 assert( p->pBt->pPager!=0 );
59852 return sqlite3PagerJournalname(p->pBt->pPager);
59875 BtShared *pBt = p->pBt;
59877 if( pBt->inTransaction!=TRANS_NONE ){
59880 rc = sqlite3PagerCheckpoint(pBt->pPager, eMode, pnLog, pnCkpt);
59924 BtShared *pBt = p->pBt;
59926 if( !pBt->pSchema && nBytes ){
59927 pBt->pSchema = sqlite3DbMallocZero(0, nBytes);
59928 pBt->xFreeSchema = xFree;
59931 return pBt->pSchema;
60009 VVA_ONLY(rc =) saveAllCursors(pCsr->pBt, pCsr->pgnoRoot, pCsr);
60022 assert( (pCsr->pBt->btsFlags & BTS_READ_ONLY)==0
60023 && pCsr->pBt->inTransaction==TRANS_WRITE );
60045 BtShared *pBt = pBtree->pBt;
60053 pBt->btsFlags &= ~BTS_NO_WAL;
60054 if( iVersion==1 ) pBt->btsFlags |= BTS_NO_WAL;
60058 u8 *aData = pBt->pPage1->aData;
60062 rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
60071 pBt->btsFlags &= ~BTS_NO_WAL;
60088 return (p->pBt->btsFlags & BTS_READ_ONLY)!=0;
60202 return pDb->aDb[i].pBt;
60324 assert( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) );
60361 if( iDest==PENDING_BYTE_PAGE(p->pDest->pBt) ) continue;
60444 if( p->pDestDb && p->pSrc->pBt->inTransaction==TRANS_WRITE ){
60483 if( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ){
60544 if( nDestTruncate==(int)PENDING_BYTE_PAGE(p->pDest->pBt) ){
60572 nDestTruncate==(int)(PENDING_BYTE_PAGE(p->pDest->pBt)-1)
60584 if( iPg!=PENDING_BYTE_PAGE(p->pDest->pBt) ){
60742 assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
60775 assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
60827 pTo->pBt->btsFlags &= ~BTS_PAGESIZE_FIXED;
63366 if( i!=1 && sqlite3BtreeSharable(p->db->aDb[i].pBt) ){
63403 if( i!=1 && DbMaskTest(p->lockMask,i) && ALWAYS(aDb[i].pBt!=0) ){
63404 sqlite3BtreeEnter(aDb[i].pBt);
63424 if( i!=1 && DbMaskTest(p->lockMask,i) && ALWAYS(aDb[i].pBt!=0) ){
63425 sqlite3BtreeLeave(aDb[i].pBt);
63975 if( pCx->pBt ){
63976 sqlite3BtreeClose(pCx->pBt);
64169 Btree *pBt = db->aDb[i].pBt;
64170 if( sqlite3BtreeIsInTrans(pBt) ){
64173 sqlite3BtreeEnter(pBt);
64174 rc = sqlite3PagerExclusiveLock(sqlite3BtreePager(pBt));
64175 sqlite3BtreeLeave(pBt);
64199 if( 0==sqlite3Strlen30(sqlite3BtreeGetFilename(db->aDb[0].pBt))
64203 Btree *pBt = db->aDb[i].pBt;
64204 if( pBt ){
64205 rc = sqlite3BtreeCommitPhaseOne(pBt, 0);
64215 Btree *pBt = db->aDb[i].pBt;
64216 if( pBt ){
64217 rc = sqlite3BtreeCommitPhaseTwo(pBt, 0);
64234 char const *zMainFile = sqlite3BtreeGetFilename(db->aDb[0].pBt);
64285 Btree *pBt = db->aDb[i].pBt;
64286 if( sqlite3BtreeIsInTrans(pBt) ){
64287 char const *zFile = sqlite3BtreeGetJournalname(pBt);
64292 if( !needSync && !sqlite3BtreeSyncDisabled(pBt) ){
64330 Btree *pBt = db->aDb[i].pBt;
64331 if( pBt ){
64332 rc = sqlite3BtreeCommitPhaseOne(pBt, zMaster);
64363 Btree *pBt = db->aDb[i].pBt;
64364 if( pBt ){
64365 sqlite3BtreeCommitPhaseTwo(pBt, 1);
64439 Btree *pBt = db->aDb[i].pBt;
64440 if( pBt ){
64442 rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_ROLLBACK, iSavepoint);
64445 rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_RELEASE, iSavepoint);
66617 Btree *pBt = db->aDb[i].pBt;
66618 if( pBt ){
66619 int nEntry = sqlite3PagerWalCallback(sqlite3BtreePager(pBt));
70899 sqlite3BtreeTripAllCursors(db->aDb[ii].pBt, SQLITE_ABORT);
70903 rc = sqlite3BtreeSavepoint(db->aDb[ii].pBt, p1, iSavepoint);
71060 Btree *pBt;
71072 pBt = db->aDb[pOp->p1].pBt;
71074 if( pBt ){
71075 rc = sqlite3BtreeBeginTrans(pBt, pOp->p2);
71088 assert( sqlite3BtreeIsInTrans(pBt) );
71097 rc = sqlite3BtreeBeginStmt(pBt, p->iStatement);
71108 sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&iMeta);
71161 assert( db->aDb[iDb].pBt!=0 );
71164 sqlite3BtreeGetMeta(db->aDb[iDb].pBt, iCookie, (u32 *)&iMeta);
71186 assert( pDb->pBt!=0 );
71191 rc = sqlite3BtreeUpdateMeta(pDb->pBt, pOp->p2, (int)pIn3->u.i);
71316 pX = pDb->pBt;
71420 rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pCx->pBt,
71423 rc = sqlite3BtreeBeginTrans(pCx->pBt, 1);
71434 rc = sqlite3BtreeCreateTable(pCx->pBt, &pgno, BTREE_BLOBKEY | pOp->p5);
71440 rc = sqlite3BtreeCursor(pCx->pBt, pgno, 1, pKeyInfo, pCx->pCursor);
71444 rc = sqlite3BtreeCursor(pCx->pBt, MASTER_ROOT, 1, 0, pCx->pCursor);
72982 rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved);
73022 db->aDb[pOp->p2].pBt, pOp->p1, (pOp->p3 ? &nChange : 0)
73093 assert( pDb->pBt!=0 );
73100 rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, flags);
73125 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
73259 z = sqlite3BtreeIntegrityCheck(db->aDb[pOp->p5].pBt, aRoot, nRoot,
73796 Btree *pBt; /* Btree to change journal mode of */
73797 Pager *pPager; /* Pager associated with pBt */
73816 pBt = db->aDb[pOp->p1].pBt;
73817 pPager = sqlite3BtreePager(pBt);
73866 assert( sqlite3BtreeIsInTrans(pBt)==0 );
73868 rc = sqlite3BtreeSetVersion(pBt, (eNew==PAGER_JOURNALMODE_WAL ? 2 : 1));
73911 Btree *pBt;
73916 pBt = db->aDb[pOp->p1].pBt;
73917 rc = sqlite3BtreeIncrVacuum(pBt);
73969 rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock);
74353 pOut->u.i = sqlite3BtreeLastPage(db->aDb[pOp->p1].pBt);
74370 Btree *pBt;
74372 pBt = db->aDb[pOp->p1].pBt;
74375 newMax = sqlite3BtreeLastPage(pBt);
74378 pOut->u.i = sqlite3BtreeMaxPageCount(pBt, newMax);
75346 nBuf = sqlite3BtreeGetPageSize(db->aDb[0].pBt);
75491 assert( pCsr->pKeyInfo && pCsr->pBt==0 );
75502 pgsz = sqlite3BtreeGetPageSize(db->aDb[0].pBt);
75659 int nBuf = sqlite3BtreeGetPageSize(db->aDb[0].pBt);
85234 assert( db->aDb[iDb].pBt!=0 );
85421 rc = sqlite3BtreeOpen(pVfs, zPath, db, &aNew->pBt, 0, flags);
85429 aNew->pSchema = sqlite3SchemaGet(db, aNew->pBt);
85437 pPager = sqlite3BtreePager(aNew->pBt);
85439 sqlite3BtreeSecureDelete(aNew->pBt,
85440 sqlite3BtreeSecureDelete(db->aDb[0].pBt,-1) );
85442 sqlite3BtreeSetPagerFlags(aNew->pBt, 3 | (db->flags & PAGER_FLAGS_MASK));
85476 if( nKey>0 || sqlite3BtreeGetReserve(db->aDb[0].pBt)>0 ){
85497 if( db->aDb[iDb].pBt ){
85498 sqlite3BtreeClose(db->aDb[iDb].pBt);
85499 db->aDb[iDb].pBt = 0;
85549 if( pDb->pBt==0 ) continue;
85566 if( sqlite3BtreeIsInReadTrans(pDb->pBt) || sqlite3BtreeIsInBackup(pDb->pBt) ){
85571 sqlite3BtreeClose(pDb->pBt);
85572 pDb->pBt = 0;
86566 if( pDb->pBt==0 ){
87436 && !sqlite3BtreeIsReadonly(db->aDb[db->init.iDb].pBt)
89860 /* if( db->aDb[0].pBt==0 ) return; */
89935 if( db->aDb[1].pBt==0 && !pParse->explain ){
89937 Btree *pBt;
89945 rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pBt, 0, flags);
89952 db->aDb[1].pBt = pBt;
89954 if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, -1, 0) ){
89973 assert( db->aDb[iDb].pBt!=0 || iDb==1 );
89994 if( pDb->pBt && (!zDb || 0==sqlite3StrICmp(zDb, pDb->zName)) ){
90833 SQLITE_PRIVATE Schema *sqlite3SchemaGet(sqlite3 *db, Btree *pBt){
90835 if( pBt ){
90836 p = (Schema *)sqlite3BtreeSchema(pBt, sizeof(Schema), sqlite3SchemaClear);
98790 if( db->aDb[1].pBt!=0 ){
98791 if( !db->autoCommit || sqlite3BtreeIsInReadTrans(db->aDb[1].pBt) ){
98796 sqlite3BtreeClose(db->aDb[1].pBt);
98797 db->aDb[1].pBt = 0;
98855 if( pDb->pBt ){
98856 sqlite3BtreeSetPagerFlags(pDb->pBt,
99077 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
99094 Btree *pBt = pDb->pBt;
99095 assert( pBt!=0 );
99097 int size = ALWAYS(pBt) ? sqlite3BtreeGetPageSize(pBt) : 0;
99104 if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize,-1,0) ){
99120 Btree *pBt = pDb->pBt;
99122 assert( pBt!=0 );
99129 sqlite3BtreeSecureDelete(db->aDb[ii].pBt, b);
99132 b = sqlite3BtreeSecureDelete(pBt, b);
99198 pPager = sqlite3BtreePager(db->aDb[ii].pBt);
99203 pPager = sqlite3BtreePager(pDb->pBt);
99253 if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
99269 Pager *pPager = sqlite3BtreePager(pDb->pBt);
99291 Btree *pBt = pDb->pBt;
99292 assert( pBt!=0 );
99294 returnSingleInt(pParse, "auto_vacuum", sqlite3BtreeGetAutoVacuum(pBt));
99304 rc = sqlite3BtreeSetAutoVacuum(pBt, eAuto);
99375 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
99404 if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
99405 sqlite3BtreeSetMmapLimit(db->aDb[ii].pBt, sz);
99546 Pager *pPager = sqlite3BtreePager(pDb->pBt);
99560 Pager *pPager = sqlite3BtreePager(pDb->pBt);
99783 if( db->aDb[i].pBt==0 ) continue;
99788 sqlite3BtreeGetFilename(db->aDb[i].pBt), 0);
100511 Btree *pBt;
100516 pBt = db->aDb[i].pBt;
100517 if( pBt==0 || sqlite3BtreePager(pBt)==0 ){
100760 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
100795 if( pDb->pBt==0 ){
100805 sqlite3BtreeEnter(pDb->pBt);
100806 if( !sqlite3BtreeIsInReadTrans(pDb->pBt) ){
100807 rc = sqlite3BtreeBeginTrans(pDb->pBt, 0);
100833 sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);
100875 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
100953 sqlite3BtreeCommit(pDb->pBt);
100955 sqlite3BtreeLeave(pDb->pBt);
101045 Btree *pBt = db->aDb[iDb].pBt; /* Btree database to read cookie from */
101046 if( pBt==0 ) continue;
101051 if( !sqlite3BtreeIsInReadTrans(pBt) ){
101052 rc = sqlite3BtreeBeginTrans(pBt, 0);
101063 sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&cookie);
101072 sqlite3BtreeCommit(pBt);
101172 Btree *pBt = db->aDb[i].pBt;
101173 if( pBt ){
101174 assert( sqlite3BtreeHoldsMutex(pBt) );
101175 rc = sqlite3BtreeSchemaLocked(pBt);
109129 pMain = db->aDb[0].pBt;
109158 pTemp = db->aDb[db->nDb-1].pBt;
109336 sqlite3BtreeClose(pDb->pBt);
109337 pDb->pBt = 0;
122790 Btree *pBt = db->aDb[i].pBt;
122791 if( pBt ){
122792 Pager *pPager = sqlite3BtreePager(pBt);
123001 Btree *pBt = db->aDb[j].pBt;
123002 if( pBt && sqlite3BtreeIsInBackup(pBt) ) return 1;
123109 if( pDb->pBt ){
123110 sqlite3BtreeClose(pDb->pBt);
123111 pDb->pBt = 0;
123211 Btree *p = db->aDb[i].pBt;
123990 rc = sqlite3BtreeCheckpoint(db->aDb[i].pBt, eMode, pnLog, pnCkpt);
124154 if( pDb->pBt==0 ) continue;
124155 sqlite3BtreeEnter(pDb->pBt);
124165 sqlite3BtreeLeave(pDb->pBt);
124733 rc = sqlite3BtreeOpen(db->pVfs, zOpen, db, &db->aDb[0].pBt, 0,
124742 db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt);
124816 sqlite3PagerLockingMode(sqlite3BtreePager(db->aDb[0].pBt),
125438 sqlite3BtreeSetPageSize(db->aDb[0].pBt, 0, x, 0);
125617 if( db->aDb[i].pBt
125620 return db->aDb[i].pBt;
125631 Btree *pBt = sqlite3DbNameToBtree(db, zDbName);
125632 return pBt ? sqlite3BtreeGetFilename(pBt) : 0;
125640 Btree *pBt = sqlite3DbNameToBtree(db, zDbName);
125641 return pBt ? sqlite3BtreeIsReadonly(pBt) : -1;
