internal static RC sqlite3BtreeIncrVacuum(Btree p) { var pBt = p.Shared; p.sqlite3BtreeEnter(); Debug.Assert(pBt.InTransaction == TRANS.WRITE && p.InTransaction == TRANS.WRITE); RC rc; if (!pBt.AutoVacuum) { rc = RC.DONE; } else { Btree.invalidateAllOverflowCache(pBt); rc = incrVacuumStep(pBt, 0, pBt.btreePagecount()); if (rc == RC.OK) { rc = Pager.Write(pBt.Page1.DbPage); ConvertEx.Put4(pBt.Page1.Data, 28, pBt.Pages); } } p.sqlite3BtreeLeave(); return(rc); }
// was:sqlite3BtreeSetVersion public RC SetVersion(int iVersion) { var pBt = this.Shared; Debug.Assert(this.InTransaction == TRANS.NONE); Debug.Assert(iVersion == 1 || iVersion == 2); // If setting the version fields to 1, do not automatically open the WAL connection, even if the version fields are currently set to 2. pBt.DoNotUseWal = iVersion == 1; var rc = BeginTrans(0); if (rc == RC.OK) { var aData = pBt.Page1.Data; if (aData[18] != (byte)iVersion || aData[19] != (byte)iVersion) { rc = BeginTrans(2); if (rc == RC.OK) { rc = Pager.Write(pBt.Page1.DbPage); if (rc == RC.OK) { aData[18] = (byte)iVersion; aData[19] = (byte)iVersion; } } } } pBt.DoNotUseWal = false; return(rc); }
internal static RC autoVacuumCommit(BtShared pBt) { var rc = RC.OK; var pPager = pBt.Pager; #if DEBUG var nRef = pPager.RefCount; #else var nRef = 0; #endif Debug.Assert(MutexEx.Held(pBt.Mutex)); Btree.invalidateAllOverflowCache(pBt); Debug.Assert(pBt.AutoVacuum); if (!pBt.IncrVacuum) { var nOrig = pBt.btreePagecount(); // Database size before freeing if (PTRMAP_ISPAGE(pBt, nOrig) || nOrig == PENDING_BYTE_PAGE(pBt)) { // It is not possible to create a database for which the final page is either a pointer-map page or the pending-byte page. If one // is encountered, this indicates corruption. return(SysEx.SQLITE_CORRUPT_BKPT()); } var nFree = (Pgno)ConvertEx.Get4(pBt.Page1.Data, 36); // Number of pages on the freelist initially var nEntry = (int)pBt.UsableSize / 5; // Number of entries on one ptrmap page var nPtrmap = (Pgno)((nFree - nOrig + PTRMAP_PAGENO(pBt, nOrig) + (Pgno)nEntry) / nEntry); // Number of PtrMap pages to be freed var nFin = nOrig - nFree - nPtrmap; // Number of pages in database after autovacuuming if (nOrig > PENDING_BYTE_PAGE(pBt) && nFin < PENDING_BYTE_PAGE(pBt)) { nFin--; } while (PTRMAP_ISPAGE(pBt, nFin) || nFin == PENDING_BYTE_PAGE(pBt)) { nFin--; } if (nFin > nOrig) { return(SysEx.SQLITE_CORRUPT_BKPT()); } for (var iFree = nOrig; iFree > nFin && rc == RC.OK; iFree--) { rc = incrVacuumStep(pBt, nFin, iFree); } if ((rc == RC.DONE || rc == RC.OK) && nFree > 0) { rc = Pager.Write(pBt.Page1.DbPage); ConvertEx.Put4(pBt.Page1.Data, 32, 0); ConvertEx.Put4(pBt.Page1.Data, 36, 0); ConvertEx.Put4(pBt.Page1.Data, 28, nFin); pBt.Pager.TruncateImage(nFin); pBt.Pages = nFin; } if (rc != RC.OK) { pPager.Rollback(); } } Debug.Assert(nRef == pPager.RefCount); return(rc); }
internal RC clearDatabasePage(Pgno pgno, int freePageFlag, ref int pnChange) { var pPage = new MemPage(); Debug.Assert(MutexEx.Held(this.Mutex)); if (pgno > btreePagecount()) { return(SysEx.SQLITE_CORRUPT_BKPT()); } var rc = getAndInitPage(pgno, ref pPage); if (rc != RC.OK) { return(rc); } for (var i = 0; i < pPage.Cells; i++) { var iCell = pPage.FindCell(i); var pCell = pPage.Data; if (pPage.Leaf == 0) { rc = clearDatabasePage(ConvertEx.Get4(pCell, iCell), 1, ref pnChange); if (rc != RC.OK) { goto cleardatabasepage_out; } } rc = pPage.clearCell(iCell); if (rc != RC.OK) { goto cleardatabasepage_out; } } if (pPage.Leaf == 0) { rc = clearDatabasePage(ConvertEx.Get4(pPage.Data, 8), 1, ref pnChange); if (rc != RC.OK) { goto cleardatabasepage_out; } } else { pnChange += pPage.Cells; } if (freePageFlag != 0) { pPage.freePage(ref rc); } else if ((rc = Pager.Write(pPage.DbPage)) == RC.OK) { pPage.zeroPage(pPage.Data[0] | Btree.PTF_LEAF); } cleardatabasepage_out: pPage.releasePage(); return(rc); }
internal void ptrmapPut(Pgno key, PTRMAP eType, Pgno parent, ref RC rRC) { if (rRC != RC.OK) { return; } Debug.Assert(MutexEx.Held(this.Mutex)); // The master-journal page number must never be used as a pointer map page Debug.Assert(!MemPage.PTRMAP_ISPAGE(this, MemPage.PENDING_BYTE_PAGE(this))); Debug.Assert(this.AutoVacuum); if (key == 0) { rRC = SysEx.SQLITE_CORRUPT_BKPT(); return; } var iPtrmap = MemPage.PTRMAP_PAGENO(this, key); var pDbPage = new PgHdr(); // The pointer map page var rc = this.Pager.Get(iPtrmap, ref pDbPage); if (rc != RC.OK) { rRC = rc; return; } var offset = (int)MemPage.PTRMAP_PTROFFSET(iPtrmap, key); if (offset < 0) { rRC = SysEx.SQLITE_CORRUPT_BKPT(); goto ptrmap_exit; } Debug.Assert(offset <= (int)this.UsableSize - 5); var pPtrmap = Pager.sqlite3PagerGetData(pDbPage); // The pointer map data if (eType != (PTRMAP)pPtrmap[offset] || ConvertEx.Get4(pPtrmap, offset + 1) != parent) { Btree.TRACE("PTRMAP_UPDATE: {0}->({1},{2})", key, eType, parent); rRC = rc = Pager.Write(pDbPage); if (rc == RC.OK) { pPtrmap[offset] = (byte)eType; ConvertEx.Put4L(pPtrmap, (uint)offset + 1, parent); } } ptrmap_exit: Pager.Unref(pDbPage); }
internal static RC balance_deeper(MemPage pRoot, ref MemPage ppChild) { MemPage pChild = null; // Pointer to a new child page Pgno pgnoChild = 0; // Page number of the new child page var pBt = pRoot.Shared; Debug.Assert(pRoot.NOverflows > 0); Debug.Assert(MutexEx.Held(pBt.Mutex)); // Make pRoot, the root page of the b-tree, writable. Allocate a new page that will become the new right-child of pPage. Copy the contents // of the node stored on pRoot into the new child page. var rc = Pager.Write(pRoot.DbPage); if (rc == RC.OK) { rc = pBt.allocateBtreePage(ref pChild, ref pgnoChild, pRoot.ID, 0); copyNodeContent(pRoot, pChild, ref rc); #if !SQLITE_OMIT_AUTOVACUUM if (pBt.AutoVacuum) #else if (false) #endif { pBt.ptrmapPut(pgnoChild, PTRMAP.BTREE, pRoot.ID, ref rc); } } if (rc != RC.OK) { ppChild = null; pChild.releasePage(); return(rc); } Debug.Assert(Pager.IsPageWriteable(pChild.DbPage)); Debug.Assert(Pager.IsPageWriteable(pRoot.DbPage)); Debug.Assert(pChild.Cells == pRoot.Cells); Btree.TRACE("BALANCE: copy root %d into %d\n", pRoot.ID, pChild.ID); // Copy the overflow cells from pRoot to pChild Array.Copy(pRoot.Overflows, pChild.Overflows, pRoot.NOverflows); pChild.NOverflows = pRoot.NOverflows; // Zero the contents of pRoot. Then install pChild as the right-child. pRoot.zeroPage(pChild.Data[0] & ~Btree.PTF_LEAF); ConvertEx.Put4L(pRoot.Data, pRoot.HeaderOffset + 8, pgnoChild); ppChild = pChild; return(RC.OK); }
// was:fetchPayload private static RC CopyPayload(DbPage dbPage, byte[] payload, uint payloadOffset, byte[] b, uint bOffset, uint count, bool writeOperation) { if (writeOperation) { // Copy data from buffer to page (a write operation) var rc = Pager.Write(dbPage); if (rc != RC.OK) { return(rc); } Buffer.BlockCopy(b, (int)bOffset, payload, (int)payloadOffset, (int)count); } else { // Copy data from page to buffer (a read operation) Buffer.BlockCopy(payload, (int)payloadOffset, b, (int)bOffset, (int)count); } return(RC.OK); }
internal RC newDatabase() { Debug.Assert(MutexEx.Held(this.Mutex)); if (this.Pages > 0) { return(RC.OK); } var pP1 = this.Page1; Debug.Assert(pP1 != null); var data = pP1.Data; var rc = Pager.Write(pP1.DbPage); if (rc != RC.OK) { return(rc); } Buffer.BlockCopy(Btree.zMagicHeader, 0, data, 0, 16); Debug.Assert(Btree.zMagicHeader.Length == 16); data[16] = (byte)((this.PageSize >> 8) & 0xff); data[17] = (byte)((this.PageSize >> 16) & 0xff); data[18] = 1; data[19] = 1; Debug.Assert(this.UsableSize <= this.PageSize && this.UsableSize + 255 >= this.PageSize); data[20] = (byte)(this.PageSize - this.UsableSize); data[21] = 64; data[22] = 32; data[23] = 32; pP1.zeroPage(Btree.PTF_INTKEY | Btree.PTF_LEAF | Btree.PTF_LEAFDATA); this.PageSizeFixed = true; #if !SQLITE_OMIT_AUTOVACUUM Debug.Assert(this.AutoVacuum == true || this.AutoVacuum == false); Debug.Assert(this.IncrVacuum == true || this.IncrVacuum == false); ConvertEx.Put4(data, 36 + 4 * 4, this.AutoVacuum ? 1 : 0); ConvertEx.Put4(data, 36 + 7 * 4, this.IncrVacuum ? 1 : 0); #endif this.Pages = 1; data[31] = 1; return(RC.OK); }
// was:sqlite3BtreeUpdateMeta public RC SetMeta(int idx, uint iMeta) { var pBt = this.Shared; Debug.Assert(idx >= 1 && idx <= 15); sqlite3BtreeEnter(); Debug.Assert(this.InTransaction == TRANS.WRITE); Debug.Assert(pBt.Page1 != null); var pP1 = pBt.Page1.Data; var rc = Pager.Write(pBt.Page1.DbPage); if (rc == RC.OK) { ConvertEx.Put4L(pP1, (uint)(36 + idx * 4), iMeta); #if !SQLITE_OMIT_AUTOVACUUM if (idx == (int)META.INCR_VACUUM) { Debug.Assert(pBt.AutoVacuum || iMeta == 0); Debug.Assert(iMeta == 0 || iMeta == 1); pBt.IncrVacuum = iMeta != 0; } #endif } sqlite3BtreeLeave(); return rc; }
// was:sqlite3BtreeBeginTrans public RC BeginTrans(byte wrflag) { var shared = this.Shared; var rc = RC.OK; sqlite3BtreeEnter(); btreeIntegrity(); // If the btree is already in a write-transaction, or it is already in a read-transaction and a read-transaction is requested, this is a no-op. if (this.InTransaction == TRANS.WRITE || (this.InTransaction == TRANS.READ && wrflag == 0)) goto trans_begun; // Write transactions are not possible on a read-only database if (shared.ReadOnly && wrflag != 0) { rc = RC.READONLY; goto trans_begun; } #if !SQLITE_OMIT_SHARED_CACHE // If another database handle has already opened a write transaction on this shared-btree structure and a second write transaction is // requested, return SQLITE_LOCKED. sqlite3b sharedDB = null; if ((wrflag != 0 && shared.InTransaction == TRANS.WRITE) || shared.IsPending) sharedDB = shared.Writer.DB; else if (wrflag > 1) for (var @lock = shared.Locks; @lock != null; @lock = @lock.Next) if (@lock.Tree != this) { sharedDB = @lock.Tree.DB; break; } if (sharedDB != null) { sqlite3b.sqlite3ConnectionBlocked(this.DB, sharedDB); rc = RC.LOCKED_SHAREDCACHE; goto trans_begun; } #endif // Any read-only or read-write transaction implies a read-lock on page 1. So if some other shared-cache client already has a write-lock // on page 1, the transaction cannot be opened. */ rc = querySharedCacheTableLock(MASTER_ROOT, LOCK.READ); if (rc != RC.OK) goto trans_begun; shared.InitiallyEmpty = shared.Pages == 0; do { // Call lockBtree() until either pBt.pPage1 is populated or lockBtree() returns something other than SQLITE_OK. lockBtree() // may return SQLITE_OK but leave pBt.pPage1 set to 0 if after reading page 1 it discovers that the page-size of the database // file is not pBt.pageSize. In this case lockBtree() will update pBt.pageSize to the page-size of the file on disk. while (shared.Page1 == null && (rc = shared.lockBtree()) == RC.OK) ; if (rc == RC.OK && wrflag != 0) { if (shared.ReadOnly) rc = RC.READONLY; else { rc = shared.Pager.Begin(wrflag > 1, this.DB.sqlite3TempInMemory()); if (rc == RC.OK) rc = shared.newDatabase(); } } if (rc != RC.OK) shared.unlockBtreeIfUnused(); } while (((int)rc & 0xFF) == (int)RC.BUSY && shared.InTransaction == TRANS.NONE && btreeInvokeBusyHandler(shared) != 0); if (rc == RC.OK) { if (this.InTransaction == TRANS.NONE) { shared.Transactions++; #if !SQLITE_OMIT_SHARED_CACHE if (Sharable) { Debug.Assert(Locks.Tree == this && Locks.TableID == 1); Locks.Lock = LOCK.READ; Locks.Next = shared.Locks; shared.Locks = Locks; } #endif } this.InTransaction = (wrflag != 0 ? TRANS.WRITE : TRANS.READ); if (this.InTransaction > shared.InTransaction) shared.InTransaction = this.InTransaction; if (wrflag != 0) { var pPage1 = shared.Page1; #if !SQLITE_OMIT_SHARED_CACHE Debug.Assert(shared.Writer == null); shared.Writer = this; shared.IsExclusive = (wrflag > 1); #endif // If the db-size header field is incorrect (as it may be if an old client has been writing the database file), update it now. Doing // this sooner rather than later means the database size can safely re-read the database size from page 1 if a savepoint or transaction // rollback occurs within the transaction. if (shared.Pages != ConvertEx.Get4(pPage1.Data, 28)) { rc = Pager.Write(pPage1.DbPage); if (rc == RC.OK) ConvertEx.Put4(pPage1.Data, 28, shared.Pages); } } } trans_begun: if (rc == RC.OK && wrflag != 0) // This call makes sure that the pager has the correct number of open savepoints. If the second parameter is greater than 0 and // the sub-journal is not already open, then it will be opened here. rc = shared.Pager.OpenSavepoint(this.DB.nSavepoint); btreeIntegrity(); sqlite3BtreeLeave(); return rc; }
internal static RC incrVacuumStep(BtShared pBt, Pgno nFin, Pgno iLastPg) { Pgno nFreeList; // Number of pages still on the free-list Debug.Assert(MutexEx.Held(pBt.Mutex)); Debug.Assert(iLastPg > nFin); if (!PTRMAP_ISPAGE(pBt, iLastPg) && iLastPg != PENDING_BYTE_PAGE(pBt)) { PTRMAP eType = 0; Pgno iPtrPage = 0; nFreeList = ConvertEx.Get4(pBt.Page1.Data, 36); if (nFreeList == 0) { return(RC.DONE); } var rc = pBt.ptrmapGet(iLastPg, ref eType, ref iPtrPage); if (rc != RC.OK) { return(rc); } if (eType == PTRMAP.ROOTPAGE) { return(SysEx.SQLITE_CORRUPT_BKPT()); } if (eType == PTRMAP.FREEPAGE) { if (nFin == 0) { // Remove the page from the files free-list. This is not required if nFin is non-zero. In that case, the free-list will be // truncated to zero after this function returns, so it doesn't matter if it still contains some garbage entries. Pgno iFreePg = 0; var pFreePg = new MemPage(); rc = pBt.allocateBtreePage(ref pFreePg, ref iFreePg, iLastPg, 1); if (rc != RC.OK) { return(rc); } Debug.Assert(iFreePg == iLastPg); pFreePg.releasePage(); } } else { Pgno iFreePg = 0; // Index of free page to move pLastPg to var pLastPg = new MemPage(); rc = pBt.btreeGetPage(iLastPg, ref pLastPg, 0); if (rc != RC.OK) { return(rc); } // If nFin is zero, this loop runs exactly once and page pLastPg is swapped with the first free page pulled off the free list. // On the other hand, if nFin is greater than zero, then keep looping until a free-page located within the first nFin pages of the file is found. do { var pFreePg = new MemPage(); rc = pBt.allocateBtreePage(ref pFreePg, ref iFreePg, 0, 0); if (rc != RC.OK) { pLastPg.releasePage(); return(rc); } pFreePg.releasePage(); } while (nFin != 0 && iFreePg > nFin); Debug.Assert(iFreePg < iLastPg); rc = Pager.Write(pLastPg.DbPage); if (rc == RC.OK) { rc = relocatePage(pBt, pLastPg, eType, iPtrPage, iFreePg, (nFin != 0) ? 1 : 0); } pLastPg.releasePage(); if (rc != RC.OK) { return(rc); } } } if (nFin == 0) { iLastPg--; while (iLastPg == PENDING_BYTE_PAGE(pBt) || PTRMAP_ISPAGE(pBt, iLastPg)) { if (PTRMAP_ISPAGE(pBt, iLastPg)) { var pPg = new MemPage(); var rc = pBt.btreeGetPage(iLastPg, ref pPg, 0); if (rc != RC.OK) { return(rc); } rc = Pager.Write(pPg.DbPage); pPg.releasePage(); if (rc != RC.OK) { return(rc); } } iLastPg--; } pBt.Pager.TruncateImage(iLastPg); pBt.Pages = iLastPg; } return(RC.OK); }
internal static RC balance_nonroot(MemPage pParent, int iParentIdx, byte[] aOvflSpace, int isRoot) { var apOld = new MemPage[NB]; // pPage and up to two siblings var apCopy = new MemPage[NB]; // Private copies of apOld[] pages var apNew = new MemPage[NB + 2]; // pPage and up to NB siblings after balancing var apDiv = new int[NB - 1]; // Divider cells in pParent var cntNew = new int[NB + 2]; // Index in aCell[] of cell after i-th page var szNew = new int[NB + 2]; // Combined size of cells place on i-th page var szCell = new ushort[1]; // Local size of all cells in apCell[] BtShared pBt; // The whole database int nCell = 0; // Number of cells in apCell[] int nMaxCells = 0; // Allocated size of apCell, szCell, aFrom. int nNew = 0; // Number of pages in apNew[] ushort leafCorrection; // 4 if pPage is a leaf. 0 if not int leafData; // True if pPage is a leaf of a LEAFDATA tree int usableSpace; // Bytes in pPage beyond the header int pageFlags; // Value of pPage.aData[0] int subtotal; // Subtotal of bytes in cells on one page int iOvflSpace = 0; // First unused byte of aOvflSpace[] //int szScratch; // Size of scratch memory requested byte[][] apCell = null; // All cells begin balanced // pBt = pParent.Shared; Debug.Assert(MutexEx.Held(pBt.Mutex)); Debug.Assert(Pager.IsPageWriteable(pParent.DbPage)); #if false Btree.TRACE("BALANCE: begin page %d child of %d\n", pPage.pgno, pParent.pgno); #endif // At this point pParent may have at most one overflow cell. And if this overflow cell is present, it must be the cell with // index iParentIdx. This scenario comes about when this function is called (indirectly) from sqlite3BtreeDelete(). Debug.Assert(pParent.NOverflows == 0 || pParent.NOverflows == 1); Debug.Assert(pParent.NOverflows == 0 || pParent.Overflows[0].Index == iParentIdx); // Find the sibling pages to balance. Also locate the cells in pParent that divide the siblings. An attempt is made to find NN siblings on // either side of pPage. More siblings are taken from one side, however, if there are fewer than NN siblings on the other side. If pParent // has NB or fewer children then all children of pParent are taken. // This loop also drops the divider cells from the parent page. This way, the remainder of the function does not have to deal with any // overflow cells in the parent page, since if any existed they will have already been removed. int nOld; // Number of pages in apOld[] int nxDiv; // Next divider slot in pParent.aCell[] var i = pParent.NOverflows + pParent.Cells; if (i < 2) { nxDiv = 0; nOld = i + 1; } else { nOld = 3; if (iParentIdx == 0) { nxDiv = 0; } else if (iParentIdx == i) { nxDiv = i - 2; } else { nxDiv = iParentIdx - 1; } i = 2; } var pRight = ((i + nxDiv - pParent.NOverflows) == pParent.Cells ? pParent.HeaderOffset + 8 : pParent.FindCell(i + nxDiv - pParent.NOverflows)); // Location in parent of right-sibling pointer var pgno = (Pgno)ConvertEx.Get4(pParent.Data, pRight); var rc = RC.OK; while (true) { rc = pBt.getAndInitPage(pgno, ref apOld[i]); if (rc != RC.OK) { goto balance_cleanup; } nMaxCells += 1 + apOld[i].Cells + apOld[i].NOverflows; if (i-- == 0) { break; } if (i + nxDiv == pParent.Overflows[0].Index && pParent.NOverflows != 0) { apDiv[i] = 0; pgno = ConvertEx.Get4(pParent.Overflows[0].Cell, apDiv[i]); szNew[i] = pParent.cellSizePtr(apDiv[i]); pParent.NOverflows = 0; } else { apDiv[i] = pParent.FindCell(i + nxDiv - pParent.NOverflows); pgno = ConvertEx.Get4(pParent.Data, apDiv[i]); szNew[i] = pParent.cellSizePtr(apDiv[i]); // Drop the cell from the parent page. apDiv[i] still points to the cell within the parent, even though it has been dropped. // This is safe because dropping a cell only overwrites the first four bytes of it, and this function does not need the first // four bytes of the divider cell. So the pointer is safe to use later on. // // Unless SQLite is compiled in secure-delete mode. In this case, the dropCell() routine will overwrite the entire cell with zeroes. // In this case, temporarily copy the cell into the aOvflSpace[] buffer. It will be copied out again as soon as the aSpace[] buffer // is allocated. //if (pBt.secureDelete) //{ // int iOff = (int)(apDiv[i]) - (int)(pParent.aData); //SQLITE_PTR_TO_INT(apDiv[i]) - SQLITE_PTR_TO_INT(pParent.aData); // if( (iOff+szNew[i])>(int)pBt->usableSize ) // { // rc = SQLITE_CORRUPT_BKPT(); // Array.Clear(apOld[0].aData,0,apOld[0].aData.Length); //memset(apOld, 0, (i + 1) * sizeof(MemPage*)); // goto balance_cleanup; // } // else // { // memcpy(&aOvflSpace[iOff], apDiv[i], szNew[i]); // apDiv[i] = &aOvflSpace[apDiv[i] - pParent.aData]; // } //} pParent.dropCell(i + nxDiv - pParent.NOverflows, szNew[i], ref rc); } } // Make nMaxCells a multiple of 4 in order to preserve 8-byte alignment nMaxCells = (nMaxCells + 3) & ~3; // Allocate space for memory structures apCell = MallocEx.sqlite3ScratchMalloc(apCell, nMaxCells); if (szCell.Length < nMaxCells) { Array.Resize(ref szCell, nMaxCells); } // Load pointers to all cells on sibling pages and the divider cells into the local apCell[] array. Make copies of the divider cells // into space obtained from aSpace1[] and remove the the divider Cells from pParent. // If the siblings are on leaf pages, then the child pointers of the divider cells are stripped from the cells before they are copied // into aSpace1[]. In this way, all cells in apCell[] are without child pointers. If siblings are not leaves, then all cell in // apCell[] include child pointers. Either way, all cells in apCell[] are alike. // leafCorrection: 4 if pPage is a leaf. 0 if pPage is not a leaf. // leafData: 1 if pPage holds key+data and pParent holds only keys. leafCorrection = (ushort)(apOld[0].Leaf * 4); leafData = apOld[0].HasData; int j; for (i = 0; i < nOld; i++) { // Before doing anything else, take a copy of the i'th original sibling The rest of this function will use data from the copies rather // that the original pages since the original pages will be in the process of being overwritten. var pOld = apCopy[i] = apOld[i].Clone(); var limit = pOld.Cells + pOld.NOverflows; if (pOld.NOverflows > 0 || true) { for (j = 0; j < limit; j++) { Debug.Assert(nCell < nMaxCells); var iFOFC = pOld.FindOverflowCell(j); szCell[nCell] = pOld.cellSizePtr(iFOFC); // Copy the Data Locally if (apCell[nCell] == null) { apCell[nCell] = new byte[szCell[nCell]]; } else if (apCell[nCell].Length < szCell[nCell]) { Array.Resize(ref apCell[nCell], szCell[nCell]); } if (iFOFC < 0) // Overflow Cell { Buffer.BlockCopy(pOld.Overflows[-(iFOFC + 1)].Cell, 0, apCell[nCell], 0, szCell[nCell]); } else { Buffer.BlockCopy(pOld.Data, iFOFC, apCell[nCell], 0, szCell[nCell]); } nCell++; } } else { var aData = pOld.Data; var maskPage = pOld.MaskPage; var cellOffset = pOld.CellOffset; for (j = 0; j < limit; j++) { Debugger.Break(); Debug.Assert(nCell < nMaxCells); apCell[nCell] = FindCellv2(aData, maskPage, cellOffset, j); szCell[nCell] = pOld.cellSizePtr(apCell[nCell]); nCell++; } } if (i < nOld - 1 && 0 == leafData) { var sz = (ushort)szNew[i]; var pTemp = MallocEx.sqlite3Malloc(sz + leafCorrection); Debug.Assert(nCell < nMaxCells); szCell[nCell] = sz; Debug.Assert(sz <= pBt.MaxLocal + 23); Buffer.BlockCopy(pParent.Data, apDiv[i], pTemp, 0, sz); if (apCell[nCell] == null || apCell[nCell].Length < sz) { Array.Resize(ref apCell[nCell], sz); } Buffer.BlockCopy(pTemp, leafCorrection, apCell[nCell], 0, sz); Debug.Assert(leafCorrection == 0 || leafCorrection == 4); szCell[nCell] = (ushort)(szCell[nCell] - leafCorrection); if (0 == pOld.Leaf) { Debug.Assert(leafCorrection == 0); Debug.Assert(pOld.HeaderOffset == 0); // The right pointer of the child page pOld becomes the left pointer of the divider cell Buffer.BlockCopy(pOld.Data, 8, apCell[nCell], 0, 4);//memcpy( apCell[nCell], ref pOld.aData[8], 4 ); } else { Debug.Assert(leafCorrection == 4); if (szCell[nCell] < 4) { // Do not allow any cells smaller than 4 bytes. szCell[nCell] = 4; } } nCell++; } } // Figure out the number of pages needed to hold all nCell cells. Store this number in "k". Also compute szNew[] which is the total // size of all cells on the i-th page and cntNew[] which is the index in apCell[] of the cell that divides page i from page i+1. // cntNew[k] should equal nCell. // Values computed by this block: // k: The total number of sibling pages // szNew[i]: Spaced used on the i-th sibling page. // cntNew[i]: Index in apCell[] and szCell[] for the first cell to // the right of the i-th sibling page. // usableSpace: Number of bytes of space available on each sibling. usableSpace = (int)pBt.UsableSize - 12 + leafCorrection; int k; for (subtotal = k = i = 0; i < nCell; i++) { Debug.Assert(i < nMaxCells); subtotal += szCell[i] + 2; if (subtotal > usableSpace) { szNew[k] = subtotal - szCell[i]; cntNew[k] = i; if (leafData != 0) { i--; } subtotal = 0; k++; if (k > NB + 1) { rc = SysEx.SQLITE_CORRUPT_BKPT(); goto balance_cleanup; } } } szNew[k] = subtotal; cntNew[k] = nCell; k++; // The packing computed by the previous block is biased toward the siblings on the left side. The left siblings are always nearly full, while the // right-most sibling might be nearly empty. This block of code attempts to adjust the packing of siblings to get a better balance. // // This adjustment is more than an optimization. The packing above might be so out of balance as to be illegal. For example, the right-most // sibling might be completely empty. This adjustment is not optional. for (i = k - 1; i > 0; i--) { var szRight = szNew[i]; // Size of sibling on the right var szLeft = szNew[i - 1]; // Size of sibling on the left var r = cntNew[i - 1] - 1; // Index of right-most cell in left sibling var d = r + 1 - leafData; // Index of first cell to the left of right sibling Debug.Assert(d < nMaxCells); Debug.Assert(r < nMaxCells); while (szRight == 0 || szRight + szCell[d] + 2 <= szLeft - (szCell[r] + 2)) { szRight += szCell[d] + 2; szLeft -= szCell[r] + 2; cntNew[i - 1]--; r = cntNew[i - 1] - 1; d = r + 1 - leafData; } szNew[i] = szRight; szNew[i - 1] = szLeft; } // Either we found one or more cells (cntnew[0])>0) or pPage is a virtual root page. A virtual root page is when the real root // page is page 1 and we are the only child of that page. Debug.Assert(cntNew[0] > 0 || (pParent.ID == 1 && pParent.Cells == 0)); Btree.TRACE("BALANCE: old: %d %d %d ", apOld[0].ID, (nOld >= 2 ? apOld[1].ID : 0), (nOld >= 3 ? apOld[2].ID : 0)); // Allocate k new pages. Reuse old pages where possible. if (apOld[0].ID <= 1) { rc = SysEx.SQLITE_CORRUPT_BKPT(); goto balance_cleanup; } pageFlags = apOld[0].Data[0]; for (i = 0; i < k; i++) { var pNew = new MemPage(); if (i < nOld) { pNew = apNew[i] = apOld[i]; apOld[i] = null; rc = Pager.Write(pNew.DbPage); nNew++; if (rc != RC.OK) { goto balance_cleanup; } } else { Debug.Assert(i > 0); rc = pBt.allocateBtreePage(ref pNew, ref pgno, pgno, 0); if (rc != 0) { goto balance_cleanup; } apNew[i] = pNew; nNew++; // Set the pointer-map entry for the new sibling page. #if !SQLITE_OMIT_AUTOVACUUM if (pBt.AutoVacuum) #else if (false) #endif { pBt.ptrmapPut(pNew.ID, PTRMAP.BTREE, pParent.ID, ref rc); if (rc != RC.OK) { goto balance_cleanup; } } } } // Free any old pages that were not reused as new pages. while (i < nOld) { apOld[i].freePage(ref rc); if (rc != RC.OK) { goto balance_cleanup; } apOld[i].releasePage(); apOld[i] = null; i++; } // Put the new pages in accending order. This helps to keep entries in the disk file in order so that a scan // of the table is a linear scan through the file. That in turn helps the operating system to deliver pages // from the disk more rapidly. // An O(n^2) insertion sort algorithm is used, but since n is never more than NB (a small constant), that should // not be a problem. // When NB==3, this one optimization makes the database about 25% faster for large insertions and deletions. for (i = 0; i < k - 1; i++) { var minV = (int)apNew[i].ID; var minI = i; for (j = i + 1; j < k; j++) { if (apNew[j].ID < (uint)minV) { minI = j; minV = (int)apNew[j].ID; } } if (minI > i) { var pT = apNew[i]; apNew[i] = apNew[minI]; apNew[minI] = pT; } } Btree.TRACE("new: %d(%d) %d(%d) %d(%d) %d(%d) %d(%d)\n", apNew[0].ID, szNew[0], (nNew >= 2 ? apNew[1].ID : 0), (nNew >= 2 ? szNew[1] : 0), (nNew >= 3 ? apNew[2].ID : 0), (nNew >= 3 ? szNew[2] : 0), (nNew >= 4 ? apNew[3].ID : 0), (nNew >= 4 ? szNew[3] : 0), (nNew >= 5 ? apNew[4].ID : 0), (nNew >= 5 ? szNew[4] : 0)); Debug.Assert(Pager.IsPageWriteable(pParent.DbPage)); ConvertEx.Put4L(pParent.Data, pRight, apNew[nNew - 1].ID); // Evenly distribute the data in apCell[] across the new pages. Insert divider cells into pParent as necessary. j = 0; for (i = 0; i < nNew; i++) { // Assemble the new sibling page. MemPage pNew = apNew[i]; Debug.Assert(j < nMaxCells); pNew.zeroPage(pageFlags); pNew.assemblePage(cntNew[i] - j, apCell, szCell, j); Debug.Assert(pNew.Cells > 0 || (nNew == 1 && cntNew[0] == 0)); Debug.Assert(pNew.NOverflows == 0); j = cntNew[i]; // If the sibling page assembled above was not the right-most sibling, insert a divider cell into the parent page. Debug.Assert(i < nNew - 1 || j == nCell); if (j < nCell) { Debug.Assert(j < nMaxCells); var pCell = apCell[j]; var sz = szCell[j] + leafCorrection; var pTemp = MallocEx.sqlite3Malloc(sz); if (pNew.Leaf == 0) { Buffer.BlockCopy(pCell, 0, pNew.Data, 8, 4); } else if (leafData != 0) { // If the tree is a leaf-data tree, and the siblings are leaves, then there is no divider cell in apCell[]. Instead, the divider // cell consists of the integer key for the right-most cell of the sibling-page assembled above only. var info = new CellInfo(); j--; pNew.btreeParseCellPtr(apCell[j], ref info); pCell = pTemp; sz = 4 + ConvertEx.PutVarint9L(pCell, 4, (ulong)info.nKey); pTemp = null; } else { //------------ pCell -= 4; var _pCell_4 = MallocEx.sqlite3Malloc(pCell.Length + 4); Buffer.BlockCopy(pCell, 0, _pCell_4, 4, pCell.Length); pCell = _pCell_4; // Obscure case for non-leaf-data trees: If the cell at pCell was previously stored on a leaf node, and its reported size was 4 // bytes, then it may actually be smaller than this (see btreeParseCellPtr(), 4 bytes is the minimum size of // any cell). But it is important to pass the correct size to insertCell(), so reparse the cell now. // Note that this can never happen in an SQLite data file, as all cells are at least 4 bytes. It only happens in b-trees used // to evaluate "IN (SELECT ...)" and similar clauses. if (szCell[j] == 4) { Debug.Assert(leafCorrection == 4); sz = pParent.cellSizePtr(pCell); } } iOvflSpace += sz; Debug.Assert(sz <= pBt.MaxLocal + 23); Debug.Assert(iOvflSpace <= (int)pBt.PageSize); pParent.insertCell(nxDiv, pCell, sz, pTemp, pNew.ID, ref rc); if (rc != RC.OK) { goto balance_cleanup; } Debug.Assert(Pager.IsPageWriteable(pParent.DbPage)); j++; nxDiv++; } } Debug.Assert(j == nCell); Debug.Assert(nOld > 0); Debug.Assert(nNew > 0); if ((pageFlags & Btree.PTF_LEAF) == 0) { Buffer.BlockCopy(apCopy[nOld - 1].Data, 8, apNew[nNew - 1].Data, 8, 4); } if (isRoot != 0 && pParent.Cells == 0 && pParent.HeaderOffset <= apNew[0].FreeBytes) { // The root page of the b-tree now contains no cells. The only sibling page is the right-child of the parent. Copy the contents of the // child page into the parent, decreasing the overall height of the b-tree structure by one. This is described as the "balance-shallower" // sub-algorithm in some documentation. // If this is an auto-vacuum database, the call to copyNodeContent() sets all pointer-map entries corresponding to database image pages // for which the pointer is stored within the content being copied. // The second Debug.Assert below verifies that the child page is defragmented (it must be, as it was just reconstructed using assemblePage()). This // is important if the parent page happens to be page 1 of the database image. */ Debug.Assert(nNew == 1); Debug.Assert(apNew[0].FreeBytes == (ConvertEx.Get2(apNew[0].Data, 5) - apNew[0].CellOffset - apNew[0].Cells * 2)); copyNodeContent(apNew[0], pParent, ref rc); apNew[0].freePage(ref rc); } else #if !SQLITE_OMIT_AUTOVACUUM if (pBt.AutoVacuum) #else if (false) #endif { // Fix the pointer-map entries for all the cells that were shifted around. There are several different types of pointer-map entries that need to // be dealt with by this routine. Some of these have been set already, but many have not. The following is a summary: // 1) The entries associated with new sibling pages that were not siblings when this function was called. These have already // been set. We don't need to worry about old siblings that were moved to the free-list - the freePage() code has taken care // of those. // 2) The pointer-map entries associated with the first overflow page in any overflow chains used by new divider cells. These // have also already been taken care of by the insertCell() code. // 3) If the sibling pages are not leaves, then the child pages of cells stored on the sibling pages may need to be updated. // 4) If the sibling pages are not internal intkey nodes, then any overflow pages used by these cells may need to be updated // (internal intkey nodes never contain pointers to overflow pages). // 5) If the sibling pages are not leaves, then the pointer-map entries for the right-child pages of each sibling may need // to be updated. // Cases 1 and 2 are dealt with above by other code. The next block deals with cases 3 and 4 and the one after that, case 5. Since // setting a pointer map entry is a relatively expensive operation, this code only sets pointer map entries for child or overflow pages that have // actually moved between pages. var pNew = apNew[0]; var pOld = apCopy[0]; var nOverflow = pOld.NOverflows; var iNextOld = pOld.Cells + nOverflow; var iOverflow = (nOverflow != 0 ? pOld.Overflows[0].Index : -1); j = 0; // Current 'old' sibling page k = 0; // Current 'new' sibling page for (i = 0; i < nCell; i++) { var isDivider = 0; while (i == iNextOld) { // Cell i is the cell immediately following the last cell on old sibling page j. If the siblings are not leaf pages of an // intkey b-tree, then cell i was a divider cell. pOld = apCopy[++j]; iNextOld = i + (0 == leafData ? 1 : 0) + pOld.Cells + pOld.NOverflows; if (pOld.NOverflows != 0) { nOverflow = pOld.NOverflows; iOverflow = i + (0 == leafData ? 1 : 0) + pOld.Overflows[0].Index; } isDivider = 0 == leafData ? 1 : 0; } Debug.Assert(nOverflow > 0 || iOverflow < i); Debug.Assert(nOverflow < 2 || pOld.Overflows[0].Index == pOld.Overflows[1].Index - 1); Debug.Assert(nOverflow < 3 || pOld.Overflows[1].Index == pOld.Overflows[2].Index - 1); if (i == iOverflow) { isDivider = 1; if (--nOverflow > 0) { iOverflow++; } } if (i == cntNew[k]) { // Cell i is the cell immediately following the last cell on new sibling page k. If the siblings are not leaf pages of an // intkey b-tree, then cell i is a divider cell. pNew = apNew[++k]; if (leafData == 0) { continue; } } Debug.Assert(j < nOld); Debug.Assert(k < nNew); // If the cell was originally divider cell (and is not now) or an overflow cell, or if the cell was located on a different sibling // page before the balancing, then the pointer map entries associated with any child or overflow pages need to be updated. if (isDivider != 0 || pOld.ID != pNew.ID) { if (leafCorrection == 0) { pBt.ptrmapPut(ConvertEx.Get4(apCell[i]), PTRMAP.BTREE, pNew.ID, ref rc); } if (szCell[i] > pNew.MinLocal) { pNew.ptrmapPutOvflPtr(apCell[i], ref rc); } } } if (leafCorrection == 0) { for (i = 0; i < nNew; i++) { var key = ConvertEx.Get4(apNew[i].Data, 8); pBt.ptrmapPut(key, PTRMAP.BTREE, apNew[i].ID, ref rc); } } #if false // The ptrmapCheckPages() contains Debug.Assert() statements that verify that all pointer map pages are set correctly. This is helpful while // debugging. This is usually disabled because a corrupt database may cause an Debug.Assert() statement to fail. ptrmapCheckPages(apNew, nNew); ptrmapCheckPages(pParent, 1); #endif } Debug.Assert(pParent.HasInit); Btree.TRACE("BALANCE: finished: old=%d new=%d cells=%d\n", nOld, nNew, nCell); // Cleanup before returning. balance_cleanup: MallocEx.sqlite3ScratchFree(apCell); for (i = 0; i < nOld; i++) { apOld[i].releasePage(); } for (i = 0; i < nNew; i++) { apNew[i].releasePage(); } return(rc); }
// was:sqlite3BtreeDelete public RC Delete() { MemPage pPage; // Page to delete cell from int pCell; // Pointer to cell to delete int iCellIdx; // Index of cell to delete int iCellDepth; // Depth of node containing pCell var p = this.Tree; var pBt = p.Shared; Debug.Assert(HoldsMutex()); Debug.Assert(pBt.InTransaction == TRANS.WRITE); Debug.Assert(!pBt.ReadOnly); Debug.Assert(this.Writeable); Debug.Assert(p.hasSharedCacheTableLock(this.RootID, (this.KeyInfo != null), LOCK.WRITE)); Debug.Assert(!p.hasReadConflicts(this.RootID)); if (Check.NEVER(this.PagesIndexs[this.PageID] >= this.Pages[this.PageID].Cells) || Check.NEVER(this.State != CursorState.VALID)) { return(RC.ERROR); } // If this is a delete operation to remove a row from a table b-tree, invalidate any incrblob cursors open on the row being deleted. if (this.KeyInfo == null) { Btree.invalidateIncrblobCursors(p, this.Info.nKey, false); } iCellDepth = this.PageID; iCellIdx = this.PagesIndexs[iCellDepth]; pPage = this.Pages[iCellDepth]; pCell = pPage.FindCell(iCellIdx); // If the page containing the entry to delete is not a leaf page, move the cursor to the largest entry in the tree that is smaller than // the entry being deleted. This cell will replace the cell being deleted from the internal node. The 'previous' entry is used for this instead // of the 'next' entry, as the previous entry is always a part of the sub-tree headed by the child page of the cell being deleted. This makes // balancing the tree following the delete operation easier. RC rc; if (pPage.Leaf == 0) { var notUsed = 0; rc = MovePrevious(ref notUsed); if (rc != RC.OK) { return(rc); } } // Save the positions of any other cursors open on this table before making any modifications. Make the page containing the entry to be // deleted writable. Then free any overflow pages associated with the entry and finally remove the cell itself from within the page. rc = pBt.saveAllCursors(this.RootID, this); if (rc != RC.OK) { return(rc); } rc = Pager.Write(pPage.DbPage); if (rc != RC.OK) { return(rc); } rc = pPage.clearCell(pCell); pPage.dropCell(iCellIdx, pPage.cellSizePtr(pCell), ref rc); if (rc != RC.OK) { return(rc); } // If the cell deleted was not located on a leaf page, then the cursor is currently pointing to the largest entry in the sub-tree headed // by the child-page of the cell that was just deleted from an internal node. The cell from the leaf node needs to be moved to the internal // node to replace the deleted cell. if (pPage.Leaf == 0) { var pLeaf = this.Pages[this.PageID]; int nCell; var n = this.Pages[iCellDepth + 1].ID; pCell = pLeaf.FindCell(pLeaf.Cells - 1); nCell = pLeaf.cellSizePtr(pCell); Debug.Assert(Btree.MX_CELL_SIZE(pBt) >= nCell); rc = Pager.Write(pLeaf.DbPage); var pNext_4 = MallocEx.sqlite3Malloc(nCell + 4); Buffer.BlockCopy(pLeaf.Data, pCell - 4, pNext_4, 0, nCell + 4); pPage.insertCell(iCellIdx, pNext_4, nCell + 4, null, n, ref rc); pLeaf.dropCell(pLeaf.Cells - 1, nCell, ref rc); if (rc != RC.OK) { return(rc); } } // Balance the tree. If the entry deleted was located on a leaf page, then the cursor still points to that page. In this case the first // call to balance() repairs the tree, and the if(...) condition is never true. // // Otherwise, if the entry deleted was on an internal node page, then pCur is pointing to the leaf page from which a cell was removed to // replace the cell deleted from the internal node. This is slightly tricky as the leaf node may be underfull, and the internal node may // be either under or overfull. In this case run the balancing algorithm on the leaf node first. If the balance proceeds far enough up the // tree that we can be sure that any problem in the internal node has been corrected, so be it. Otherwise, after balancing the leaf node, // walk the cursor up the tree to the internal node and balance it as well. rc = Balance(); if (rc == RC.OK && this.PageID > iCellDepth) { while (this.PageID > iCellDepth) { this.Pages[this.PageID--].releasePage(); } rc = Balance(); } if (rc == RC.OK) { MoveToRoot(); } return(rc); }
internal RC freePage2(MemPage pMemPage, Pgno iPage) { MemPage pTrunk = null; // Free-list trunk page var pPage1 = this.Page1; // Local reference to page 1 Debug.Assert(MutexEx.Held(this.Mutex)); Debug.Assert(iPage > 1); Debug.Assert(pMemPage == null || pMemPage.ID == iPage); MemPage pPage; // Page being freed. May be NULL. if (pMemPage != null) { pPage = pMemPage; Pager.AddPageRef(pPage.DbPage); } else { pPage = btreePageLookup(iPage); } // Increment the free page count on pPage1 var rc = Pager.Write(pPage1.DbPage); if (rc != RC.OK) { goto freepage_out; } var nFree = (int)ConvertEx.Get4(pPage1.Data, 36); // Initial number of pages on free-list ConvertEx.Put4(pPage1.Data, 36, nFree + 1); if (this.SecureDelete) { // If the secure_delete option is enabled, then always fully overwrite deleted information with zeros. if ((pPage == null && ((rc = btreeGetPage(iPage, ref pPage, 0)) != RC.OK)) || ((rc = Pager.Write(pPage.DbPage)) != RC.OK)) { goto freepage_out; } Array.Clear(pPage.Data, 0, (int)pPage.Shared.PageSize); } // If the database supports auto-vacuum, write an entry in the pointer-map to indicate that the page is free. #if !SQLITE_OMIT_AUTOVACUUM if (this.AutoVacuum) #else if (false) #endif { ptrmapPut(iPage, PTRMAP.FREEPAGE, 0, ref rc); if (rc != RC.OK) { goto freepage_out; } } // Now manipulate the actual database free-list structure. There are two possibilities. If the free-list is currently empty, or if the first // trunk page in the free-list is full, then this page will become a new free-list trunk page. Otherwise, it will become a leaf of the // first trunk page in the current free-list. This block tests if it is possible to add the page as a new free-list leaf. Pgno iTrunk = 0; // Page number of free-list trunk page if (nFree != 0) { uint nLeaf; // Initial number of leaf cells on trunk page iTrunk = (Pgno)ConvertEx.Get4(pPage1.Data, 32); // Page number of free-list trunk page rc = btreeGetPage(iTrunk, ref pTrunk, 0); if (rc != RC.OK) { goto freepage_out; } nLeaf = ConvertEx.Get4(pTrunk.Data, 4); Debug.Assert(this.UsableSize > 32); if (nLeaf > (uint)this.UsableSize / 4 - 2) { rc = SysEx.SQLITE_CORRUPT_BKPT(); goto freepage_out; } if (nLeaf < (uint)this.UsableSize / 4 - 8) { // In this case there is room on the trunk page to insert the page being freed as a new leaf. // Note: that the trunk page is not really full until it contains usableSize/4 - 2 entries, not usableSize/4 - 8 entries as we have // coded. But due to a coding error in versions of SQLite prior to 3.6.0, databases with freelist trunk pages holding more than // usableSize/4 - 8 entries will be reported as corrupt. In order to maintain backwards compatibility with older versions of SQLite, // we will continue to restrict the number of entries to usableSize/4 - 8 for now. At some point in the future (once everyone has upgraded // to 3.6.0 or later) we should consider fixing the conditional above to read "usableSize/4-2" instead of "usableSize/4-8". rc = Pager.Write(pTrunk.DbPage); if (rc == RC.OK) { ConvertEx.Put4(pTrunk.Data, 4, nLeaf + 1); ConvertEx.Put4(pTrunk.Data, (uint)(8 + nLeaf * 4), iPage); if (pPage != null && !this.SecureDelete) { Pager.DontWrite(pPage.DbPage); } rc = btreeSetHasContent(iPage); } Btree.TRACE("FREE-PAGE: %d leaf on trunk page %d\n", iPage, pTrunk.ID); goto freepage_out; } } // If control flows to this point, then it was not possible to add the the page being freed as a leaf page of the first trunk in the free-list. // Possibly because the free-list is empty, or possibly because the first trunk in the free-list is full. Either way, the page being freed // will become the new first trunk page in the free-list. if (pPage == null && (rc = btreeGetPage(iPage, ref pPage, 0)) != RC.OK) { goto freepage_out; } rc = Pager.Write(pPage.DbPage); if (rc != RC.OK) { goto freepage_out; } ConvertEx.Put4L(pPage.Data, iTrunk); ConvertEx.Put4(pPage.Data, 4, 0); ConvertEx.Put4(pPage1.Data, 32, iPage); Btree.TRACE("FREE-PAGE: %d new trunk page replacing %d\n", pPage.ID, iTrunk); freepage_out: if (pPage != null) { pPage.HasInit = false; } pPage.releasePage(); pTrunk.releasePage(); return(rc); }
internal void insertCell(int i, byte[] pCell, int sz, byte[] pTemp, Pgno iChild, ref RC pRC) { var nSkip = (iChild != 0 ? 4 : 0); if (pRC != RC.OK) { return; } Debug.Assert(i >= 0 && i <= this.Cells + this.NOverflows); Debug.Assert(this.Cells <= Btree.MX_CELL(this.Shared) && Btree.MX_CELL(this.Shared) <= 10921); Debug.Assert(this.NOverflows <= this.Overflows.Length); Debug.Assert(MutexEx.Held(this.Shared.Mutex)); // The cell should normally be sized correctly. However, when moving a malformed cell from a leaf page to an interior page, if the cell size // wanted to be less than 4 but got rounded up to 4 on the leaf, then size might be less than 8 (leaf-size + pointer) on the interior node. Hence // the term after the || in the following assert(). Debug.Assert(sz == cellSizePtr(pCell) || (sz == 8 && iChild > 0)); if (this.NOverflows != 0 || sz + 2 > this.FreeBytes) { if (pTemp != null) { Buffer.BlockCopy(pCell, nSkip, pTemp, nSkip, sz - nSkip); pCell = pTemp; } if (iChild != 0) { ConvertEx.Put4L(pCell, iChild); } var j = this.NOverflows++; Debug.Assert(j < this.Overflows.Length); this.Overflows[j].Cell = pCell; this.Overflows[j].Index = (ushort)i; } else { var rc = Pager.Write(this.DbPage); if (rc != RC.OK) { pRC = rc; return; } Debug.Assert(Pager.IsPageWriteable(this.DbPage)); var data = this.Data; // The content of the whole page var cellOffset = (int)this.CellOffset; // Address of first cell pointer in data[] var end = cellOffset + 2 * this.Cells; // First byte past the last cell pointer in data[] var ins = cellOffset + 2 * i; // Index in data[] where new cell pointer is inserted int idx = 0; // Where to write new cell content in data[] rc = allocateSpace(sz, ref idx); if (rc != RC.OK) { pRC = rc; return; } // The allocateSpace() routine guarantees the following two properties if it returns success Debug.Assert(idx >= end + 2); Debug.Assert(idx + sz <= (int)this.Shared.UsableSize); this.Cells++; this.FreeBytes -= (ushort)(2 + sz); Buffer.BlockCopy(pCell, nSkip, data, idx + nSkip, sz - nSkip); if (iChild != 0) { ConvertEx.Put4L(data, (uint)idx, iChild); } for (var j = end; j > ins; j -= 2) { data[j + 0] = data[j - 2]; data[j + 1] = data[j - 1]; } ConvertEx.Put2(data, ins, idx); ConvertEx.Put2(data, this.HeaderOffset + 3, this.Cells); #if !SQLITE_OMIT_AUTOVACUUM if (this.Shared.AutoVacuum) { // The cell may contain a pointer to an overflow page. If so, write the entry for the overflow page into the pointer map. ptrmapPutOvflPtr(pCell, ref pRC); } #endif } }
internal RC allocateBtreePage(ref MemPage ppPage, ref Pgno pPgno, Pgno nearby, byte exact) { MemPage pTrunk = null; MemPage pPrevTrunk = null; Debug.Assert(MutexEx.Held(this.Mutex)); var pPage1 = this.Page1; var mxPage = btreePagecount(); // Total size of the database file var n = ConvertEx.Get4(pPage1.Data, 36); // Number of pages on the freelist if (n >= mxPage) { return(SysEx.SQLITE_CORRUPT_BKPT()); } RC rc; if (n > 0) { // There are pages on the freelist. Reuse one of those pages. Pgno iTrunk; byte searchList = 0; // If the free-list must be searched for 'nearby' // If the 'exact' parameter was true and a query of the pointer-map shows that the page 'nearby' is somewhere on the free-list, then the entire-list will be searched for that page. #if !SQLITE_OMIT_AUTOVACUUM if (exact != 0 && nearby <= mxPage) { Debug.Assert(nearby > 0); Debug.Assert(this.AutoVacuum); PTRMAP eType = 0; uint dummy0 = 0; rc = ptrmapGet(nearby, ref eType, ref dummy0); if (rc != RC.OK) { return(rc); } if (eType == PTRMAP.FREEPAGE) { searchList = 1; } pPgno = nearby; } #endif // Decrement the free-list count by 1. Set iTrunk to the index of the first free-list trunk page. iPrevTrunk is initially 1. rc = Pager.Write(pPage1.DbPage); if (rc != RC.OK) { return(rc); } ConvertEx.Put4(pPage1.Data, 36, n - 1); // The code within this loop is run only once if the 'searchList' variable is not true. Otherwise, it runs once for each trunk-page on the // free-list until the page 'nearby' is located. do { pPrevTrunk = pTrunk; iTrunk = (pPrevTrunk != null ? ConvertEx.Get4(pPrevTrunk.Data, 0) : ConvertEx.Get4(pPage1.Data, 32)); rc = (iTrunk > mxPage ? SysEx.SQLITE_CORRUPT_BKPT() : btreeGetPage(iTrunk, ref pTrunk, 0)); if (rc != RC.OK) { pTrunk = null; goto end_allocate_page; } var k = ConvertEx.Get4(pTrunk.Data, 4); // # of leaves on this trunk page if (k == 0 && searchList == 0) { // The trunk has no leaves and the list is not being searched. So extract the trunk page itself and use it as the newly allocated page Debug.Assert(pPrevTrunk == null); rc = Pager.Write(pTrunk.DbPage); if (rc != RC.OK) { goto end_allocate_page; } pPgno = iTrunk; Buffer.BlockCopy(pTrunk.Data, 0, pPage1.Data, 32, 4); ppPage = pTrunk; pTrunk = null; Btree.TRACE("ALLOCATE: %d trunk - %d free pages left\n", pPgno, n - 1); } else if (k > (uint)(this.UsableSize / 4 - 2)) { // Value of k is out of range. Database corruption rc = SysEx.SQLITE_CORRUPT_BKPT(); goto end_allocate_page; #if !SQLITE_OMIT_AUTOVACUUM } else if (searchList != 0 && nearby == iTrunk) { // The list is being searched and this trunk page is the page to allocate, regardless of whether it has leaves. Debug.Assert(pPgno == iTrunk); ppPage = pTrunk; searchList = 0; rc = Pager.Write(pTrunk.DbPage); if (rc != RC.OK) { goto end_allocate_page; } if (k == 0) { if (pPrevTrunk == null) { pPage1.Data[32 + 0] = pTrunk.Data[0 + 0]; pPage1.Data[32 + 1] = pTrunk.Data[0 + 1]; pPage1.Data[32 + 2] = pTrunk.Data[0 + 2]; pPage1.Data[32 + 3] = pTrunk.Data[0 + 3]; } else { rc = Pager.Write(pPrevTrunk.DbPage); if (rc != RC.OK) { goto end_allocate_page; } pPrevTrunk.Data[0 + 0] = pTrunk.Data[0 + 0]; pPrevTrunk.Data[0 + 1] = pTrunk.Data[0 + 1]; pPrevTrunk.Data[0 + 2] = pTrunk.Data[0 + 2]; pPrevTrunk.Data[0 + 3] = pTrunk.Data[0 + 3]; } } else { // The trunk page is required by the caller but it contains pointers to free-list leaves. The first leaf becomes a trunk page in this case. var pNewTrunk = new MemPage(); var iNewTrunk = (Pgno)ConvertEx.Get4(pTrunk.Data, 8); if (iNewTrunk > mxPage) { rc = SysEx.SQLITE_CORRUPT_BKPT(); goto end_allocate_page; } rc = btreeGetPage(iNewTrunk, ref pNewTrunk, 0); if (rc != RC.OK) { goto end_allocate_page; } rc = Pager.Write(pNewTrunk.DbPage); if (rc != RC.OK) { pNewTrunk.releasePage(); goto end_allocate_page; } pNewTrunk.Data[0 + 0] = pTrunk.Data[0 + 0]; pNewTrunk.Data[0 + 1] = pTrunk.Data[0 + 1]; pNewTrunk.Data[0 + 2] = pTrunk.Data[0 + 2]; pNewTrunk.Data[0 + 3] = pTrunk.Data[0 + 3]; ConvertEx.Put4(pNewTrunk.Data, 4, (uint)(k - 1)); Buffer.BlockCopy(pTrunk.Data, 12, pNewTrunk.Data, 8, (int)(k - 1) * 4); pNewTrunk.releasePage(); if (pPrevTrunk == null) { Debug.Assert(Pager.IsPageWriteable(pPage1.DbPage)); ConvertEx.Put4(pPage1.Data, 32, iNewTrunk); } else { rc = Pager.Write(pPrevTrunk.DbPage); if (rc != RC.OK) { goto end_allocate_page; } ConvertEx.Put4(pPrevTrunk.Data, 0, iNewTrunk); } } pTrunk = null; Btree.TRACE("ALLOCATE: %d trunk - %d free pages left\n", pPgno, n - 1); #endif } else if (k > 0) { // Extract a leaf from the trunk uint closest; var aData = pTrunk.Data; if (nearby > 0) { closest = 0; var dist = Math.Abs((int)(ConvertEx.Get4(aData, 8) - nearby)); for (uint i = 1; i < k; i++) { int dist2 = Math.Abs((int)(ConvertEx.Get4(aData, 8 + i * 4) - nearby)); if (dist2 < dist) { closest = i; dist = dist2; } } } else { closest = 0; } // var iPage = (Pgno)ConvertEx.Get4(aData, 8 + closest * 4); if (iPage > mxPage) { rc = SysEx.SQLITE_CORRUPT_BKPT(); goto end_allocate_page; } if (searchList == 0 || iPage == nearby) { pPgno = iPage; Btree.TRACE("ALLOCATE: %d was leaf %d of %d on trunk %d" + ": %d more free pages\n", pPgno, closest + 1, k, pTrunk.ID, n - 1); rc = Pager.Write(pTrunk.DbPage); if (rc != RC.OK) { goto end_allocate_page; } if (closest < k - 1) { Buffer.BlockCopy(aData, (int)(4 + k * 4), aData, 8 + (int)closest * 4, 4); } ConvertEx.Put4(aData, 4, (k - 1)); var noContent = (!btreeGetHasContent(pPgno) ? 1 : 0); rc = btreeGetPage(pPgno, ref ppPage, noContent); if (rc == RC.OK) { rc = Pager.Write((ppPage).DbPage); if (rc != RC.OK) { ppPage.releasePage(); } } searchList = 0; } } pPrevTrunk.releasePage(); pPrevTrunk = null; } while (searchList != 0); } else { // There are no pages on the freelist, so create a new page at the end of the file rc = Pager.Write(this.Page1.DbPage); if (rc != RC.OK) { return(rc); } this.Pages++; if (this.Pages == MemPage.PENDING_BYTE_PAGE(this)) { this.Pages++; } #if !SQLITE_OMIT_AUTOVACUUM if (this.AutoVacuum && MemPage.PTRMAP_ISPAGE(this, this.Pages)) { // If pPgno refers to a pointer-map page, allocate two new pages at the end of the file instead of one. The first allocated page // becomes a new pointer-map page, the second is used by the caller. MemPage pPg = null; Btree.TRACE("ALLOCATE: %d from end of file (pointer-map page)\n", pPgno); Debug.Assert(this.Pages != MemPage.PENDING_BYTE_PAGE(this)); rc = btreeGetPage(this.Pages, ref pPg, 1); if (rc == RC.OK) { rc = Pager.Write(pPg.DbPage); pPg.releasePage(); } if (rc != RC.OK) { return(rc); } this.Pages++; if (this.Pages == MemPage.PENDING_BYTE_PAGE(this)) { this.Pages++; } } #endif ConvertEx.Put4(this.Page1.Data, 28, this.Pages); pPgno = this.Pages; Debug.Assert(pPgno != MemPage.PENDING_BYTE_PAGE(this)); rc = btreeGetPage(pPgno, ref ppPage, 1); if (rc != RC.OK) { return(rc); } rc = Pager.Write((ppPage).DbPage); if (rc != RC.OK) { ppPage.releasePage(); } Btree.TRACE("ALLOCATE: %d from end of file\n", pPgno); } Debug.Assert(pPgno != MemPage.PENDING_BYTE_PAGE(this)); end_allocate_page: pTrunk.releasePage(); pPrevTrunk.releasePage(); if (rc == RC.OK) { if (Pager.GetPageRefCount((ppPage).DbPage) > 1) { ppPage.releasePage(); return(SysEx.SQLITE_CORRUPT_BKPT()); } (ppPage).HasInit = false; } else { ppPage = null; } Debug.Assert(rc != RC.OK || Pager.IsPageWriteable((ppPage).DbPage)); return(rc); }
// was:sqlite3BtreeInsert public RC Insert(byte[] key, long nKey, byte[] data, int nData, int nZero, bool appendBiasRight, int seekResult) { var loc = seekResult; // -1: before desired location +1: after var szNew = 0; int idx; var p = this.Tree; var pBt = p.Shared; int oldCell; byte[] newCell = null; if (this.State == CursorState.FAULT) { Debug.Assert(this.SkipNext != 0); return((RC)this.SkipNext); } Debug.Assert(HoldsMutex()); Debug.Assert(this.Writeable && pBt.InTransaction == TRANS.WRITE && !pBt.ReadOnly); Debug.Assert(p.hasSharedCacheTableLock(this.RootID, (this.KeyInfo != null), LOCK.WRITE)); // Assert that the caller has been consistent. If this cursor was opened expecting an index b-tree, then the caller should be inserting blob // keys with no associated data. If the cursor was opened expecting an intkey table, the caller should be inserting integer keys with a // blob of associated data. Debug.Assert((key == null) == (this.KeyInfo == null)); // If this is an insert into a table b-tree, invalidate any incrblob cursors open on the row being replaced (assuming this is a replace // operation - if it is not, the following is a no-op). */ if (this.KeyInfo == null) { Btree.invalidateIncrblobCursors(p, nKey, false); } // Save the positions of any other cursors open on this table. // In some cases, the call to btreeMoveto() below is a no-op. For example, when inserting data into a table with auto-generated integer // keys, the VDBE layer invokes sqlite3BtreeLast() to figure out the integer key to use. It then calls this function to actually insert the // data into the intkey B-Tree. In this case btreeMoveto() recognizes that the cursor is already where it needs to be and returns without // doing any work. To avoid thwarting these optimizations, it is important not to clear the cursor here. var rc = pBt.saveAllCursors(this.RootID, this); if (rc != RC.OK) { return(rc); } if (loc == 0) { rc = BtreeMoveTo(key, nKey, appendBiasRight, ref loc); if (rc != RC.OK) { return(rc); } } Debug.Assert(this.State == CursorState.VALID || (this.State == CursorState.INVALID && loc != 0)); var pPage = this.Pages[this.PageID]; Debug.Assert(pPage.HasIntKey || nKey >= 0); Debug.Assert(pPage.Leaf != 0 || !pPage.HasIntKey); Btree.TRACE("INSERT: table=%d nkey=%lld ndata=%d page=%d %s\n", this.RootID, nKey, nData, pPage.ID, (loc == 0 ? "overwrite" : "new entry")); Debug.Assert(pPage.HasInit); pBt.allocateTempSpace(); newCell = pBt.pTmpSpace; rc = pPage.fillInCell(newCell, key, nKey, data, nData, nZero, ref szNew); if (rc != RC.OK) { goto end_insert; } Debug.Assert(szNew == pPage.cellSizePtr(newCell)); Debug.Assert(szNew <= Btree.MX_CELL_SIZE(pBt)); idx = this.PagesIndexs[this.PageID]; if (loc == 0) { ushort szOld; Debug.Assert(idx < pPage.Cells); rc = Pager.Write(pPage.DbPage); if (rc != RC.OK) { goto end_insert; } oldCell = pPage.FindCell(idx); if (0 == pPage.Leaf) { newCell[0] = pPage.Data[oldCell + 0]; newCell[1] = pPage.Data[oldCell + 1]; newCell[2] = pPage.Data[oldCell + 2]; newCell[3] = pPage.Data[oldCell + 3]; } szOld = pPage.cellSizePtr(oldCell); rc = pPage.clearCell(oldCell); pPage.dropCell(idx, szOld, ref rc); if (rc != RC.OK) { goto end_insert; } } else if (loc < 0 && pPage.Cells > 0) { Debug.Assert(pPage.Leaf != 0); idx = ++this.PagesIndexs[this.PageID]; } else { Debug.Assert(pPage.Leaf != 0); } pPage.insertCell(idx, newCell, szNew, null, 0, ref rc); Debug.Assert(rc != RC.OK || pPage.Cells > 0 || pPage.NOverflows > 0); // If no error has occured and pPage has an overflow cell, call balance() to redistribute the cells within the tree. Since balance() may move // the cursor, zero the BtCursor.info.nSize and BtCursor.validNKey variables. // Previous versions of SQLite called moveToRoot() to move the cursor back to the root page as balance() used to invalidate the contents // of BtCursor.apPage[] and BtCursor.aiIdx[]. Instead of doing that, set the cursor state to "invalid". This makes common insert operations // slightly faster. // There is a subtle but important optimization here too. When inserting multiple records into an intkey b-tree using a single cursor (as can // happen while processing an "INSERT INTO ... SELECT" statement), it is advantageous to leave the cursor pointing to the last entry in // the b-tree if possible. If the cursor is left pointing to the last entry in the table, and the next row inserted has an integer key // larger than the largest existing key, it is possible to insert the row without seeking the cursor. This can be a big performance boost. this.Info.nSize = 0; this.ValidNKey = false; if (rc == RC.OK && pPage.NOverflows != 0) { rc = Balance(); // Must make sure nOverflow is reset to zero even if the balance() fails. Internal data structure corruption will result otherwise. // Also, set the cursor state to invalid. This stops saveCursorPosition() from trying to save the current position of the cursor. this.Pages[this.PageID].NOverflows = 0; this.State = CursorState.INVALID; } Debug.Assert(this.Pages[this.PageID].NOverflows == 0); end_insert: return(rc); }
internal RC btreeCreateTable(ref int piTable, CREATETABLE createTabFlags) { var pBt = this.Shared; var pRoot = new MemPage(); Pgno pgnoRoot = 0; int ptfFlags; // Page-type flage for the root page of new table RC rc; Debug.Assert(sqlite3BtreeHoldsMutex()); Debug.Assert(pBt.InTransaction == TRANS.WRITE); Debug.Assert(!pBt.ReadOnly); #if SQLITE_OMIT_AUTOVACUUM rc = allocateBtreePage(pBt, ref pRoot, ref pgnoRoot, 1, 0); if (rc != SQLITE.OK) { return(rc); } #else if (pBt.AutoVacuum) { Pgno pgnoMove = 0; // Move a page here to make room for the root-page var pPageMove = new MemPage(); // The page to move to. // Creating a new table may probably require moving an existing database to make room for the new tables root page. In case this page turns // out to be an overflow page, delete all overflow page-map caches held by open cursors. invalidateAllOverflowCache(pBt); // Read the value of meta[3] from the database to determine where the root page of the new table should go. meta[3] is the largest root-page // created so far, so the new root-page is (meta[3]+1). GetMeta((int)META.LARGEST_ROOT_PAGE, ref pgnoRoot); pgnoRoot++; // The new root-page may not be allocated on a pointer-map page, or the PENDING_BYTE page. while (pgnoRoot == MemPage.PTRMAP_PAGENO(pBt, pgnoRoot) || pgnoRoot == MemPage.PENDING_BYTE_PAGE(pBt)) { pgnoRoot++; } Debug.Assert(pgnoRoot >= 3); // Allocate a page. The page that currently resides at pgnoRoot will be moved to the allocated page (unless the allocated page happens to reside at pgnoRoot). rc = pBt.allocateBtreePage(ref pPageMove, ref pgnoMove, pgnoRoot, 1); if (rc != RC.OK) { return(rc); } if (pgnoMove != pgnoRoot) { // pgnoRoot is the page that will be used for the root-page of the new table (assuming an error did not occur). But we were // allocated pgnoMove. If required (i.e. if it was not allocated by extending the file), the current page at position pgnoMove // is already journaled. PTRMAP eType = 0; Pgno iPtrPage = 0; pPageMove.releasePage(); // Move the page currently at pgnoRoot to pgnoMove. rc = pBt.btreeGetPage(pgnoRoot, ref pRoot, 0); if (rc != RC.OK) { return(rc); } rc = pBt.ptrmapGet(pgnoRoot, ref eType, ref iPtrPage); if (eType == PTRMAP.ROOTPAGE || eType == PTRMAP.FREEPAGE) { rc = SysEx.SQLITE_CORRUPT_BKPT(); } if (rc != RC.OK) { pRoot.releasePage(); return(rc); } Debug.Assert(eType != PTRMAP.ROOTPAGE); Debug.Assert(eType != PTRMAP.FREEPAGE); rc = MemPage.relocatePage(pBt, pRoot, eType, iPtrPage, pgnoMove, 0); pRoot.releasePage(); // Obtain the page at pgnoRoot if (rc != RC.OK) { return(rc); } rc = pBt.btreeGetPage(pgnoRoot, ref pRoot, 0); if (rc != RC.OK) { return(rc); } rc = Pager.Write(pRoot.DbPage); if (rc != RC.OK) { pRoot.releasePage(); return(rc); } } else { pRoot = pPageMove; } // Update the pointer-map and meta-data with the new root-page number. pBt.ptrmapPut(pgnoRoot, PTRMAP.ROOTPAGE, 0, ref rc); if (rc != RC.OK) { pRoot.releasePage(); return(rc); } // When the new root page was allocated, page 1 was made writable in order either to increase the database filesize, or to decrement the // freelist count. Hence, the sqlite3BtreeUpdateMeta() call cannot fail. Debug.Assert(Pager.IsPageWriteable(pBt.Page1.DbPage)); rc = SetMeta(4, pgnoRoot); if (Check.NEVER(rc != RC.OK)) { pRoot.releasePage(); return(rc); } } else { rc = pBt.allocateBtreePage(ref pRoot, ref pgnoRoot, 1, 0); if (rc != RC.OK) { return(rc); } } #endif Debug.Assert(Pager.IsPageWriteable(pRoot.DbPage)); ptfFlags = ((createTabFlags & CREATETABLE.INTKEY) != 0 ? PTF_INTKEY | PTF_LEAFDATA | PTF_LEAF : PTF_ZERODATA | PTF_LEAF); pRoot.zeroPage(ptfFlags); Pager.Unref(pRoot.DbPage); Debug.Assert((pBt.OpenFlags & OPEN.SINGLE) == 0 || pgnoRoot == 2); piTable = (int)pgnoRoot; return(RC.OK); }
// was:balance private RC Balance() { var rc = RC.OK; var nMin = (int)this.Shared.UsableSize * 2 / 3; var balance_quick_called = 0; var balance_deeper_called = 0; do { var pageID = this.PageID; var page = this.Pages[pageID]; if (pageID == 0) { if (page.NOverflows != 0) { // The root page of the b-tree is overfull. In this case call the balance_deeper() function to create a new child for the root-page // and copy the current contents of the root-page to it. The next iteration of the do-loop will balance the child page. Debug.Assert((balance_deeper_called++) == 0); rc = MemPage.balance_deeper(page, ref this.Pages[1]); if (rc == RC.OK) { this.PageID = 1; this.PagesIndexs[0] = 0; this.PagesIndexs[1] = 0; Debug.Assert(this.Pages[1].NOverflows != 0); } } else { break; } } else if (page.NOverflows == 0 && page.FreeBytes <= nMin) { break; } else { var pParent = this.Pages[pageID - 1]; var iIdx = this.PagesIndexs[pageID - 1]; rc = Pager.Write(pParent.DbPage); if (rc == RC.OK) { #if !SQLITE_OMIT_QUICKBALANCE if (page.HasData != 0 && page.NOverflows == 1 && page.Overflows[0].Index == page.Cells && pParent.ID != 1 && pParent.Cells == iIdx) { // Call balance_quick() to create a new sibling of pPage on which to store the overflow cell. balance_quick() inserts a new cell // into pParent, which may cause pParent overflow. If this happens, the next interation of the do-loop will balance pParent // use either balance_nonroot() or balance_deeper(). Until this happens, the overflow cell is stored in the aBalanceQuickSpace[] // buffer. // The purpose of the following Debug.Assert() is to check that only a single call to balance_quick() is made for each call to this // function. If this were not verified, a subtle bug involving reuse of the aBalanceQuickSpace[] might sneak in. Debug.Assert((balance_quick_called++) == 0); rc = MemPage.balance_quick(pParent, page, _balanceQuickSpaces); } else #endif { // In this case, call balance_nonroot() to redistribute cells between pPage and up to 2 of its sibling pages. This involves // modifying the contents of pParent, which may cause pParent to become overfull or underfull. The next iteration of the do-loop // will balance the parent page to correct this. // If the parent page becomes overfull, the overflow cell or cells are stored in the pSpace buffer allocated immediately below. // A subsequent iteration of the do-loop will deal with this by calling balance_nonroot() (balance_deeper() may be called first, // but it doesn't deal with overflow cells - just moves them to a different page). Once this subsequent call to balance_nonroot() // has completed, it is safe to release the pSpace buffer used by the previous call, as the overflow cell data will have been // copied either into the body of a database page or into the new pSpace buffer passed to the latter call to balance_nonroot(). var pSpace = new byte[this.Shared.PageSize];// u8 pSpace = sqlite3PageMalloc( pCur.pBt.pageSize ); rc = MemPage.balance_nonroot(pParent, iIdx, null, pageID == 1 ? 1 : 0); // The pSpace buffer will be freed after the next call to balance_nonroot(), or just before this function returns, whichever comes first. } } page.NOverflows = 0; // The next iteration of the do-loop balances the parent page. page.releasePage(); this.PageID--; } } while (rc == RC.OK); return(rc); }
internal static RC relocatePage(BtShared pBt, MemPage pDbPage, PTRMAP eType, Pgno iPtrPage, Pgno iFreePage, int isCommit) { var pPtrPage = new MemPage(); // The page that contains a pointer to pDbPage var iDbPage = pDbPage.ID; var pPager = pBt.Pager; Debug.Assert(eType == PTRMAP.OVERFLOW2 || eType == PTRMAP.OVERFLOW1 || eType == PTRMAP.BTREE || eType == PTRMAP.ROOTPAGE); Debug.Assert(MutexEx.Held(pBt.Mutex)); Debug.Assert(pDbPage.Shared == pBt); // Move page iDbPage from its current location to page number iFreePage Btree.TRACE("AUTOVACUUM: Moving %d to free page %d (ptr page %d type %d)\n", iDbPage, iFreePage, iPtrPage, eType); var rc = pPager.sqlite3PagerMovepage(pDbPage.DbPage, iFreePage, isCommit); if (rc != RC.OK) { return(rc); } pDbPage.ID = iFreePage; // If pDbPage was a btree-page, then it may have child pages and/or cells that point to overflow pages. The pointer map entries for all these // pages need to be changed. // If pDbPage is an overflow page, then the first 4 bytes may store a pointer to a subsequent overflow page. If this is the case, then // the pointer map needs to be updated for the subsequent overflow page. if (eType == PTRMAP.BTREE || eType == PTRMAP.ROOTPAGE) { rc = pDbPage.setChildPtrmaps(); if (rc != RC.OK) { return(rc); } } else { var nextOvfl = (Pgno)ConvertEx.Get4(pDbPage.Data); if (nextOvfl != 0) { pBt.ptrmapPut(nextOvfl, PTRMAP.OVERFLOW2, iFreePage, ref rc); if (rc != RC.OK) { return(rc); } } } // Fix the database pointer on page iPtrPage that pointed at iDbPage so that it points at iFreePage. Also fix the pointer map entry for iPtrPage. if (eType != PTRMAP.ROOTPAGE) { rc = pBt.btreeGetPage(iPtrPage, ref pPtrPage, 0); if (rc != RC.OK) { return(rc); } rc = Pager.Write(pPtrPage.DbPage); if (rc != RC.OK) { pPtrPage.releasePage(); return(rc); } rc = pPtrPage.modifyPagePointer(iDbPage, iFreePage, eType); pPtrPage.releasePage(); if (rc == RC.OK) { pBt.ptrmapPut(iFreePage, eType, iPtrPage, ref rc); } } return(rc); }