Lines Matching defs:pBt
7808 SQLITE_PRIVATE int sqlite3BtreeSetVersion(Btree *pBt, int iVersion);
9008 Btree *pBt; /* The B*Tree structure for this database file */
12259 Btree *pBt; /* Separate file holding temporary table */
12767 Btree *pBt = db->aDb[i].pBt;
12768 if( pBt ){
12769 Pager *pPager = sqlite3BtreePager(pBt);
14822 void **pBt;
14836 pBt = (void**)&z[mem.nTitle];
14837 pHdr = (struct MemBlockHdr*)&pBt[mem.nBacktrace];
14853 memcpy(pBt, &aAddr[1], pHdr->nBacktrace*sizeof(void*));
14854 assert(pBt[0]);
14881 void **pBt;
14886 pBt = (void**)pHdr;
14887 pBt -= pHdr->nBacktraceSlots;
14903 z = (char*)pBt;
15044 void **pBt = (void**)pHdr;
15045 pBt -= pHdr->nBacktraceSlots;
15046 mem.xBacktrace(pHdr->iSize, pHdr->nBacktrace-1, &pBt[1]);
15057 void **pBt;
15072 pBt = (void**)pHdr;
15073 pBt -= pHdr->nBacktraceSlots;
15074 backtrace_symbols_fd(pBt, pHdr->nBacktrace, fileno(out));
46423 #define MX_CELL_SIZE(pBt) ((int)(pBt->pageSize-8))
46430 #define MX_CELL(pBt) ((pBt->pageSize-8)/6)
46472 ** stored in MemPage.pBt->mutex.
46492 BtShared *pBt; /* Pointer to BtShared that this page is part of */
46539 ** The pBt pointer itself may not be changed while there exists cursors
46546 BtShared *pBt; /* Sharable content of this btree */
46548 u8 sharable; /* True if we can share pBt with another db */
46549 u8 locked; /* True if db currently has pBt locked */
46684 ** found at self->pBt->mutex.
46688 BtShared *pBt; /* The BtShared this cursor points to */
46743 # define PENDING_BYTE_PAGE(pBt) PAGER_MJ_PGNO(pBt)
46760 #define PTRMAP_PAGENO(pBt, pgno) ptrmapPageno(pBt, pgno)
46762 #define PTRMAP_ISPAGE(pBt, pgno) (PTRMAP_PAGENO((pBt),(pgno))==(pgno))
46805 assert( p->pBt->inTransaction!=TRANS_NONE || p->pBt->nTransaction==0 ); \
46806 assert( p->pBt->inTransaction>=p->inTrans );
46817 #define ISAUTOVACUUM (pBt->autoVacuum)
46829 BtShared *pBt; /* The tree being checked out */
46830 Pager *pPager; /* The associated pager. Also accessible by pBt->pPager */
46859 assert( sqlite3_mutex_notheld(p->pBt->mutex) );
46862 sqlite3_mutex_enter(p->pBt->mutex);
46863 p->pBt->db = p->db;
46872 BtShared *pBt = p->pBt;
46874 assert( sqlite3_mutex_held(pBt->mutex) );
46876 assert( p->db==pBt->db );
46878 sqlite3_mutex_leave(pBt->mutex);
46903 ** Btree.pBt value. All elements of the list should belong to
46905 assert( p->pNext==0 || p->pNext->pBt>p->pBt );
46906 assert( p->pPrev==0 || p->pPrev->pBt<p->pBt );
46920 assert( (p->locked==0 && p->sharable) || p->pBt->db==p->db );
46930 if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){
46931 p->pBt->db = p->db;
46943 assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt );
46979 assert( p->sharable==0 || p->locked==0 || p->db==p->pBt->db );
46980 assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->pBt->mutex) );
47022 p = db->aDb[i].pBt;
47031 p = db->aDb[i].pBt;
47058 p = db->aDb[i].pBt;
47060 (p->wantToLock==0 || !sqlite3_mutex_held(p->pBt->mutex)) ){
47075 ** (2) if iDb!=1, then the mutex on db->aDb[iDb].pBt.
47087 p = db->aDb[iDb].pBt;
47105 p->pBt->db = p->db;
47110 Btree *p = db->aDb[i].pBt;
47112 p->pBt->db = p->db;
47246 Schema *pSchema = (Schema *)pBtree->pBt->pSchema;
47288 for(pLock=pBtree->pBt->pLock; pLock; pLock=pLock->pNext){
47323 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
47342 BtShared *pBt = p->pBt;
47354 assert( eLock==READ_LOCK || (p==pBt->pWriter && p->inTrans==TRANS_WRITE) );
47355 assert( eLock==READ_LOCK || pBt->inTransaction==TRANS_WRITE );
47365 if( pBt->pWriter!=p && pBt->isExclusive ){
47366 sqlite3ConnectionBlocked(p->db, pBt->pWriter->db);
47370 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
47385 assert( p==pBt->pWriter );
47386 pBt->isPending = 1;
47414 BtShared *pBt = p->pBt;
47434 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
47451 pLock->pNext = pBt->pLock;
47452 pBt->pLock = pLock;
47478 BtShared *pBt = p->pBt;
47479 BtLock **ppIter = &pBt->pLock;
47487 assert( pBt->isExclusive==0 || pBt->pWriter==pLock->pBtree );
47500 assert( pBt->isPending==0 || pBt->pWriter );
47501 if( pBt->pWriter==p ){
47502 pBt->pWriter = 0;
47503 pBt->isExclusive = 0;
47504 pBt->isPending = 0;
47505 }else if( pBt->nTransaction==2 ){
47515 pBt->isPending = 0;
47523 BtShared *pBt = p->pBt;
47524 if( pBt->pWriter==p ){
47526 pBt->pWriter = 0;
47527 pBt->isExclusive = 0;
47528 pBt->isPending = 0;
47529 for(pLock=pBt->pLock; pLock; pLock=pLock->pNext){
47547 return sqlite3_mutex_held(p->pBt->mutex);
47564 ** on the shared btree structure pBt.
47566 static void invalidateAllOverflowCache(BtShared *pBt){
47568 assert( sqlite3_mutex_held(pBt->mutex) );
47569 for(p=pBt->pCursor; p; p=p->pNext){
47593 BtShared *pBt = pBtree->pBt;
47595 for(p=pBt->pCursor; p; p=p->pNext){
47644 static int btreeSetHasContent(BtShared *pBt, Pgno pgno){
47646 if( !pBt->pHasContent ){
47647 assert( pgno<=pBt->nPage );
47648 pBt->pHasContent = sqlite3BitvecCreate(pBt->nPage);
47649 if( !pBt->pHasContent ){
47653 if( rc==SQLITE_OK && pgno<=sqlite3BitvecSize(pBt->pHasContent) ){
47654 rc = sqlite3BitvecSet(pBt->pHasContent, pgno);
47666 static int btreeGetHasContent(BtShared *pBt, Pgno pgno){
47667 Bitvec *p = pBt->pHasContent;
47675 static void btreeClearHasContent(BtShared *pBt){
47676 sqlite3BitvecDestroy(pBt->pHasContent);
47677 pBt->pHasContent = 0;
47737 static int saveAllCursors(BtShared *pBt, Pgno iRoot, BtCursor *pExcept){
47739 assert( sqlite3_mutex_held(pBt->mutex) );
47740 assert( pExcept==0 || pExcept->pBt==pBt );
47741 for(p=pBt->pCursor; p; p=p->pNext){
47857 static Pgno ptrmapPageno(BtShared *pBt, Pgno pgno){
47860 assert( sqlite3_mutex_held(pBt->mutex) );
47862 nPagesPerMapPage = (pBt->usableSize/5)+1;
47865 if( ret==PENDING_BYTE_PAGE(pBt) ){
47881 static void ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent, int *pRC){
47890 assert( sqlite3_mutex_held(pBt->mutex) );
47892 assert( 0==PTRMAP_ISPAGE(pBt, PENDING_BYTE_PAGE(pBt)) );
47894 assert( pBt->autoVacuum );
47899 iPtrmap = PTRMAP_PAGENO(pBt, key);
47900 rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage);
47932 static int ptrmapGet(BtShared *pBt, Pgno key, u8 *pEType, Pgno *pPgno){
47939 assert( sqlite3_mutex_held(pBt->mutex) );
47941 iPtrmap = PTRMAP_PAGENO(pBt, key);
47942 rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage);
47980 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
48013 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
48059 surplus = minLocal + (nPayload - minLocal)%(pPage->pBt->usableSize - 4);
48121 nSize = minLocal + (nSize - minLocal) % (pPage->pBt->usableSize - 4);
48162 ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, pRC);
48190 assert( pPage->pBt!=0 );
48191 assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE );
48193 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
48194 temp = sqlite3PagerTempSpace(pPage->pBt->pPager);
48200 usableSize = pPage->pBt->usableSize;
48274 assert( pPage->pBt );
48275 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
48279 usableSize = pPage->pBt->usableSize;
48350 assert( top+nByte <= (int)pPage->pBt->usableSize );
48368 assert( pPage->pBt!=0 );
48371 assert( (start + size) <= (int)pPage->pBt->usableSize );
48372 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
48375 if( pPage->pBt->secureDelete ){
48392 iLast = pPage->pBt->usableSize - 4;
48414 assert( pbegin <= (int)pPage->pBt->usableSize-4 );
48457 BtShared *pBt; /* A copy of pPage->pBt */
48460 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
48464 pBt = pPage->pBt;
48468 pPage->maxLocal = pBt->maxLeaf;
48469 pPage->minLocal = pBt->minLeaf;
48473 pPage->maxLocal = pBt->maxLocal;
48474 pPage->minLocal = pBt->minLocal;
48492 assert( pPage->pBt!=0 );
48493 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
48502 BtShared *pBt; /* The main btree structure */
48510 pBt = pPage->pBt;
48515 assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
48516 pPage->maskPage = (u16)(pBt->pageSize - 1);
48518 usableSize = pBt->usableSize;
48522 if( pPage->nCell>MX_CELL(pBt) ){
48526 testcase( pPage->nCell==MX_CELL(pBt) );
48602 BtShared *pBt = pPage->pBt;
48610 assert( sqlite3_mutex_held(pBt->mutex) );
48611 if( pBt->secureDelete ){
48612 memset(&data[hdr], 0, pBt->usableSize - hdr);
48618 put2byte(&data[hdr+5], pBt->usableSize);
48619 pPage->nFree = (u16)(pBt->usableSize - first);
48624 assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
48625 pPage->maskPage = (u16)(pBt->pageSize - 1);
48635 static MemPage *btreePageFromDbPage(DbPage *pDbPage, Pgno pgno, BtShared *pBt){
48639 pPage->pBt = pBt;
48646 ** Get a page from the pager. Initialize the MemPage.pBt and
48657 BtShared *pBt, /* The btree */
48665 assert( sqlite3_mutex_held(pBt->mutex) );
48666 rc = sqlite3PagerAcquire(pBt->pPager, pgno, (DbPage**)&pDbPage, noContent);
48668 *ppPage = btreePageFromDbPage(pDbPage, pgno, pBt);
48674 ** already in the pager cache return NULL. Initialize the MemPage.pBt and
48677 static MemPage *btreePageLookup(BtShared *pBt, Pgno pgno){
48679 assert( sqlite3_mutex_held(pBt->mutex) );
48680 pDbPage = sqlite3PagerLookup(pBt->pPager, pgno);
48682 return btreePageFromDbPage(pDbPage, pgno, pBt);
48691 static Pgno btreePagecount(BtShared *pBt){
48692 return pBt->nPage;
48696 assert( ((p->pBt->nPage)&0x8000000)==0 );
48697 return (int)btreePagecount(p->pBt);
48709 BtShared *pBt, /* The database file */
48714 assert( sqlite3_mutex_held(pBt->mutex) );
48716 if( pgno>btreePagecount(pBt) ){
48719 rc = btreeGetPage(pBt, pgno, ppPage, 0);
48740 assert( pPage->pBt );
48743 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
48761 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
48779 BtShared *pBt = (BtShared*)pArg;
48780 assert( pBt->db );
48781 assert( sqlite3_mutex_held(pBt->db->mutex) );
48782 return sqlite3InvokeBusyHandler(&pBt->db->busyHandler);
48817 BtShared *pBt = 0; /* Shared part of btree structure */
48888 for(pBt=GLOBAL(BtShared*,sqlite3SharedCacheList); pBt; pBt=pBt->pNext){
48889 assert( pBt->nRef>0 );
48890 if( 0==strcmp(zFullPathname, sqlite3PagerFilename(pBt->pPager))
48891 && sqlite3PagerVfs(pBt->pPager)==pVfs ){
48894 Btree *pExisting = db->aDb[iDb].pBt;
48895 if( pExisting && pExisting->pBt==pBt ){
48903 p->pBt = pBt;
48904 pBt->nRef++;
48923 if( pBt==0 ){
48935 pBt = sqlite3MallocZero( sizeof(*pBt) );
48936 if( pBt==0 ){
48940 rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename,
48943 rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader);
48948 pBt->openFlags = (u8)flags;
48949 pBt->db = db;
48950 sqlite3PagerSetBusyhandler(pBt->pPager, btreeInvokeBusyHandler, pBt);
48951 p->pBt = pBt;
48953 pBt->pCursor = 0;
48954 pBt->pPage1 = 0;
48955 pBt->readOnly = sqlite3PagerIsreadonly(pBt->pPager);
48957 pBt->secureDelete = 1;
48959 pBt->pageSize = (zDbHeader[16]<<8) | (zDbHeader[17]<<16);
48960 if( pBt->pageSize<512 || pBt->pageSize>SQLITE_MAX_PAGE_SIZE
48961 || ((pBt->pageSize-1)&pBt->pageSize)!=0 ){
48962 pBt->pageSize = 0;
48971 pBt->autoVacuum = (SQLITE_DEFAULT_AUTOVACUUM ? 1 : 0);
48972 pBt->incrVacuum = (SQLITE_DEFAULT_AUTOVACUUM==2 ? 1 : 0);
48978 pBt->pageSizeFixed = 1;
48980 pBt->autoVacuum = (get4byte(&zDbHeader[36 + 4*4])?1:0);
48981 pBt->incrVacuum = (get4byte(&zDbHeader[36 + 7*4])?1:0);
48984 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
48986 pBt->usableSize = pBt->pageSize - nReserve;
48987 assert( (pBt->pageSize & 7)==0 ); /* 8-byte alignment of pageSize */
48994 pBt->nRef = 1;
48997 pBt->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_FAST);
48998 if( pBt->mutex==0 ){
49005 pBt->pNext = GLOBAL(BtShared*,sqlite3SharedCacheList);
49006 GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt;
49015 ** The list is kept in ascending order by pBt address.
49021 if( (pSib = db->aDb[i].pBt)!=0 && pSib->sharable ){
49023 if( p->pBt<pSib->pBt ){
49028 while( pSib->pNext && pSib->pNext->pBt<p->pBt ){
49047 if( pBt && pBt->pPager ){
49048 sqlite3PagerClose(pBt->pPager);
49050 sqlite3_free(pBt);
49059 sqlite3PagerSetCachesize(p->pBt->pPager, SQLITE_DEFAULT_CACHE_SIZE);
49075 static int removeFromSharingList(BtShared *pBt){
49081 assert( sqlite3_mutex_notheld(pBt->mutex) );
49084 pBt->nRef--;
49085 if( pBt->nRef<=0 ){
49086 if( GLOBAL(BtShared*,sqlite3SharedCacheList)==pBt ){
49087 GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt->pNext;
49090 while( ALWAYS(pList) && pList->pNext!=pBt ){
49094 pList->pNext = pBt->pNext;
49098 sqlite3_mutex_free(pBt->mutex);
49110 ** Make sure pBt->pTmpSpace points to an allocation of
49111 ** MX_CELL_SIZE(pBt) bytes.
49113 static void allocateTempSpace(BtShared *pBt){
49114 if( !pBt->pTmpSpace ){
49115 pBt->pTmpSpace = sqlite3PageMalloc( pBt->pageSize );
49120 ** Free the pBt->pTmpSpace allocation
49122 static void freeTempSpace(BtShared *pBt){
49123 sqlite3PageFree( pBt->pTmpSpace);
49124 pBt->pTmpSpace = 0;
49131 BtShared *pBt = p->pBt;
49137 pCur = pBt->pCursor;
49158 if( !p->sharable || removeFromSharingList(pBt) ){
49159 /* The pBt is no longer on the sharing list, so we can access
49164 assert( !pBt->pCursor );
49165 sqlite3PagerClose(pBt->pPager);
49166 if( pBt->xFreeSchema && pBt->pSchema ){
49167 pBt->xFreeSchema(pBt->pSchema);
49169 sqlite3DbFree(0, pBt->pSchema);
49170 freeTempSpace(pBt);
49171 sqlite3_free(pBt);
49201 BtShared *pBt = p->pBt;
49204 sqlite3PagerSetCachesize(pBt->pPager, mxPage);
49224 BtShared *pBt = p->pBt;
49228 sqlite3PagerSetSafetyLevel(pBt->pPager, level, fullSync, ckptFullSync);
49239 BtShared *pBt = p->pBt;
49243 assert( pBt && pBt->pPager );
49244 rc = sqlite3PagerNosync(pBt->pPager);
49271 BtShared *pBt = p->pBt;
49274 if( pBt->pageSizeFixed ){
49279 nReserve = pBt->pageSize - pBt->usableSize;
49285 assert( !pBt->pPage1 && !pBt->pCursor );
49286 pBt->pageSize = (u32)pageSize;
49287 freeTempSpace(pBt);
49289 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
49290 pBt->usableSize = pBt->pageSize - (u16)nReserve;
49291 if( iFix ) pBt->pageSizeFixed = 1;
49300 return p->pBt->pageSize;
49312 n = p->pBt->pageSize - p->pBt->usableSize;
49325 n = sqlite3PagerMaxPageCount(p->pBt->pPager, mxPage);
49340 p->pBt->secureDelete = (newFlag!=0) ? 1 : 0;
49342 b = p->pBt->secureDelete;
49358 BtShared *pBt = p->pBt;
49363 if( pBt->pageSizeFixed && (av ?1:0)!=pBt->autoVacuum ){
49366 pBt->autoVacuum = av ?1:0;
49367 pBt->incrVacuum = av==2 ?1:0;
49385 (!p->pBt->autoVacuum)?BTREE_AUTOVACUUM_NONE:
49386 (!p->pBt->incrVacuum)?BTREE_AUTOVACUUM_FULL:
49404 static int lockBtree(BtShared *pBt){
49411 assert( sqlite3_mutex_held(pBt->mutex) );
49412 assert( pBt->pPage1==0 );
49413 rc = sqlite3PagerSharedLock(pBt->pPager);
49415 rc = btreeGetPage(pBt, 1, &pPage1, 0);
49422 sqlite3PagerPagecount(pBt->pPager, &nPageFile);
49437 pBt->readOnly = 1;
49444 pBt->readOnly = 1;
49458 if( page1[19]==2 && pBt->doNotUseWAL==0 ){
49460 rc = sqlite3PagerOpenWal(pBt->pPager, &isOpen);
49488 if( (u32)pageSize!=pBt->pageSize ){
49491 ** actually pageSize. Unlock the database, leave pBt->pPage1 at
49496 pBt->usableSize = usableSize;
49497 pBt->pageSize = pageSize;
49498 freeTempSpace(pBt);
49499 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize,
49503 if( (pBt->db->flags & SQLITE_RecoveryMode)==0 && nPage>nPageFile ){
49510 pBt->pageSize = pageSize;
49511 pBt->usableSize = usableSize;
49513 pBt->autoVacuum = (get4byte(&page1[36 + 4*4])?1:0);
49514 pBt->incrVacuum = (get4byte(&page1[36 + 7*4])?1:0);
49531 pBt->maxLocal = (u16)((pBt->usableSize-12)*64/255 - 23);
49532 pBt->minLocal = (u16)((pBt->usableSize-12)*32/255 - 23);
49533 pBt->maxLeaf = (u16)(pBt->usableSize - 35);
49534 pBt->minLeaf = (u16)((pBt->usableSize-12)*32/255 - 23);
49535 assert( pBt->maxLeaf + 23 <= MX_CELL_SIZE(pBt) );
49536 pBt->pPage1 = pPage1;
49537 pBt->nPage = nPage;
49542 pBt->pPage1 = 0;
49554 static void unlockBtreeIfUnused(BtShared *pBt){
49555 assert( sqlite3_mutex_held(pBt->mutex) );
49556 assert( pBt->pCursor==0 || pBt->inTransaction>TRANS_NONE );
49557 if( pBt->inTransaction==TRANS_NONE && pBt->pPage1!=0 ){
49558 assert( pBt->pPage1->aData );
49559 assert( sqlite3PagerRefcount(pBt->pPager)==1 );
49560 assert( pBt->pPage1->aData );
49561 releasePage(pBt->pPage1);
49562 pBt->pPage1 = 0;
49567 ** If pBt points to an empty file then convert that empty file
49571 static int newDatabase(BtShared *pBt){
49576 assert( sqlite3_mutex_held(pBt->mutex) );
49577 if( pBt->nPage>0 ){
49580 pP1 = pBt->pPage1;
49587 pBt->pageSize>>8)&0xff);
49588 data[17] = (u8)((pBt->pageSize>>16)&0xff);
49591 assert( pBt->usableSize<=pBt->pageSize && pBt->usableSize+255>=pBt->pageSize);
49592 data[20] = (u8)(pBt->pageSize - pBt->usableSize);
49598 pBt->pageSizeFixed = 1;
49600 assert( pBt->autoVacuum==1 || pBt->autoVacuum==0 );
49601 assert( pBt->incrVacuum==1 || pBt->incrVacuum==0 );
49602 put4byte(&data[36 + 4*4], pBt->autoVacuum);
49603 put4byte(&data[36 + 7*4], pBt->incrVacuum);
49605 pBt->nPage = 1;
49647 BtShared *pBt = p->pBt;
49662 if( pBt->readOnly && wrflag ){
49672 if( (wrflag && pBt->inTransaction==TRANS_WRITE) || pBt->isPending ){
49673 pBlock = pBt->pWriter->db;
49676 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
49696 pBt->initiallyEmpty = (u8)(pBt->nPage==0);
49698 /* Call lockBtree() until either pBt->pPage1 is populated or
49700 ** may return SQLITE_OK but leave pBt->pPage1 set to 0 if after
49702 ** file is not pBt->pageSize. In this case lockBtree() will update
49703 ** pBt->pageSize to the page-size of the file on disk.
49705 while( pBt->pPage1==0 && SQLITE_OK==(rc = lockBtree(pBt)) );
49708 if( pBt->readOnly ){
49711 rc = sqlite3PagerBegin(pBt->pPager,wrflag>1,sqlite3TempInMemory(p->db));
49713 rc = newDatabase(pBt);
49719 unlockBtreeIfUnused(pBt);
49721 }while( (rc&0xFF)==SQLITE_BUSY && pBt->inTransaction==TRANS_NONE &&
49722 btreeInvokeBusyHandler(pBt) );
49726 pBt->nTransaction++;
49731 p->lock.pNext = pBt->pLock;
49732 pBt->pLock = &p->lock;
49737 if( p->inTrans>pBt->inTransaction ){
49738 pBt->inTransaction = p->inTrans;
49741 MemPage *pPage1 = pBt->pPage1;
49743 assert( !pBt->pWriter );
49744 pBt->pWriter = p;
49745 pBt->isExclusive = (u8)(wrflag>1);
49754 if( pBt->nPage!=get4byte(&pPage1->aData[28]) ){
49757 put4byte(&pPage1->aData[28], pBt->nPage);
49770 rc = sqlite3PagerOpenSavepoint(pBt->pPager, p->db->nSavepoint);
49789 BtShared *pBt = pPage->pBt;
49793 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
49807 ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
49813 ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
49836 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
49895 BtShared *pBt, /* Btree */
49904 Pager *pPager = pBt->pPager;
49909 assert( sqlite3_mutex_held(pBt->mutex) );
49910 assert( pDbPage->pBt==pBt );
49937 ptrmapPut(pBt, nextOvfl, PTRMAP_OVERFLOW2, iFreePage, &rc);
49949 rc = btreeGetPage(pBt, iPtrPage, &pPtrPage, 0);
49961 ptrmapPut(pBt, iFreePage, eType, iPtrPage, &rc);
49988 static int incrVacuumStep(BtShared *pBt, Pgno nFin, Pgno iLastPg){
49992 assert( sqlite3_mutex_held(pBt->mutex) );
49995 if( !PTRMAP_ISPAGE(pBt, iLastPg) && iLastPg!=PENDING_BYTE_PAGE(pBt) ){
49999 nFreeList = get4byte(&pBt->pPage1->aData[36]);
50004 rc = ptrmapGet(pBt, iLastPg, &eType, &iPtrPage);
50021 rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, iLastPg, 1);
50032 rc = btreeGetPage(pBt, iLastPg, &pLastPg, 0);
50046 rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, 0, 0);
50057 rc = relocatePage(pBt, pLastPg, eType, iPtrPage, iFreePg, nFin!=0);
50068 while( iLastPg==PENDING_BYTE_PAGE(pBt)||PTRMAP_ISPAGE(pBt, iLastPg) ){
50069 if( PTRMAP_ISPAGE(pBt, iLastPg) ){
50071 rc = btreeGetPage(pBt, iLastPg, &pPg, 0);
50083 sqlite3PagerTruncateImage(pBt->pPager, iLastPg);
50084 pBt->nPage = iLastPg;
50099 BtShared *pBt = p->pBt;
50102 assert( pBt->inTransaction==TRANS_WRITE && p->inTrans==TRANS_WRITE );
50103 if( !pBt->autoVacuum ){
50106 invalidateAllOverflowCache(pBt);
50107 rc = incrVacuumStep(pBt, 0, btreePagecount(pBt));
50109 rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
50110 put4byte(&pBt->pPage1->aData[28], pBt->nPage);
50126 static int autoVacuumCommit(BtShared *pBt){
50128 Pager *pPager = pBt->pPager;
50131 assert( sqlite3_mutex_held(pBt->mutex) );
50132 invalidateAllOverflowCache(pBt);
50133 assert(pBt->autoVacuum);
50134 if( !pBt->incrVacuum ){
50142 nOrig = btreePagecount(pBt);
50143 if( PTRMAP_ISPAGE(pBt, nOrig) || nOrig==PENDING_BYTE_PAGE(pBt) ){
50151 nFree = get4byte(&pBt->pPage1->aData[36]);
50152 nEntry = pBt->usableSize/5;
50153 nPtrmap = (nFree-nOrig+PTRMAP_PAGENO(pBt, nOrig)+nEntry)/nEntry;
50155 if( nOrig>PENDING_BYTE_PAGE(pBt) && nFin<PENDING_BYTE_PAGE(pBt) ){
50158 while( PTRMAP_ISPAGE(pBt, nFin) || nFin==PENDING_BYTE_PAGE(pBt) ){
50164 rc = incrVacuumStep(pBt, nFin, iFree);
50167 rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
50168 put4byte(&pBt->pPage1->aData[32], 0);
50169 put4byte(&pBt->pPage1->aData[36], 0);
50170 put4byte(&pBt->pPage1->aData[28], nFin);
50171 sqlite3PagerTruncateImage(pBt->pPager, nFin);
50172 pBt->nPage = nFin;
50200 ** This call is a no-op if no write-transaction is currently active on pBt.
50202 ** Otherwise, sync the database file for the btree pBt. zMaster points to
50216 BtShared *pBt = p->pBt;
50219 if( pBt->autoVacuum ){
50220 rc = autoVacuumCommit(pBt);
50227 rc = sqlite3PagerCommitPhaseOne(pBt->pPager, zMaster, 0);
50238 BtShared *pBt = p->pBt;
50241 btreeClearHasContent(pBt);
50255 pBt->nTransaction--;
50256 if( 0==pBt->nTransaction ){
50257 pBt->inTransaction = TRANS_NONE;
50264 unlockBtreeIfUnused(pBt);
50307 BtShared *pBt = p->pBt;
50308 assert( pBt->inTransaction==TRANS_WRITE );
50309 assert( pBt->nTransaction>0 );
50310 rc = sqlite3PagerCommitPhaseTwo(pBt->pPager);
50315 pBt->inTransaction = TRANS_READ;
50348 static int countWriteCursors(BtShared *pBt){
50351 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
50378 for(p=pBtree->pBt->pCursor; p; p=p->pNext){
50402 BtShared *pBt = p->pBt;
50406 rc = saveAllCursors(pBt, 0, 0);
50424 assert( TRANS_WRITE==pBt->inTransaction );
50425 rc2 = sqlite3PagerRollback(pBt->pPager);
50433 if( btreeGetPage(pBt, 1, &pPage1, 0)==SQLITE_OK ){
50436 if( nPage==0 ) sqlite3PagerPagecount(pBt->pPager, &nPage);
50437 testcase( pBt->nPage!=nPage );
50438 pBt->nPage = nPage;
50441 assert( countWriteCursors(pBt)==0 );
50442 pBt->inTransaction = TRANS_READ;
50470 BtShared *pBt = p->pBt;
50473 assert( pBt->readOnly==0 );
50476 assert( pBt->inTransaction==TRANS_WRITE );
50482 rc = sqlite3PagerOpenSavepoint(pBt->pPager, iStatement);
50502 BtShared *pBt = p->pBt;
50506 rc = sqlite3PagerSavepoint(pBt->pPager, op, iSavepoint);
50508 if( iSavepoint<0 && pBt->initiallyEmpty ) pBt->nPage = 0;
50509 rc = newDatabase(pBt);
50510 pBt->nPage = get4byte(28 + pBt->pPage1->aData);
50515 assert( pBt->nPage>0 );
50561 BtShared *pBt = p->pBt; /* Shared b-tree handle */
50576 assert( pBt->pPage1 && pBt->pPage1->aData );
50578 if( NEVER(wrFlag && pBt->readOnly) ){
50581 if( iTable==1 && btreePagecount(pBt)==0 ){
50591 pCur->pBt = pBt;
50593 pCur->pNext = pBt->pCursor;
50597 pBt->pCursor = pCur;
50654 for(p=pCur->pBt->pCursor; p; p=p->pNext){
50678 BtShared *pBt = pCur->pBt;
50684 pBt->pCursor = pCur->pNext;
50692 unlockBtreeIfUnused(pBt);
50824 BtShared *pBt, /* The database file */
50833 assert( sqlite3_mutex_held(pBt->mutex) );
50843 if( pBt->autoVacuum ){
50848 while( PTRMAP_ISPAGE(pBt, iGuess) || iGuess==PENDING_BYTE_PAGE(pBt) ){
50852 if( iGuess<=btreePagecount(pBt) ){
50853 rc = ptrmapGet(pBt, iGuess, &eType, &pgno);
50864 rc = btreeGetPage(pBt, ovfl, &pPage, 0);
50952 BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */
50964 || &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize]
50985 const u32 ovflSize = pBt->usableSize - 4; /* Bytes content per ovfl page */
51041 rc = getOverflowPage(pBt, nextPage, 0, &nextPage);
51049 rc = sqlite3PagerGet(pBt->pPager, nextPage, &pDbPage);
51225 BtShared *pBt = pCur->pBt;
51233 rc = getAndInitPage(pBt, newPgno, &pNewPage);
51316 BtShared *pBt = p->pBt;
51337 rc = getAndInitPage(pBt, pCur->pgnoRoot, &pCur->apPage[0]);
51867 BtShared *pBt,
51881 assert( sqlite3_mutex_held(pBt->mutex) );
51882 pPage1 = pBt->pPage1;
51883 mxPage = btreePagecount(pBt);
51902 assert( pBt->autoVacuum );
51903 rc = ptrmapGet(pBt, nearby, &eType, 0);
51934 rc = btreeGetPage(pBt, iTrunk, &pTrunk, 0);
51956 }else if( k>(u32)(pBt->usableSize/4 - 2) ){
51994 rc = btreeGetPage(pBt, iNewTrunk, &pNewTrunk, 0);
52061 noContent = !btreeGetHasContent(pBt, *pPgno);
52062 rc = btreeGetPage(pBt, *pPgno, ppPage, noContent);
52078 rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
52080 pBt->nPage++;
52081 if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ) pBt->nPage++;
52084 if( pBt->autoVacuum && PTRMAP_ISPAGE(pBt, pBt->nPage) ){
52090 TRACE(("ALLOCATE: %d from end of file (pointer-map page)\n", pBt->nPage));
52091 assert( pBt->nPage!=PENDING_BYTE_PAGE(pBt) );
52092 rc = btreeGetPage(pBt, pBt->nPage, &pPg, 1);
52098 pBt->nPage++;
52099 if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ){ pBt->nPage++; }
52102 put4byte(28 + (u8*)pBt->pPage1->aData, pBt->nPage);
52103 *pPgno = pBt->nPage;
52105 assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
52106 rc = btreeGetPage(pBt, *pPgno, ppPage, 1);
52115 assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
52145 static int freePage2(BtShared *pBt, MemPage *pMemPage, Pgno iPage){
52148 MemPage *pPage1 = pBt->pPage1; /* Local reference to page 1 */
52153 assert( sqlite3_mutex_held(pBt->mutex) );
52161 pPage = btreePageLookup(pBt, iPage);
52170 if( pBt->secureDelete ){
52174 if( (!pPage && ((rc = btreeGetPage(pBt, iPage, &pPage, 0))!=0) )
52179 memset(pPage->aData, 0, pPage->pBt->pageSize);
52186 ptrmapPut(pBt, iPage, PTRMAP_FREEPAGE, 0, &rc);
52201 rc = btreeGetPage(pBt, iTrunk, &pTrunk, 0);
52207 assert( pBt->usableSize>32 );
52208 if( nLeaf > (u32)pBt->usableSize/4 - 2 ){
52212 if( nLeaf < (u32)pBt->usableSize/4 - 8 ){
52231 if( pPage && !pBt->secureDelete ){
52234 rc = btreeSetHasContent(pBt, iPage);
52247 if( pPage==0 && SQLITE_OK!=(rc = btreeGetPage(pBt, iPage, &pPage, 0)) ){
52269 *pRC = freePage2(pPage->pBt, pPage, pPage->pgno);
52277 BtShared *pBt = pPage->pBt;
52284 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
52290 assert( pBt->usableSize > 4 );
52291 ovflPageSize = pBt->usableSize - 4;
52297 if( ovflPgno<2 || ovflPgno>btreePagecount(pBt) ){
52304 rc = getOverflowPage(pBt, ovflPgno, &pOvfl, &iNext);
52308 if( ( pOvfl || ((pOvfl = btreePageLookup(pBt, ovflPgno))!=0) )
52323 rc = freePage2(pBt, pOvfl, ovflPgno);
52363 BtShared *pBt = pPage->pBt;
52368 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
52372 assert( pCell<pPage->aData || pCell>=&pPage->aData[pBt->pageSize]
52414 if( pBt->autoVacuum ){
52418 PTRMAP_ISPAGE(pBt, pgnoOvfl) || pgnoOvfl==PENDING_BYTE_PAGE(pBt)
52422 rc = allocateBtreePage(pBt, &pOvfl, &pgnoOvfl, pgnoOvfl, 0);
52434 if( pBt->autoVacuum && rc==SQLITE_OK ){
52436 ptrmapPut(pBt, pgnoOvfl, eType, pgnoPtrmap, &rc);
52453 assert( pPrior<pPage->aData || pPrior>=&pPage->aData[pBt->pageSize]
52462 spaceLeft = pBt->usableSize - 4;
52473 assert( pPayload<pPage->aData || pPayload>=&pPage->aData[pBt->pageSize]
52518 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
52524 testcase( pc+sz==pPage->pBt->usableSize );
52525 if( pc < (u32)get2byte(&data[hdr+5]) || pc+sz > pPage->pBt->usableSize ){
52582 assert( pPage->nCell<=MX_CELL(pPage->pBt) && MX_CELL(pPage->pBt)<=10921 );
52584 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
52619 assert( idx+sz <= (int)pPage->pBt->usableSize );
52633 if( pPage->pBt->autoVacuum ){
52658 const int nUsable = pPage->pBt->usableSize; /* Usable size of page */
52661 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
52662 assert( nCell>=0 && nCell<=(int)MX_CELL(pPage->pBt)
52663 && (int)MX_CELL(pPage->pBt)<=10921);
52725 BtShared *const pBt = pPage->pBt; /* B-Tree Database */
52730 assert( sqlite3_mutex_held(pPage->pBt->mutex) );
52741 rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0);
52765 ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno, &rc);
52817 BtShared *pBt = pPage->pBt;
52828 ptrmapGet(pBt, ovfl, &e, &n);
52833 ptrmapGet(pBt, child, &e, &n);
52839 ptrmapGet(pBt, child, &e, &n);
52866 BtShared * const pBt = pFrom->pBt;
52877 assert( get2byte(&aFrom[iFromHdr+5]) <= (int)pBt->usableSize );
52881 memcpy(&aTo[iData], &aFrom[iData], pBt->usableSize-iData);
52951 BtShared *pBt; /* The whole database */
52979 pBt = pParent->pBt;
52980 assert( sqlite3_mutex_held(pBt->mutex) );
53032 rc = getAndInitPage(pBt, pgno, &apOld[i]);
53062 if( pBt->secureDelete ){
53064 if( (iOff+szNew[i])>(int)pBt->usableSize ){
53084 k = pBt->pageSize + ROUND8(sizeof(MemPage));
53088 + pBt->pageSize /* aSpace1 */
53124 MemPage *pOld = apCopy[i] = (MemPage*)&aSpace1[pBt->pageSize + k*i];
53127 memcpy(pOld->aData, apOld[i]->aData, pBt->pageSize);
53143 assert( sz<=pBt->maxLocal+23 );
53144 assert( iSpace1 <= (int)pBt->pageSize );
53182 usableSpace = pBt->usableSize - 12 + leafCorrection;
53260 rc = allocateBtreePage(pBt, &pNew, &pgno, pgno, 0);
53267 ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno, &rc);
53387 assert( sz<=pBt->maxLocal+23 );
53388 assert( iOvflSpace <= (int)pBt->pageSize );
53506 ptrmapPut(pBt, get4byte(apCell[i]), PTRMAP_BTREE, pNew->pgno, &rc);
53517 ptrmapPut(pBt, key, PTRMAP_BTREE, apNew[i]->pgno, &rc);
53574 BtShared *pBt = pRoot->pBt; /* The BTree */
53577 assert( sqlite3_mutex_held(pBt->mutex) );
53585 rc = allocateBtreePage(pBt,&pChild,&pgnoChild,pRoot->pgno,0);
53588 ptrmapPut(pBt, pgnoChild, PTRMAP_BTREE, pRoot->pgno, &rc);
53626 const int nMin = pCur->pBt->usableSize * 2 / 3;
53705 u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
53773 BtShared *pBt = p->pBt;
53783 assert( pCur->wrFlag && pBt->inTransaction==TRANS_WRITE && !pBt->readOnly );
53811 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
53827 allocateTempSpace(pBt);
53828 newCell = pBt->pTmpSpace;
53833 assert( szNew <= MX_CELL_SIZE(pBt) );
53903 BtShared *pBt = p->pBt;
53911 assert( pBt->inTransaction==TRANS_WRITE );
53912 assert( !pBt->readOnly );
53952 rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
53973 assert( MX_CELL_SIZE(pBt) >= nCell );
53975 allocateTempSpace(pBt);
53976 pTmp = pBt->pTmpSpace;
54025 BtShared *pBt = p->pBt;
54032 assert( pBt->inTransaction==TRANS_WRITE );
54033 assert( !pBt->readOnly );
54036 rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0);
54041 if( pBt->autoVacuum ){
54050 invalidateAllOverflowCache(pBt);
54062 while( pgnoRoot==PTRMAP_PAGENO(pBt, pgnoRoot) ||
54063 pgnoRoot==PENDING_BYTE_PAGE(pBt) ){
54072 rc = allocateBtreePage(pBt, &pPageMove, &pgnoMove, pgnoRoot, 1);
54090 rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0);
54094 rc = ptrmapGet(pBt, pgnoRoot, &eType, &iPtrPage);
54104 rc = relocatePage(pBt, pRoot, eType, iPtrPage, pgnoMove, 0);
54111 rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0);
54125 ptrmapPut(pBt, pgnoRoot, PTRMAP_ROOTPAGE, 0, &rc);
54135 assert( sqlite3PagerIswriteable(pBt->pPage1->pDbPage) );
54143 rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0);
54155 assert( (pBt->openFlags & BTREE_SINGLE)==0 || pgnoRoot==2 );
54172 BtShared *pBt, /* The BTree that contains the table */
54182 assert( sqlite3_mutex_held(pBt->mutex) );
54183 if( pgno>btreePagecount(pBt) ){
54187 rc = getAndInitPage(pBt, pgno, &pPage);
54192 rc = clearDatabasePage(pBt, get4byte(pCell), 1, pnChange);
54199 rc = clearDatabasePage(pBt, get4byte(&pPage->aData[8]), 1, pnChange);
54231 BtShared *pBt = p->pBt;
54240 rc = saveAllCursors(pBt, (Pgno)iTable, 0);
54242 rc = clearDatabasePage(pBt, (Pgno)iTable, 0, pnChange);
54271 BtShared *pBt = p->pBt;
54284 if( NEVER(pBt->pCursor) ){
54285 sqlite3ConnectionBlocked(p->db, pBt->pCursor->pBtree->db);
54289 rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0);
54304 if( pBt->autoVacuum ){
54324 rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0);
54328 rc = relocatePage(pBt, pMove, PTRMAP_ROOTPAGE, 0, iTable, 0);
54334 rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0);
54349 while( maxRootPgno==PENDING_BYTE_PAGE(pBt)
54350 || PTRMAP_ISPAGE(pBt, maxRootPgno) ){
54353 assert( maxRootPgno!=PENDING_BYTE_PAGE(pBt) );
54394 BtShared *pBt = p->pBt;
54399 assert( pBt->pPage1 );
54402 *pMeta = get4byte(&pBt->pPage1->aData[36 + idx*4]);
54407 if( idx==BTREE_LARGEST_ROOT_PAGE && *pMeta>0 ) pBt->readOnly = 1;
54418 BtShared *pBt = p->pBt;
54424 assert( pBt->pPage1!=0 );
54425 pP1 = pBt->pPage1->aData;
54426 rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
54431 assert( pBt->autoVacuum || iMeta==0 );
54433 pBt->incrVacuum = (u8)iMeta;
54516 return p->pBt->pPager;
54587 rc = ptrmapGet(pCheck->pBt, iChild, &ePtrmapType, &iPtrmapParent);
54634 if( pCheck->pBt->autoVacuum ){
54638 if( n>(int)pCheck->pBt->usableSize/4-2 ){
54646 if( pCheck->pBt->autoVacuum ){
54661 if( pCheck->pBt->autoVacuum && N>0 ){
54704 BtShared *pBt;
54715 pBt = pCheck->pBt;
54716 usableSize = pBt->usableSize;
54719 if( (rc = btreeGetPage(pBt, (Pgno)iPage, &pPage, 0))!=0 ){
54764 && (&pCell[info.iOverflow]<=&pPage->aData[pBt->usableSize])
54769 if( pBt->autoVacuum ){
54781 if( pBt->autoVacuum ){
54798 if( pBt->autoVacuum ){
54845 hit = sqlite3PageMalloc( pBt->pageSize );
54926 BtShared *pBt = p->pBt;
54930 assert( p->inTrans>TRANS_NONE && pBt->inTransaction>TRANS_NONE );
54931 nRef = sqlite3PagerRefcount(pBt->pPager);
54932 sCheck.pBt = pBt;
54933 sCheck.pPager = pBt->pPager;
54934 sCheck.nPage = btreePagecount(sCheck.pBt);
54950 i = PENDING_BYTE_PAGE(pBt);
54959 checkList(&sCheck, 1, get4byte(&pBt->pPage1->aData[32]),
54960 get4byte(&pBt->pPage1->aData[36]), "Main freelist: ");
54967 if( pBt->autoVacuum && aRoot[i]>1 ){
54986 (PTRMAP_PAGENO(pBt, i)!=i || !pBt->autoVacuum) ){
54990 (PTRMAP_PAGENO(pBt, i)==i && pBt->autoVacuum) ){
55000 if( NEVER(nRef != sqlite3PagerRefcount(pBt->pPager)) ){
55003 nRef, sqlite3PagerRefcount(pBt->pPager)
55029 assert( p->pBt->pPager!=0 );
55030 return sqlite3PagerFilename(p->pBt->pPager);
55042 assert( p->pBt->pPager!=0 );
55043 return sqlite3PagerJournalname(p->pBt->pPager);
55066 BtShared *pBt = p->pBt;
55068 if( pBt->inTransaction!=TRANS_NONE ){
55071 rc = sqlite3PagerCheckpoint(pBt->pPager, eMode, pnLog, pnCkpt);
55115 BtShared *pBt = p->pBt;
55117 if( !pBt->pSchema && nBytes ){
55118 pBt->pSchema = sqlite3DbMallocZero(0, nBytes);
55119 pBt->xFreeSchema = xFree;
55122 return pBt->pSchema;
55202 assert( !pCsr->pBt->readOnly && pCsr->pBt->inTransaction==TRANS_WRITE );
55234 BtShared *pBt = pBtree->pBt;
55243 pBt->doNotUseWAL = (u8)(iVersion==1);
55247 u8 *aData = pBt->pPage1->aData;
55251 rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
55260 pBt->doNotUseWAL = 0;
55380 return pDb->aDb[i].pBt;
55495 assert( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) );
55532 if( iDest==PENDING_BYTE_PAGE(p->pDest->pBt) ) continue;
55612 if( p->pDestDb && p->pSrc->pBt->inTransaction==TRANS_WRITE ){
55651 if( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ){
55702 if( nDestTruncate==(int)PENDING_BYTE_PAGE(p->pDest->pBt) ){
55727 nDestTruncate==(int)(PENDING_BYTE_PAGE(p->pDest->pBt)-1)
55882 assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
55915 assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
55957 pTo->pBt->pageSizeFixed = 0;
58087 if( i!=1 && sqlite3BtreeSharable(p->db->aDb[i].pBt) ){
58125 if( i!=1 && (mask & p->lockMask)!=0 && ALWAYS(aDb[i].pBt!=0) ){
58126 sqlite3BtreeEnter(aDb[i].pBt);
58147 if( i!=1 && (mask & p->lockMask)!=0 && ALWAYS(aDb[i].pBt!=0) ){
58148 sqlite3BtreeLeave(aDb[i].pBt);
58664 if( pCx->pBt ){
58665 sqlite3BtreeClose(pCx->pBt);
58850 Btree *pBt = db->aDb[i].pBt;
58851 if( sqlite3BtreeIsInTrans(pBt) ){
58854 pBt));
58878 if( 0==sqlite3Strlen30(sqlite3BtreeGetFilename(db->aDb[0].pBt))
58882 Btree *pBt = db->aDb[i].pBt;
58883 if( pBt ){
58884 rc = sqlite3BtreeCommitPhaseOne(pBt, 0);
58894 Btree *pBt = db->aDb[i].pBt;
58895 if( pBt ){
58896 rc = sqlite3BtreeCommitPhaseTwo(pBt, 0);
58913 char const *zMainFile = sqlite3BtreeGetFilename(db->aDb[0].pBt);
58948 Btree *pBt = db->aDb[i].pBt;
58949 if( sqlite3BtreeIsInTrans(pBt) ){
58950 char const *zFile = sqlite3BtreeGetJournalname(pBt);
58955 if( !needSync && !sqlite3BtreeSyncDisabled(pBt) ){
58993 Btree *pBt = db->aDb[i].pBt;
58994 if( pBt ){
58995 rc = sqlite3BtreeCommitPhaseOne(pBt, zMaster);
59026 Btree *pBt = db->aDb[i].pBt;
59027 if( pBt ){
59028 sqlite3BtreeCommitPhaseTwo(pBt, 1);
59089 Btree *p = db->aDb[i].pBt;
59125 Btree *pBt = db->aDb[i].pBt;
59126 if( pBt ){
59128 rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_ROLLBACK, iSavepoint);
59131 rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_RELEASE, iSavepoint);
60654 Btree *pBt = db->aDb[i].pBt;
60655 if( pBt ){
60656 int nEntry = sqlite3PagerWalCallback(sqlite3BtreePager(pBt));
62612 Btree *pBt;
62625 Btree *pBt;
62822 Btree *pBt; /* Btree to change journal mode of */
62823 Pager *pPager; /* Pager associated with pBt */
62829 Btree *pBt;
65000 rc = sqlite3BtreeSavepoint(db->aDb[u.aq.ii].pBt, u.aq.p1, u.aq.iSavepoint);
65147 Btree *pBt;
65152 u.as.pBt = db->aDb[pOp->p1].pBt;
65154 if( u.as.pBt ){
65155 rc = sqlite3BtreeBeginTrans(u.as.pBt, pOp->p2);
65168 assert( sqlite3BtreeIsInTrans(u.as.pBt) );
65174 rc = sqlite3BtreeBeginStmt(u.as.pBt, p->iStatement);
65208 assert( db->aDb[u.at.iDb].pBt!=0 );
65211 sqlite3BtreeGetMeta(db->aDb[u.at.iDb].pBt, u.at.iCookie, (u32 *)&u.at.iMeta);
65234 assert( u.au.pDb->pBt!=0 );
65239 rc = sqlite3BtreeUpdateMeta(u.au.pDb->pBt, pOp->p2, (int)pIn3->u.i);
65279 Btree *pBt;
65285 u.av.pBt = db->aDb[pOp->p1].pBt;
65286 if( u.av.pBt ){
65287 sqlite3BtreeGetMeta(u.av.pBt, BTREE_SCHEMA_VERSION, (u32 *)&u.av.iMeta);
65392 u.aw.pX = u.aw.pDb->pBt;
65495 rc = sqlite3BtreeOpen(0, db, &u.ax.pCx->pBt,
65498 rc = sqlite3BtreeBeginTrans(u.ax.pCx->pBt, 1);
65509 rc = sqlite3BtreeCreateTable(u.ax.pCx->pBt, &pgno, BTREE_BLOBKEY);
65512 rc = sqlite3BtreeCursor(u.ax.pCx->pBt, pgno, 1,
65519 rc = sqlite3BtreeCursor(u.ax.pCx->pBt, MASTER_ROOT, 1, 0, u.ax.pCx->pCursor);
66929 rc = sqlite3BtreeDropTable(db->aDb[u.br.iDb].pBt, pOp->p1, &u.br.iMoved);
66970 db->aDb[pOp->p2].pBt, pOp->p1, (pOp->p3 ? &u.bs.nChange : 0)
67017 assert( u.bt.pDb->pBt!=0 );
67024 rc = sqlite3BtreeCreateTable(u.bt.pDb->pBt, &u.bt.pgno, u.bt.flags);
67051 assert( u.bu.iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[u.bu.iDb].pBt) );
67182 u.bv.z = sqlite3BtreeIntegrityCheck(db->aDb[pOp->p5].pBt, u.bv.aRoot, u.bv.nRoot,
67709 Btree *pBt; /* Btree to change journal mode of */
67710 Pager *pPager; /* Pager associated with pBt */
67727 u.ce.pBt = db->aDb[pOp->p1].pBt;
67728 u.ce.pPager = sqlite3BtreePager(u.ce.pBt);
67777 assert( sqlite3BtreeIsInTrans(u.ce.pBt)==0 );
67779 rc = sqlite3BtreeSetVersion(u.ce.pBt, (u.ce.eNew==PAGER_JOURNALMODE_WAL ? 2 : 1));
67822 Btree *pBt;
67827 u.cf.pBt = db->aDb[pOp->p1].pBt;
67828 rc = sqlite3BtreeIncrVacuum(u.cf.pBt);
67877 rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock);
68250 pOut->u.i = sqlite3BtreeLastPage(db->aDb[pOp->p1].pBt);
68267 Btree *pBt;
68269 pBt = db->aDb[pOp->p1].pBt;
68272 newMax = sqlite3BtreeLastPage(pBt);
68275 pOut->u.i = sqlite3BtreeMaxPageCount(pBt, newMax);
75930 assert( db->aDb[iDb].pBt!=0 );
76170 rc = sqlite3BtreeOpen(zFile, db, &aNew->pBt, 0,
76178 aNew->pSchema = sqlite3SchemaGet(db, aNew->pBt);
76186 pPager = sqlite3BtreePager(aNew->pBt);
76188 sqlite3BtreeSecureDelete(aNew->pBt,
76189 sqlite3BtreeSecureDelete(db->aDb[0].pBt,-1) );
76222 if( nKey>0 || sqlite3BtreeGetReserve(db->aDb[0].pBt)>0 ){
76243 if( db->aDb[iDb].pBt ){
76244 sqlite3BtreeClose(db->aDb[iDb].pBt);
76245 db->aDb[iDb].pBt = 0;
76295 if( pDb->pBt==0 ) continue;
76312 if( sqlite3BtreeIsInReadTrans(pDb->pBt) || sqlite3BtreeIsInBackup(pDb->pBt) ){
76317 sqlite3BtreeClose(pDb->pBt);
76318 pDb->pBt = 0;
77292 if( pDb->pBt==0 ){
80194 /* if( db->aDb[0].pBt==0 ) return; */
80219 /* if( db->aDb[0].pBt==0 ) return; */
80239 /* if( db->aDb[0].pBt==0 ) return; */
80275 if( db->aDb[1].pBt==0 && !pParse->explain ){
80277 Btree *pBt;
80285 rc = sqlite3BtreeOpen(0, db, &pBt, 0, flags);
80292 db->aDb[1].pBt = pBt;
80294 if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, -1, 0) ){
80337 assert( db->aDb[iDb].pBt!=0 || iDb==1 );
80360 if( pDb->pBt && (!zDb || 0==sqlite3StrICmp(zDb, pDb->zName)) ){
81038 SQLITE_PRIVATE Schema *sqlite3SchemaGet(sqlite3 *db, Btree *pBt){
81040 if( pBt ){
81041 p = (Schema *)sqlite3BtreeSchema(pBt, sizeof(Schema), sqlite3SchemaClear);
87646 if( db->aDb[1].pBt!=0 ){
87647 if( !db->autoCommit || sqlite3BtreeIsInReadTrans(db->aDb[1].pBt) ){
87652 sqlite3BtreeClose(db->aDb[1].pBt);
87653 db->aDb[1].pBt = 0;
87929 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
87943 Btree *pBt = pDb->pBt;
87944 assert( pBt!=0 );
87946 int size = ALWAYS(pBt) ? sqlite3BtreeGetPageSize(pBt) : 0;
87953 if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, -1, 0) ){
87968 Btree *pBt = pDb->pBt;
87970 assert( pBt!=0 );
87977 sqlite3BtreeSecureDelete(db->aDb[ii].pBt, b);
87980 b = sqlite3BtreeSecureDelete(pBt, b);
88042 pPager = sqlite3BtreePager(db->aDb[ii].pBt);
88047 pPager = sqlite3BtreePager(pDb->pBt);
88101 if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
88116 Pager *pPager = sqlite3BtreePager(pDb->pBt);
88137 Btree *pBt = pDb->pBt;
88138 assert( pBt!=0 );
88144 if( ALWAYS(pBt) ){
88145 auto_vacuum = sqlite3BtreeGetAutoVacuum(pBt);
88160 int rc = sqlite3BtreeSetAutoVacuum(pBt, eAuto);
88236 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
88323 Pager *pPager = sqlite3BtreePager(pDb->pBt);
88337 Pager *pPager = sqlite3BtreePager(pDb->pBt);
88497 if( db->aDb[i].pBt==0 ) continue;
88502 sqlite3BtreeGetFilename(db->aDb[i].pBt), 0);
88983 Btree *pBt;
88989 pBt = db->aDb[i].pBt;
88990 if( pBt==0 || (pPager = sqlite3BtreePager(pBt))==0 ){
89050 sqlite3BtreeSetSafetyLevel(pDb->pBt, pDb->safety_level,
89238 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
89273 if( pDb->pBt==0 ){
89283 sqlite3BtreeEnter(pDb->pBt);
89284 if( !sqlite3BtreeIsInReadTrans(pDb->pBt) ){
89285 rc = sqlite3BtreeBeginTrans(pDb->pBt, 0);
89311 sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);
89346 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
89424 sqlite3BtreeCommit(pDb->pBt);
89426 sqlite3BtreeLeave(pDb->pBt);
89516 Btree *pBt = db->aDb[iDb].pBt; /* Btree database to read cookie from */
89517 if( pBt==0 ) continue;
89522 if( !sqlite3BtreeIsInReadTrans(pBt) ){
89523 rc = sqlite3BtreeBeginTrans(pBt, 0);
89534 sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&cookie);
89543 sqlite3BtreeCommit(pBt);
89632 Btree *pBt = db->aDb[i].pBt;
89633 if( pBt ){
89634 assert( sqlite3BtreeHoldsMutex(pBt) );
89635 rc = sqlite3BtreeSchemaLocked(pBt);
96494 pMain = db->aDb[0].pBt;
96523 pTemp = db->aDb[db->nDb-1].pBt;
96698 sqlite3BtreeClose(pDb->pBt);
96699 pDb->pBt = 0;
107957 Btree *pBt = db->aDb[j].pBt;
107958 if( pBt && sqlite3BtreeIsInBackup(pBt) ){
107971 if( pDb->pBt ){
107972 sqlite3BtreeClose(pDb->pBt);
107973 pDb->pBt = 0;
108057 if( db->aDb[i].pBt ){
108058 if( sqlite3BtreeIsInTrans(db->aDb[i].pBt) ){
108061 sqlite3BtreeRollback(db->aDb[i].pBt);
108709 rc = sqlite3BtreeCheckpoint(db->aDb[i].pBt, eMode, pnLog, pnCkpt);
109182 rc = sqlite3BtreeOpen(zFilename, db, &db->aDb[0].pBt, 0,
109191 db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt);
109264 sqlite3PagerLockingMode(sqlite3BtreePager(db->aDb[0].pBt),
109670 Btree *pBtree = db->aDb[iDb].pBt;
109847 sqlite3BtreeSetPageSize(db->aDb[0].pBt, 0, x, 0);
110641 Btree *pBt = NULL;
110645 pBt = db->aDb[i].pBt;
110649 if( !pBt ){
110653 *pPager = sqlite3BtreePager(pBt);
110654 *pnPageSize = sqlite3BtreeGetPageSize(pBt) - sqlite3BtreeGetReserve(pBt);
