| /* |
| ** 2004 April 6 |
| ** |
| ** The author disclaims copyright to this source code. In place of |
| ** a legal notice, here is a blessing: |
| ** |
| ** May you do good and not evil. |
| ** May you find forgiveness for yourself and forgive others. |
| ** May you share freely, never taking more than you give. |
| ** |
| ************************************************************************* |
| ** This file implements a external (disk-based) database using BTrees. |
| ** See the header comment on "btreeInt.h" for additional information. |
| ** Including a description of file format and an overview of operation. |
| */ |
| #include "btreeInt.h" |
| |
| /* |
| ** The header string that appears at the beginning of every |
| ** SQLite database. |
| */ |
| static const char zMagicHeader[] = SQLITE_FILE_HEADER; |
| |
| /* |
| ** Set this global variable to 1 to enable tracing using the TRACE |
| ** macro. |
| */ |
| #if 0 |
| int sqlite3BtreeTrace=1; /* True to enable tracing */ |
| # define TRACE(X) if(sqlite3BtreeTrace){printf X;fflush(stdout);} |
| #else |
| # define TRACE(X) |
| #endif |
| |
| /* |
| ** Extract a 2-byte big-endian integer from an array of unsigned bytes. |
| ** But if the value is zero, make it 65536. |
| ** |
| ** This routine is used to extract the "offset to cell content area" value |
| ** from the header of a btree page. If the page size is 65536 and the page |
| ** is empty, the offset should be 65536, but the 2-byte value stores zero. |
| ** This routine makes the necessary adjustment to 65536. |
| */ |
| #define get2byteNotZero(X) (((((int)get2byte(X))-1)&0xffff)+1) |
| |
| #ifndef SQLITE_OMIT_SHARED_CACHE |
| /* |
| ** A list of BtShared objects that are eligible for participation |
| ** in shared cache. This variable has file scope during normal builds, |
| ** but the test harness needs to access it so we make it global for |
| ** test builds. |
| ** |
| ** Access to this variable is protected by SQLITE_MUTEX_STATIC_MASTER. |
| */ |
| #ifdef SQLITE_TEST |
| BtShared *SQLITE_WSD sqlite3SharedCacheList = 0; |
| #else |
| static BtShared *SQLITE_WSD sqlite3SharedCacheList = 0; |
| #endif |
| #endif /* SQLITE_OMIT_SHARED_CACHE */ |
| |
| #ifndef SQLITE_OMIT_SHARED_CACHE |
| /* |
| ** Enable or disable the shared pager and schema features. |
| ** |
| ** This routine has no effect on existing database connections. |
| ** The shared cache setting effects only future calls to |
| ** sqlite3_open(), sqlite3_open16(), or sqlite3_open_v2(). |
| */ |
| int sqlite3_enable_shared_cache(int enable){ |
| sqlite3GlobalConfig.sharedCacheEnabled = enable; |
| return SQLITE_OK; |
| } |
| #endif |
| |
| |
| |
| #ifdef SQLITE_OMIT_SHARED_CACHE |
| /* |
| ** The functions querySharedCacheTableLock(), setSharedCacheTableLock(), |
| ** and clearAllSharedCacheTableLocks() |
| ** manipulate entries in the BtShared.pLock linked list used to store |
| ** shared-cache table level locks. If the library is compiled with the |
| ** shared-cache feature disabled, then there is only ever one user |
| ** of each BtShared structure and so this locking is not necessary. |
| ** So define the lock related functions as no-ops. |
| */ |
| #define querySharedCacheTableLock(a,b,c) SQLITE_OK |
| #define setSharedCacheTableLock(a,b,c) SQLITE_OK |
| #define clearAllSharedCacheTableLocks(a) |
| #define downgradeAllSharedCacheTableLocks(a) |
| #define hasSharedCacheTableLock(a,b,c,d) 1 |
| #define hasReadConflicts(a, b) 0 |
| #endif |
| |
| #ifndef SQLITE_OMIT_SHARED_CACHE |
| |
| #ifdef SQLITE_DEBUG |
| /* |
| **** This function is only used as part of an assert() statement. *** |
| ** |
| ** Check to see if pBtree holds the required locks to read or write to the |
| ** table with root page iRoot. Return 1 if it does and 0 if not. |
| ** |
| ** For example, when writing to a table with root-page iRoot via |
| ** Btree connection pBtree: |
| ** |
| ** assert( hasSharedCacheTableLock(pBtree, iRoot, 0, WRITE_LOCK) ); |
| ** |
| ** When writing to an index that resides in a sharable database, the |
| ** caller should have first obtained a lock specifying the root page of |
| ** the corresponding table. This makes things a bit more complicated, |
| ** as this module treats each table as a separate structure. To determine |
| ** the table corresponding to the index being written, this |
| ** function has to search through the database schema. |
| ** |
| ** Instead of a lock on the table/index rooted at page iRoot, the caller may |
| ** hold a write-lock on the schema table (root page 1). This is also |
| ** acceptable. |
| */ |
| static int hasSharedCacheTableLock( |
| Btree *pBtree, /* Handle that must hold lock */ |
| Pgno iRoot, /* Root page of b-tree */ |
| int isIndex, /* True if iRoot is the root of an index b-tree */ |
| int eLockType /* Required lock type (READ_LOCK or WRITE_LOCK) */ |
| ){ |
| Schema *pSchema = (Schema *)pBtree->pBt->pSchema; |
| Pgno iTab = 0; |
| BtLock *pLock; |
| |
| /* If this database is not shareable, or if the client is reading |
| ** and has the read-uncommitted flag set, then no lock is required. |
| ** Return true immediately. |
| */ |
| if( (pBtree->sharable==0) |
| || (eLockType==READ_LOCK && (pBtree->db->flags & SQLITE_ReadUncommitted)) |
| ){ |
| return 1; |
| } |
| |
| /* If the client is reading or writing an index and the schema is |
| ** not loaded, then it is too difficult to actually check to see if |
| ** the correct locks are held. So do not bother - just return true. |
| ** This case does not come up very often anyhow. |
| */ |
| if( isIndex && (!pSchema || (pSchema->flags&DB_SchemaLoaded)==0) ){ |
| return 1; |
| } |
| |
| /* Figure out the root-page that the lock should be held on. For table |
| ** b-trees, this is just the root page of the b-tree being read or |
| ** written. For index b-trees, it is the root page of the associated |
| ** table. */ |
| if( isIndex ){ |
| HashElem *p; |
| for(p=sqliteHashFirst(&pSchema->idxHash); p; p=sqliteHashNext(p)){ |
| Index *pIdx = (Index *)sqliteHashData(p); |
| if( pIdx->tnum==(int)iRoot ){ |
| iTab = pIdx->pTable->tnum; |
| } |
| } |
| }else{ |
| iTab = iRoot; |
| } |
| |
| /* Search for the required lock. Either a write-lock on root-page iTab, a |
| ** write-lock on the schema table, or (if the client is reading) a |
| ** read-lock on iTab will suffice. Return 1 if any of these are found. */ |
| for(pLock=pBtree->pBt->pLock; pLock; pLock=pLock->pNext){ |
| if( pLock->pBtree==pBtree |
| && (pLock->iTable==iTab || (pLock->eLock==WRITE_LOCK && pLock->iTable==1)) |
| && pLock->eLock>=eLockType |
| ){ |
| return 1; |
| } |
| } |
| |
| /* Failed to find the required lock. */ |
| return 0; |
| } |
| #endif /* SQLITE_DEBUG */ |
| |
| #ifdef SQLITE_DEBUG |
| /* |
| **** This function may be used as part of assert() statements only. **** |
| ** |
| ** Return true if it would be illegal for pBtree to write into the |
| ** table or index rooted at iRoot because other shared connections are |
| ** simultaneously reading that same table or index. |
| ** |
| ** It is illegal for pBtree to write if some other Btree object that |
| ** shares the same BtShared object is currently reading or writing |
| ** the iRoot table. Except, if the other Btree object has the |
| ** read-uncommitted flag set, then it is OK for the other object to |
| ** have a read cursor. |
| ** |
| ** For example, before writing to any part of the table or index |
| ** rooted at page iRoot, one should call: |
| ** |
| ** assert( !hasReadConflicts(pBtree, iRoot) ); |
| */ |
| static int hasReadConflicts(Btree *pBtree, Pgno iRoot){ |
| BtCursor *p; |
| for(p=pBtree->pBt->pCursor; p; p=p->pNext){ |
| if( p->pgnoRoot==iRoot |
| && p->pBtree!=pBtree |
| && 0==(p->pBtree->db->flags & SQLITE_ReadUncommitted) |
| ){ |
| return 1; |
| } |
| } |
| return 0; |
| } |
| #endif /* #ifdef SQLITE_DEBUG */ |
| |
| /* |
| ** Query to see if Btree handle p may obtain a lock of type eLock |
| ** (READ_LOCK or WRITE_LOCK) on the table with root-page iTab. Return |
| ** SQLITE_OK if the lock may be obtained (by calling |
| ** setSharedCacheTableLock()), or SQLITE_LOCKED if not. |
| */ |
| static int querySharedCacheTableLock(Btree *p, Pgno iTab, u8 eLock){ |
| BtShared *pBt = p->pBt; |
| BtLock *pIter; |
| |
| assert( sqlite3BtreeHoldsMutex(p) ); |
| assert( eLock==READ_LOCK || eLock==WRITE_LOCK ); |
| assert( p->db!=0 ); |
| assert( !(p->db->flags&SQLITE_ReadUncommitted)||eLock==WRITE_LOCK||iTab==1 ); |
| |
| /* If requesting a write-lock, then the Btree must have an open write |
| ** transaction on this file. And, obviously, for this to be so there |
| ** must be an open write transaction on the file itself. |
| */ |
| assert( eLock==READ_LOCK || (p==pBt->pWriter && p->inTrans==TRANS_WRITE) ); |
| assert( eLock==READ_LOCK || pBt->inTransaction==TRANS_WRITE ); |
| |
| /* This routine is a no-op if the shared-cache is not enabled */ |
| if( !p->sharable ){ |
| return SQLITE_OK; |
| } |
| |
| /* If some other connection is holding an exclusive lock, the |
| ** requested lock may not be obtained. |
| */ |
| if( pBt->pWriter!=p && pBt->isExclusive ){ |
| sqlite3ConnectionBlocked(p->db, pBt->pWriter->db); |
| return SQLITE_LOCKED_SHAREDCACHE; |
| } |
| |
| for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){ |
| /* The condition (pIter->eLock!=eLock) in the following if(...) |
| ** statement is a simplification of: |
| ** |
| ** (eLock==WRITE_LOCK || pIter->eLock==WRITE_LOCK) |
| ** |
| ** since we know that if eLock==WRITE_LOCK, then no other connection |
| ** may hold a WRITE_LOCK on any table in this file (since there can |
| ** only be a single writer). |
| */ |
| assert( pIter->eLock==READ_LOCK || pIter->eLock==WRITE_LOCK ); |
| assert( eLock==READ_LOCK || pIter->pBtree==p || pIter->eLock==READ_LOCK); |
| if( pIter->pBtree!=p && pIter->iTable==iTab && pIter->eLock!=eLock ){ |
| sqlite3ConnectionBlocked(p->db, pIter->pBtree->db); |
| if( eLock==WRITE_LOCK ){ |
| assert( p==pBt->pWriter ); |
| pBt->isPending = 1; |
| } |
| return SQLITE_LOCKED_SHAREDCACHE; |
| } |
| } |
| return SQLITE_OK; |
| } |
| #endif /* !SQLITE_OMIT_SHARED_CACHE */ |
| |
| #ifndef SQLITE_OMIT_SHARED_CACHE |
| /* |
| ** Add a lock on the table with root-page iTable to the shared-btree used |
| ** by Btree handle p. Parameter eLock must be either READ_LOCK or |
| ** WRITE_LOCK. |
| ** |
| ** This function assumes the following: |
| ** |
| ** (a) The specified Btree object p is connected to a sharable |
| ** database (one with the BtShared.sharable flag set), and |
| ** |
| ** (b) No other Btree objects hold a lock that conflicts |
| ** with the requested lock (i.e. querySharedCacheTableLock() has |
| ** already been called and returned SQLITE_OK). |
| ** |
| ** SQLITE_OK is returned if the lock is added successfully. SQLITE_NOMEM |
| ** is returned if a malloc attempt fails. |
| */ |
| static int setSharedCacheTableLock(Btree *p, Pgno iTable, u8 eLock){ |
| BtShared *pBt = p->pBt; |
| BtLock *pLock = 0; |
| BtLock *pIter; |
| |
| assert( sqlite3BtreeHoldsMutex(p) ); |
| assert( eLock==READ_LOCK || eLock==WRITE_LOCK ); |
| assert( p->db!=0 ); |
| |
| /* A connection with the read-uncommitted flag set will never try to |
| ** obtain a read-lock using this function. The only read-lock obtained |
| ** by a connection in read-uncommitted mode is on the sqlite_master |
| ** table, and that lock is obtained in BtreeBeginTrans(). */ |
| assert( 0==(p->db->flags&SQLITE_ReadUncommitted) || eLock==WRITE_LOCK ); |
| |
| /* This function should only be called on a sharable b-tree after it |
| ** has been determined that no other b-tree holds a conflicting lock. */ |
| assert( p->sharable ); |
| assert( SQLITE_OK==querySharedCacheTableLock(p, iTable, eLock) ); |
| |
| /* First search the list for an existing lock on this table. */ |
| for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){ |
| if( pIter->iTable==iTable && pIter->pBtree==p ){ |
| pLock = pIter; |
| break; |
| } |
| } |
| |
| /* If the above search did not find a BtLock struct associating Btree p |
| ** with table iTable, allocate one and link it into the list. |
| */ |
| if( !pLock ){ |
| pLock = (BtLock *)sqlite3MallocZero(sizeof(BtLock)); |
| if( !pLock ){ |
| return SQLITE_NOMEM; |
| } |
| pLock->iTable = iTable; |
| pLock->pBtree = p; |
| pLock->pNext = pBt->pLock; |
| pBt->pLock = pLock; |
| } |
| |
| /* Set the BtLock.eLock variable to the maximum of the current lock |
| ** and the requested lock. This means if a write-lock was already held |
| ** and a read-lock requested, we don't incorrectly downgrade the lock. |
| */ |
| assert( WRITE_LOCK>READ_LOCK ); |
| if( eLock>pLock->eLock ){ |
| pLock->eLock = eLock; |
| } |
| |
| return SQLITE_OK; |
| } |
| #endif /* !SQLITE_OMIT_SHARED_CACHE */ |
| |
| #ifndef SQLITE_OMIT_SHARED_CACHE |
| /* |
| ** Release all the table locks (locks obtained via calls to |
| ** the setSharedCacheTableLock() procedure) held by Btree object p. |
| ** |
| ** This function assumes that Btree p has an open read or write |
| ** transaction. If it does not, then the BtShared.isPending variable |
| ** may be incorrectly cleared. |
| */ |
| static void clearAllSharedCacheTableLocks(Btree *p){ |
| BtShared *pBt = p->pBt; |
| BtLock **ppIter = &pBt->pLock; |
| |
| assert( sqlite3BtreeHoldsMutex(p) ); |
| assert( p->sharable || 0==*ppIter ); |
| assert( p->inTrans>0 ); |
| |
| while( *ppIter ){ |
| BtLock *pLock = *ppIter; |
| assert( pBt->isExclusive==0 || pBt->pWriter==pLock->pBtree ); |
| assert( pLock->pBtree->inTrans>=pLock->eLock ); |
| if( pLock->pBtree==p ){ |
| *ppIter = pLock->pNext; |
| assert( pLock->iTable!=1 || pLock==&p->lock ); |
| if( pLock->iTable!=1 ){ |
| sqlite3_free(pLock); |
| } |
| }else{ |
| ppIter = &pLock->pNext; |
| } |
| } |
| |
| assert( pBt->isPending==0 || pBt->pWriter ); |
| if( pBt->pWriter==p ){ |
| pBt->pWriter = 0; |
| pBt->isExclusive = 0; |
| pBt->isPending = 0; |
| }else if( pBt->nTransaction==2 ){ |
| /* This function is called when Btree p is concluding its |
| ** transaction. If there currently exists a writer, and p is not |
| ** that writer, then the number of locks held by connections other |
| ** than the writer must be about to drop to zero. In this case |
| ** set the isPending flag to 0. |
| ** |
| ** If there is not currently a writer, then BtShared.isPending must |
| ** be zero already. So this next line is harmless in that case. |
| */ |
| pBt->isPending = 0; |
| } |
| } |
| |
| /* |
| ** This function changes all write-locks held by Btree p into read-locks. |
| */ |
| static void downgradeAllSharedCacheTableLocks(Btree *p){ |
| BtShared *pBt = p->pBt; |
| if( pBt->pWriter==p ){ |
| BtLock *pLock; |
| pBt->pWriter = 0; |
| pBt->isExclusive = 0; |
| pBt->isPending = 0; |
| for(pLock=pBt->pLock; pLock; pLock=pLock->pNext){ |
| assert( pLock->eLock==READ_LOCK || pLock->pBtree==p ); |
| pLock->eLock = READ_LOCK; |
| } |
| } |
| } |
| |
| #endif /* SQLITE_OMIT_SHARED_CACHE */ |
| |
| static void releasePage(MemPage *pPage); /* Forward reference */ |
| |
| /* |
| ***** This routine is used inside of assert() only **** |
| ** |
| ** Verify that the cursor holds the mutex on its BtShared |
| */ |
| #ifdef SQLITE_DEBUG |
| static int cursorHoldsMutex(BtCursor *p){ |
| return sqlite3_mutex_held(p->pBt->mutex); |
| } |
| #endif |
| |
| |
| #ifndef SQLITE_OMIT_INCRBLOB |
| /* |
| ** Invalidate the overflow page-list cache for cursor pCur, if any. |
| */ |
| static void invalidateOverflowCache(BtCursor *pCur){ |
| assert( cursorHoldsMutex(pCur) ); |
| sqlite3_free(pCur->aOverflow); |
| pCur->aOverflow = 0; |
| } |
| |
| /* |
| ** Invalidate the overflow page-list cache for all cursors opened |
| ** on the shared btree structure pBt. |
| */ |
| static void invalidateAllOverflowCache(BtShared *pBt){ |
| BtCursor *p; |
| assert( sqlite3_mutex_held(pBt->mutex) ); |
| for(p=pBt->pCursor; p; p=p->pNext){ |
| invalidateOverflowCache(p); |
| } |
| } |
| |
| /* |
| ** This function is called before modifying the contents of a table |
| ** to invalidate any incrblob cursors that are open on the |
| ** row or one of the rows being modified. |
| ** |
| ** If argument isClearTable is true, then the entire contents of the |
| ** table is about to be deleted. In this case invalidate all incrblob |
| ** cursors open on any row within the table with root-page pgnoRoot. |
| ** |
| ** Otherwise, if argument isClearTable is false, then the row with |
| ** rowid iRow is being replaced or deleted. In this case invalidate |
| ** only those incrblob cursors open on that specific row. |
| */ |
| static void invalidateIncrblobCursors( |
| Btree *pBtree, /* The database file to check */ |
| i64 iRow, /* The rowid that might be changing */ |
| int isClearTable /* True if all rows are being deleted */ |
| ){ |
| BtCursor *p; |
| BtShared *pBt = pBtree->pBt; |
| assert( sqlite3BtreeHoldsMutex(pBtree) ); |
| for(p=pBt->pCursor; p; p=p->pNext){ |
| if( p->isIncrblobHandle && (isClearTable || p->info.nKey==iRow) ){ |
| p->eState = CURSOR_INVALID; |
| } |
| } |
| } |
| |
| #else |
| /* Stub functions when INCRBLOB is omitted */ |
| #define invalidateOverflowCache(x) |
| #define invalidateAllOverflowCache(x) |
| #define invalidateIncrblobCursors(x,y,z) |
| #endif /* SQLITE_OMIT_INCRBLOB */ |
| |
| /* |
| ** Set bit pgno of the BtShared.pHasContent bitvec. This is called |
| ** when a page that previously contained data becomes a free-list leaf |
| ** page. |
| ** |
| ** The BtShared.pHasContent bitvec exists to work around an obscure |
| ** bug caused by the interaction of two useful IO optimizations surrounding |
| ** free-list leaf pages: |
| ** |
| ** 1) When all data is deleted from a page and the page becomes |
| ** a free-list leaf page, the page is not written to the database |
| ** (as free-list leaf pages contain no meaningful data). Sometimes |
| ** such a page is not even journalled (as it will not be modified, |
| ** why bother journalling it?). |
| ** |
| ** 2) When a free-list leaf page is reused, its content is not read |
| ** from the database or written to the journal file (why should it |
| ** be, if it is not at all meaningful?). |
| ** |
| ** By themselves, these optimizations work fine and provide a handy |
| ** performance boost to bulk delete or insert operations. However, if |
| ** a page is moved to the free-list and then reused within the same |
| ** transaction, a problem comes up. If the page is not journalled when |
| ** it is moved to the free-list and it is also not journalled when it |
| ** is extracted from the free-list and reused, then the original data |
| ** may be lost. In the event of a rollback, it may not be possible |
| ** to restore the database to its original configuration. |
| ** |
| ** The solution is the BtShared.pHasContent bitvec. Whenever a page is |
| ** moved to become a free-list leaf page, the corresponding bit is |
| ** set in the bitvec. Whenever a leaf page is extracted from the free-list, |
| ** optimization 2 above is omitted if the corresponding bit is already |
| ** set in BtShared.pHasContent. The contents of the bitvec are cleared |
| ** at the end of every transaction. |
| */ |
| static int btreeSetHasContent(BtShared *pBt, Pgno pgno){ |
| int rc = SQLITE_OK; |
| if( !pBt->pHasContent ){ |
| assert( pgno<=pBt->nPage ); |
| pBt->pHasContent = sqlite3BitvecCreate(pBt->nPage); |
| if( !pBt->pHasContent ){ |
| rc = SQLITE_NOMEM; |
| } |
| } |
| if( rc==SQLITE_OK && pgno<=sqlite3BitvecSize(pBt->pHasContent) ){ |
| rc = sqlite3BitvecSet(pBt->pHasContent, pgno); |
| } |
| return rc; |
| } |
| |
| /* |
| ** Query the BtShared.pHasContent vector. |
| ** |
| ** This function is called when a free-list leaf page is removed from the |
| ** free-list for reuse. It returns false if it is safe to retrieve the |
| ** page from the pager layer with the 'no-content' flag set. True otherwise. |
| */ |
| static int btreeGetHasContent(BtShared *pBt, Pgno pgno){ |
| Bitvec *p = pBt->pHasContent; |
| return (p && (pgno>sqlite3BitvecSize(p) || sqlite3BitvecTest(p, pgno))); |
| } |
| |
| /* |
| ** Clear (destroy) the BtShared.pHasContent bitvec. This should be |
| ** invoked at the conclusion of each write-transaction. |
| */ |
| static void btreeClearHasContent(BtShared *pBt){ |
| sqlite3BitvecDestroy(pBt->pHasContent); |
| pBt->pHasContent = 0; |
| } |
| |
| /* |
| ** Save the current cursor position in the variables BtCursor.nKey |
| ** and BtCursor.pKey. The cursor's state is set to CURSOR_REQUIRESEEK. |
| ** |
| ** The caller must ensure that the cursor is valid (has eState==CURSOR_VALID) |
| ** prior to calling this routine. |
| */ |
| static int saveCursorPosition(BtCursor *pCur){ |
| int rc; |
| |
| assert( CURSOR_VALID==pCur->eState ); |
| assert( 0==pCur->pKey ); |
| assert( cursorHoldsMutex(pCur) ); |
| |
| rc = sqlite3BtreeKeySize(pCur, &pCur->nKey); |
| assert( rc==SQLITE_OK ); /* KeySize() cannot fail */ |
| |
| /* If this is an intKey table, then the above call to BtreeKeySize() |
| ** stores the integer key in pCur->nKey. In this case this value is |
| ** all that is required. Otherwise, if pCur is not open on an intKey |
| ** table, then malloc space for and store the pCur->nKey bytes of key |
| ** data. |
| */ |
| if( 0==pCur->apPage[0]->intKey ){ |
| void *pKey = sqlite3Malloc( (int)pCur->nKey ); |
| if( pKey ){ |
| rc = sqlite3BtreeKey(pCur, 0, (int)pCur->nKey, pKey); |
| if( rc==SQLITE_OK ){ |
| pCur->pKey = pKey; |
| }else{ |
| sqlite3_free(pKey); |
| } |
| }else{ |
| rc = SQLITE_NOMEM; |
| } |
| } |
| assert( !pCur->apPage[0]->intKey || !pCur->pKey ); |
| |
| if( rc==SQLITE_OK ){ |
| int i; |
| for(i=0; i<=pCur->iPage; i++){ |
| releasePage(pCur->apPage[i]); |
| pCur->apPage[i] = 0; |
| } |
| pCur->iPage = -1; |
| pCur->eState = CURSOR_REQUIRESEEK; |
| } |
| |
| invalidateOverflowCache(pCur); |
| return rc; |
| } |
| |
| /* |
| ** Save the positions of all cursors (except pExcept) that are open on |
| ** the table with root-page iRoot. Usually, this is called just before cursor |
| ** pExcept is used to modify the table (BtreeDelete() or BtreeInsert()). |
| */ |
| static int saveAllCursors(BtShared *pBt, Pgno iRoot, BtCursor *pExcept){ |
| BtCursor *p; |
| assert( sqlite3_mutex_held(pBt->mutex) ); |
| assert( pExcept==0 || pExcept->pBt==pBt ); |
| for(p=pBt->pCursor; p; p=p->pNext){ |
| if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) && |
| p->eState==CURSOR_VALID ){ |
| int rc = saveCursorPosition(p); |
| if( SQLITE_OK!=rc ){ |
| return rc; |
| } |
| } |
| } |
| return SQLITE_OK; |
| } |
| |
| /* |
| ** Clear the current cursor position. |
| */ |
| void sqlite3BtreeClearCursor(BtCursor *pCur){ |
| assert( cursorHoldsMutex(pCur) ); |
| sqlite3_free(pCur->pKey); |
| pCur->pKey = 0; |
| pCur->eState = CURSOR_INVALID; |
| } |
| |
| /* |
| ** In this version of BtreeMoveto, pKey is a packed index record |
| ** such as is generated by the OP_MakeRecord opcode. Unpack the |
| ** record and then call BtreeMovetoUnpacked() to do the work. |
| */ |
| static int btreeMoveto( |
| BtCursor *pCur, /* Cursor open on the btree to be searched */ |
| const void *pKey, /* Packed key if the btree is an index */ |
| i64 nKey, /* Integer key for tables. Size of pKey for indices */ |
| int bias, /* Bias search to the high end */ |
| int *pRes /* Write search results here */ |
| ){ |
| int rc; /* Status code */ |
| UnpackedRecord *pIdxKey; /* Unpacked index key */ |
| char aSpace[150]; /* Temp space for pIdxKey - to avoid a malloc */ |
| |
| if( pKey ){ |
| assert( nKey==(i64)(int)nKey ); |
| pIdxKey = sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey, |
| aSpace, sizeof(aSpace)); |
| if( pIdxKey==0 ) return SQLITE_NOMEM; |
| }else{ |
| pIdxKey = 0; |
| } |
| rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes); |
| if( pKey ){ |
| sqlite3VdbeDeleteUnpackedRecord(pIdxKey); |
| } |
| return rc; |
| } |
| |
| /* |
| ** Restore the cursor to the position it was in (or as close to as possible) |
| ** when saveCursorPosition() was called. Note that this call deletes the |
| ** saved position info stored by saveCursorPosition(), so there can be |
| ** at most one effective restoreCursorPosition() call after each |
| ** saveCursorPosition(). |
| */ |
| static int btreeRestoreCursorPosition(BtCursor *pCur){ |
| int rc; |
| assert( cursorHoldsMutex(pCur) ); |
| assert( pCur->eState>=CURSOR_REQUIRESEEK ); |
| if( pCur->eState==CURSOR_FAULT ){ |
| return pCur->skipNext; |
| } |
| pCur->eState = CURSOR_INVALID; |
| rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &pCur->skipNext); |
| if( rc==SQLITE_OK ){ |
| sqlite3_free(pCur->pKey); |
| pCur->pKey = 0; |
| assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID ); |
| } |
| return rc; |
| } |
| |
| #define restoreCursorPosition(p) \ |
| (p->eState>=CURSOR_REQUIRESEEK ? \ |
| btreeRestoreCursorPosition(p) : \ |
| SQLITE_OK) |
| |
| /* |
| ** Determine whether or not a cursor has moved from the position it |
| ** was last placed at. Cursors can move when the row they are pointing |
| ** at is deleted out from under them. |
| ** |
| ** This routine returns an error code if something goes wrong. The |
| ** integer *pHasMoved is set to one if the cursor has moved and 0 if not. |
| */ |
| int sqlite3BtreeCursorHasMoved(BtCursor *pCur, int *pHasMoved){ |
| int rc; |
| |
| rc = restoreCursorPosition(pCur); |
| if( rc ){ |
| *pHasMoved = 1; |
| return rc; |
| } |
| if( pCur->eState!=CURSOR_VALID || pCur->skipNext!=0 ){ |
| *pHasMoved = 1; |
| }else{ |
| *pHasMoved = 0; |
| } |
| return SQLITE_OK; |
| } |
| |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| /* |
| ** Given a page number of a regular database page, return the page |
| ** number for the pointer-map page that contains the entry for the |
| ** input page number. |
| ** |
| ** Return 0 (not a valid page) for pgno==1 since there is |
| ** no pointer map associated with page 1. The integrity_check logic |
| ** requires that ptrmapPageno(*,1)!=1. |
| */ |
| static Pgno ptrmapPageno(BtShared *pBt, Pgno pgno){ |
| int nPagesPerMapPage; |
| Pgno iPtrMap, ret; |
| assert( sqlite3_mutex_held(pBt->mutex) ); |
| if( pgno<2 ) return 0; |
| nPagesPerMapPage = (pBt->usableSize/5)+1; |
| iPtrMap = (pgno-2)/nPagesPerMapPage; |
| ret = (iPtrMap*nPagesPerMapPage) + 2; |
| if( ret==PENDING_BYTE_PAGE(pBt) ){ |
| ret++; |
| } |
| return ret; |
| } |
| |
| /* |
| ** Write an entry into the pointer map. |
| ** |
| ** This routine updates the pointer map entry for page number 'key' |
| ** so that it maps to type 'eType' and parent page number 'pgno'. |
| ** |
| ** If *pRC is initially non-zero (non-SQLITE_OK) then this routine is |
| ** a no-op. If an error occurs, the appropriate error code is written |
| ** into *pRC. |
| */ |
| static void ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent, int *pRC){ |
| DbPage *pDbPage; /* The pointer map page */ |
| u8 *pPtrmap; /* The pointer map data */ |
| Pgno iPtrmap; /* The pointer map page number */ |
| int offset; /* Offset in pointer map page */ |
| int rc; /* Return code from subfunctions */ |
| |
| if( *pRC ) return; |
| |
| assert( sqlite3_mutex_held(pBt->mutex) ); |
| /* The master-journal page number must never be used as a pointer map page */ |
| assert( 0==PTRMAP_ISPAGE(pBt, PENDING_BYTE_PAGE(pBt)) ); |
| |
| assert( pBt->autoVacuum ); |
| if( key==0 ){ |
| *pRC = SQLITE_CORRUPT_BKPT; |
| return; |
| } |
| iPtrmap = PTRMAP_PAGENO(pBt, key); |
| rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage); |
| if( rc!=SQLITE_OK ){ |
| *pRC = rc; |
| return; |
| } |
| offset = PTRMAP_PTROFFSET(iPtrmap, key); |
| if( offset<0 ){ |
| *pRC = SQLITE_CORRUPT_BKPT; |
| goto ptrmap_exit; |
| } |
| pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage); |
| |
| if( eType!=pPtrmap[offset] || get4byte(&pPtrmap[offset+1])!=parent ){ |
| TRACE(("PTRMAP_UPDATE: %d->(%d,%d)\n", key, eType, parent)); |
| *pRC= rc = sqlite3PagerWrite(pDbPage); |
| if( rc==SQLITE_OK ){ |
| pPtrmap[offset] = eType; |
| put4byte(&pPtrmap[offset+1], parent); |
| } |
| } |
| |
| ptrmap_exit: |
| sqlite3PagerUnref(pDbPage); |
| } |
| |
| /* |
| ** Read an entry from the pointer map. |
| ** |
| ** This routine retrieves the pointer map entry for page 'key', writing |
| ** the type and parent page number to *pEType and *pPgno respectively. |
| ** An error code is returned if something goes wrong, otherwise SQLITE_OK. |
| */ |
| static int ptrmapGet(BtShared *pBt, Pgno key, u8 *pEType, Pgno *pPgno){ |
| DbPage *pDbPage; /* The pointer map page */ |
| int iPtrmap; /* Pointer map page index */ |
| u8 *pPtrmap; /* Pointer map page data */ |
| int offset; /* Offset of entry in pointer map */ |
| int rc; |
| |
| assert( sqlite3_mutex_held(pBt->mutex) ); |
| |
| iPtrmap = PTRMAP_PAGENO(pBt, key); |
| rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage); |
| if( rc!=0 ){ |
| return rc; |
| } |
| pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage); |
| |
| offset = PTRMAP_PTROFFSET(iPtrmap, key); |
| assert( pEType!=0 ); |
| *pEType = pPtrmap[offset]; |
| if( pPgno ) *pPgno = get4byte(&pPtrmap[offset+1]); |
| |
| sqlite3PagerUnref(pDbPage); |
| if( *pEType<1 || *pEType>5 ) return SQLITE_CORRUPT_BKPT; |
| return SQLITE_OK; |
| } |
| |
| #else /* if defined SQLITE_OMIT_AUTOVACUUM */ |
| #define ptrmapPut(w,x,y,z,rc) |
| #define ptrmapGet(w,x,y,z) SQLITE_OK |
| #define ptrmapPutOvflPtr(x, y, rc) |
| #endif |
| |
| /* |
| ** Given a btree page and a cell index (0 means the first cell on |
| ** the page, 1 means the second cell, and so forth) return a pointer |
| ** to the cell content. |
| ** |
| ** This routine works only for pages that do not contain overflow cells. |
| */ |
| #define findCell(P,I) \ |
| ((P)->aData + ((P)->maskPage & get2byte(&(P)->aData[(P)->cellOffset+2*(I)]))) |
| |
| /* |
| ** This a more complex version of findCell() that works for |
| ** pages that do contain overflow cells. |
| */ |
| static u8 *findOverflowCell(MemPage *pPage, int iCell){ |
| int i; |
| assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
| for(i=pPage->nOverflow-1; i>=0; i--){ |
| int k; |
| struct _OvflCell *pOvfl; |
| pOvfl = &pPage->aOvfl[i]; |
| k = pOvfl->idx; |
| if( k<=iCell ){ |
| if( k==iCell ){ |
| return pOvfl->pCell; |
| } |
| iCell--; |
| } |
| } |
| return findCell(pPage, iCell); |
| } |
| |
| /* |
| ** Parse a cell content block and fill in the CellInfo structure. There |
| ** are two versions of this function. btreeParseCell() takes a |
| ** cell index as the second argument and btreeParseCellPtr() |
| ** takes a pointer to the body of the cell as its second argument. |
| ** |
| ** Within this file, the parseCell() macro can be called instead of |
| ** btreeParseCellPtr(). Using some compilers, this will be faster. |
| */ |
| static void btreeParseCellPtr( |
| MemPage *pPage, /* Page containing the cell */ |
| u8 *pCell, /* Pointer to the cell text. */ |
| CellInfo *pInfo /* Fill in this structure */ |
| ){ |
| u16 n; /* Number bytes in cell content header */ |
| u32 nPayload; /* Number of bytes of cell payload */ |
| |
| assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
| |
| pInfo->pCell = pCell; |
| assert( pPage->leaf==0 || pPage->leaf==1 ); |
| n = pPage->childPtrSize; |
| assert( n==4-4*pPage->leaf ); |
| if( pPage->intKey ){ |
| if( pPage->hasData ){ |
| n += getVarint32(&pCell[n], nPayload); |
| }else{ |
| nPayload = 0; |
| } |
| n += getVarint(&pCell[n], (u64*)&pInfo->nKey); |
| pInfo->nData = nPayload; |
| }else{ |
| pInfo->nData = 0; |
| n += getVarint32(&pCell[n], nPayload); |
| pInfo->nKey = nPayload; |
| } |
| pInfo->nPayload = nPayload; |
| pInfo->nHeader = n; |
| testcase( nPayload==pPage->maxLocal ); |
| testcase( nPayload==pPage->maxLocal+1 ); |
| if( likely(nPayload<=pPage->maxLocal) ){ |
| /* This is the (easy) common case where the entire payload fits |
| ** on the local page. No overflow is required. |
| */ |
| if( (pInfo->nSize = (u16)(n+nPayload))<4 ) pInfo->nSize = 4; |
| pInfo->nLocal = (u16)nPayload; |
| pInfo->iOverflow = 0; |
| }else{ |
| /* If the payload will not fit completely on the local page, we have |
| ** to decide how much to store locally and how much to spill onto |
| ** overflow pages. The strategy is to minimize the amount of unused |
| ** space on overflow pages while keeping the amount of local storage |
| ** in between minLocal and maxLocal. |
| ** |
| ** Warning: changing the way overflow payload is distributed in any |
| ** way will result in an incompatible file format. |
| */ |
| int minLocal; /* Minimum amount of payload held locally */ |
| int maxLocal; /* Maximum amount of payload held locally */ |
| int surplus; /* Overflow payload available for local storage */ |
| |
| minLocal = pPage->minLocal; |
| maxLocal = pPage->maxLocal; |
| surplus = minLocal + (nPayload - minLocal)%(pPage->pBt->usableSize - 4); |
| testcase( surplus==maxLocal ); |
| testcase( surplus==maxLocal+1 ); |
| if( surplus <= maxLocal ){ |
| pInfo->nLocal = (u16)surplus; |
| }else{ |
| pInfo->nLocal = (u16)minLocal; |
| } |
| pInfo->iOverflow = (u16)(pInfo->nLocal + n); |
| pInfo->nSize = pInfo->iOverflow + 4; |
| } |
| } |
| #define parseCell(pPage, iCell, pInfo) \ |
| btreeParseCellPtr((pPage), findCell((pPage), (iCell)), (pInfo)) |
| static void btreeParseCell( |
| MemPage *pPage, /* Page containing the cell */ |
| int iCell, /* The cell index. First cell is 0 */ |
| CellInfo *pInfo /* Fill in this structure */ |
| ){ |
| parseCell(pPage, iCell, pInfo); |
| } |
| |
| /* |
| ** Compute the total number of bytes that a Cell needs in the cell |
| ** data area of the btree-page. The return number includes the cell |
| ** data header and the local payload, but not any overflow page or |
| ** the space used by the cell pointer. |
| */ |
| static u16 cellSizePtr(MemPage *pPage, u8 *pCell){ |
| u8 *pIter = &pCell[pPage->childPtrSize]; |
| u32 nSize; |
| |
| #ifdef SQLITE_DEBUG |
| /* The value returned by this function should always be the same as |
| ** the (CellInfo.nSize) value found by doing a full parse of the |
| ** cell. If SQLITE_DEBUG is defined, an assert() at the bottom of |
| ** this function verifies that this invariant is not violated. */ |
| CellInfo debuginfo; |
| btreeParseCellPtr(pPage, pCell, &debuginfo); |
| #endif |
| |
| if( pPage->intKey ){ |
| u8 *pEnd; |
| if( pPage->hasData ){ |
| pIter += getVarint32(pIter, nSize); |
| }else{ |
| nSize = 0; |
| } |
| |
| /* pIter now points at the 64-bit integer key value, a variable length |
| ** integer. The following block moves pIter to point at the first byte |
| ** past the end of the key value. */ |
| pEnd = &pIter[9]; |
| while( (*pIter++)&0x80 && pIter<pEnd ); |
| }else{ |
| pIter += getVarint32(pIter, nSize); |
| } |
| |
| testcase( nSize==pPage->maxLocal ); |
| testcase( nSize==pPage->maxLocal+1 ); |
| if( nSize>pPage->maxLocal ){ |
| int minLocal = pPage->minLocal; |
| nSize = minLocal + (nSize - minLocal) % (pPage->pBt->usableSize - 4); |
| testcase( nSize==pPage->maxLocal ); |
| testcase( nSize==pPage->maxLocal+1 ); |
| if( nSize>pPage->maxLocal ){ |
| nSize = minLocal; |
| } |
| nSize += 4; |
| } |
| nSize += (u32)(pIter - pCell); |
| |
| /* The minimum size of any cell is 4 bytes. */ |
| if( nSize<4 ){ |
| nSize = 4; |
| } |
| |
| assert( nSize==debuginfo.nSize ); |
| return (u16)nSize; |
| } |
| |
| #ifdef SQLITE_DEBUG |
| /* This variation on cellSizePtr() is used inside of assert() statements |
| ** only. */ |
| static u16 cellSize(MemPage *pPage, int iCell){ |
| return cellSizePtr(pPage, findCell(pPage, iCell)); |
| } |
| #endif |
| |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| /* |
| ** If the cell pCell, part of page pPage contains a pointer |
| ** to an overflow page, insert an entry into the pointer-map |
| ** for the overflow page. |
| */ |
| static void ptrmapPutOvflPtr(MemPage *pPage, u8 *pCell, int *pRC){ |
| CellInfo info; |
| if( *pRC ) return; |
| assert( pCell!=0 ); |
| btreeParseCellPtr(pPage, pCell, &info); |
| assert( (info.nData+(pPage->intKey?0:info.nKey))==info.nPayload ); |
| if( info.iOverflow ){ |
| Pgno ovfl = get4byte(&pCell[info.iOverflow]); |
| ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, pRC); |
| } |
| } |
| #endif |
| |
| |
| /* |
| ** Defragment the page given. All Cells are moved to the |
| ** end of the page and all free space is collected into one |
| ** big FreeBlk that occurs in between the header and cell |
| ** pointer array and the cell content area. |
| */ |
| static int defragmentPage(MemPage *pPage){ |
| int i; /* Loop counter */ |
| int pc; /* Address of a i-th cell */ |
| int hdr; /* Offset to the page header */ |
| int size; /* Size of a cell */ |
| int usableSize; /* Number of usable bytes on a page */ |
| int cellOffset; /* Offset to the cell pointer array */ |
| int cbrk; /* Offset to the cell content area */ |
| int nCell; /* Number of cells on the page */ |
| unsigned char *data; /* The page data */ |
| unsigned char *temp; /* Temp area for cell content */ |
| int iCellFirst; /* First allowable cell index */ |
| int iCellLast; /* Last possible cell index */ |
| |
| |
| assert( sqlite3PagerIswriteable(pPage->pDbPage) ); |
| assert( pPage->pBt!=0 ); |
| assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE ); |
| assert( pPage->nOverflow==0 ); |
| assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
| temp = sqlite3PagerTempSpace(pPage->pBt->pPager); |
| data = pPage->aData; |
| hdr = pPage->hdrOffset; |
| cellOffset = pPage->cellOffset; |
| nCell = pPage->nCell; |
| assert( nCell==get2byte(&data[hdr+3]) ); |
| usableSize = pPage->pBt->usableSize; |
| cbrk = get2byte(&data[hdr+5]); |
| memcpy(&temp[cbrk], &data[cbrk], usableSize - cbrk); |
| cbrk = usableSize; |
| iCellFirst = cellOffset + 2*nCell; |
| iCellLast = usableSize - 4; |
| for(i=0; i<nCell; i++){ |
| u8 *pAddr; /* The i-th cell pointer */ |
| pAddr = &data[cellOffset + i*2]; |
| pc = get2byte(pAddr); |
| testcase( pc==iCellFirst ); |
| testcase( pc==iCellLast ); |
| #if !defined(SQLITE_ENABLE_OVERSIZE_CELL_CHECK) |
| /* These conditions have already been verified in btreeInitPage() |
| ** if SQLITE_ENABLE_OVERSIZE_CELL_CHECK is defined |
| */ |
| if( pc<iCellFirst || pc>iCellLast ){ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| #endif |
| assert( pc>=iCellFirst && pc<=iCellLast ); |
| size = cellSizePtr(pPage, &temp[pc]); |
| cbrk -= size; |
| #if defined(SQLITE_ENABLE_OVERSIZE_CELL_CHECK) |
| if( cbrk<iCellFirst ){ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| #else |
| if( cbrk<iCellFirst || pc+size>usableSize ){ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| #endif |
| assert( cbrk+size<=usableSize && cbrk>=iCellFirst ); |
| testcase( cbrk+size==usableSize ); |
| testcase( pc+size==usableSize ); |
| memcpy(&data[cbrk], &temp[pc], size); |
| put2byte(pAddr, cbrk); |
| } |
| assert( cbrk>=iCellFirst ); |
| put2byte(&data[hdr+5], cbrk); |
| data[hdr+1] = 0; |
| data[hdr+2] = 0; |
| data[hdr+7] = 0; |
| memset(&data[iCellFirst], 0, cbrk-iCellFirst); |
| assert( sqlite3PagerIswriteable(pPage->pDbPage) ); |
| if( cbrk-iCellFirst!=pPage->nFree ){ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| return SQLITE_OK; |
| } |
| |
| /* |
| ** Allocate nByte bytes of space from within the B-Tree page passed |
| ** as the first argument. Write into *pIdx the index into pPage->aData[] |
| ** of the first byte of allocated space. Return either SQLITE_OK or |
| ** an error code (usually SQLITE_CORRUPT). |
| ** |
| ** The caller guarantees that there is sufficient space to make the |
| ** allocation. This routine might need to defragment in order to bring |
| ** all the space together, however. This routine will avoid using |
| ** the first two bytes past the cell pointer area since presumably this |
| ** allocation is being made in order to insert a new cell, so we will |
| ** also end up needing a new cell pointer. |
| */ |
| static int allocateSpace(MemPage *pPage, int nByte, int *pIdx){ |
| const int hdr = pPage->hdrOffset; /* Local cache of pPage->hdrOffset */ |
| u8 * const data = pPage->aData; /* Local cache of pPage->aData */ |
| int nFrag; /* Number of fragmented bytes on pPage */ |
| int top; /* First byte of cell content area */ |
| int gap; /* First byte of gap between cell pointers and cell content */ |
| int rc; /* Integer return code */ |
| int usableSize; /* Usable size of the page */ |
| |
| assert( sqlite3PagerIswriteable(pPage->pDbPage) ); |
| assert( pPage->pBt ); |
| assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
| assert( nByte>=0 ); /* Minimum cell size is 4 */ |
| assert( pPage->nFree>=nByte ); |
| assert( pPage->nOverflow==0 ); |
| usableSize = pPage->pBt->usableSize; |
| assert( nByte < usableSize-8 ); |
| |
| nFrag = data[hdr+7]; |
| assert( pPage->cellOffset == hdr + 12 - 4*pPage->leaf ); |
| gap = pPage->cellOffset + 2*pPage->nCell; |
| top = get2byteNotZero(&data[hdr+5]); |
| if( gap>top ) return SQLITE_CORRUPT_BKPT; |
| testcase( gap+2==top ); |
| testcase( gap+1==top ); |
| testcase( gap==top ); |
| |
| if( nFrag>=60 ){ |
| /* Always defragment highly fragmented pages */ |
| rc = defragmentPage(pPage); |
| if( rc ) return rc; |
| top = get2byteNotZero(&data[hdr+5]); |
| }else if( gap+2<=top ){ |
| /* Search the freelist looking for a free slot big enough to satisfy |
| ** the request. The allocation is made from the first free slot in |
| ** the list that is large enough to accomadate it. |
| */ |
| int pc, addr; |
| for(addr=hdr+1; (pc = get2byte(&data[addr]))>0; addr=pc){ |
| int size; /* Size of the free slot */ |
| if( pc>usableSize-4 || pc<addr+4 ){ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| size = get2byte(&data[pc+2]); |
| if( size>=nByte ){ |
| int x = size - nByte; |
| testcase( x==4 ); |
| testcase( x==3 ); |
| if( x<4 ){ |
| /* Remove the slot from the free-list. Update the number of |
| ** fragmented bytes within the page. */ |
| memcpy(&data[addr], &data[pc], 2); |
| data[hdr+7] = (u8)(nFrag + x); |
| }else if( size+pc > usableSize ){ |
| return SQLITE_CORRUPT_BKPT; |
| }else{ |
| /* The slot remains on the free-list. Reduce its size to account |
| ** for the portion used by the new allocation. */ |
| put2byte(&data[pc+2], x); |
| } |
| *pIdx = pc + x; |
| return SQLITE_OK; |
| } |
| } |
| } |
| |
| /* Check to make sure there is enough space in the gap to satisfy |
| ** the allocation. If not, defragment. |
| */ |
| testcase( gap+2+nByte==top ); |
| if( gap+2+nByte>top ){ |
| rc = defragmentPage(pPage); |
| if( rc ) return rc; |
| top = get2byteNotZero(&data[hdr+5]); |
| assert( gap+nByte<=top ); |
| } |
| |
| |
| /* Allocate memory from the gap in between the cell pointer array |
| ** and the cell content area. The btreeInitPage() call has already |
| ** validated the freelist. Given that the freelist is valid, there |
| ** is no way that the allocation can extend off the end of the page. |
| ** The assert() below verifies the previous sentence. |
| */ |
| top -= nByte; |
| put2byte(&data[hdr+5], top); |
| assert( top+nByte <= (int)pPage->pBt->usableSize ); |
| *pIdx = top; |
| return SQLITE_OK; |
| } |
| |
| /* |
| ** Return a section of the pPage->aData to the freelist. |
| ** The first byte of the new free block is pPage->aDisk[start] |
| ** and the size of the block is "size" bytes. |
| ** |
| ** Most of the effort here is involved in coalesing adjacent |
| ** free blocks into a single big free block. |
| */ |
| static int freeSpace(MemPage *pPage, int start, int size){ |
| int addr, pbegin, hdr; |
| int iLast; /* Largest possible freeblock offset */ |
| unsigned char *data = pPage->aData; |
| |
| assert( pPage->pBt!=0 ); |
| assert( sqlite3PagerIswriteable(pPage->pDbPage) ); |
| assert( start>=pPage->hdrOffset+6+pPage->childPtrSize ); |
| assert( (start + size) <= (int)pPage->pBt->usableSize ); |
| assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
| assert( size>=0 ); /* Minimum cell size is 4 */ |
| |
| if( pPage->pBt->secureDelete ){ |
| /* Overwrite deleted information with zeros when the secure_delete |
| ** option is enabled */ |
| memset(&data[start], 0, size); |
| } |
| |
| /* Add the space back into the linked list of freeblocks. Note that |
| ** even though the freeblock list was checked by btreeInitPage(), |
| ** btreeInitPage() did not detect overlapping cells or |
| ** freeblocks that overlapped cells. Nor does it detect when the |
| ** cell content area exceeds the value in the page header. If these |
| ** situations arise, then subsequent insert operations might corrupt |
| ** the freelist. So we do need to check for corruption while scanning |
| ** the freelist. |
| */ |
| hdr = pPage->hdrOffset; |
| addr = hdr + 1; |
| iLast = pPage->pBt->usableSize - 4; |
| assert( start<=iLast ); |
| while( (pbegin = get2byte(&data[addr]))<start && pbegin>0 ){ |
| if( pbegin<addr+4 ){ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| addr = pbegin; |
| } |
| if( pbegin>iLast ){ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| assert( pbegin>addr || pbegin==0 ); |
| put2byte(&data[addr], start); |
| put2byte(&data[start], pbegin); |
| put2byte(&data[start+2], size); |
| pPage->nFree = pPage->nFree + (u16)size; |
| |
| /* Coalesce adjacent free blocks */ |
| addr = hdr + 1; |
| while( (pbegin = get2byte(&data[addr]))>0 ){ |
| int pnext, psize, x; |
| assert( pbegin>addr ); |
| assert( pbegin <= (int)pPage->pBt->usableSize-4 ); |
| pnext = get2byte(&data[pbegin]); |
| psize = get2byte(&data[pbegin+2]); |
| if( pbegin + psize + 3 >= pnext && pnext>0 ){ |
| int frag = pnext - (pbegin+psize); |
| if( (frag<0) || (frag>(int)data[hdr+7]) ){ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| data[hdr+7] -= (u8)frag; |
| x = get2byte(&data[pnext]); |
| put2byte(&data[pbegin], x); |
| x = pnext + get2byte(&data[pnext+2]) - pbegin; |
| put2byte(&data[pbegin+2], x); |
| }else{ |
| addr = pbegin; |
| } |
| } |
| |
| /* If the cell content area begins with a freeblock, remove it. */ |
| if( data[hdr+1]==data[hdr+5] && data[hdr+2]==data[hdr+6] ){ |
| int top; |
| pbegin = get2byte(&data[hdr+1]); |
| memcpy(&data[hdr+1], &data[pbegin], 2); |
| top = get2byte(&data[hdr+5]) + get2byte(&data[pbegin+2]); |
| put2byte(&data[hdr+5], top); |
| } |
| assert( sqlite3PagerIswriteable(pPage->pDbPage) ); |
| return SQLITE_OK; |
| } |
| |
| /* |
| ** Decode the flags byte (the first byte of the header) for a page |
| ** and initialize fields of the MemPage structure accordingly. |
| ** |
| ** Only the following combinations are supported. Anything different |
| ** indicates a corrupt database files: |
| ** |
| ** PTF_ZERODATA |
| ** PTF_ZERODATA | PTF_LEAF |
| ** PTF_LEAFDATA | PTF_INTKEY |
| ** PTF_LEAFDATA | PTF_INTKEY | PTF_LEAF |
| */ |
| static int decodeFlags(MemPage *pPage, int flagByte){ |
| BtShared *pBt; /* A copy of pPage->pBt */ |
| |
| assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) ); |
| assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
| pPage->leaf = (u8)(flagByte>>3); assert( PTF_LEAF == 1<<3 ); |
| flagByte &= ~PTF_LEAF; |
| pPage->childPtrSize = 4-4*pPage->leaf; |
| pBt = pPage->pBt; |
| if( flagByte==(PTF_LEAFDATA | PTF_INTKEY) ){ |
| pPage->intKey = 1; |
| pPage->hasData = pPage->leaf; |
| pPage->maxLocal = pBt->maxLeaf; |
| pPage->minLocal = pBt->minLeaf; |
| }else if( flagByte==PTF_ZERODATA ){ |
| pPage->intKey = 0; |
| pPage->hasData = 0; |
| pPage->maxLocal = pBt->maxLocal; |
| pPage->minLocal = pBt->minLocal; |
| }else{ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| return SQLITE_OK; |
| } |
| |
| /* |
| ** Initialize the auxiliary information for a disk block. |
| ** |
| ** Return SQLITE_OK on success. If we see that the page does |
| ** not contain a well-formed database page, then return |
| ** SQLITE_CORRUPT. Note that a return of SQLITE_OK does not |
| ** guarantee that the page is well-formed. It only shows that |
| ** we failed to detect any corruption. |
| */ |
| static int btreeInitPage(MemPage *pPage){ |
| |
| assert( pPage->pBt!=0 ); |
| assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
| assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) ); |
| assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) ); |
| assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) ); |
| |
| if( !pPage->isInit ){ |
| u16 pc; /* Address of a freeblock within pPage->aData[] */ |
| u8 hdr; /* Offset to beginning of page header */ |
| u8 *data; /* Equal to pPage->aData */ |
| BtShared *pBt; /* The main btree structure */ |
| int usableSize; /* Amount of usable space on each page */ |
| u16 cellOffset; /* Offset from start of page to first cell pointer */ |
| int nFree; /* Number of unused bytes on the page */ |
| int top; /* First byte of the cell content area */ |
| int iCellFirst; /* First allowable cell or freeblock offset */ |
| int iCellLast; /* Last possible cell or freeblock offset */ |
| |
| pBt = pPage->pBt; |
| |
| hdr = pPage->hdrOffset; |
| data = pPage->aData; |
| if( decodeFlags(pPage, data[hdr]) ) return SQLITE_CORRUPT_BKPT; |
| assert( pBt->pageSize>=512 && pBt->pageSize<=65536 ); |
| pPage->maskPage = (u16)(pBt->pageSize - 1); |
| pPage->nOverflow = 0; |
| usableSize = pBt->usableSize; |
| pPage->cellOffset = cellOffset = hdr + 12 - 4*pPage->leaf; |
| top = get2byteNotZero(&data[hdr+5]); |
| pPage->nCell = get2byte(&data[hdr+3]); |
| if( pPage->nCell>MX_CELL(pBt) ){ |
| /* To many cells for a single page. The page must be corrupt */ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| testcase( pPage->nCell==MX_CELL(pBt) ); |
| |
| /* A malformed database page might cause us to read past the end |
| ** of page when parsing a cell. |
| ** |
| ** The following block of code checks early to see if a cell extends |
| ** past the end of a page boundary and causes SQLITE_CORRUPT to be |
| ** returned if it does. |
| */ |
| iCellFirst = cellOffset + 2*pPage->nCell; |
| iCellLast = usableSize - 4; |
| #if defined(SQLITE_ENABLE_OVERSIZE_CELL_CHECK) |
| { |
| int i; /* Index into the cell pointer array */ |
| int sz; /* Size of a cell */ |
| |
| if( !pPage->leaf ) iCellLast--; |
| for(i=0; i<pPage->nCell; i++){ |
| pc = get2byte(&data[cellOffset+i*2]); |
| testcase( pc==iCellFirst ); |
| testcase( pc==iCellLast ); |
| if( pc<iCellFirst || pc>iCellLast ){ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| sz = cellSizePtr(pPage, &data[pc]); |
| testcase( pc+sz==usableSize ); |
| if( pc+sz>usableSize ){ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| } |
| if( !pPage->leaf ) iCellLast++; |
| } |
| #endif |
| |
| /* Compute the total free space on the page */ |
| pc = get2byte(&data[hdr+1]); |
| nFree = data[hdr+7] + top; |
| while( pc>0 ){ |
| u16 next, size; |
| if( pc<iCellFirst || pc>iCellLast ){ |
| /* Start of free block is off the page */ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| next = get2byte(&data[pc]); |
| size = get2byte(&data[pc+2]); |
| if( (next>0 && next<=pc+size+3) || pc+size>usableSize ){ |
| /* Free blocks must be in ascending order. And the last byte of |
| ** the free-block must lie on the database page. */ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| nFree = nFree + size; |
| pc = next; |
| } |
| |
| /* At this point, nFree contains the sum of the offset to the start |
| ** of the cell-content area plus the number of free bytes within |
| ** the cell-content area. If this is greater than the usable-size |
| ** of the page, then the page must be corrupted. This check also |
| ** serves to verify that the offset to the start of the cell-content |
| ** area, according to the page header, lies within the page. |
| */ |
| if( nFree>usableSize ){ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| pPage->nFree = (u16)(nFree - iCellFirst); |
| pPage->isInit = 1; |
| } |
| return SQLITE_OK; |
| } |
| |
| /* |
| ** Set up a raw page so that it looks like a database page holding |
| ** no entries. |
| */ |
| static void zeroPage(MemPage *pPage, int flags){ |
| unsigned char *data = pPage->aData; |
| BtShared *pBt = pPage->pBt; |
| u8 hdr = pPage->hdrOffset; |
| u16 first; |
| |
| assert( sqlite3PagerPagenumber(pPage->pDbPage)==pPage->pgno ); |
| assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage ); |
| assert( sqlite3PagerGetData(pPage->pDbPage) == data ); |
| assert( sqlite3PagerIswriteable(pPage->pDbPage) ); |
| assert( sqlite3_mutex_held(pBt->mutex) ); |
| if( pBt->secureDelete ){ |
| memset(&data[hdr], 0, pBt->usableSize - hdr); |
| } |
| data[hdr] = (char)flags; |
| first = hdr + 8 + 4*((flags&PTF_LEAF)==0 ?1:0); |
| memset(&data[hdr+1], 0, 4); |
| data[hdr+7] = 0; |
| put2byte(&data[hdr+5], pBt->usableSize); |
| pPage->nFree = (u16)(pBt->usableSize - first); |
| decodeFlags(pPage, flags); |
| pPage->hdrOffset = hdr; |
| pPage->cellOffset = first; |
| pPage->nOverflow = 0; |
| assert( pBt->pageSize>=512 && pBt->pageSize<=65536 ); |
| pPage->maskPage = (u16)(pBt->pageSize - 1); |
| pPage->nCell = 0; |
| pPage->isInit = 1; |
| } |
| |
| |
| /* |
| ** Convert a DbPage obtained from the pager into a MemPage used by |
| ** the btree layer. |
| */ |
| static MemPage *btreePageFromDbPage(DbPage *pDbPage, Pgno pgno, BtShared *pBt){ |
| MemPage *pPage = (MemPage*)sqlite3PagerGetExtra(pDbPage); |
| pPage->aData = sqlite3PagerGetData(pDbPage); |
| pPage->pDbPage = pDbPage; |
| pPage->pBt = pBt; |
| pPage->pgno = pgno; |
| pPage->hdrOffset = pPage->pgno==1 ? 100 : 0; |
| return pPage; |
| } |
| |
| /* |
| ** Get a page from the pager. Initialize the MemPage.pBt and |
| ** MemPage.aData elements if needed. |
| ** |
| ** If the noContent flag is set, it means that we do not care about |
| ** the content of the page at this time. So do not go to the disk |
| ** to fetch the content. Just fill in the content with zeros for now. |
| ** If in the future we call sqlite3PagerWrite() on this page, that |
| ** means we have started to be concerned about content and the disk |
| ** read should occur at that point. |
| */ |
| static int btreeGetPage( |
| BtShared *pBt, /* The btree */ |
| Pgno pgno, /* Number of the page to fetch */ |
| MemPage **ppPage, /* Return the page in this parameter */ |
| int noContent /* Do not load page content if true */ |
| ){ |
| int rc; |
| DbPage *pDbPage; |
| |
| assert( sqlite3_mutex_held(pBt->mutex) ); |
| rc = sqlite3PagerAcquire(pBt->pPager, pgno, (DbPage**)&pDbPage, noContent); |
| if( rc ) return rc; |
| *ppPage = btreePageFromDbPage(pDbPage, pgno, pBt); |
| return SQLITE_OK; |
| } |
| |
| /* |
| ** Retrieve a page from the pager cache. If the requested page is not |
| ** already in the pager cache return NULL. Initialize the MemPage.pBt and |
| ** MemPage.aData elements if needed. |
| */ |
| static MemPage *btreePageLookup(BtShared *pBt, Pgno pgno){ |
| DbPage *pDbPage; |
| assert( sqlite3_mutex_held(pBt->mutex) ); |
| pDbPage = sqlite3PagerLookup(pBt->pPager, pgno); |
| if( pDbPage ){ |
| return btreePageFromDbPage(pDbPage, pgno, pBt); |
| } |
| return 0; |
| } |
| |
| /* |
| ** Return the size of the database file in pages. If there is any kind of |
| ** error, return ((unsigned int)-1). |
| */ |
| static Pgno btreePagecount(BtShared *pBt){ |
| return pBt->nPage; |
| } |
| u32 sqlite3BtreeLastPage(Btree *p){ |
| assert( sqlite3BtreeHoldsMutex(p) ); |
| assert( ((p->pBt->nPage)&0x8000000)==0 ); |
| return (int)btreePagecount(p->pBt); |
| } |
| |
| /* |
| ** Get a page from the pager and initialize it. This routine is just a |
| ** convenience wrapper around separate calls to btreeGetPage() and |
| ** btreeInitPage(). |
| ** |
| ** If an error occurs, then the value *ppPage is set to is undefined. It |
| ** may remain unchanged, or it may be set to an invalid value. |
| */ |
| static int getAndInitPage( |
| BtShared *pBt, /* The database file */ |
| Pgno pgno, /* Number of the page to get */ |
| MemPage **ppPage /* Write the page pointer here */ |
| ){ |
| int rc; |
| assert( sqlite3_mutex_held(pBt->mutex) ); |
| |
| if( pgno>btreePagecount(pBt) ){ |
| rc = SQLITE_CORRUPT_BKPT; |
| }else{ |
| rc = btreeGetPage(pBt, pgno, ppPage, 0); |
| if( rc==SQLITE_OK ){ |
| rc = btreeInitPage(*ppPage); |
| if( rc!=SQLITE_OK ){ |
| releasePage(*ppPage); |
| } |
| } |
| } |
| |
| testcase( pgno==0 ); |
| assert( pgno!=0 || rc==SQLITE_CORRUPT ); |
| return rc; |
| } |
| |
| /* |
| ** Release a MemPage. This should be called once for each prior |
| ** call to btreeGetPage. |
| */ |
| static void releasePage(MemPage *pPage){ |
| if( pPage ){ |
| assert( pPage->aData ); |
| assert( pPage->pBt ); |
| assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage ); |
| assert( sqlite3PagerGetData(pPage->pDbPage)==pPage->aData ); |
| assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
| sqlite3PagerUnref(pPage->pDbPage); |
| } |
| } |
| |
| /* |
| ** During a rollback, when the pager reloads information into the cache |
| ** so that the cache is restored to its original state at the start of |
| ** the transaction, for each page restored this routine is called. |
| ** |
| ** This routine needs to reset the extra data section at the end of the |
| ** page to agree with the restored data. |
| */ |
| static void pageReinit(DbPage *pData){ |
| MemPage *pPage; |
| pPage = (MemPage *)sqlite3PagerGetExtra(pData); |
| assert( sqlite3PagerPageRefcount(pData)>0 ); |
| if( pPage->isInit ){ |
| assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
| pPage->isInit = 0; |
| if( sqlite3PagerPageRefcount(pData)>1 ){ |
| /* pPage might not be a btree page; it might be an overflow page |
| ** or ptrmap page or a free page. In those cases, the following |
| ** call to btreeInitPage() will likely return SQLITE_CORRUPT. |
| ** But no harm is done by this. And it is very important that |
| ** btreeInitPage() be called on every btree page so we make |
| ** the call for every page that comes in for re-initing. */ |
| btreeInitPage(pPage); |
| } |
| } |
| } |
| |
| /* |
| ** Invoke the busy handler for a btree. |
| */ |
| static int btreeInvokeBusyHandler(void *pArg){ |
| BtShared *pBt = (BtShared*)pArg; |
| assert( pBt->db ); |
| assert( sqlite3_mutex_held(pBt->db->mutex) ); |
| return sqlite3InvokeBusyHandler(&pBt->db->busyHandler); |
| } |
| |
| /* |
| ** Open a database file. |
| ** |
| ** zFilename is the name of the database file. If zFilename is NULL |
| ** then an ephemeral database is created. The ephemeral database might |
| ** be exclusively in memory, or it might use a disk-based memory cache. |
| ** Either way, the ephemeral database will be automatically deleted |
| ** when sqlite3BtreeClose() is called. |
| ** |
| ** If zFilename is ":memory:" then an in-memory database is created |
| ** that is automatically destroyed when it is closed. |
| ** |
| ** The "flags" parameter is a bitmask that might contain bits |
| ** BTREE_OMIT_JOURNAL and/or BTREE_NO_READLOCK. The BTREE_NO_READLOCK |
| ** bit is also set if the SQLITE_NoReadlock flags is set in db->flags. |
| ** These flags are passed through into sqlite3PagerOpen() and must |
| ** be the same values as PAGER_OMIT_JOURNAL and PAGER_NO_READLOCK. |
| ** |
| ** If the database is already opened in the same database connection |
| ** and we are in shared cache mode, then the open will fail with an |
| ** SQLITE_CONSTRAINT error. We cannot allow two or more BtShared |
| ** objects in the same database connection since doing so will lead |
| ** to problems with locking. |
| */ |
| int sqlite3BtreeOpen( |
| const char *zFilename, /* Name of the file containing the BTree database */ |
| sqlite3 *db, /* Associated database handle */ |
| Btree **ppBtree, /* Pointer to new Btree object written here */ |
| int flags, /* Options */ |
| int vfsFlags /* Flags passed through to sqlite3_vfs.xOpen() */ |
| ){ |
| sqlite3_vfs *pVfs; /* The VFS to use for this btree */ |
| BtShared *pBt = 0; /* Shared part of btree structure */ |
| Btree *p; /* Handle to return */ |
| sqlite3_mutex *mutexOpen = 0; /* Prevents a race condition. Ticket #3537 */ |
| int rc = SQLITE_OK; /* Result code from this function */ |
| u8 nReserve; /* Byte of unused space on each page */ |
| unsigned char zDbHeader[100]; /* Database header content */ |
| |
| /* True if opening an ephemeral, temporary database */ |
| const int isTempDb = zFilename==0 || zFilename[0]==0; |
| |
| /* Set the variable isMemdb to true for an in-memory database, or |
| ** false for a file-based database. |
| */ |
| #ifdef SQLITE_OMIT_MEMORYDB |
| const int isMemdb = 0; |
| #else |
| const int isMemdb = (zFilename && strcmp(zFilename, ":memory:")==0) |
| || (isTempDb && sqlite3TempInMemory(db)); |
| #endif |
| |
| assert( db!=0 ); |
| assert( sqlite3_mutex_held(db->mutex) ); |
| assert( (flags&0xff)==flags ); /* flags fit in 8 bits */ |
| |
| /* Only a BTREE_SINGLE database can be BTREE_UNORDERED */ |
| assert( (flags & BTREE_UNORDERED)==0 || (flags & BTREE_SINGLE)!=0 ); |
| |
| /* A BTREE_SINGLE database is always a temporary and/or ephemeral */ |
| assert( (flags & BTREE_SINGLE)==0 || isTempDb ); |
| |
| if( db->flags & SQLITE_NoReadlock ){ |
| flags |= BTREE_NO_READLOCK; |
| } |
| if( isMemdb ){ |
| flags |= BTREE_MEMORY; |
| } |
| if( (vfsFlags & SQLITE_OPEN_MAIN_DB)!=0 && (isMemdb || isTempDb) ){ |
| vfsFlags = (vfsFlags & ~SQLITE_OPEN_MAIN_DB) | SQLITE_OPEN_TEMP_DB; |
| } |
| pVfs = db->pVfs; |
| p = sqlite3MallocZero(sizeof(Btree)); |
| if( !p ){ |
| return SQLITE_NOMEM; |
| } |
| p->inTrans = TRANS_NONE; |
| p->db = db; |
| #ifndef SQLITE_OMIT_SHARED_CACHE |
| p->lock.pBtree = p; |
| p->lock.iTable = 1; |
| #endif |
| |
| #if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO) |
| /* |
| ** If this Btree is a candidate for shared cache, try to find an |
| ** existing BtShared object that we can share with |
| */ |
| if( isMemdb==0 && isTempDb==0 ){ |
| if( vfsFlags & SQLITE_OPEN_SHAREDCACHE ){ |
| int nFullPathname = pVfs->mxPathname+1; |
| char *zFullPathname = sqlite3Malloc(nFullPathname); |
| sqlite3_mutex *mutexShared; |
| p->sharable = 1; |
| if( !zFullPathname ){ |
| sqlite3_free(p); |
| return SQLITE_NOMEM; |
| } |
| sqlite3OsFullPathname(pVfs, zFilename, nFullPathname, zFullPathname); |
| mutexOpen = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_OPEN); |
| sqlite3_mutex_enter(mutexOpen); |
| mutexShared = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); |
| sqlite3_mutex_enter(mutexShared); |
| for(pBt=GLOBAL(BtShared*,sqlite3SharedCacheList); pBt; pBt=pBt->pNext){ |
| assert( pBt->nRef>0 ); |
| if( 0==strcmp(zFullPathname, sqlite3PagerFilename(pBt->pPager)) |
| && sqlite3PagerVfs(pBt->pPager)==pVfs ){ |
| int iDb; |
| for(iDb=db->nDb-1; iDb>=0; iDb--){ |
| Btree *pExisting = db->aDb[iDb].pBt; |
| if( pExisting && pExisting->pBt==pBt ){ |
| sqlite3_mutex_leave(mutexShared); |
| sqlite3_mutex_leave(mutexOpen); |
| sqlite3_free(zFullPathname); |
| sqlite3_free(p); |
| return SQLITE_CONSTRAINT; |
| } |
| } |
| p->pBt = pBt; |
| pBt->nRef++; |
| break; |
| } |
| } |
| sqlite3_mutex_leave(mutexShared); |
| sqlite3_free(zFullPathname); |
| } |
| #ifdef SQLITE_DEBUG |
| else{ |
| /* In debug mode, we mark all persistent databases as sharable |
| ** even when they are not. This exercises the locking code and |
| ** gives more opportunity for asserts(sqlite3_mutex_held()) |
| ** statements to find locking problems. |
| */ |
| p->sharable = 1; |
| } |
| #endif |
| } |
| #endif |
| if( pBt==0 ){ |
| /* |
| ** The following asserts make sure that structures used by the btree are |
| ** the right size. This is to guard against size changes that result |
| ** when compiling on a different architecture. |
| */ |
| assert( sizeof(i64)==8 || sizeof(i64)==4 ); |
| assert( sizeof(u64)==8 || sizeof(u64)==4 ); |
| assert( sizeof(u32)==4 ); |
| assert( sizeof(u16)==2 ); |
| assert( sizeof(Pgno)==4 ); |
| |
| pBt = sqlite3MallocZero( sizeof(*pBt) ); |
| if( pBt==0 ){ |
| rc = SQLITE_NOMEM; |
| goto btree_open_out; |
| } |
| rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename, |
| EXTRA_SIZE, flags, vfsFlags, pageReinit); |
| if( rc==SQLITE_OK ){ |
| rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader); |
| } |
| if( rc!=SQLITE_OK ){ |
| goto btree_open_out; |
| } |
| pBt->openFlags = (u8)flags; |
| pBt->db = db; |
| sqlite3PagerSetBusyhandler(pBt->pPager, btreeInvokeBusyHandler, pBt); |
| p->pBt = pBt; |
| |
| pBt->pCursor = 0; |
| pBt->pPage1 = 0; |
| pBt->readOnly = sqlite3PagerIsreadonly(pBt->pPager); |
| #ifdef SQLITE_SECURE_DELETE |
| pBt->secureDelete = 1; |
| #endif |
| pBt->pageSize = (zDbHeader[16]<<8) | (zDbHeader[17]<<16); |
| if( pBt->pageSize<512 || pBt->pageSize>SQLITE_MAX_PAGE_SIZE |
| || ((pBt->pageSize-1)&pBt->pageSize)!=0 ){ |
| pBt->pageSize = 0; |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| /* If the magic name ":memory:" will create an in-memory database, then |
| ** leave the autoVacuum mode at 0 (do not auto-vacuum), even if |
| ** SQLITE_DEFAULT_AUTOVACUUM is true. On the other hand, if |
| ** SQLITE_OMIT_MEMORYDB has been defined, then ":memory:" is just a |
| ** regular file-name. In this case the auto-vacuum applies as per normal. |
| */ |
| if( zFilename && !isMemdb ){ |
| pBt->autoVacuum = (SQLITE_DEFAULT_AUTOVACUUM ? 1 : 0); |
| pBt->incrVacuum = (SQLITE_DEFAULT_AUTOVACUUM==2 ? 1 : 0); |
| } |
| #endif |
| nReserve = 0; |
| }else{ |
| nReserve = zDbHeader[20]; |
| pBt->pageSizeFixed = 1; |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| pBt->autoVacuum = (get4byte(&zDbHeader[36 + 4*4])?1:0); |
| pBt->incrVacuum = (get4byte(&zDbHeader[36 + 7*4])?1:0); |
| #endif |
| } |
| rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve); |
| if( rc ) goto btree_open_out; |
| pBt->usableSize = pBt->pageSize - nReserve; |
| assert( (pBt->pageSize & 7)==0 ); /* 8-byte alignment of pageSize */ |
| |
| #if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO) |
| /* Add the new BtShared object to the linked list sharable BtShareds. |
| */ |
| if( p->sharable ){ |
| sqlite3_mutex *mutexShared; |
| pBt->nRef = 1; |
| mutexShared = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); |
| if( SQLITE_THREADSAFE && sqlite3GlobalConfig.bCoreMutex ){ |
| pBt->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_FAST); |
| if( pBt->mutex==0 ){ |
| rc = SQLITE_NOMEM; |
| db->mallocFailed = 0; |
| goto btree_open_out; |
| } |
| } |
| sqlite3_mutex_enter(mutexShared); |
| pBt->pNext = GLOBAL(BtShared*,sqlite3SharedCacheList); |
| GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt; |
| sqlite3_mutex_leave(mutexShared); |
| } |
| #endif |
| } |
| |
| #if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO) |
| /* If the new Btree uses a sharable pBtShared, then link the new |
| ** Btree into the list of all sharable Btrees for the same connection. |
| ** The list is kept in ascending order by pBt address. |
| */ |
| if( p->sharable ){ |
| int i; |
| Btree *pSib; |
| for(i=0; i<db->nDb; i++){ |
| if( (pSib = db->aDb[i].pBt)!=0 && pSib->sharable ){ |
| while( pSib->pPrev ){ pSib = pSib->pPrev; } |
| if( p->pBt<pSib->pBt ){ |
| p->pNext = pSib; |
| p->pPrev = 0; |
| pSib->pPrev = p; |
| }else{ |
| while( pSib->pNext && pSib->pNext->pBt<p->pBt ){ |
| pSib = pSib->pNext; |
| } |
| p->pNext = pSib->pNext; |
| p->pPrev = pSib; |
| if( p->pNext ){ |
| p->pNext->pPrev = p; |
| } |
| pSib->pNext = p; |
| } |
| break; |
| } |
| } |
| } |
| #endif |
| *ppBtree = p; |
| |
| btree_open_out: |
| if( rc!=SQLITE_OK ){ |
| if( pBt && pBt->pPager ){ |
| sqlite3PagerClose(pBt->pPager); |
| } |
| sqlite3_free(pBt); |
| sqlite3_free(p); |
| *ppBtree = 0; |
| }else{ |
| /* If the B-Tree was successfully opened, set the pager-cache size to the |
| ** default value. Except, when opening on an existing shared pager-cache, |
| ** do not change the pager-cache size. |
| */ |
| if( sqlite3BtreeSchema(p, 0, 0)==0 ){ |
| sqlite3PagerSetCachesize(p->pBt->pPager, SQLITE_DEFAULT_CACHE_SIZE); |
| } |
| } |
| if( mutexOpen ){ |
| assert( sqlite3_mutex_held(mutexOpen) ); |
| sqlite3_mutex_leave(mutexOpen); |
| } |
| return rc; |
| } |
| |
| /* |
| ** Decrement the BtShared.nRef counter. When it reaches zero, |
| ** remove the BtShared structure from the sharing list. Return |
| ** true if the BtShared.nRef counter reaches zero and return |
| ** false if it is still positive. |
| */ |
| static int removeFromSharingList(BtShared *pBt){ |
| #ifndef SQLITE_OMIT_SHARED_CACHE |
| sqlite3_mutex *pMaster; |
| BtShared *pList; |
| int removed = 0; |
| |
| assert( sqlite3_mutex_notheld(pBt->mutex) ); |
| pMaster = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); |
| sqlite3_mutex_enter(pMaster); |
| pBt->nRef--; |
| if( pBt->nRef<=0 ){ |
| if( GLOBAL(BtShared*,sqlite3SharedCacheList)==pBt ){ |
| GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt->pNext; |
| }else{ |
| pList = GLOBAL(BtShared*,sqlite3SharedCacheList); |
| while( ALWAYS(pList) && pList->pNext!=pBt ){ |
| pList=pList->pNext; |
| } |
| if( ALWAYS(pList) ){ |
| pList->pNext = pBt->pNext; |
| } |
| } |
| if( SQLITE_THREADSAFE ){ |
| sqlite3_mutex_free(pBt->mutex); |
| } |
| removed = 1; |
| } |
| sqlite3_mutex_leave(pMaster); |
| return removed; |
| #else |
| return 1; |
| #endif |
| } |
| |
| /* |
| ** Make sure pBt->pTmpSpace points to an allocation of |
| ** MX_CELL_SIZE(pBt) bytes. |
| */ |
| static void allocateTempSpace(BtShared *pBt){ |
| if( !pBt->pTmpSpace ){ |
| pBt->pTmpSpace = sqlite3PageMalloc( pBt->pageSize ); |
| } |
| } |
| |
| /* |
| ** Free the pBt->pTmpSpace allocation |
| */ |
| static void freeTempSpace(BtShared *pBt){ |
| sqlite3PageFree( pBt->pTmpSpace); |
| pBt->pTmpSpace = 0; |
| } |
| |
| /* |
| ** Close an open database and invalidate all cursors. |
| */ |
| int sqlite3BtreeClose(Btree *p){ |
| BtShared *pBt = p->pBt; |
| BtCursor *pCur; |
| |
| /* Close all cursors opened via this handle. */ |
| assert( sqlite3_mutex_held(p->db->mutex) ); |
| sqlite3BtreeEnter(p); |
| pCur = pBt->pCursor; |
| while( pCur ){ |
| BtCursor *pTmp = pCur; |
| pCur = pCur->pNext; |
| if( pTmp->pBtree==p ){ |
| sqlite3BtreeCloseCursor(pTmp); |
| } |
| } |
| |
| /* Rollback any active transaction and free the handle structure. |
| ** The call to sqlite3BtreeRollback() drops any table-locks held by |
| ** this handle. |
| */ |
| sqlite3BtreeRollback(p); |
| sqlite3BtreeLeave(p); |
| |
| /* If there are still other outstanding references to the shared-btree |
| ** structure, return now. The remainder of this procedure cleans |
| ** up the shared-btree. |
| */ |
| assert( p->wantToLock==0 && p->locked==0 ); |
| if( !p->sharable || removeFromSharingList(pBt) ){ |
| /* The pBt is no longer on the sharing list, so we can access |
| ** it without having to hold the mutex. |
| ** |
| ** Clean out and delete the BtShared object. |
| */ |
| assert( !pBt->pCursor ); |
| sqlite3PagerClose(pBt->pPager); |
| if( pBt->xFreeSchema && pBt->pSchema ){ |
| pBt->xFreeSchema(pBt->pSchema); |
| } |
| sqlite3DbFree(0, pBt->pSchema); |
| freeTempSpace(pBt); |
| sqlite3_free(pBt); |
| } |
| |
| #ifndef SQLITE_OMIT_SHARED_CACHE |
| assert( p->wantToLock==0 ); |
| assert( p->locked==0 ); |
| if( p->pPrev ) p->pPrev->pNext = p->pNext; |
| if( p->pNext ) p->pNext->pPrev = p->pPrev; |
| #endif |
| |
| sqlite3_free(p); |
| return SQLITE_OK; |
| } |
| |
| /* |
| ** Change the limit on the number of pages allowed in the cache. |
| ** |
| ** The maximum number of cache pages is set to the absolute |
| ** value of mxPage. If mxPage is negative, the pager will |
| ** operate asynchronously - it will not stop to do fsync()s |
| ** to insure data is written to the disk surface before |
| ** continuing. Transactions still work if synchronous is off, |
| ** and the database cannot be corrupted if this program |
| ** crashes. But if the operating system crashes or there is |
| ** an abrupt power failure when synchronous is off, the database |
| ** could be left in an inconsistent and unrecoverable state. |
| ** Synchronous is on by default so database corruption is not |
| ** normally a worry. |
| */ |
| int sqlite3BtreeSetCacheSize(Btree *p, int mxPage){ |
| BtShared *pBt = p->pBt; |
| assert( sqlite3_mutex_held(p->db->mutex) ); |
| sqlite3BtreeEnter(p); |
| sqlite3PagerSetCachesize(pBt->pPager, mxPage); |
| sqlite3BtreeLeave(p); |
| return SQLITE_OK; |
| } |
| |
| /* |
| ** Change the way data is synced to disk in order to increase or decrease |
| ** how well the database resists damage due to OS crashes and power |
| ** failures. Level 1 is the same as asynchronous (no syncs() occur and |
| ** there is a high probability of damage) Level 2 is the default. There |
| ** is a very low but non-zero probability of damage. Level 3 reduces the |
| ** probability of damage to near zero but with a write performance reduction. |
| */ |
| #ifndef SQLITE_OMIT_PAGER_PRAGMAS |
| int sqlite3BtreeSetSafetyLevel( |
| Btree *p, /* The btree to set the safety level on */ |
| int level, /* PRAGMA synchronous. 1=OFF, 2=NORMAL, 3=FULL */ |
| int fullSync, /* PRAGMA fullfsync. */ |
| int ckptFullSync /* PRAGMA checkpoint_fullfync */ |
| ){ |
| BtShared *pBt = p->pBt; |
| assert( sqlite3_mutex_held(p->db->mutex) ); |
| assert( level>=1 && level<=3 ); |
| sqlite3BtreeEnter(p); |
| sqlite3PagerSetSafetyLevel(pBt->pPager, level, fullSync, ckptFullSync); |
| sqlite3BtreeLeave(p); |
| return SQLITE_OK; |
| } |
| #endif |
| |
| /* |
| ** Return TRUE if the given btree is set to safety level 1. In other |
| ** words, return TRUE if no sync() occurs on the disk files. |
| */ |
| int sqlite3BtreeSyncDisabled(Btree *p){ |
| BtShared *pBt = p->pBt; |
| int rc; |
| assert( sqlite3_mutex_held(p->db->mutex) ); |
| sqlite3BtreeEnter(p); |
| assert( pBt && pBt->pPager ); |
| rc = sqlite3PagerNosync(pBt->pPager); |
| sqlite3BtreeLeave(p); |
| return rc; |
| } |
| |
| /* |
| ** Change the default pages size and the number of reserved bytes per page. |
| ** Or, if the page size has already been fixed, return SQLITE_READONLY |
| ** without changing anything. |
| ** |
| ** The page size must be a power of 2 between 512 and 65536. If the page |
| ** size supplied does not meet this constraint then the page size is not |
| ** changed. |
| ** |
| ** Page sizes are constrained to be a power of two so that the region |
| ** of the database file used for locking (beginning at PENDING_BYTE, |
| ** the first byte past the 1GB boundary, 0x40000000) needs to occur |
| ** at the beginning of a page. |
| ** |
| ** If parameter nReserve is less than zero, then the number of reserved |
| ** bytes per page is left unchanged. |
| ** |
| ** If the iFix!=0 then the pageSizeFixed flag is set so that the page size |
| ** and autovacuum mode can no longer be changed. |
| */ |
| int sqlite3BtreeSetPageSize(Btree *p, int pageSize, int nReserve, int iFix){ |
| int rc = SQLITE_OK; |
| BtShared *pBt = p->pBt; |
| assert( nReserve>=-1 && nReserve<=255 ); |
| sqlite3BtreeEnter(p); |
| if( pBt->pageSizeFixed ){ |
| sqlite3BtreeLeave(p); |
| return SQLITE_READONLY; |
| } |
| if( nReserve<0 ){ |
| nReserve = pBt->pageSize - pBt->usableSize; |
| } |
| assert( nReserve>=0 && nReserve<=255 ); |
| if( pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE && |
| ((pageSize-1)&pageSize)==0 ){ |
| assert( (pageSize & 7)==0 ); |
| assert( !pBt->pPage1 && !pBt->pCursor ); |
| pBt->pageSize = (u32)pageSize; |
| freeTempSpace(pBt); |
| } |
| rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve); |
| pBt->usableSize = pBt->pageSize - (u16)nReserve; |
| if( iFix ) pBt->pageSizeFixed = 1; |
| sqlite3BtreeLeave(p); |
| return rc; |
| } |
| |
| /* |
| ** Return the currently defined page size |
| */ |
| int sqlite3BtreeGetPageSize(Btree *p){ |
| return p->pBt->pageSize; |
| } |
| |
| #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) || !defined(SQLITE_OMIT_VACUUM) |
| /* |
| ** Return the number of bytes of space at the end of every page that |
| ** are intentually left unused. This is the "reserved" space that is |
| ** sometimes used by extensions. |
| */ |
| int sqlite3BtreeGetReserve(Btree *p){ |
| int n; |
| sqlite3BtreeEnter(p); |
| n = p->pBt->pageSize - p->pBt->usableSize; |
| sqlite3BtreeLeave(p); |
| return n; |
| } |
| |
| /* |
| ** Set the maximum page count for a database if mxPage is positive. |
| ** No changes are made if mxPage is 0 or negative. |
| ** Regardless of the value of mxPage, return the maximum page count. |
| */ |
| int sqlite3BtreeMaxPageCount(Btree *p, int mxPage){ |
| int n; |
| sqlite3BtreeEnter(p); |
| n = sqlite3PagerMaxPageCount(p->pBt->pPager, mxPage); |
| sqlite3BtreeLeave(p); |
| return n; |
| } |
| |
| /* |
| ** Set the secureDelete flag if newFlag is 0 or 1. If newFlag is -1, |
| ** then make no changes. Always return the value of the secureDelete |
| ** setting after the change. |
| */ |
| int sqlite3BtreeSecureDelete(Btree *p, int newFlag){ |
| int b; |
| if( p==0 ) return 0; |
| sqlite3BtreeEnter(p); |
| if( newFlag>=0 ){ |
| p->pBt->secureDelete = (newFlag!=0) ? 1 : 0; |
| } |
| b = p->pBt->secureDelete; |
| sqlite3BtreeLeave(p); |
| return b; |
| } |
| #endif /* !defined(SQLITE_OMIT_PAGER_PRAGMAS) || !defined(SQLITE_OMIT_VACUUM) */ |
| |
| /* |
| ** Change the 'auto-vacuum' property of the database. If the 'autoVacuum' |
| ** parameter is non-zero, then auto-vacuum mode is enabled. If zero, it |
| ** is disabled. The default value for the auto-vacuum property is |
| ** determined by the SQLITE_DEFAULT_AUTOVACUUM macro. |
| */ |
| int sqlite3BtreeSetAutoVacuum(Btree *p, int autoVacuum){ |
| #ifdef SQLITE_OMIT_AUTOVACUUM |
| return SQLITE_READONLY; |
| #else |
| BtShared *pBt = p->pBt; |
| int rc = SQLITE_OK; |
| u8 av = (u8)autoVacuum; |
| |
| sqlite3BtreeEnter(p); |
| if( pBt->pageSizeFixed && (av ?1:0)!=pBt->autoVacuum ){ |
| rc = SQLITE_READONLY; |
| }else{ |
| pBt->autoVacuum = av ?1:0; |
| pBt->incrVacuum = av==2 ?1:0; |
| } |
| sqlite3BtreeLeave(p); |
| return rc; |
| #endif |
| } |
| |
| /* |
| ** Return the value of the 'auto-vacuum' property. If auto-vacuum is |
| ** enabled 1 is returned. Otherwise 0. |
| */ |
| int sqlite3BtreeGetAutoVacuum(Btree *p){ |
| #ifdef SQLITE_OMIT_AUTOVACUUM |
| return BTREE_AUTOVACUUM_NONE; |
| #else |
| int rc; |
| sqlite3BtreeEnter(p); |
| rc = ( |
| (!p->pBt->autoVacuum)?BTREE_AUTOVACUUM_NONE: |
| (!p->pBt->incrVacuum)?BTREE_AUTOVACUUM_FULL: |
| BTREE_AUTOVACUUM_INCR |
| ); |
| sqlite3BtreeLeave(p); |
| return rc; |
| #endif |
| } |
| |
| |
| /* |
| ** Get a reference to pPage1 of the database file. This will |
| ** also acquire a readlock on that file. |
| ** |
| ** SQLITE_OK is returned on success. If the file is not a |
| ** well-formed database file, then SQLITE_CORRUPT is returned. |
| ** SQLITE_BUSY is returned if the database is locked. SQLITE_NOMEM |
| ** is returned if we run out of memory. |
| */ |
| static int lockBtree(BtShared *pBt){ |
| int rc; /* Result code from subfunctions */ |
| MemPage *pPage1; /* Page 1 of the database file */ |
| int nPage; /* Number of pages in the database */ |
| int nPageFile = 0; /* Number of pages in the database file */ |
| int nPageHeader; /* Number of pages in the database according to hdr */ |
| |
| assert( sqlite3_mutex_held(pBt->mutex) ); |
| assert( pBt->pPage1==0 ); |
| rc = sqlite3PagerSharedLock(pBt->pPager); |
| if( rc!=SQLITE_OK ) return rc; |
| rc = btreeGetPage(pBt, 1, &pPage1, 0); |
| if( rc!=SQLITE_OK ) return rc; |
| |
| /* Do some checking to help insure the file we opened really is |
| ** a valid database file. |
| */ |
| nPage = nPageHeader = get4byte(28+(u8*)pPage1->aData); |
| sqlite3PagerPagecount(pBt->pPager, &nPageFile); |
| if( nPage==0 || memcmp(24+(u8*)pPage1->aData, 92+(u8*)pPage1->aData,4)!=0 ){ |
| nPage = nPageFile; |
| } |
| if( nPage>0 ){ |
| u32 pageSize; |
| u32 usableSize; |
| u8 *page1 = pPage1->aData; |
| rc = SQLITE_NOTADB; |
| if( memcmp(page1, zMagicHeader, 16)!=0 ){ |
| goto page1_init_failed; |
| } |
| |
| #ifdef SQLITE_OMIT_WAL |
| if( page1[18]>1 ){ |
| pBt->readOnly = 1; |
| } |
| if( page1[19]>1 ){ |
| goto page1_init_failed; |
| } |
| #else |
| if( page1[18]>2 ){ |
| pBt->readOnly = 1; |
| } |
| if( page1[19]>2 ){ |
| goto page1_init_failed; |
| } |
| |
| /* If the write version is set to 2, this database should be accessed |
| ** in WAL mode. If the log is not already open, open it now. Then |
| ** return SQLITE_OK and return without populating BtShared.pPage1. |
| ** The caller detects this and calls this function again. This is |
| ** required as the version of page 1 currently in the page1 buffer |
| ** may not be the latest version - there may be a newer one in the log |
| ** file. |
| */ |
| if( page1[19]==2 && pBt->doNotUseWAL==0 ){ |
| int isOpen = 0; |
| rc = sqlite3PagerOpenWal(pBt->pPager, &isOpen); |
| if( rc!=SQLITE_OK ){ |
| goto page1_init_failed; |
| }else if( isOpen==0 ){ |
| releasePage(pPage1); |
| return SQLITE_OK; |
| } |
| rc = SQLITE_NOTADB; |
| } |
| #endif |
| |
| /* The maximum embedded fraction must be exactly 25%. And the minimum |
| ** embedded fraction must be 12.5% for both leaf-data and non-leaf-data. |
| ** The original design allowed these amounts to vary, but as of |
| ** version 3.6.0, we require them to be fixed. |
| */ |
| if( memcmp(&page1[21], "\100\040\040",3)!=0 ){ |
| goto page1_init_failed; |
| } |
| pageSize = (page1[16]<<8) | (page1[17]<<16); |
| if( ((pageSize-1)&pageSize)!=0 |
| || pageSize>SQLITE_MAX_PAGE_SIZE |
| || pageSize<=256 |
| ){ |
| goto page1_init_failed; |
| } |
| assert( (pageSize & 7)==0 ); |
| usableSize = pageSize - page1[20]; |
| if( (u32)pageSize!=pBt->pageSize ){ |
| /* After reading the first page of the database assuming a page size |
| ** of BtShared.pageSize, we have discovered that the page-size is |
| ** actually pageSize. Unlock the database, leave pBt->pPage1 at |
| ** zero and return SQLITE_OK. The caller will call this function |
| ** again with the correct page-size. |
| */ |
| releasePage(pPage1); |
| pBt->usableSize = usableSize; |
| pBt->pageSize = pageSize; |
| freeTempSpace(pBt); |
| rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, |
| pageSize-usableSize); |
| return rc; |
| } |
| if( (pBt->db->flags & SQLITE_RecoveryMode)==0 && nPage>nPageFile ){ |
| rc = SQLITE_CORRUPT_BKPT; |
| goto page1_init_failed; |
| } |
| if( usableSize<480 ){ |
| goto page1_init_failed; |
| } |
| pBt->pageSize = pageSize; |
| pBt->usableSize = usableSize; |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| pBt->autoVacuum = (get4byte(&page1[36 + 4*4])?1:0); |
| pBt->incrVacuum = (get4byte(&page1[36 + 7*4])?1:0); |
| #endif |
| } |
| |
| /* maxLocal is the maximum amount of payload to store locally for |
| ** a cell. Make sure it is small enough so that at least minFanout |
| ** cells can will fit on one page. We assume a 10-byte page header. |
| ** Besides the payload, the cell must store: |
| ** 2-byte pointer to the cell |
| ** 4-byte child pointer |
| ** 9-byte nKey value |
| ** 4-byte nData value |
| ** 4-byte overflow page pointer |
| ** So a cell consists of a 2-byte pointer, a header which is as much as |
| ** 17 bytes long, 0 to N bytes of payload, and an optional 4 byte overflow |
| ** page pointer. |
| */ |
| pBt->maxLocal = (u16)((pBt->usableSize-12)*64/255 - 23); |
| pBt->minLocal = (u16)((pBt->usableSize-12)*32/255 - 23); |
| pBt->maxLeaf = (u16)(pBt->usableSize - 35); |
| pBt->minLeaf = (u16)((pBt->usableSize-12)*32/255 - 23); |
| assert( pBt->maxLeaf + 23 <= MX_CELL_SIZE(pBt) ); |
| pBt->pPage1 = pPage1; |
| pBt->nPage = nPage; |
| return SQLITE_OK; |
| |
| page1_init_failed: |
| releasePage(pPage1); |
| pBt->pPage1 = 0; |
| return rc; |
| } |
| |
| /* |
| ** If there are no outstanding cursors and we are not in the middle |
| ** of a transaction but there is a read lock on the database, then |
| ** this routine unrefs the first page of the database file which |
| ** has the effect of releasing the read lock. |
| ** |
| ** If there is a transaction in progress, this routine is a no-op. |
| */ |
| static void unlockBtreeIfUnused(BtShared *pBt){ |
| assert( sqlite3_mutex_held(pBt->mutex) ); |
| assert( pBt->pCursor==0 || pBt->inTransaction>TRANS_NONE ); |
| if( pBt->inTransaction==TRANS_NONE && pBt->pPage1!=0 ){ |
| assert( pBt->pPage1->aData ); |
| assert( sqlite3PagerRefcount(pBt->pPager)==1 ); |
| assert( pBt->pPage1->aData ); |
| releasePage(pBt->pPage1); |
| pBt->pPage1 = 0; |
| } |
| } |
| |
| /* |
| ** If pBt points to an empty file then convert that empty file |
| ** into a new empty database by initializing the first page of |
| ** the database. |
| */ |
| static int newDatabase(BtShared *pBt){ |
| MemPage *pP1; |
| unsigned char *data; |
| int rc; |
| |
| assert( sqlite3_mutex_held(pBt->mutex) ); |
| if( pBt->nPage>0 ){ |
| return SQLITE_OK; |
| } |
| pP1 = pBt->pPage1; |
| assert( pP1!=0 ); |
| data = pP1->aData; |
| rc = sqlite3PagerWrite(pP1->pDbPage); |
| if( rc ) return rc; |
| memcpy(data, zMagicHeader, sizeof(zMagicHeader)); |
| assert( sizeof(zMagicHeader)==16 ); |
| data[16] = (u8)((pBt->pageSize>>8)&0xff); |
| data[17] = (u8)((pBt->pageSize>>16)&0xff); |
| data[18] = 1; |
| data[19] = 1; |
| assert( pBt->usableSize<=pBt->pageSize && pBt->usableSize+255>=pBt->pageSize); |
| data[20] = (u8)(pBt->pageSize - pBt->usableSize); |
| data[21] = 64; |
| data[22] = 32; |
| data[23] = 32; |
| memset(&data[24], 0, 100-24); |
| zeroPage(pP1, PTF_INTKEY|PTF_LEAF|PTF_LEAFDATA ); |
| pBt->pageSizeFixed = 1; |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| assert( pBt->autoVacuum==1 || pBt->autoVacuum==0 ); |
| assert( pBt->incrVacuum==1 || pBt->incrVacuum==0 ); |
| put4byte(&data[36 + 4*4], pBt->autoVacuum); |
| put4byte(&data[36 + 7*4], pBt->incrVacuum); |
| #endif |
| pBt->nPage = 1; |
| data[31] = 1; |
| return SQLITE_OK; |
| } |
| |
| /* |
| ** Attempt to start a new transaction. A write-transaction |
| ** is started if the second argument is nonzero, otherwise a read- |
| ** transaction. If the second argument is 2 or more and exclusive |
| ** transaction is started, meaning that no other process is allowed |
| ** to access the database. A preexisting transaction may not be |
| ** upgraded to exclusive by calling this routine a second time - the |
| ** exclusivity flag only works for a new transaction. |
| ** |
| ** A write-transaction must be started before attempting any |
| ** changes to the database. None of the following routines |
| ** will work unless a transaction is started first: |
| ** |
| ** sqlite3BtreeCreateTable() |
| ** sqlite3BtreeCreateIndex() |
| ** sqlite3BtreeClearTable() |
| ** sqlite3BtreeDropTable() |
| ** sqlite3BtreeInsert() |
| ** sqlite3BtreeDelete() |
| ** sqlite3BtreeUpdateMeta() |
| ** |
| ** If an initial attempt to acquire the lock fails because of lock contention |
| ** and the database was previously unlocked, then invoke the busy handler |
| ** if there is one. But if there was previously a read-lock, do not |
| ** invoke the busy handler - just return SQLITE_BUSY. SQLITE_BUSY is |
| ** returned when there is already a read-lock in order to avoid a deadlock. |
| ** |
| ** Suppose there are two processes A and B. A has a read lock and B has |
| ** a reserved lock. B tries to promote to exclusive but is blocked because |
| ** of A's read lock. A tries to promote to reserved but is blocked by B. |
| ** One or the other of the two processes must give way or there can be |
| ** no progress. By returning SQLITE_BUSY and not invoking the busy callback |
| ** when A already has a read lock, we encourage A to give up and let B |
| ** proceed. |
| */ |
| int sqlite3BtreeBeginTrans(Btree *p, int wrflag){ |
| sqlite3 *pBlock = 0; |
| BtShared *pBt = p->pBt; |
| int rc = SQLITE_OK; |
| |
| sqlite3BtreeEnter(p); |
| btreeIntegrity(p); |
| |
| /* 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( p->inTrans==TRANS_WRITE || (p->inTrans==TRANS_READ && !wrflag) ){ |
| goto trans_begun; |
| } |
| |
| /* Write transactions are not possible on a read-only database */ |
| if( pBt->readOnly && wrflag ){ |
| rc = SQLITE_READONLY; |
| goto trans_begun; |
| } |
| |
| #ifndef 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. |
| */ |
| if( (wrflag && pBt->inTransaction==TRANS_WRITE) || pBt->isPending ){ |
| pBlock = pBt->pWriter->db; |
| }else if( wrflag>1 ){ |
| BtLock *pIter; |
| for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){ |
| if( pIter->pBtree!=p ){ |
| pBlock = pIter->pBtree->db; |
| break; |
| } |
| } |
| } |
| if( pBlock ){ |
| sqlite3ConnectionBlocked(p->db, pBlock); |
| rc = SQLITE_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(p, MASTER_ROOT, READ_LOCK); |
| if( SQLITE_OK!=rc ) goto trans_begun; |
| |
| pBt->initiallyEmpty = (u8)(pBt->nPage==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( pBt->pPage1==0 && SQLITE_OK==(rc = lockBtree(pBt)) ); |
| |
| if( rc==SQLITE_OK && wrflag ){ |
| if( pBt->readOnly ){ |
| rc = SQLITE_READONLY; |
| }else{ |
| rc = sqlite3PagerBegin(pBt->pPager,wrflag>1,sqlite3TempInMemory(p->db)); |
| if( rc==SQLITE_OK ){ |
| rc = newDatabase(pBt); |
| } |
| } |
| } |
| |
| if( rc!=SQLITE_OK ){ |
| unlockBtreeIfUnused(pBt); |
| } |
| }while( (rc&0xFF)==SQLITE_BUSY && pBt->inTransaction==TRANS_NONE && |
| btreeInvokeBusyHandler(pBt) ); |
| |
| if( rc==SQLITE_OK ){ |
| if( p->inTrans==TRANS_NONE ){ |
| pBt->nTransaction++; |
| #ifndef SQLITE_OMIT_SHARED_CACHE |
| if( p->sharable ){ |
| assert( p->lock.pBtree==p && p->lock.iTable==1 ); |
| p->lock.eLock = READ_LOCK; |
| p->lock.pNext = pBt->pLock; |
| pBt->pLock = &p->lock; |
| } |
| #endif |
| } |
| p->inTrans = (wrflag?TRANS_WRITE:TRANS_READ); |
| if( p->inTrans>pBt->inTransaction ){ |
| pBt->inTransaction = p->inTrans; |
| } |
| if( wrflag ){ |
| MemPage *pPage1 = pBt->pPage1; |
| #ifndef SQLITE_OMIT_SHARED_CACHE |
| assert( !pBt->pWriter ); |
| pBt->pWriter = p; |
| pBt->isExclusive = (u8)(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( pBt->nPage!=get4byte(&pPage1->aData[28]) ){ |
| rc = sqlite3PagerWrite(pPage1->pDbPage); |
| if( rc==SQLITE_OK ){ |
| put4byte(&pPage1->aData[28], pBt->nPage); |
| } |
| } |
| } |
| } |
| |
| |
| trans_begun: |
| if( rc==SQLITE_OK && wrflag ){ |
| /* 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 = sqlite3PagerOpenSavepoint(pBt->pPager, p->db->nSavepoint); |
| } |
| |
| btreeIntegrity(p); |
| sqlite3BtreeLeave(p); |
| return rc; |
| } |
| |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| |
| /* |
| ** Set the pointer-map entries for all children of page pPage. Also, if |
| ** pPage contains cells that point to overflow pages, set the pointer |
| ** map entries for the overflow pages as well. |
| */ |
| static int setChildPtrmaps(MemPage *pPage){ |
| int i; /* Counter variable */ |
| int nCell; /* Number of cells in page pPage */ |
| int rc; /* Return code */ |
| BtShared *pBt = pPage->pBt; |
| u8 isInitOrig = pPage->isInit; |
| Pgno pgno = pPage->pgno; |
| |
| assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
| rc = btreeInitPage(pPage); |
| if( rc!=SQLITE_OK ){ |
| goto set_child_ptrmaps_out; |
| } |
| nCell = pPage->nCell; |
| |
| for(i=0; i<nCell; i++){ |
| u8 *pCell = findCell(pPage, i); |
| |
| ptrmapPutOvflPtr(pPage, pCell, &rc); |
| |
| if( !pPage->leaf ){ |
| Pgno childPgno = get4byte(pCell); |
| ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc); |
| } |
| } |
| |
| if( !pPage->leaf ){ |
| Pgno childPgno = get4byte(&pPage->aData[pPage->hdrOffset+8]); |
| ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc); |
| } |
| |
| set_child_ptrmaps_out: |
| pPage->isInit = isInitOrig; |
| return rc; |
| } |
| |
| /* |
| ** Somewhere on pPage is a pointer to page iFrom. Modify this pointer so |
| ** that it points to iTo. Parameter eType describes the type of pointer to |
| ** be modified, as follows: |
| ** |
| ** PTRMAP_BTREE: pPage is a btree-page. The pointer points at a child |
| ** page of pPage. |
| ** |
| ** PTRMAP_OVERFLOW1: pPage is a btree-page. The pointer points at an overflow |
| ** page pointed to by one of the cells on pPage. |
| ** |
| ** PTRMAP_OVERFLOW2: pPage is an overflow-page. The pointer points at the next |
| ** overflow page in the list. |
| */ |
| static int modifyPagePointer(MemPage *pPage, Pgno iFrom, Pgno iTo, u8 eType){ |
| assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
| assert( sqlite3PagerIswriteable(pPage->pDbPage) ); |
| if( eType==PTRMAP_OVERFLOW2 ){ |
| /* The pointer is always the first 4 bytes of the page in this case. */ |
| if( get4byte(pPage->aData)!=iFrom ){ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| put4byte(pPage->aData, iTo); |
| }else{ |
| u8 isInitOrig = pPage->isInit; |
| int i; |
| int nCell; |
| |
| btreeInitPage(pPage); |
| nCell = pPage->nCell; |
| |
| for(i=0; i<nCell; i++){ |
| u8 *pCell = findCell(pPage, i); |
| if( eType==PTRMAP_OVERFLOW1 ){ |
| CellInfo info; |
| btreeParseCellPtr(pPage, pCell, &info); |
| if( info.iOverflow ){ |
| if( iFrom==get4byte(&pCell[info.iOverflow]) ){ |
| put4byte(&pCell[info.iOverflow], iTo); |
| break; |
| } |
| } |
| }else{ |
| if( get4byte(pCell)==iFrom ){ |
| put4byte(pCell, iTo); |
| break; |
| } |
| } |
| } |
| |
| if( i==nCell ){ |
| if( eType!=PTRMAP_BTREE || |
| get4byte(&pPage->aData[pPage->hdrOffset+8])!=iFrom ){ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| put4byte(&pPage->aData[pPage->hdrOffset+8], iTo); |
| } |
| |
| pPage->isInit = isInitOrig; |
| } |
| return SQLITE_OK; |
| } |
| |
| |
| /* |
| ** Move the open database page pDbPage to location iFreePage in the |
| ** database. The pDbPage reference remains valid. |
| ** |
| ** The isCommit flag indicates that there is no need to remember that |
| ** the journal needs to be sync()ed before database page pDbPage->pgno |
| ** can be written to. The caller has already promised not to write to that |
| ** page. |
| */ |
| static int relocatePage( |
| BtShared *pBt, /* Btree */ |
| MemPage *pDbPage, /* Open page to move */ |
| u8 eType, /* Pointer map 'type' entry for pDbPage */ |
| Pgno iPtrPage, /* Pointer map 'page-no' entry for pDbPage */ |
| Pgno iFreePage, /* The location to move pDbPage to */ |
| int isCommit /* isCommit flag passed to sqlite3PagerMovepage */ |
| ){ |
| MemPage *pPtrPage; /* The page that contains a pointer to pDbPage */ |
| Pgno iDbPage = pDbPage->pgno; |
| Pager *pPager = pBt->pPager; |
| int rc; |
| |
| assert( eType==PTRMAP_OVERFLOW2 || eType==PTRMAP_OVERFLOW1 || |
| eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE ); |
| assert( sqlite3_mutex_held(pBt->mutex) ); |
| assert( pDbPage->pBt==pBt ); |
| |
| /* Move page iDbPage from its current location to page number iFreePage */ |
| TRACE(("AUTOVACUUM: Moving %d to free page %d (ptr page %d type %d)\n", |
| iDbPage, iFreePage, iPtrPage, eType)); |
| rc = sqlite3PagerMovepage(pPager, pDbPage->pDbPage, iFreePage, isCommit); |
| if( rc!=SQLITE_OK ){ |
| return rc; |
| } |
| pDbPage->pgno = 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 = setChildPtrmaps(pDbPage); |
| if( rc!=SQLITE_OK ){ |
| return rc; |
| } |
| }else{ |
| Pgno nextOvfl = get4byte(pDbPage->aData); |
| if( nextOvfl!=0 ){ |
| ptrmapPut(pBt, nextOvfl, PTRMAP_OVERFLOW2, iFreePage, &rc); |
| if( rc!=SQLITE_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 = btreeGetPage(pBt, iPtrPage, &pPtrPage, 0); |
| if( rc!=SQLITE_OK ){ |
| return rc; |
| } |
| rc = sqlite3PagerWrite(pPtrPage->pDbPage); |
| if( rc!=SQLITE_OK ){ |
| releasePage(pPtrPage); |
| return rc; |
| } |
| rc = modifyPagePointer(pPtrPage, iDbPage, iFreePage, eType); |
| releasePage(pPtrPage); |
| if( rc==SQLITE_OK ){ |
| ptrmapPut(pBt, iFreePage, eType, iPtrPage, &rc); |
| } |
| } |
| return rc; |
| } |
| |
| /* Forward declaration required by incrVacuumStep(). */ |
| static int allocateBtreePage(BtShared *, MemPage **, Pgno *, Pgno, u8); |
| |
| /* |
| ** Perform a single step of an incremental-vacuum. If successful, |
| ** return SQLITE_OK. If there is no work to do (and therefore no |
| ** point in calling this function again), return SQLITE_DONE. |
| ** |
| ** More specificly, this function attempts to re-organize the |
| ** database so that the last page of the file currently in use |
| ** is no longer in use. |
| ** |
| ** If the nFin parameter is non-zero, this function assumes |
| ** that the caller will keep calling incrVacuumStep() until |
| ** it returns SQLITE_DONE or an error, and that nFin is the |
| ** number of pages the database file will contain after this |
| ** process is complete. If nFin is zero, it is assumed that |
| ** incrVacuumStep() will be called a finite amount of times |
| ** which may or may not empty the freelist. A full autovacuum |
| ** has nFin>0. A "PRAGMA incremental_vacuum" has nFin==0. |
| */ |
| static int incrVacuumStep(BtShared *pBt, Pgno nFin, Pgno iLastPg){ |
| Pgno nFreeList; /* Number of pages still on the free-list */ |
| int rc; |
| |
| assert( sqlite3_mutex_held(pBt->mutex) ); |
| assert( iLastPg>nFin ); |
| |
| if( !PTRMAP_ISPAGE(pBt, iLastPg) && iLastPg!=PENDING_BYTE_PAGE(pBt) ){ |
| u8 eType; |
| Pgno iPtrPage; |
| |
| nFreeList = get4byte(&pBt->pPage1->aData[36]); |
| if( nFreeList==0 ){ |
| return SQLITE_DONE; |
| } |
| |
| rc = ptrmapGet(pBt, iLastPg, &eType, &iPtrPage); |
| if( rc!=SQLITE_OK ){ |
| return rc; |
| } |
| if( eType==PTRMAP_ROOTPAGE ){ |
| return 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; |
| MemPage *pFreePg; |
| rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, iLastPg, 1); |
| if( rc!=SQLITE_OK ){ |
| return rc; |
| } |
| assert( iFreePg==iLastPg ); |
| releasePage(pFreePg); |
| } |
| } else { |
| Pgno iFreePg; /* Index of free page to move pLastPg to */ |
| MemPage *pLastPg; |
| |
| rc = btreeGetPage(pBt, iLastPg, &pLastPg, 0); |
| if( rc!=SQLITE_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 { |
| MemPage *pFreePg; |
| rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, 0, 0); |
| if( rc!=SQLITE_OK ){ |
| releasePage(pLastPg); |
| return rc; |
| } |
| releasePage(pFreePg); |
| }while( nFin!=0 && iFreePg>nFin ); |
| assert( iFreePg<iLastPg ); |
| |
| rc = sqlite3PagerWrite(pLastPg->pDbPage); |
| if( rc==SQLITE_OK ){ |
| rc = relocatePage(pBt, pLastPg, eType, iPtrPage, iFreePg, nFin!=0); |
| } |
| releasePage(pLastPg); |
| if( rc!=SQLITE_OK ){ |
| return rc; |
| } |
| } |
| } |
| |
| if( nFin==0 ){ |
| iLastPg--; |
| while( iLastPg==PENDING_BYTE_PAGE(pBt)||PTRMAP_ISPAGE(pBt, iLastPg) ){ |
| if( PTRMAP_ISPAGE(pBt, iLastPg) ){ |
| MemPage *pPg; |
| rc = btreeGetPage(pBt, iLastPg, &pPg, 0); |
| if( rc!=SQLITE_OK ){ |
| return rc; |
| } |
| rc = sqlite3PagerWrite(pPg->pDbPage); |
| releasePage(pPg); |
| if( rc!=SQLITE_OK ){ |
| return rc; |
| } |
| } |
| iLastPg--; |
| } |
| sqlite3PagerTruncateImage(pBt->pPager, iLastPg); |
| pBt->nPage = iLastPg; |
| } |
| return SQLITE_OK; |
| } |
| |
| /* |
| ** A write-transaction must be opened before calling this function. |
| ** It performs a single unit of work towards an incremental vacuum. |
| ** |
| ** If the incremental vacuum is finished after this function has run, |
| ** SQLITE_DONE is returned. If it is not finished, but no error occurred, |
| ** SQLITE_OK is returned. Otherwise an SQLite error code. |
| */ |
| int sqlite3BtreeIncrVacuum(Btree *p){ |
| int rc; |
| BtShared *pBt = p->pBt; |
| |
| sqlite3BtreeEnter(p); |
| assert( pBt->inTransaction==TRANS_WRITE && p->inTrans==TRANS_WRITE ); |
| if( !pBt->autoVacuum ){ |
| rc = SQLITE_DONE; |
| }else{ |
| invalidateAllOverflowCache(pBt); |
| rc = incrVacuumStep(pBt, 0, btreePagecount(pBt)); |
| if( rc==SQLITE_OK ){ |
| rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); |
| put4byte(&pBt->pPage1->aData[28], pBt->nPage); |
| } |
| } |
| sqlite3BtreeLeave(p); |
| return rc; |
| } |
| |
| /* |
| ** This routine is called prior to sqlite3PagerCommit when a transaction |
| ** is commited for an auto-vacuum database. |
| ** |
| ** If SQLITE_OK is returned, then *pnTrunc is set to the number of pages |
| ** the database file should be truncated to during the commit process. |
| ** i.e. the database has been reorganized so that only the first *pnTrunc |
| ** pages are in use. |
| */ |
| static int autoVacuumCommit(BtShared *pBt){ |
| int rc = SQLITE_OK; |
| Pager *pPager = pBt->pPager; |
| VVA_ONLY( int nRef = sqlite3PagerRefcount(pPager) ); |
| |
| assert( sqlite3_mutex_held(pBt->mutex) ); |
| invalidateAllOverflowCache(pBt); |
| assert(pBt->autoVacuum); |
| if( !pBt->incrVacuum ){ |
| Pgno nFin; /* Number of pages in database after autovacuuming */ |
| Pgno nFree; /* Number of pages on the freelist initially */ |
| Pgno nPtrmap; /* Number of PtrMap pages to be freed */ |
| Pgno iFree; /* The next page to be freed */ |
| int nEntry; /* Number of entries on one ptrmap page */ |
| Pgno nOrig; /* Database size before freeing */ |
| |
| nOrig = btreePagecount(pBt); |
| 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 SQLITE_CORRUPT_BKPT; |
| } |
| |
| nFree = get4byte(&pBt->pPage1->aData[36]); |
| nEntry = pBt->usableSize/5; |
| nPtrmap = (nFree-nOrig+PTRMAP_PAGENO(pBt, nOrig)+nEntry)/nEntry; |
| nFin = nOrig - nFree - nPtrmap; |
| 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 SQLITE_CORRUPT_BKPT; |
| |
| for(iFree=nOrig; iFree>nFin && rc==SQLITE_OK; iFree--){ |
| rc = incrVacuumStep(pBt, nFin, iFree); |
| } |
| if( (rc==SQLITE_DONE || rc==SQLITE_OK) && nFree>0 ){ |
| rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); |
| put4byte(&pBt->pPage1->aData[32], 0); |
| put4byte(&pBt->pPage1->aData[36], 0); |
| put4byte(&pBt->pPage1->aData[28], nFin); |
| sqlite3PagerTruncateImage(pBt->pPager, nFin); |
| pBt->nPage = nFin; |
| } |
| if( rc!=SQLITE_OK ){ |
| sqlite3PagerRollback(pPager); |
| } |
| } |
| |
| assert( nRef==sqlite3PagerRefcount(pPager) ); |
| return rc; |
| } |
| |
| #else /* ifndef SQLITE_OMIT_AUTOVACUUM */ |
| # define setChildPtrmaps(x) SQLITE_OK |
| #endif |
| |
| /* |
| ** This routine does the first phase of a two-phase commit. This routine |
| ** causes a rollback journal to be created (if it does not already exist) |
| ** and populated with enough information so that if a power loss occurs |
| ** the database can be restored to its original state by playing back |
| ** the journal. Then the contents of the journal are flushed out to |
| ** the disk. After the journal is safely on oxide, the changes to the |
| ** database are written into the database file and flushed to oxide. |
| ** At the end of this call, the rollback journal still exists on the |
| ** disk and we are still holding all locks, so the transaction has not |
| ** committed. See sqlite3BtreeCommitPhaseTwo() for the second phase of the |
| ** commit process. |
| ** |
| ** This call is a no-op if no write-transaction is currently active on pBt. |
| ** |
| ** Otherwise, sync the database file for the btree pBt. zMaster points to |
| ** the name of a master journal file that should be written into the |
| ** individual journal file, or is NULL, indicating no master journal file |
| ** (single database transaction). |
| ** |
| ** When this is called, the master journal should already have been |
| ** created, populated with this journal pointer and synced to disk. |
| ** |
| ** Once this is routine has returned, the only thing required to commit |
| ** the write-transaction for this database file is to delete the journal. |
| */ |
| int sqlite3BtreeCommitPhaseOne(Btree *p, const char *zMaster){ |
| int rc = SQLITE_OK; |
| if( p->inTrans==TRANS_WRITE ){ |
| BtShared *pBt = p->pBt; |
| sqlite3BtreeEnter(p); |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| if( pBt->autoVacuum ){ |
| rc = autoVacuumCommit(pBt); |
| if( rc!=SQLITE_OK ){ |
| sqlite3BtreeLeave(p); |
| return rc; |
| } |
| } |
| #endif |
| rc = sqlite3PagerCommitPhaseOne(pBt->pPager, zMaster, 0); |
| sqlite3BtreeLeave(p); |
| } |
| return rc; |
| } |
| |
| /* |
| ** This function is called from both BtreeCommitPhaseTwo() and BtreeRollback() |
| ** at the conclusion of a transaction. |
| */ |
| static void btreeEndTransaction(Btree *p){ |
| BtShared *pBt = p->pBt; |
| assert( sqlite3BtreeHoldsMutex(p) ); |
| |
| btreeClearHasContent(pBt); |
| if( p->inTrans>TRANS_NONE && p->db->activeVdbeCnt>1 ){ |
| /* If there are other active statements that belong to this database |
| ** handle, downgrade to a read-only transaction. The other statements |
| ** may still be reading from the database. */ |
| downgradeAllSharedCacheTableLocks(p); |
| p->inTrans = TRANS_READ; |
| }else{ |
| /* If the handle had any kind of transaction open, decrement the |
| ** transaction count of the shared btree. If the transaction count |
| ** reaches 0, set the shared state to TRANS_NONE. The unlockBtreeIfUnused() |
| ** call below will unlock the pager. */ |
| if( p->inTrans!=TRANS_NONE ){ |
| clearAllSharedCacheTableLocks(p); |
| pBt->nTransaction--; |
| if( 0==pBt->nTransaction ){ |
| pBt->inTransaction = TRANS_NONE; |
| } |
| } |
| |
| /* Set the current transaction state to TRANS_NONE and unlock the |
| ** pager if this call closed the only read or write transaction. */ |
| p->inTrans = TRANS_NONE; |
| unlockBtreeIfUnused(pBt); |
| } |
| |
| btreeIntegrity(p); |
| } |
| |
| /* |
| ** Commit the transaction currently in progress. |
| ** |
| ** This routine implements the second phase of a 2-phase commit. The |
| ** sqlite3BtreeCommitPhaseOne() routine does the first phase and should |
| ** be invoked prior to calling this routine. The sqlite3BtreeCommitPhaseOne() |
| ** routine did all the work of writing information out to disk and flushing the |
| ** contents so that they are written onto the disk platter. All this |
| ** routine has to do is delete or truncate or zero the header in the |
| ** the rollback journal (which causes the transaction to commit) and |
| ** drop locks. |
| ** |
| ** Normally, if an error occurs while the pager layer is attempting to |
| ** finalize the underlying journal file, this function returns an error and |
| ** the upper layer will attempt a rollback. However, if the second argument |
| ** is non-zero then this b-tree transaction is part of a multi-file |
| ** transaction. In this case, the transaction has already been committed |
| ** (by deleting a master journal file) and the caller will ignore this |
| ** functions return code. So, even if an error occurs in the pager layer, |
| ** reset the b-tree objects internal state to indicate that the write |
| ** transaction has been closed. This is quite safe, as the pager will have |
| ** transitioned to the error state. |
| ** |
| ** This will release the write lock on the database file. If there |
| ** are no active cursors, it also releases the read lock. |
| */ |
| int sqlite3BtreeCommitPhaseTwo(Btree *p, int bCleanup){ |
| |
| if( p->inTrans==TRANS_NONE ) return SQLITE_OK; |
| sqlite3BtreeEnter(p); |
| btreeIntegrity(p); |
| |
| /* If the handle has a write-transaction open, commit the shared-btrees |
| ** transaction and set the shared state to TRANS_READ. |
| */ |
| if( p->inTrans==TRANS_WRITE ){ |
| int rc; |
| BtShared *pBt = p->pBt; |
| assert( pBt->inTransaction==TRANS_WRITE ); |
| assert( pBt->nTransaction>0 ); |
| rc = sqlite3PagerCommitPhaseTwo(pBt->pPager); |
| if( rc!=SQLITE_OK && bCleanup==0 ){ |
| sqlite3BtreeLeave(p); |
| return rc; |
| } |
| pBt->inTransaction = TRANS_READ; |
| } |
| |
| btreeEndTransaction(p); |
| sqlite3BtreeLeave(p); |
| return SQLITE_OK; |
| } |
| |
| /* |
| ** Do both phases of a commit. |
| */ |
| int sqlite3BtreeCommit(Btree *p){ |
| int rc; |
| sqlite3BtreeEnter(p); |
| rc = sqlite3BtreeCommitPhaseOne(p, 0); |
| if( rc==SQLITE_OK ){ |
| rc = sqlite3BtreeCommitPhaseTwo(p, 0); |
| } |
| sqlite3BtreeLeave(p); |
| return rc; |
| } |
| |
| #ifndef NDEBUG |
| /* |
| ** Return the number of write-cursors open on this handle. This is for use |
| ** in assert() expressions, so it is only compiled if NDEBUG is not |
| ** defined. |
| ** |
| ** For the purposes of this routine, a write-cursor is any cursor that |
| ** is capable of writing to the databse. That means the cursor was |
| ** originally opened for writing and the cursor has not be disabled |
| ** by having its state changed to CURSOR_FAULT. |
| */ |
| static int countWriteCursors(BtShared *pBt){ |
| BtCursor *pCur; |
| int r = 0; |
| for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){ |
| if( pCur->wrFlag && pCur->eState!=CURSOR_FAULT ) r++; |
| } |
| return r; |
| } |
| #endif |
| |
| /* |
| ** This routine sets the state to CURSOR_FAULT and the error |
| ** code to errCode for every cursor on BtShared that pBtree |
| ** references. |
| ** |
| ** Every cursor is tripped, including cursors that belong |
| ** to other database connections that happen to be sharing |
| ** the cache with pBtree. |
| ** |
| ** This routine gets called when a rollback occurs. |
| ** All cursors using the same cache must be tripped |
| ** to prevent them from trying to use the btree after |
| ** the rollback. The rollback may have deleted tables |
| ** or moved root pages, so it is not sufficient to |
| ** save the state of the cursor. The cursor must be |
| ** invalidated. |
| */ |
| void sqlite3BtreeTripAllCursors(Btree *pBtree, int errCode){ |
| BtCursor *p; |
| sqlite3BtreeEnter(pBtree); |
| for(p=pBtree->pBt->pCursor; p; p=p->pNext){ |
| int i; |
| sqlite3BtreeClearCursor(p); |
| p->eState = CURSOR_FAULT; |
| p->skipNext = errCode; |
| for(i=0; i<=p->iPage; i++){ |
| releasePage(p->apPage[i]); |
| p->apPage[i] = 0; |
| } |
| } |
| sqlite3BtreeLeave(pBtree); |
| } |
| |
| /* |
| ** Rollback the transaction in progress. All cursors will be |
| ** invalided by this operation. Any attempt to use a cursor |
| ** that was open at the beginning of this operation will result |
| ** in an error. |
| ** |
| ** This will release the write lock on the database file. If there |
| ** are no active cursors, it also releases the read lock. |
| */ |
| int sqlite3BtreeRollback(Btree *p){ |
| int rc; |
| BtShared *pBt = p->pBt; |
| MemPage *pPage1; |
| |
| sqlite3BtreeEnter(p); |
| rc = saveAllCursors(pBt, 0, 0); |
| #ifndef SQLITE_OMIT_SHARED_CACHE |
| if( rc!=SQLITE_OK ){ |
| /* This is a horrible situation. An IO or malloc() error occurred whilst |
| ** trying to save cursor positions. If this is an automatic rollback (as |
| ** the result of a constraint, malloc() failure or IO error) then |
| ** the cache may be internally inconsistent (not contain valid trees) so |
| ** we cannot simply return the error to the caller. Instead, abort |
| ** all queries that may be using any of the cursors that failed to save. |
| */ |
| sqlite3BtreeTripAllCursors(p, rc); |
| } |
| #endif |
| btreeIntegrity(p); |
| |
| if( p->inTrans==TRANS_WRITE ){ |
| int rc2; |
| |
| assert( TRANS_WRITE==pBt->inTransaction ); |
| rc2 = sqlite3PagerRollback(pBt->pPager); |
| if( rc2!=SQLITE_OK ){ |
| rc = rc2; |
| } |
| |
| /* The rollback may have destroyed the pPage1->aData value. So |
| ** call btreeGetPage() on page 1 again to make |
| ** sure pPage1->aData is set correctly. */ |
| if( btreeGetPage(pBt, 1, &pPage1, 0)==SQLITE_OK ){ |
| int nPage = get4byte(28+(u8*)pPage1->aData); |
| testcase( nPage==0 ); |
| if( nPage==0 ) sqlite3PagerPagecount(pBt->pPager, &nPage); |
| testcase( pBt->nPage!=nPage ); |
| pBt->nPage = nPage; |
| releasePage(pPage1); |
| } |
| assert( countWriteCursors(pBt)==0 ); |
| pBt->inTransaction = TRANS_READ; |
| } |
| |
| btreeEndTransaction(p); |
| sqlite3BtreeLeave(p); |
| return rc; |
| } |
| |
| /* |
| ** Start a statement subtransaction. The subtransaction can can be rolled |
| ** back independently of the main transaction. You must start a transaction |
| ** before starting a subtransaction. The subtransaction is ended automatically |
| ** if the main transaction commits or rolls back. |
| ** |
| ** Statement subtransactions are used around individual SQL statements |
| ** that are contained within a BEGIN...COMMIT block. If a constraint |
| ** error occurs within the statement, the effect of that one statement |
| ** can be rolled back without having to rollback the entire transaction. |
| ** |
| ** A statement sub-transaction is implemented as an anonymous savepoint. The |
| ** value passed as the second parameter is the total number of savepoints, |
| ** including the new anonymous savepoint, open on the B-Tree. i.e. if there |
| ** are no active savepoints and no other statement-transactions open, |
| ** iStatement is 1. This anonymous savepoint can be released or rolled back |
| ** using the sqlite3BtreeSavepoint() function. |
| */ |
| int sqlite3BtreeBeginStmt(Btree *p, int iStatement){ |
| int rc; |
| BtShared *pBt = p->pBt; |
| sqlite3BtreeEnter(p); |
| assert( p->inTrans==TRANS_WRITE ); |
| assert( pBt->readOnly==0 ); |
| assert( iStatement>0 ); |
| assert( iStatement>p->db->nSavepoint ); |
| assert( pBt->inTransaction==TRANS_WRITE ); |
| /* At the pager level, a statement transaction is a savepoint with |
| ** an index greater than all savepoints created explicitly using |
| ** SQL statements. It is illegal to open, release or rollback any |
| ** such savepoints while the statement transaction savepoint is active. |
| */ |
| rc = sqlite3PagerOpenSavepoint(pBt->pPager, iStatement); |
| sqlite3BtreeLeave(p); |
| return rc; |
| } |
| |
| /* |
| ** The second argument to this function, op, is always SAVEPOINT_ROLLBACK |
| ** or SAVEPOINT_RELEASE. This function either releases or rolls back the |
| ** savepoint identified by parameter iSavepoint, depending on the value |
| ** of op. |
| ** |
| ** Normally, iSavepoint is greater than or equal to zero. However, if op is |
| ** SAVEPOINT_ROLLBACK, then iSavepoint may also be -1. In this case the |
| ** contents of the entire transaction are rolled back. This is different |
| ** from a normal transaction rollback, as no locks are released and the |
| ** transaction remains open. |
| */ |
| int sqlite3BtreeSavepoint(Btree *p, int op, int iSavepoint){ |
| int rc = SQLITE_OK; |
| if( p && p->inTrans==TRANS_WRITE ){ |
| BtShared *pBt = p->pBt; |
| assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK ); |
| assert( iSavepoint>=0 || (iSavepoint==-1 && op==SAVEPOINT_ROLLBACK) ); |
| sqlite3BtreeEnter(p); |
| rc = sqlite3PagerSavepoint(pBt->pPager, op, iSavepoint); |
| if( rc==SQLITE_OK ){ |
| if( iSavepoint<0 && pBt->initiallyEmpty ) pBt->nPage = 0; |
| rc = newDatabase(pBt); |
| pBt->nPage = get4byte(28 + pBt->pPage1->aData); |
| |
| /* The database size was written into the offset 28 of the header |
| ** when the transaction started, so we know that the value at offset |
| ** 28 is nonzero. */ |
| assert( pBt->nPage>0 ); |
| } |
| sqlite3BtreeLeave(p); |
| } |
| return rc; |
| } |
| |
| /* |
| ** Create a new cursor for the BTree whose root is on the page |
| ** iTable. If a read-only cursor is requested, it is assumed that |
| ** the caller already has at least a read-only transaction open |
| ** on the database already. If a write-cursor is requested, then |
| ** the caller is assumed to have an open write transaction. |
| ** |
| ** If wrFlag==0, then the cursor can only be used for reading. |
| ** If wrFlag==1, then the cursor can be used for reading or for |
| ** writing if other conditions for writing are also met. These |
| ** are the conditions that must be met in order for writing to |
| ** be allowed: |
| ** |
| ** 1: The cursor must have been opened with wrFlag==1 |
| ** |
| ** 2: Other database connections that share the same pager cache |
| ** but which are not in the READ_UNCOMMITTED state may not have |
| ** cursors open with wrFlag==0 on the same table. Otherwise |
| ** the changes made by this write cursor would be visible to |
| ** the read cursors in the other database connection. |
| ** |
| ** 3: The database must be writable (not on read-only media) |
| ** |
| ** 4: There must be an active transaction. |
| ** |
| ** No checking is done to make sure that page iTable really is the |
| ** root page of a b-tree. If it is not, then the cursor acquired |
| ** will not work correctly. |
| ** |
| ** It is assumed that the sqlite3BtreeCursorZero() has been called |
| ** on pCur to initialize the memory space prior to invoking this routine. |
| */ |
| static int btreeCursor( |
| Btree *p, /* The btree */ |
| int iTable, /* Root page of table to open */ |
| int wrFlag, /* 1 to write. 0 read-only */ |
| struct KeyInfo *pKeyInfo, /* First arg to comparison function */ |
| BtCursor *pCur /* Space for new cursor */ |
| ){ |
| BtShared *pBt = p->pBt; /* Shared b-tree handle */ |
| |
| assert( sqlite3BtreeHoldsMutex(p) ); |
| assert( wrFlag==0 || wrFlag==1 ); |
| |
| /* The following assert statements verify that if this is a sharable |
| ** b-tree database, the connection is holding the required table locks, |
| ** and that no other connection has any open cursor that conflicts with |
| ** this lock. */ |
| assert( hasSharedCacheTableLock(p, iTable, pKeyInfo!=0, wrFlag+1) ); |
| assert( wrFlag==0 || !hasReadConflicts(p, iTable) ); |
| |
| /* Assert that the caller has opened the required transaction. */ |
| assert( p->inTrans>TRANS_NONE ); |
| assert( wrFlag==0 || p->inTrans==TRANS_WRITE ); |
| assert( pBt->pPage1 && pBt->pPage1->aData ); |
| |
| if( NEVER(wrFlag && pBt->readOnly) ){ |
| return SQLITE_READONLY; |
| } |
| if( iTable==1 && btreePagecount(pBt)==0 ){ |
| return SQLITE_EMPTY; |
| } |
| |
| /* Now that no other errors can occur, finish filling in the BtCursor |
| ** variables and link the cursor into the BtShared list. */ |
| pCur->pgnoRoot = (Pgno)iTable; |
| pCur->iPage = -1; |
| pCur->pKeyInfo = pKeyInfo; |
| pCur->pBtree = p; |
| pCur->pBt = pBt; |
| pCur->wrFlag = (u8)wrFlag; |
| pCur->pNext = pBt->pCursor; |
| if( pCur->pNext ){ |
| pCur->pNext->pPrev = pCur; |
| } |
| pBt->pCursor = pCur; |
| pCur->eState = CURSOR_INVALID; |
| pCur->cachedRowid = 0; |
| return SQLITE_OK; |
| } |
| int sqlite3BtreeCursor( |
| Btree *p, /* The btree */ |
| int iTable, /* Root page of table to open */ |
| int wrFlag, /* 1 to write. 0 read-only */ |
| struct KeyInfo *pKeyInfo, /* First arg to xCompare() */ |
| BtCursor *pCur /* Write new cursor here */ |
| ){ |
| int rc; |
| sqlite3BtreeEnter(p); |
| rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur); |
| sqlite3BtreeLeave(p); |
| return rc; |
| } |
| |
| /* |
| ** Return the size of a BtCursor object in bytes. |
| ** |
| ** This interfaces is needed so that users of cursors can preallocate |
| ** sufficient storage to hold a cursor. The BtCursor object is opaque |
| ** to users so they cannot do the sizeof() themselves - they must call |
| ** this routine. |
| */ |
| int sqlite3BtreeCursorSize(void){ |
| return ROUND8(sizeof(BtCursor)); |
| } |
| |
| /* |
| ** Initialize memory that will be converted into a BtCursor object. |
| ** |
| ** The simple approach here would be to memset() the entire object |
| ** to zero. But it turns out that the apPage[] and aiIdx[] arrays |
| ** do not need to be zeroed and they are large, so we can save a lot |
| ** of run-time by skipping the initialization of those elements. |
| */ |
| void sqlite3BtreeCursorZero(BtCursor *p){ |
| memset(p, 0, offsetof(BtCursor, iPage)); |
| } |
| |
| /* |
| ** Set the cached rowid value of every cursor in the same database file |
| ** as pCur and having the same root page number as pCur. The value is |
| ** set to iRowid. |
| ** |
| ** Only positive rowid values are considered valid for this cache. |
| ** The cache is initialized to zero, indicating an invalid cache. |
| ** A btree will work fine with zero or negative rowids. We just cannot |
| ** cache zero or negative rowids, which means tables that use zero or |
| ** negative rowids might run a little slower. But in practice, zero |
| ** or negative rowids are very uncommon so this should not be a problem. |
| */ |
| void sqlite3BtreeSetCachedRowid(BtCursor *pCur, sqlite3_int64 iRowid){ |
| BtCursor *p; |
| for(p=pCur->pBt->pCursor; p; p=p->pNext){ |
| if( p->pgnoRoot==pCur->pgnoRoot ) p->cachedRowid = iRowid; |
| } |
| assert( pCur->cachedRowid==iRowid ); |
| } |
| |
| /* |
| ** Return the cached rowid for the given cursor. A negative or zero |
| ** return value indicates that the rowid cache is invalid and should be |
| ** ignored. If the rowid cache has never before been set, then a |
| ** zero is returned. |
| */ |
| sqlite3_int64 sqlite3BtreeGetCachedRowid(BtCursor *pCur){ |
| return pCur->cachedRowid; |
| } |
| |
| /* |
| ** Close a cursor. The read lock on the database file is released |
| ** when the last cursor is closed. |
| */ |
| int sqlite3BtreeCloseCursor(BtCursor *pCur){ |
| Btree *pBtree = pCur->pBtree; |
| if( pBtree ){ |
| int i; |
| BtShared *pBt = pCur->pBt; |
| sqlite3BtreeEnter(pBtree); |
| sqlite3BtreeClearCursor(pCur); |
| if( pCur->pPrev ){ |
| pCur->pPrev->pNext = pCur->pNext; |
| }else{ |
| pBt->pCursor = pCur->pNext; |
| } |
| if( pCur->pNext ){ |
| pCur->pNext->pPrev = pCur->pPrev; |
| } |
| for(i=0; i<=pCur->iPage; i++){ |
| releasePage(pCur->apPage[i]); |
| } |
| unlockBtreeIfUnused(pBt); |
| invalidateOverflowCache(pCur); |
| /* sqlite3_free(pCur); */ |
| sqlite3BtreeLeave(pBtree); |
| } |
| return SQLITE_OK; |
| } |
| |
| /* |
| ** Make sure the BtCursor* given in the argument has a valid |
| ** BtCursor.info structure. If it is not already valid, call |
| ** btreeParseCell() to fill it in. |
| ** |
| ** BtCursor.info is a cache of the information in the current cell. |
| ** Using this cache reduces the number of calls to btreeParseCell(). |
| ** |
| ** 2007-06-25: There is a bug in some versions of MSVC that cause the |
| ** compiler to crash when getCellInfo() is implemented as a macro. |
| ** But there is a measureable speed advantage to using the macro on gcc |
| ** (when less compiler optimizations like -Os or -O0 are used and the |
| ** compiler is not doing agressive inlining.) So we use a real function |
| ** for MSVC and a macro for everything else. Ticket #2457. |
| */ |
| #ifndef NDEBUG |
| static void assertCellInfo(BtCursor *pCur){ |
| CellInfo info; |
| int iPage = pCur->iPage; |
| memset(&info, 0, sizeof(info)); |
| btreeParseCell(pCur->apPage[iPage], pCur->aiIdx[iPage], &info); |
| assert( memcmp(&info, &pCur->info, sizeof(info))==0 ); |
| } |
| #else |
| #define assertCellInfo(x) |
| #endif |
| #ifdef _MSC_VER |
| /* Use a real function in MSVC to work around bugs in that compiler. */ |
| static void getCellInfo(BtCursor *pCur){ |
| if( pCur->info.nSize==0 ){ |
| int iPage = pCur->iPage; |
| btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info); |
| pCur->validNKey = 1; |
| }else{ |
| assertCellInfo(pCur); |
| } |
| } |
| #else /* if not _MSC_VER */ |
| /* Use a macro in all other compilers so that the function is inlined */ |
| #define getCellInfo(pCur) \ |
| if( pCur->info.nSize==0 ){ \ |
| int iPage = pCur->iPage; \ |
| btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info); \ |
| pCur->validNKey = 1; \ |
| }else{ \ |
| assertCellInfo(pCur); \ |
| } |
| #endif /* _MSC_VER */ |
| |
| #ifndef NDEBUG /* The next routine used only within assert() statements */ |
| /* |
| ** Return true if the given BtCursor is valid. A valid cursor is one |
| ** that is currently pointing to a row in a (non-empty) table. |
| ** This is a verification routine is used only within assert() statements. |
| */ |
| int sqlite3BtreeCursorIsValid(BtCursor *pCur){ |
| return pCur && pCur->eState==CURSOR_VALID; |
| } |
| #endif /* NDEBUG */ |
| |
| /* |
| ** Set *pSize to the size of the buffer needed to hold the value of |
| ** the key for the current entry. If the cursor is not pointing |
| ** to a valid entry, *pSize is set to 0. |
| ** |
| ** For a table with the INTKEY flag set, this routine returns the key |
| ** itself, not the number of bytes in the key. |
| ** |
| ** The caller must position the cursor prior to invoking this routine. |
| ** |
| ** This routine cannot fail. It always returns SQLITE_OK. |
| */ |
| int sqlite3BtreeKeySize(BtCursor *pCur, i64 *pSize){ |
| assert( cursorHoldsMutex(pCur) ); |
| assert( pCur->eState==CURSOR_INVALID || pCur->eState==CURSOR_VALID ); |
| if( pCur->eState!=CURSOR_VALID ){ |
| *pSize = 0; |
| }else{ |
| getCellInfo(pCur); |
| *pSize = pCur->info.nKey; |
| } |
| return SQLITE_OK; |
| } |
| |
| /* |
| ** Set *pSize to the number of bytes of data in the entry the |
| ** cursor currently points to. |
| ** |
| ** The caller must guarantee that the cursor is pointing to a non-NULL |
| ** valid entry. In other words, the calling procedure must guarantee |
| ** that the cursor has Cursor.eState==CURSOR_VALID. |
| ** |
| ** Failure is not possible. This function always returns SQLITE_OK. |
| ** It might just as well be a procedure (returning void) but we continue |
| ** to return an integer result code for historical reasons. |
| */ |
| int sqlite3BtreeDataSize(BtCursor *pCur, u32 *pSize){ |
| assert( cursorHoldsMutex(pCur) ); |
| assert( pCur->eState==CURSOR_VALID ); |
| getCellInfo(pCur); |
| *pSize = pCur->info.nData; |
| return SQLITE_OK; |
| } |
| |
| /* |
| ** Given the page number of an overflow page in the database (parameter |
| ** ovfl), this function finds the page number of the next page in the |
| ** linked list of overflow pages. If possible, it uses the auto-vacuum |
| ** pointer-map data instead of reading the content of page ovfl to do so. |
| ** |
| ** If an error occurs an SQLite error code is returned. Otherwise: |
| ** |
| ** The page number of the next overflow page in the linked list is |
| ** written to *pPgnoNext. If page ovfl is the last page in its linked |
| ** list, *pPgnoNext is set to zero. |
| ** |
| ** If ppPage is not NULL, and a reference to the MemPage object corresponding |
| ** to page number pOvfl was obtained, then *ppPage is set to point to that |
| ** reference. It is the responsibility of the caller to call releasePage() |
| ** on *ppPage to free the reference. In no reference was obtained (because |
| ** the pointer-map was used to obtain the value for *pPgnoNext), then |
| ** *ppPage is set to zero. |
| */ |
| static int getOverflowPage( |
| BtShared *pBt, /* The database file */ |
| Pgno ovfl, /* Current overflow page number */ |
| MemPage **ppPage, /* OUT: MemPage handle (may be NULL) */ |
| Pgno *pPgnoNext /* OUT: Next overflow page number */ |
| ){ |
| Pgno next = 0; |
| MemPage *pPage = 0; |
| int rc = SQLITE_OK; |
| |
| assert( sqlite3_mutex_held(pBt->mutex) ); |
| assert(pPgnoNext); |
| |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| /* Try to find the next page in the overflow list using the |
| ** autovacuum pointer-map pages. Guess that the next page in |
| ** the overflow list is page number (ovfl+1). If that guess turns |
| ** out to be wrong, fall back to loading the data of page |
| ** number ovfl to determine the next page number. |
| */ |
| if( pBt->autoVacuum ){ |
| Pgno pgno; |
| Pgno iGuess = ovfl+1; |
| u8 eType; |
| |
| while( PTRMAP_ISPAGE(pBt, iGuess) || iGuess==PENDING_BYTE_PAGE(pBt) ){ |
| iGuess++; |
| } |
| |
| if( iGuess<=btreePagecount(pBt) ){ |
| rc = ptrmapGet(pBt, iGuess, &eType, &pgno); |
| if( rc==SQLITE_OK && eType==PTRMAP_OVERFLOW2 && pgno==ovfl ){ |
| next = iGuess; |
| rc = SQLITE_DONE; |
| } |
| } |
| } |
| #endif |
| |
| assert( next==0 || rc==SQLITE_DONE ); |
| if( rc==SQLITE_OK ){ |
| rc = btreeGetPage(pBt, ovfl, &pPage, 0); |
| assert( rc==SQLITE_OK || pPage==0 ); |
| if( rc==SQLITE_OK ){ |
| next = get4byte(pPage->aData); |
| } |
| } |
| |
| *pPgnoNext = next; |
| if( ppPage ){ |
| *ppPage = pPage; |
| }else{ |
| releasePage(pPage); |
| } |
| return (rc==SQLITE_DONE ? SQLITE_OK : rc); |
| } |
| |
| /* |
| ** Copy data from a buffer to a page, or from a page to a buffer. |
| ** |
| ** pPayload is a pointer to data stored on database page pDbPage. |
| ** If argument eOp is false, then nByte bytes of data are copied |
| ** from pPayload to the buffer pointed at by pBuf. If eOp is true, |
| ** then sqlite3PagerWrite() is called on pDbPage and nByte bytes |
| ** of data are copied from the buffer pBuf to pPayload. |
| ** |
| ** SQLITE_OK is returned on success, otherwise an error code. |
| */ |
| static int copyPayload( |
| void *pPayload, /* Pointer to page data */ |
| void *pBuf, /* Pointer to buffer */ |
| int nByte, /* Number of bytes to copy */ |
| int eOp, /* 0 -> copy from page, 1 -> copy to page */ |
| DbPage *pDbPage /* Page containing pPayload */ |
| ){ |
| if( eOp ){ |
| /* Copy data from buffer to page (a write operation) */ |
| int rc = sqlite3PagerWrite(pDbPage); |
| if( rc!=SQLITE_OK ){ |
| return rc; |
| } |
| memcpy(pPayload, pBuf, nByte); |
| }else{ |
| /* Copy data from page to buffer (a read operation) */ |
| memcpy(pBuf, pPayload, nByte); |
| } |
| return SQLITE_OK; |
| } |
| |
| /* |
| ** This function is used to read or overwrite payload information |
| ** for the entry that the pCur cursor is pointing to. If the eOp |
| ** parameter is 0, this is a read operation (data copied into |
| ** buffer pBuf). If it is non-zero, a write (data copied from |
| ** buffer pBuf). |
| ** |
| ** A total of "amt" bytes are read or written beginning at "offset". |
| ** Data is read to or from the buffer pBuf. |
| ** |
| ** The content being read or written might appear on the main page |
| ** or be scattered out on multiple overflow pages. |
| ** |
| ** If the BtCursor.isIncrblobHandle flag is set, and the current |
| ** cursor entry uses one or more overflow pages, this function |
| ** allocates space for and lazily popluates the overflow page-list |
| ** cache array (BtCursor.aOverflow). Subsequent calls use this |
| ** cache to make seeking to the supplied offset more efficient. |
| ** |
| ** Once an overflow page-list cache has been allocated, it may be |
| ** invalidated if some other cursor writes to the same table, or if |
| ** the cursor is moved to a different row. Additionally, in auto-vacuum |
| ** mode, the following events may invalidate an overflow page-list cache. |
| ** |
| ** * An incremental vacuum, |
| ** * A commit in auto_vacuum="full" mode, |
| ** * Creating a table (may require moving an overflow page). |
| */ |
| static int accessPayload( |
| BtCursor *pCur, /* Cursor pointing to entry to read from */ |
| u32 offset, /* Begin reading this far into payload */ |
| u32 amt, /* Read this many bytes */ |
| unsigned char *pBuf, /* Write the bytes into this buffer */ |
| int eOp /* zero to read. non-zero to write. */ |
| ){ |
| unsigned char *aPayload; |
| int rc = SQLITE_OK; |
| u32 nKey; |
| int iIdx = 0; |
| MemPage *pPage = pCur->apPage[pCur->iPage]; /* Btree page of current entry */ |
| BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */ |
| |
| assert( pPage ); |
| assert( pCur->eState==CURSOR_VALID ); |
| assert( pCur->aiIdx[pCur->iPage]<pPage->nCell ); |
| assert( cursorHoldsMutex(pCur) ); |
| |
| getCellInfo(pCur); |
| aPayload = pCur->info.pCell + pCur->info.nHeader; |
| nKey = (pPage->intKey ? 0 : (int)pCur->info.nKey); |
| |
| if( NEVER(offset+amt > nKey+pCur->info.nData) |
| || &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize] |
| ){ |
| /* Trying to read or write past the end of the data is an error */ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| |
| /* Check if data must be read/written to/from the btree page itself. */ |
| if( offset<pCur->info.nLocal ){ |
| int a = amt; |
| if( a+offset>pCur->info.nLocal ){ |
| a = pCur->info.nLocal - offset; |
| } |
| rc = copyPayload(&aPayload[offset], pBuf, a, eOp, pPage->pDbPage); |
| offset = 0; |
| pBuf += a; |
| amt -= a; |
| }else{ |
| offset -= pCur->info.nLocal; |
| } |
| |
| if( rc==SQLITE_OK && amt>0 ){ |
| const u32 ovflSize = pBt->usableSize - 4; /* Bytes content per ovfl page */ |
| Pgno nextPage; |
| |
| nextPage = get4byte(&aPayload[pCur->info.nLocal]); |
| |
| #ifndef SQLITE_OMIT_INCRBLOB |
| /* If the isIncrblobHandle flag is set and the BtCursor.aOverflow[] |
| ** has not been allocated, allocate it now. The array is sized at |
| ** one entry for each overflow page in the overflow chain. The |
| ** page number of the first overflow page is stored in aOverflow[0], |
| ** etc. A value of 0 in the aOverflow[] array means "not yet known" |
| ** (the cache is lazily populated). |
| */ |
| if( pCur->isIncrblobHandle && !pCur->aOverflow ){ |
| int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize; |
| pCur->aOverflow = (Pgno *)sqlite3MallocZero(sizeof(Pgno)*nOvfl); |
| /* nOvfl is always positive. If it were zero, fetchPayload would have |
| ** been used instead of this routine. */ |
| if( ALWAYS(nOvfl) && !pCur->aOverflow ){ |
| rc = SQLITE_NOMEM; |
| } |
| } |
| |
| /* If the overflow page-list cache has been allocated and the |
| ** entry for the first required overflow page is valid, skip |
| ** directly to it. |
| */ |
| if( pCur->aOverflow && pCur->aOverflow[offset/ovflSize] ){ |
| iIdx = (offset/ovflSize); |
| nextPage = pCur->aOverflow[iIdx]; |
| offset = (offset%ovflSize); |
| } |
| #endif |
| |
| for( ; rc==SQLITE_OK && amt>0 && nextPage; iIdx++){ |
| |
| #ifndef SQLITE_OMIT_INCRBLOB |
| /* If required, populate the overflow page-list cache. */ |
| if( pCur->aOverflow ){ |
| assert(!pCur->aOverflow[iIdx] || pCur->aOverflow[iIdx]==nextPage); |
| pCur->aOverflow[iIdx] = nextPage; |
| } |
| #endif |
| |
| if( offset>=ovflSize ){ |
| /* The only reason to read this page is to obtain the page |
| ** number for the next page in the overflow chain. The page |
| ** data is not required. So first try to lookup the overflow |
| ** page-list cache, if any, then fall back to the getOverflowPage() |
| ** function. |
| */ |
| #ifndef SQLITE_OMIT_INCRBLOB |
| if( pCur->aOverflow && pCur->aOverflow[iIdx+1] ){ |
| nextPage = pCur->aOverflow[iIdx+1]; |
| } else |
| #endif |
| rc = getOverflowPage(pBt, nextPage, 0, &nextPage); |
| offset -= ovflSize; |
| }else{ |
| /* Need to read this page properly. It contains some of the |
| ** range of data that is being read (eOp==0) or written (eOp!=0). |
| */ |
| DbPage *pDbPage; |
| int a = amt; |
| rc = sqlite3PagerGet(pBt->pPager, nextPage, &pDbPage); |
| if( rc==SQLITE_OK ){ |
| aPayload = sqlite3PagerGetData(pDbPage); |
| nextPage = get4byte(aPayload); |
| if( a + offset > ovflSize ){ |
| a = ovflSize - offset; |
| } |
| rc = copyPayload(&aPayload[offset+4], pBuf, a, eOp, pDbPage); |
| sqlite3PagerUnref(pDbPage); |
| offset = 0; |
| amt -= a; |
| pBuf += a; |
| } |
| } |
| } |
| } |
| |
| if( rc==SQLITE_OK && amt>0 ){ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| return rc; |
| } |
| |
| /* |
| ** Read part of the key associated with cursor pCur. Exactly |
| ** "amt" bytes will be transfered into pBuf[]. The transfer |
| ** begins at "offset". |
| ** |
| ** The caller must ensure that pCur is pointing to a valid row |
| ** in the table. |
| ** |
| ** Return SQLITE_OK on success or an error code if anything goes |
| ** wrong. An error is returned if "offset+amt" is larger than |
| ** the available payload. |
| */ |
| int sqlite3BtreeKey(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){ |
| assert( cursorHoldsMutex(pCur) ); |
| assert( pCur->eState==CURSOR_VALID ); |
| assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] ); |
| assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell ); |
| return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0); |
| } |
| |
| /* |
| ** Read part of the data associated with cursor pCur. Exactly |
| ** "amt" bytes will be transfered into pBuf[]. The transfer |
| ** begins at "offset". |
| ** |
| ** Return SQLITE_OK on success or an error code if anything goes |
| ** wrong. An error is returned if "offset+amt" is larger than |
| ** the available payload. |
| */ |
| int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){ |
| int rc; |
| |
| #ifndef SQLITE_OMIT_INCRBLOB |
| if ( pCur->eState==CURSOR_INVALID ){ |
| return SQLITE_ABORT; |
| } |
| #endif |
| |
| assert( cursorHoldsMutex(pCur) ); |
| rc = restoreCursorPosition(pCur); |
| if( rc==SQLITE_OK ){ |
| assert( pCur->eState==CURSOR_VALID ); |
| assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] ); |
| assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell ); |
| rc = accessPayload(pCur, offset, amt, pBuf, 0); |
| } |
| return rc; |
| } |
| |
| /* |
| ** Return a pointer to payload information from the entry that the |
| ** pCur cursor is pointing to. The pointer is to the beginning of |
| ** the key if skipKey==0 and it points to the beginning of data if |
| ** skipKey==1. The number of bytes of available key/data is written |
| ** into *pAmt. If *pAmt==0, then the value returned will not be |
| ** a valid pointer. |
| ** |
| ** This routine is an optimization. It is common for the entire key |
| ** and data to fit on the local page and for there to be no overflow |
| ** pages. When that is so, this routine can be used to access the |
| ** key and data without making a copy. If the key and/or data spills |
| ** onto overflow pages, then accessPayload() must be used to reassemble |
| ** the key/data and copy it into a preallocated buffer. |
| ** |
| ** The pointer returned by this routine looks directly into the cached |
| ** page of the database. The data might change or move the next time |
| ** any btree routine is called. |
| */ |
| static const unsigned char *fetchPayload( |
| BtCursor *pCur, /* Cursor pointing to entry to read from */ |
| int *pAmt, /* Write the number of available bytes here */ |
| int skipKey /* read beginning at data if this is true */ |
| ){ |
| unsigned char *aPayload; |
| MemPage *pPage; |
| u32 nKey; |
| u32 nLocal; |
| |
| assert( pCur!=0 && pCur->iPage>=0 && pCur->apPage[pCur->iPage]); |
| assert( pCur->eState==CURSOR_VALID ); |
| assert( cursorHoldsMutex(pCur) ); |
| pPage = pCur->apPage[pCur->iPage]; |
| assert( pCur->aiIdx[pCur->iPage]<pPage->nCell ); |
| if( NEVER(pCur->info.nSize==0) ){ |
| btreeParseCell(pCur->apPage[pCur->iPage], pCur->aiIdx[pCur->iPage], |
| &pCur->info); |
| } |
| aPayload = pCur->info.pCell; |
| aPayload += pCur->info.nHeader; |
| if( pPage->intKey ){ |
| nKey = 0; |
| }else{ |
| nKey = (int)pCur->info.nKey; |
| } |
| if( skipKey ){ |
| aPayload += nKey; |
| nLocal = pCur->info.nLocal - nKey; |
| }else{ |
| nLocal = pCur->info.nLocal; |
| assert( nLocal<=nKey ); |
| } |
| *pAmt = nLocal; |
| return aPayload; |
| } |
| |
| |
| /* |
| ** For the entry that cursor pCur is point to, return as |
| ** many bytes of the key or data as are available on the local |
| ** b-tree page. Write the number of available bytes into *pAmt. |
| ** |
| ** The pointer returned is ephemeral. The key/data may move |
| ** or be destroyed on the next call to any Btree routine, |
| ** including calls from other threads against the same cache. |
| ** Hence, a mutex on the BtShared should be held prior to calling |
| ** this routine. |
| ** |
| ** These routines is used to get quick access to key and data |
| ** in the common case where no overflow pages are used. |
| */ |
| const void *sqlite3BtreeKeyFetch(BtCursor *pCur, int *pAmt){ |
| const void *p = 0; |
| assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); |
| assert( cursorHoldsMutex(pCur) ); |
| if( ALWAYS(pCur->eState==CURSOR_VALID) ){ |
| p = (const void*)fetchPayload(pCur, pAmt, 0); |
| } |
| return p; |
| } |
| const void *sqlite3BtreeDataFetch(BtCursor *pCur, int *pAmt){ |
| const void *p = 0; |
| assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); |
| assert( cursorHoldsMutex(pCur) ); |
| if( ALWAYS(pCur->eState==CURSOR_VALID) ){ |
| p = (const void*)fetchPayload(pCur, pAmt, 1); |
| } |
| return p; |
| } |
| |
| |
| /* |
| ** Move the cursor down to a new child page. The newPgno argument is the |
| ** page number of the child page to move to. |
| ** |
| ** This function returns SQLITE_CORRUPT if the page-header flags field of |
| ** the new child page does not match the flags field of the parent (i.e. |
| ** if an intkey page appears to be the parent of a non-intkey page, or |
| ** vice-versa). |
| */ |
| static int moveToChild(BtCursor *pCur, u32 newPgno){ |
| int rc; |
| int i = pCur->iPage; |
| MemPage *pNewPage; |
| BtShared *pBt = pCur->pBt; |
| |
| assert( cursorHoldsMutex(pCur) ); |
| assert( pCur->eState==CURSOR_VALID ); |
| assert( pCur->iPage<BTCURSOR_MAX_DEPTH ); |
| if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| rc = getAndInitPage(pBt, newPgno, &pNewPage); |
| if( rc ) return rc; |
| pCur->apPage[i+1] = pNewPage; |
| pCur->aiIdx[i+1] = 0; |
| pCur->iPage++; |
| |
| pCur->info.nSize = 0; |
| pCur->validNKey = 0; |
| if( pNewPage->nCell<1 || pNewPage->intKey!=pCur->apPage[i]->intKey ){ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| return SQLITE_OK; |
| } |
| |
| #ifndef NDEBUG |
| /* |
| ** Page pParent is an internal (non-leaf) tree page. This function |
| ** asserts that page number iChild is the left-child if the iIdx'th |
| ** cell in page pParent. Or, if iIdx is equal to the total number of |
| ** cells in pParent, that page number iChild is the right-child of |
| ** the page. |
| */ |
| static void assertParentIndex(MemPage *pParent, int iIdx, Pgno iChild){ |
| assert( iIdx<=pParent->nCell ); |
| if( iIdx==pParent->nCell ){ |
| assert( get4byte(&pParent->aData[pParent->hdrOffset+8])==iChild ); |
| }else{ |
| assert( get4byte(findCell(pParent, iIdx))==iChild ); |
| } |
| } |
| #else |
| # define assertParentIndex(x,y,z) |
| #endif |
| |
| /* |
| ** Move the cursor up to the parent page. |
| ** |
| ** pCur->idx is set to the cell index that contains the pointer |
| ** to the page we are coming from. If we are coming from the |
| ** right-most child page then pCur->idx is set to one more than |
| ** the largest cell index. |
| */ |
| static void moveToParent(BtCursor *pCur){ |
| assert( cursorHoldsMutex(pCur) ); |
| assert( pCur->eState==CURSOR_VALID ); |
| assert( pCur->iPage>0 ); |
| assert( pCur->apPage[pCur->iPage] ); |
| assertParentIndex( |
| pCur->apPage[pCur->iPage-1], |
| pCur->aiIdx[pCur->iPage-1], |
| pCur->apPage[pCur->iPage]->pgno |
| ); |
| releasePage(pCur->apPage[pCur->iPage]); |
| pCur->iPage--; |
| pCur->info.nSize = 0; |
| pCur->validNKey = 0; |
| } |
| |
| /* |
| ** Move the cursor to point to the root page of its b-tree structure. |
| ** |
| ** If the table has a virtual root page, then the cursor is moved to point |
| ** to the virtual root page instead of the actual root page. A table has a |
| ** virtual root page when the actual root page contains no cells and a |
| ** single child page. This can only happen with the table rooted at page 1. |
| ** |
| ** If the b-tree structure is empty, the cursor state is set to |
| ** CURSOR_INVALID. Otherwise, the cursor is set to point to the first |
| ** cell located on the root (or virtual root) page and the cursor state |
| ** is set to CURSOR_VALID. |
| ** |
| ** If this function returns successfully, it may be assumed that the |
| ** page-header flags indicate that the [virtual] root-page is the expected |
| ** kind of b-tree page (i.e. if when opening the cursor the caller did not |
| ** specify a KeyInfo structure the flags byte is set to 0x05 or 0x0D, |
| ** indicating a table b-tree, or if the caller did specify a KeyInfo |
| ** structure the flags byte is set to 0x02 or 0x0A, indicating an index |
| ** b-tree). |
| */ |
| static int moveToRoot(BtCursor *pCur){ |
| MemPage *pRoot; |
| int rc = SQLITE_OK; |
| Btree *p = pCur->pBtree; |
| BtShared *pBt = p->pBt; |
| |
| assert( cursorHoldsMutex(pCur) ); |
| assert( CURSOR_INVALID < CURSOR_REQUIRESEEK ); |
| assert( CURSOR_VALID < CURSOR_REQUIRESEEK ); |
| assert( CURSOR_FAULT > CURSOR_REQUIRESEEK ); |
| if( pCur->eState>=CURSOR_REQUIRESEEK ){ |
| if( pCur->eState==CURSOR_FAULT ){ |
| assert( pCur->skipNext!=SQLITE_OK ); |
| return pCur->skipNext; |
| } |
| sqlite3BtreeClearCursor(pCur); |
| } |
| |
| if( pCur->iPage>=0 ){ |
| int i; |
| for(i=1; i<=pCur->iPage; i++){ |
| releasePage(pCur->apPage[i]); |
| } |
| pCur->iPage = 0; |
| }else{ |
| rc = getAndInitPage(pBt, pCur->pgnoRoot, &pCur->apPage[0]); |
| if( rc!=SQLITE_OK ){ |
| pCur->eState = CURSOR_INVALID; |
| return rc; |
| } |
| pCur->iPage = 0; |
| |
| /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor |
| ** expected to open it on an index b-tree. Otherwise, if pKeyInfo is |
| ** NULL, the caller expects a table b-tree. If this is not the case, |
| ** return an SQLITE_CORRUPT error. */ |
| assert( pCur->apPage[0]->intKey==1 || pCur->apPage[0]->intKey==0 ); |
| if( (pCur->pKeyInfo==0)!=pCur->apPage[0]->intKey ){ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| } |
| |
| /* Assert that the root page is of the correct type. This must be the |
| ** case as the call to this function that loaded the root-page (either |
| ** this call or a previous invocation) would have detected corruption |
| ** if the assumption were not true, and it is not possible for the flags |
| ** byte to have been modified while this cursor is holding a reference |
| ** to the page. */ |
| pRoot = pCur->apPage[0]; |
| assert( pRoot->pgno==pCur->pgnoRoot ); |
| assert( pRoot->isInit && (pCur->pKeyInfo==0)==pRoot->intKey ); |
| |
| pCur->aiIdx[0] = 0; |
| pCur->info.nSize = 0; |
| pCur->atLast = 0; |
| pCur->validNKey = 0; |
| |
| if( pRoot->nCell==0 && !pRoot->leaf ){ |
| Pgno subpage; |
| if( pRoot->pgno!=1 ) return SQLITE_CORRUPT_BKPT; |
| subpage = get4byte(&pRoot->aData[pRoot->hdrOffset+8]); |
| pCur->eState = CURSOR_VALID; |
| rc = moveToChild(pCur, subpage); |
| }else{ |
| pCur->eState = ((pRoot->nCell>0)?CURSOR_VALID:CURSOR_INVALID); |
| } |
| return rc; |
| } |
| |
| /* |
| ** Move the cursor down to the left-most leaf entry beneath the |
| ** entry to which it is currently pointing. |
| ** |
| ** The left-most leaf is the one with the smallest key - the first |
| ** in ascending order. |
| */ |
| static int moveToLeftmost(BtCursor *pCur){ |
| Pgno pgno; |
| int rc = SQLITE_OK; |
| MemPage *pPage; |
| |
| assert( cursorHoldsMutex(pCur) ); |
| assert( pCur->eState==CURSOR_VALID ); |
| while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){ |
| assert( pCur->aiIdx[pCur->iPage]<pPage->nCell ); |
| pgno = get4byte(findCell(pPage, pCur->aiIdx[pCur->iPage])); |
| rc = moveToChild(pCur, pgno); |
| } |
| return rc; |
| } |
| |
| /* |
| ** Move the cursor down to the right-most leaf entry beneath the |
| ** page to which it is currently pointing. Notice the difference |
| ** between moveToLeftmost() and moveToRightmost(). moveToLeftmost() |
| ** finds the left-most entry beneath the *entry* whereas moveToRightmost() |
| ** finds the right-most entry beneath the *page*. |
| ** |
| ** The right-most entry is the one with the largest key - the last |
| ** key in ascending order. |
| */ |
| static int moveToRightmost(BtCursor *pCur){ |
| Pgno pgno; |
| int rc = SQLITE_OK; |
| MemPage *pPage = 0; |
| |
| assert( cursorHoldsMutex(pCur) ); |
| assert( pCur->eState==CURSOR_VALID ); |
| while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){ |
| pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]); |
| pCur->aiIdx[pCur->iPage] = pPage->nCell; |
| rc = moveToChild(pCur, pgno); |
| } |
| if( rc==SQLITE_OK ){ |
| pCur->aiIdx[pCur->iPage] = pPage->nCell-1; |
| pCur->info.nSize = 0; |
| pCur->validNKey = 0; |
| } |
| return rc; |
| } |
| |
| /* Move the cursor to the first entry in the table. Return SQLITE_OK |
| ** on success. Set *pRes to 0 if the cursor actually points to something |
| ** or set *pRes to 1 if the table is empty. |
| */ |
| int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){ |
| int rc; |
| |
| assert( cursorHoldsMutex(pCur) ); |
| assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); |
| rc = moveToRoot(pCur); |
| if( rc==SQLITE_OK ){ |
| if( pCur->eState==CURSOR_INVALID ){ |
| assert( pCur->apPage[pCur->iPage]->nCell==0 ); |
| *pRes = 1; |
| }else{ |
| assert( pCur->apPage[pCur->iPage]->nCell>0 ); |
| *pRes = 0; |
| rc = moveToLeftmost(pCur); |
| } |
| } |
| return rc; |
| } |
| |
| /* Move the cursor to the last entry in the table. Return SQLITE_OK |
| ** on success. Set *pRes to 0 if the cursor actually points to something |
| ** or set *pRes to 1 if the table is empty. |
| */ |
| int sqlite3BtreeLast(BtCursor *pCur, int *pRes){ |
| int rc; |
| |
| assert( cursorHoldsMutex(pCur) ); |
| assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); |
| |
| /* If the cursor already points to the last entry, this is a no-op. */ |
| if( CURSOR_VALID==pCur->eState && pCur->atLast ){ |
| #ifdef SQLITE_DEBUG |
| /* This block serves to assert() that the cursor really does point |
| ** to the last entry in the b-tree. */ |
| int ii; |
| for(ii=0; ii<pCur->iPage; ii++){ |
| assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell ); |
| } |
| assert( pCur->aiIdx[pCur->iPage]==pCur->apPage[pCur->iPage]->nCell-1 ); |
| assert( pCur->apPage[pCur->iPage]->leaf ); |
| #endif |
| return SQLITE_OK; |
| } |
| |
| rc = moveToRoot(pCur); |
| if( rc==SQLITE_OK ){ |
| if( CURSOR_INVALID==pCur->eState ){ |
| assert( pCur->apPage[pCur->iPage]->nCell==0 ); |
| *pRes = 1; |
| }else{ |
| assert( pCur->eState==CURSOR_VALID ); |
| *pRes = 0; |
| rc = moveToRightmost(pCur); |
| pCur->atLast = rc==SQLITE_OK ?1:0; |
| } |
| } |
| return rc; |
| } |
| |
| /* Move the cursor so that it points to an entry near the key |
| ** specified by pIdxKey or intKey. Return a success code. |
| ** |
| ** For INTKEY tables, the intKey parameter is used. pIdxKey |
| ** must be NULL. For index tables, pIdxKey is used and intKey |
| ** is ignored. |
| ** |
| ** If an exact match is not found, then the cursor is always |
| ** left pointing at a leaf page which would hold the entry if it |
| ** were present. The cursor might point to an entry that comes |
| ** before or after the key. |
| ** |
| ** An integer is written into *pRes which is the result of |
| ** comparing the key with the entry to which the cursor is |
| ** pointing. The meaning of the integer written into |
| ** *pRes is as follows: |
| ** |
| ** *pRes<0 The cursor is left pointing at an entry that |
| ** is smaller than intKey/pIdxKey or if the table is empty |
| ** and the cursor is therefore left point to nothing. |
| ** |
| ** *pRes==0 The cursor is left pointing at an entry that |
| ** exactly matches intKey/pIdxKey. |
| ** |
| ** *pRes>0 The cursor is left pointing at an entry that |
| ** is larger than intKey/pIdxKey. |
| ** |
| */ |
| int sqlite3BtreeMovetoUnpacked( |
| BtCursor *pCur, /* The cursor to be moved */ |
| UnpackedRecord *pIdxKey, /* Unpacked index key */ |
| i64 intKey, /* The table key */ |
| int biasRight, /* If true, bias the search to the high end */ |
| int *pRes /* Write search results here */ |
| ){ |
| int rc; |
| |
| assert( cursorHoldsMutex(pCur) ); |
| assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); |
| assert( pRes ); |
| assert( (pIdxKey==0)==(pCur->pKeyInfo==0) ); |
| |
| /* If the cursor is already positioned at the point we are trying |
| ** to move to, then just return without doing any work */ |
| if( pCur->eState==CURSOR_VALID && pCur->validNKey |
| && pCur->apPage[0]->intKey |
| ){ |
| if( pCur->info.nKey==intKey ){ |
| *pRes = 0; |
| return SQLITE_OK; |
| } |
| if( pCur->atLast && pCur->info.nKey<intKey ){ |
| *pRes = -1; |
| return SQLITE_OK; |
| } |
| } |
| |
| rc = moveToRoot(pCur); |
| if( rc ){ |
| return rc; |
| } |
| assert( pCur->apPage[pCur->iPage] ); |
| assert( pCur->apPage[pCur->iPage]->isInit ); |
| assert( pCur->apPage[pCur->iPage]->nCell>0 || pCur->eState==CURSOR_INVALID ); |
| if( pCur->eState==CURSOR_INVALID ){ |
| *pRes = -1; |
| assert( pCur->apPage[pCur->iPage]->nCell==0 ); |
| return SQLITE_OK; |
| } |
| assert( pCur->apPage[0]->intKey || pIdxKey ); |
| for(;;){ |
| int lwr, upr; |
| Pgno chldPg; |
| MemPage *pPage = pCur->apPage[pCur->iPage]; |
| int c; |
| |
| /* pPage->nCell must be greater than zero. If this is the root-page |
| ** the cursor would have been INVALID above and this for(;;) loop |
| ** not run. If this is not the root-page, then the moveToChild() routine |
| ** would have already detected db corruption. Similarly, pPage must |
| ** be the right kind (index or table) of b-tree page. Otherwise |
| ** a moveToChild() or moveToRoot() call would have detected corruption. */ |
| assert( pPage->nCell>0 ); |
| assert( pPage->intKey==(pIdxKey==0) ); |
| lwr = 0; |
| upr = pPage->nCell-1; |
| if( biasRight ){ |
| pCur->aiIdx[pCur->iPage] = (u16)upr; |
| }else{ |
| pCur->aiIdx[pCur->iPage] = (u16)((upr+lwr)/2); |
| } |
| for(;;){ |
| int idx = pCur->aiIdx[pCur->iPage]; /* Index of current cell in pPage */ |
| u8 *pCell; /* Pointer to current cell in pPage */ |
| |
| pCur->info.nSize = 0; |
| pCell = findCell(pPage, idx) + pPage->childPtrSize; |
| if( pPage->intKey ){ |
| i64 nCellKey; |
| if( pPage->hasData ){ |
| u32 dummy; |
| pCell += getVarint32(pCell, dummy); |
| } |
| getVarint(pCell, (u64*)&nCellKey); |
| if( nCellKey==intKey ){ |
| c = 0; |
| }else if( nCellKey<intKey ){ |
| c = -1; |
| }else{ |
| assert( nCellKey>intKey ); |
| c = +1; |
| } |
| pCur->validNKey = 1; |
| pCur->info.nKey = nCellKey; |
| }else{ |
| /* The maximum supported page-size is 65536 bytes. This means that |
| ** the maximum number of record bytes stored on an index B-Tree |
| ** page is less than 16384 bytes and may be stored as a 2-byte |
| ** varint. This information is used to attempt to avoid parsing |
| ** the entire cell by checking for the cases where the record is |
| ** stored entirely within the b-tree page by inspecting the first |
| ** 2 bytes of the cell. |
| */ |
| int nCell = pCell[0]; |
| if( !(nCell & 0x80) && nCell<=pPage->maxLocal ){ |
| /* This branch runs if the record-size field of the cell is a |
| ** single byte varint and the record fits entirely on the main |
| ** b-tree page. */ |
| c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[1], pIdxKey); |
| }else if( !(pCell[1] & 0x80) |
| && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal |
| ){ |
| /* The record-size field is a 2 byte varint and the record |
| ** fits entirely on the main b-tree page. */ |
| c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[2], pIdxKey); |
| }else{ |
| /* The record flows over onto one or more overflow pages. In |
| ** this case the whole cell needs to be parsed, a buffer allocated |
| ** and accessPayload() used to retrieve the record into the |
| ** buffer before VdbeRecordCompare() can be called. */ |
| void *pCellKey; |
| u8 * const pCellBody = pCell - pPage->childPtrSize; |
| btreeParseCellPtr(pPage, pCellBody, &pCur->info); |
| nCell = (int)pCur->info.nKey; |
| pCellKey = sqlite3Malloc( nCell ); |
| if( pCellKey==0 ){ |
| rc = SQLITE_NOMEM; |
| goto moveto_finish; |
| } |
| rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0); |
| if( rc ){ |
| sqlite3_free(pCellKey); |
| goto moveto_finish; |
| } |
| c = sqlite3VdbeRecordCompare(nCell, pCellKey, pIdxKey); |
| sqlite3_free(pCellKey); |
| } |
| } |
| if( c==0 ){ |
| if( pPage->intKey && !pPage->leaf ){ |
| lwr = idx; |
| upr = lwr - 1; |
| break; |
| }else{ |
| *pRes = 0; |
| rc = SQLITE_OK; |
| goto moveto_finish; |
| } |
| } |
| if( c<0 ){ |
| lwr = idx+1; |
| }else{ |
| upr = idx-1; |
| } |
| if( lwr>upr ){ |
| break; |
| } |
| pCur->aiIdx[pCur->iPage] = (u16)((lwr+upr)/2); |
| } |
| assert( lwr==upr+1 ); |
| assert( pPage->isInit ); |
| if( pPage->leaf ){ |
| chldPg = 0; |
| }else if( lwr>=pPage->nCell ){ |
| chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]); |
| }else{ |
| chldPg = get4byte(findCell(pPage, lwr)); |
| } |
| if( chldPg==0 ){ |
| assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell ); |
| *pRes = c; |
| rc = SQLITE_OK; |
| goto moveto_finish; |
| } |
| pCur->aiIdx[pCur->iPage] = (u16)lwr; |
| pCur->info.nSize = 0; |
| pCur->validNKey = 0; |
| rc = moveToChild(pCur, chldPg); |
| if( rc ) goto moveto_finish; |
| } |
| moveto_finish: |
| return rc; |
| } |
| |
| |
| /* |
| ** Return TRUE if the cursor is not pointing at an entry of the table. |
| ** |
| ** TRUE will be returned after a call to sqlite3BtreeNext() moves |
| ** past the last entry in the table or sqlite3BtreePrev() moves past |
| ** the first entry. TRUE is also returned if the table is empty. |
| */ |
| int sqlite3BtreeEof(BtCursor *pCur){ |
| /* TODO: What if the cursor is in CURSOR_REQUIRESEEK but all table entries |
| ** have been deleted? This API will need to change to return an error code |
| ** as well as the boolean result value. |
| */ |
| return (CURSOR_VALID!=pCur->eState); |
| } |
| |
| /* |
| ** Advance the cursor to the next entry in the database. If |
| ** successful then set *pRes=0. If the cursor |
| ** was already pointing to the last entry in the database before |
| ** this routine was called, then set *pRes=1. |
| */ |
| int sqlite3BtreeNext(BtCursor *pCur, int *pRes){ |
| int rc; |
| int idx; |
| MemPage *pPage; |
| |
| assert( cursorHoldsMutex(pCur) ); |
| rc = restoreCursorPosition(pCur); |
| if( rc!=SQLITE_OK ){ |
| return rc; |
| } |
| assert( pRes!=0 ); |
| if( CURSOR_INVALID==pCur->eState ){ |
| *pRes = 1; |
| return SQLITE_OK; |
| } |
| if( pCur->skipNext>0 ){ |
| pCur->skipNext = 0; |
| *pRes = 0; |
| return SQLITE_OK; |
| } |
| pCur->skipNext = 0; |
| |
| pPage = pCur->apPage[pCur->iPage]; |
| idx = ++pCur->aiIdx[pCur->iPage]; |
| assert( pPage->isInit ); |
| assert( idx<=pPage->nCell ); |
| |
| pCur->info.nSize = 0; |
| pCur->validNKey = 0; |
| if( idx>=pPage->nCell ){ |
| if( !pPage->leaf ){ |
| rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8])); |
| if( rc ) return rc; |
| rc = moveToLeftmost(pCur); |
| *pRes = 0; |
| return rc; |
| } |
| do{ |
| if( pCur->iPage==0 ){ |
| *pRes = 1; |
| pCur->eState = CURSOR_INVALID; |
| return SQLITE_OK; |
| } |
| moveToParent(pCur); |
| pPage = pCur->apPage[pCur->iPage]; |
| }while( pCur->aiIdx[pCur->iPage]>=pPage->nCell ); |
| *pRes = 0; |
| if( pPage->intKey ){ |
| rc = sqlite3BtreeNext(pCur, pRes); |
| }else{ |
| rc = SQLITE_OK; |
| } |
| return rc; |
| } |
| *pRes = 0; |
| if( pPage->leaf ){ |
| return SQLITE_OK; |
| } |
| rc = moveToLeftmost(pCur); |
| return rc; |
| } |
| |
| |
| /* |
| ** Step the cursor to the back to the previous entry in the database. If |
| ** successful then set *pRes=0. If the cursor |
| ** was already pointing to the first entry in the database before |
| ** this routine was called, then set *pRes=1. |
| */ |
| int sqlite3BtreePrevious(BtCursor *pCur, int *pRes){ |
| int rc; |
| MemPage *pPage; |
| |
| assert( cursorHoldsMutex(pCur) ); |
| rc = restoreCursorPosition(pCur); |
| if( rc!=SQLITE_OK ){ |
| return rc; |
| } |
| pCur->atLast = 0; |
| if( CURSOR_INVALID==pCur->eState ){ |
| *pRes = 1; |
| return SQLITE_OK; |
| } |
| if( pCur->skipNext<0 ){ |
| pCur->skipNext = 0; |
| *pRes = 0; |
| return SQLITE_OK; |
| } |
| pCur->skipNext = 0; |
| |
| pPage = pCur->apPage[pCur->iPage]; |
| assert( pPage->isInit ); |
| if( !pPage->leaf ){ |
| int idx = pCur->aiIdx[pCur->iPage]; |
| rc = moveToChild(pCur, get4byte(findCell(pPage, idx))); |
| if( rc ){ |
| return rc; |
| } |
| rc = moveToRightmost(pCur); |
| }else{ |
| while( pCur->aiIdx[pCur->iPage]==0 ){ |
| if( pCur->iPage==0 ){ |
| pCur->eState = CURSOR_INVALID; |
| *pRes = 1; |
| return SQLITE_OK; |
| } |
| moveToParent(pCur); |
| } |
| pCur->info.nSize = 0; |
| pCur->validNKey = 0; |
| |
| pCur->aiIdx[pCur->iPage]--; |
| pPage = pCur->apPage[pCur->iPage]; |
| if( pPage->intKey && !pPage->leaf ){ |
| rc = sqlite3BtreePrevious(pCur, pRes); |
| }else{ |
| rc = SQLITE_OK; |
| } |
| } |
| *pRes = 0; |
| return rc; |
| } |
| |
| /* |
| ** Allocate a new page from the database file. |
| ** |
| ** The new page is marked as dirty. (In other words, sqlite3PagerWrite() |
| ** has already been called on the new page.) The new page has also |
| ** been referenced and the calling routine is responsible for calling |
| ** sqlite3PagerUnref() on the new page when it is done. |
| ** |
| ** SQLITE_OK is returned on success. Any other return value indicates |
| ** an error. *ppPage and *pPgno are undefined in the event of an error. |
| ** Do not invoke sqlite3PagerUnref() on *ppPage if an error is returned. |
| ** |
| ** If the "nearby" parameter is not 0, then a (feeble) effort is made to |
| ** locate a page close to the page number "nearby". This can be used in an |
| ** attempt to keep related pages close to each other in the database file, |
| ** which in turn can make database access faster. |
| ** |
| ** If the "exact" parameter is not 0, and the page-number nearby exists |
| ** anywhere on the free-list, then it is guarenteed to be returned. This |
| ** is only used by auto-vacuum databases when allocating a new table. |
| */ |
| static int allocateBtreePage( |
| BtShared *pBt, |
| MemPage **ppPage, |
| Pgno *pPgno, |
| Pgno nearby, |
| u8 exact |
| ){ |
| MemPage *pPage1; |
| int rc; |
| u32 n; /* Number of pages on the freelist */ |
| u32 k; /* Number of leaves on the trunk of the freelist */ |
| MemPage *pTrunk = 0; |
| MemPage *pPrevTrunk = 0; |
| Pgno mxPage; /* Total size of the database file */ |
| |
| assert( sqlite3_mutex_held(pBt->mutex) ); |
| pPage1 = pBt->pPage1; |
| mxPage = btreePagecount(pBt); |
| n = get4byte(&pPage1->aData[36]); |
| testcase( n==mxPage-1 ); |
| if( n>=mxPage ){ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| if( n>0 ){ |
| /* There are pages on the freelist. Reuse one of those pages. */ |
| Pgno iTrunk; |
| u8 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. |
| */ |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| if( exact && nearby<=mxPage ){ |
| u8 eType; |
| assert( nearby>0 ); |
| assert( pBt->autoVacuum ); |
| rc = ptrmapGet(pBt, nearby, &eType, 0); |
| if( rc ) 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 = sqlite3PagerWrite(pPage1->pDbPage); |
| if( rc ) return rc; |
| put4byte(&pPage1->aData[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; |
| if( pPrevTrunk ){ |
| iTrunk = get4byte(&pPrevTrunk->aData[0]); |
| }else{ |
| iTrunk = get4byte(&pPage1->aData[32]); |
| } |
| testcase( iTrunk==mxPage ); |
| if( iTrunk>mxPage ){ |
| rc = SQLITE_CORRUPT_BKPT; |
| }else{ |
| rc = btreeGetPage(pBt, iTrunk, &pTrunk, 0); |
| } |
| if( rc ){ |
| pTrunk = 0; |
| goto end_allocate_page; |
| } |
| |
| k = get4byte(&pTrunk->aData[4]); /* # of leaves on this trunk page */ |
| if( k==0 && !searchList ){ |
| /* 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 */ |
| assert( pPrevTrunk==0 ); |
| rc = sqlite3PagerWrite(pTrunk->pDbPage); |
| if( rc ){ |
| goto end_allocate_page; |
| } |
| *pPgno = iTrunk; |
| memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4); |
| *ppPage = pTrunk; |
| pTrunk = 0; |
| TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1)); |
| }else if( k>(u32)(pBt->usableSize/4 - 2) ){ |
| /* Value of k is out of range. Database corruption */ |
| rc = SQLITE_CORRUPT_BKPT; |
| goto end_allocate_page; |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| }else if( searchList && nearby==iTrunk ){ |
| /* The list is being searched and this trunk page is the page |
| ** to allocate, regardless of whether it has leaves. |
| */ |
| assert( *pPgno==iTrunk ); |
| *ppPage = pTrunk; |
| searchList = 0; |
| rc = sqlite3PagerWrite(pTrunk->pDbPage); |
| if( rc ){ |
| goto end_allocate_page; |
| } |
| if( k==0 ){ |
| if( !pPrevTrunk ){ |
| memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4); |
| }else{ |
| rc = sqlite3PagerWrite(pPrevTrunk->pDbPage); |
| if( rc!=SQLITE_OK ){ |
| goto end_allocate_page; |
| } |
| memcpy(&pPrevTrunk->aData[0], &pTrunk->aData[0], 4); |
| } |
| }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. |
| */ |
| MemPage *pNewTrunk; |
| Pgno iNewTrunk = get4byte(&pTrunk->aData[8]); |
| if( iNewTrunk>mxPage ){ |
| rc = SQLITE_CORRUPT_BKPT; |
| goto end_allocate_page; |
| } |
| testcase( iNewTrunk==mxPage ); |
| rc = btreeGetPage(pBt, iNewTrunk, &pNewTrunk, 0); |
| if( rc!=SQLITE_OK ){ |
| goto end_allocate_page; |
| } |
| rc = sqlite3PagerWrite(pNewTrunk->pDbPage); |
| if( rc!=SQLITE_OK ){ |
| releasePage(pNewTrunk); |
| goto end_allocate_page; |
| } |
| memcpy(&pNewTrunk->aData[0], &pTrunk->aData[0], 4); |
| put4byte(&pNewTrunk->aData[4], k-1); |
| memcpy(&pNewTrunk->aData[8], &pTrunk->aData[12], (k-1)*4); |
| releasePage(pNewTrunk); |
| if( !pPrevTrunk ){ |
| assert( sqlite3PagerIswriteable(pPage1->pDbPage) ); |
| put4byte(&pPage1->aData[32], iNewTrunk); |
| }else{ |
| rc = sqlite3PagerWrite(pPrevTrunk->pDbPage); |
| if( rc ){ |
| goto end_allocate_page; |
| } |
| put4byte(&pPrevTrunk->aData[0], iNewTrunk); |
| } |
| } |
| pTrunk = 0; |
| TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1)); |
| #endif |
| }else if( k>0 ){ |
| /* Extract a leaf from the trunk */ |
| u32 closest; |
| Pgno iPage; |
| unsigned char *aData = pTrunk->aData; |
| if( nearby>0 ){ |
| u32 i; |
| int dist; |
| closest = 0; |
| dist = sqlite3AbsInt32(get4byte(&aData[8]) - nearby); |
| for(i=1; i<k; i++){ |
| int d2 = sqlite3AbsInt32(get4byte(&aData[8+i*4]) - nearby); |
| if( d2<dist ){ |
| closest = i; |
| dist = d2; |
| } |
| } |
| }else{ |
| closest = 0; |
| } |
| |
| iPage = get4byte(&aData[8+closest*4]); |
| testcase( iPage==mxPage ); |
| if( iPage>mxPage ){ |
| rc = SQLITE_CORRUPT_BKPT; |
| goto end_allocate_page; |
| } |
| testcase( iPage==mxPage ); |
| if( !searchList || iPage==nearby ){ |
| int noContent; |
| *pPgno = iPage; |
| TRACE(("ALLOCATE: %d was leaf %d of %d on trunk %d" |
| ": %d more free pages\n", |
| *pPgno, closest+1, k, pTrunk->pgno, n-1)); |
| rc = sqlite3PagerWrite(pTrunk->pDbPage); |
| if( rc ) goto end_allocate_page; |
| if( closest<k-1 ){ |
| memcpy(&aData[8+closest*4], &aData[4+k*4], 4); |
| } |
| put4byte(&aData[4], k-1); |
| noContent = !btreeGetHasContent(pBt, *pPgno); |
| rc = btreeGetPage(pBt, *pPgno, ppPage, noContent); |
| if( rc==SQLITE_OK ){ |
| rc = sqlite3PagerWrite((*ppPage)->pDbPage); |
| if( rc!=SQLITE_OK ){ |
| releasePage(*ppPage); |
| } |
| } |
| searchList = 0; |
| } |
| } |
| releasePage(pPrevTrunk); |
| pPrevTrunk = 0; |
| }while( searchList ); |
| }else{ |
| /* There are no pages on the freelist, so create a new page at the |
| ** end of the file */ |
| rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); |
| if( rc ) return rc; |
| pBt->nPage++; |
| if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ) pBt->nPage++; |
| |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| if( pBt->autoVacuum && PTRMAP_ISPAGE(pBt, pBt->nPage) ){ |
| /* 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 = 0; |
| TRACE(("ALLOCATE: %d from end of file (pointer-map page)\n", pBt->nPage)); |
| assert( pBt->nPage!=PENDING_BYTE_PAGE(pBt) ); |
| rc = btreeGetPage(pBt, pBt->nPage, &pPg, 1); |
| if( rc==SQLITE_OK ){ |
| rc = sqlite3PagerWrite(pPg->pDbPage); |
| releasePage(pPg); |
| } |
| if( rc ) return rc; |
| pBt->nPage++; |
| if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ){ pBt->nPage++; } |
| } |
| #endif |
| put4byte(28 + (u8*)pBt->pPage1->aData, pBt->nPage); |
| *pPgno = pBt->nPage; |
| |
| assert( *pPgno!=PENDING_BYTE_PAGE(pBt) ); |
| rc = btreeGetPage(pBt, *pPgno, ppPage, 1); |
| if( rc ) return rc; |
| rc = sqlite3PagerWrite((*ppPage)->pDbPage); |
| if( rc!=SQLITE_OK ){ |
| releasePage(*ppPage); |
| } |
| TRACE(("ALLOCATE: %d from end of file\n", *pPgno)); |
| } |
| |
| assert( *pPgno!=PENDING_BYTE_PAGE(pBt) ); |
| |
| end_allocate_page: |
| releasePage(pTrunk); |
| releasePage(pPrevTrunk); |
| if( rc==SQLITE_OK ){ |
| if( sqlite3PagerPageRefcount((*ppPage)->pDbPage)>1 ){ |
| releasePage(*ppPage); |
| return SQLITE_CORRUPT_BKPT; |
| } |
| (*ppPage)->isInit = 0; |
| }else{ |
| *ppPage = 0; |
| } |
| assert( rc!=SQLITE_OK || sqlite3PagerIswriteable((*ppPage)->pDbPage) ); |
| return rc; |
| } |
| |
| /* |
| ** This function is used to add page iPage to the database file free-list. |
| ** It is assumed that the page is not already a part of the free-list. |
| ** |
| ** The value passed as the second argument to this function is optional. |
| ** If the caller happens to have a pointer to the MemPage object |
| ** corresponding to page iPage handy, it may pass it as the second value. |
| ** Otherwise, it may pass NULL. |
| ** |
| ** If a pointer to a MemPage object is passed as the second argument, |
| ** its reference count is not altered by this function. |
| */ |
| static int freePage2(BtShared *pBt, MemPage *pMemPage, Pgno iPage){ |
| MemPage *pTrunk = 0; /* Free-list trunk page */ |
| Pgno iTrunk = 0; /* Page number of free-list trunk page */ |
| MemPage *pPage1 = pBt->pPage1; /* Local reference to page 1 */ |
| MemPage *pPage; /* Page being freed. May be NULL. */ |
| int rc; /* Return Code */ |
| int nFree; /* Initial number of pages on free-list */ |
| |
| assert( sqlite3_mutex_held(pBt->mutex) ); |
| assert( iPage>1 ); |
| assert( !pMemPage || pMemPage->pgno==iPage ); |
| |
| if( pMemPage ){ |
| pPage = pMemPage; |
| sqlite3PagerRef(pPage->pDbPage); |
| }else{ |
| pPage = btreePageLookup(pBt, iPage); |
| } |
| |
| /* Increment the free page count on pPage1 */ |
| rc = sqlite3PagerWrite(pPage1->pDbPage); |
| if( rc ) goto freepage_out; |
| nFree = get4byte(&pPage1->aData[36]); |
| put4byte(&pPage1->aData[36], nFree+1); |
| |
| if( pBt->secureDelete ){ |
| /* If the secure_delete option is enabled, then |
| ** always fully overwrite deleted information with zeros. |
| */ |
| if( (!pPage && ((rc = btreeGetPage(pBt, iPage, &pPage, 0))!=0) ) |
| || ((rc = sqlite3PagerWrite(pPage->pDbPage))!=0) |
| ){ |
| goto freepage_out; |
| } |
| memset(pPage->aData, 0, pPage->pBt->pageSize); |
| } |
| |
| /* If the database supports auto-vacuum, write an entry in the pointer-map |
| ** to indicate that the page is free. |
| */ |
| if( ISAUTOVACUUM ){ |
| ptrmapPut(pBt, iPage, PTRMAP_FREEPAGE, 0, &rc); |
| if( rc ) 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. |
| */ |
| if( nFree!=0 ){ |
| u32 nLeaf; /* Initial number of leaf cells on trunk page */ |
| |
| iTrunk = get4byte(&pPage1->aData[32]); |
| rc = btreeGetPage(pBt, iTrunk, &pTrunk, 0); |
| if( rc!=SQLITE_OK ){ |
| goto freepage_out; |
| } |
| |
| nLeaf = get4byte(&pTrunk->aData[4]); |
| assert( pBt->usableSize>32 ); |
| if( nLeaf > (u32)pBt->usableSize/4 - 2 ){ |
| rc = SQLITE_CORRUPT_BKPT; |
| goto freepage_out; |
| } |
| if( nLeaf < (u32)pBt->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 = sqlite3PagerWrite(pTrunk->pDbPage); |
| if( rc==SQLITE_OK ){ |
| put4byte(&pTrunk->aData[4], nLeaf+1); |
| put4byte(&pTrunk->aData[8+nLeaf*4], iPage); |
| if( pPage && !pBt->secureDelete ){ |
| sqlite3PagerDontWrite(pPage->pDbPage); |
| } |
| rc = btreeSetHasContent(pBt, iPage); |
| } |
| TRACE(("FREE-PAGE: %d leaf on trunk page %d\n",pPage->pgno,pTrunk->pgno)); |
| 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==0 && SQLITE_OK!=(rc = btreeGetPage(pBt, iPage, &pPage, 0)) ){ |
| goto freepage_out; |
| } |
| rc = sqlite3PagerWrite(pPage->pDbPage); |
| if( rc!=SQLITE_OK ){ |
| goto freepage_out; |
| } |
| put4byte(pPage->aData, iTrunk); |
| put4byte(&pPage->aData[4], 0); |
| put4byte(&pPage1->aData[32], iPage); |
| TRACE(("FREE-PAGE: %d new trunk page replacing %d\n", pPage->pgno, iTrunk)); |
| |
| freepage_out: |
| if( pPage ){ |
| pPage->isInit = 0; |
| } |
| releasePage(pPage); |
| releasePage(pTrunk); |
| return rc; |
| } |
| static void freePage(MemPage *pPage, int *pRC){ |
| if( (*pRC)==SQLITE_OK ){ |
| *pRC = freePage2(pPage->pBt, pPage, pPage->pgno); |
| } |
| } |
| |
| /* |
| ** Free any overflow pages associated with the given Cell. |
| */ |
| static int clearCell(MemPage *pPage, unsigned char *pCell){ |
| BtShared *pBt = pPage->pBt; |
| CellInfo info; |
| Pgno ovflPgno; |
| int rc; |
| int nOvfl; |
| u32 ovflPageSize; |
| |
| assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
| btreeParseCellPtr(pPage, pCell, &info); |
| if( info.iOverflow==0 ){ |
| return SQLITE_OK; /* No overflow pages. Return without doing anything */ |
| } |
| ovflPgno = get4byte(&pCell[info.iOverflow]); |
| assert( pBt->usableSize > 4 ); |
| ovflPageSize = pBt->usableSize - 4; |
| nOvfl = (info.nPayload - info.nLocal + ovflPageSize - 1)/ovflPageSize; |
| assert( ovflPgno==0 || nOvfl>0 ); |
| while( nOvfl-- ){ |
| Pgno iNext = 0; |
| MemPage *pOvfl = 0; |
| if( ovflPgno<2 || ovflPgno>btreePagecount(pBt) ){ |
| /* 0 is not a legal page number and page 1 cannot be an |
| ** overflow page. Therefore if ovflPgno<2 or past the end of the |
| ** file the database must be corrupt. */ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| if( nOvfl ){ |
| rc = getOverflowPage(pBt, ovflPgno, &pOvfl, &iNext); |
| if( rc ) return rc; |
| } |
| |
| if( ( pOvfl || ((pOvfl = btreePageLookup(pBt, ovflPgno))!=0) ) |
| && sqlite3PagerPageRefcount(pOvfl->pDbPage)!=1 |
| ){ |
| /* There is no reason any cursor should have an outstanding reference |
| ** to an overflow page belonging to a cell that is being deleted/updated. |
| ** So if there exists more than one reference to this page, then it |
| ** must not really be an overflow page and the database must be corrupt. |
| ** It is helpful to detect this before calling freePage2(), as |
| ** freePage2() may zero the page contents if secure-delete mode is |
| ** enabled. If this 'overflow' page happens to be a page that the |
| ** caller is iterating through or using in some other way, this |
| ** can be problematic. |
| */ |
| rc = SQLITE_CORRUPT_BKPT; |
| }else{ |
| rc = freePage2(pBt, pOvfl, ovflPgno); |
| } |
| |
| if( pOvfl ){ |
| sqlite3PagerUnref(pOvfl->pDbPage); |
| } |
| if( rc ) return rc; |
| ovflPgno = iNext; |
| } |
| return SQLITE_OK; |
| } |
| |
| /* |
| ** Create the byte sequence used to represent a cell on page pPage |
| ** and write that byte sequence into pCell[]. Overflow pages are |
| ** allocated and filled in as necessary. The calling procedure |
| ** is responsible for making sure sufficient space has been allocated |
| ** for pCell[]. |
| ** |
| ** Note that pCell does not necessary need to point to the pPage->aData |
| ** area. pCell might point to some temporary storage. The cell will |
| ** be constructed in this temporary area then copied into pPage->aData |
| ** later. |
| */ |
| static int fillInCell( |
| MemPage *pPage, /* The page that contains the cell */ |
| unsigned char *pCell, /* Complete text of the cell */ |
| const void *pKey, i64 nKey, /* The key */ |
| const void *pData,int nData, /* The data */ |
| int nZero, /* Extra zero bytes to append to pData */ |
| int *pnSize /* Write cell size here */ |
| ){ |
| int nPayload; |
| const u8 *pSrc; |
| int nSrc, n, rc; |
| int spaceLeft; |
| MemPage *pOvfl = 0; |
| MemPage *pToRelease = 0; |
| unsigned char *pPrior; |
| unsigned char *pPayload; |
| BtShared *pBt = pPage->pBt; |
| Pgno pgnoOvfl = 0; |
| int nHeader; |
| CellInfo info; |
| |
| assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
| |
| /* pPage is not necessarily writeable since pCell might be auxiliary |
| ** buffer space that is separate from the pPage buffer area */ |
| assert( pCell<pPage->aData || pCell>=&pPage->aData[pBt->pageSize] |
| || sqlite3PagerIswriteable(pPage->pDbPage) ); |
| |
| /* Fill in the header. */ |
| nHeader = 0; |
| if( !pPage->leaf ){ |
| nHeader += 4; |
| } |
| if( pPage->hasData ){ |
| nHeader += putVarint(&pCell[nHeader], nData+nZero); |
| }else{ |
| nData = nZero = 0; |
| } |
| nHeader += putVarint(&pCell[nHeader], *(u64*)&nKey); |
| btreeParseCellPtr(pPage, pCell, &info); |
| assert( info.nHeader==nHeader ); |
| assert( info.nKey==nKey ); |
| assert( info.nData==(u32)(nData+nZero) ); |
| |
| /* Fill in the payload */ |
| nPayload = nData + nZero; |
| if( pPage->intKey ){ |
| pSrc = pData; |
| nSrc = nData; |
| nData = 0; |
| }else{ |
| if( NEVER(nKey>0x7fffffff || pKey==0) ){ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| nPayload += (int)nKey; |
| pSrc = pKey; |
| nSrc = (int)nKey; |
| } |
| *pnSize = info.nSize; |
| spaceLeft = info.nLocal; |
| pPayload = &pCell[nHeader]; |
| pPrior = &pCell[info.iOverflow]; |
| |
| while( nPayload>0 ){ |
| if( spaceLeft==0 ){ |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| Pgno pgnoPtrmap = pgnoOvfl; /* Overflow page pointer-map entry page */ |
| if( pBt->autoVacuum ){ |
| do{ |
| pgnoOvfl++; |
| } while( |
| PTRMAP_ISPAGE(pBt, pgnoOvfl) || pgnoOvfl==PENDING_BYTE_PAGE(pBt) |
| ); |
| } |
| #endif |
| rc = allocateBtreePage(pBt, &pOvfl, &pgnoOvfl, pgnoOvfl, 0); |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| /* If the database supports auto-vacuum, and the second or subsequent |
| ** overflow page is being allocated, add an entry to the pointer-map |
| ** for that page now. |
| ** |
| ** If this is the first overflow page, then write a partial entry |
| ** to the pointer-map. If we write nothing to this pointer-map slot, |
| ** then the optimistic overflow chain processing in clearCell() |
| ** may misinterpret the uninitialised values and delete the |
| ** wrong pages from the database. |
| */ |
| if( pBt->autoVacuum && rc==SQLITE_OK ){ |
| u8 eType = (pgnoPtrmap?PTRMAP_OVERFLOW2:PTRMAP_OVERFLOW1); |
| ptrmapPut(pBt, pgnoOvfl, eType, pgnoPtrmap, &rc); |
| if( rc ){ |
| releasePage(pOvfl); |
| } |
| } |
| #endif |
| if( rc ){ |
| releasePage(pToRelease); |
| return rc; |
| } |
| |
| /* If pToRelease is not zero than pPrior points into the data area |
| ** of pToRelease. Make sure pToRelease is still writeable. */ |
| assert( pToRelease==0 || sqlite3PagerIswriteable(pToRelease->pDbPage) ); |
| |
| /* If pPrior is part of the data area of pPage, then make sure pPage |
| ** is still writeable */ |
| assert( pPrior<pPage->aData || pPrior>=&pPage->aData[pBt->pageSize] |
| || sqlite3PagerIswriteable(pPage->pDbPage) ); |
| |
| put4byte(pPrior, pgnoOvfl); |
| releasePage(pToRelease); |
| pToRelease = pOvfl; |
| pPrior = pOvfl->aData; |
| put4byte(pPrior, 0); |
| pPayload = &pOvfl->aData[4]; |
| spaceLeft = pBt->usableSize - 4; |
| } |
| n = nPayload; |
| if( n>spaceLeft ) n = spaceLeft; |
| |
| /* If pToRelease is not zero than pPayload points into the data area |
| ** of pToRelease. Make sure pToRelease is still writeable. */ |
| assert( pToRelease==0 || sqlite3PagerIswriteable(pToRelease->pDbPage) ); |
| |
| /* If pPayload is part of the data area of pPage, then make sure pPage |
| ** is still writeable */ |
| assert( pPayload<pPage->aData || pPayload>=&pPage->aData[pBt->pageSize] |
| || sqlite3PagerIswriteable(pPage->pDbPage) ); |
| |
| if( nSrc>0 ){ |
| if( n>nSrc ) n = nSrc; |
| assert( pSrc ); |
| memcpy(pPayload, pSrc, n); |
| }else{ |
| memset(pPayload, 0, n); |
| } |
| nPayload -= n; |
| pPayload += n; |
| pSrc += n; |
| nSrc -= n; |
| spaceLeft -= n; |
| if( nSrc==0 ){ |
| nSrc = nData; |
| pSrc = pData; |
| } |
| } |
| releasePage(pToRelease); |
| return SQLITE_OK; |
| } |
| |
| /* |
| ** Remove the i-th cell from pPage. This routine effects pPage only. |
| ** The cell content is not freed or deallocated. It is assumed that |
| ** the cell content has been copied someplace else. This routine just |
| ** removes the reference to the cell from pPage. |
| ** |
| ** "sz" must be the number of bytes in the cell. |
| */ |
| static void dropCell(MemPage *pPage, int idx, int sz, int *pRC){ |
| int i; /* Loop counter */ |
| u32 pc; /* Offset to cell content of cell being deleted */ |
| u8 *data; /* pPage->aData */ |
| u8 *ptr; /* Used to move bytes around within data[] */ |
| int rc; /* The return code */ |
| int hdr; /* Beginning of the header. 0 most pages. 100 page 1 */ |
| |
| if( *pRC ) return; |
| |
| assert( idx>=0 && idx<pPage->nCell ); |
| assert( sz==cellSize(pPage, idx) ); |
| assert( sqlite3PagerIswriteable(pPage->pDbPage) ); |
| assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
| data = pPage->aData; |
| ptr = &data[pPage->cellOffset + 2*idx]; |
| pc = get2byte(ptr); |
| hdr = pPage->hdrOffset; |
| testcase( pc==get2byte(&data[hdr+5]) ); |
| testcase( pc+sz==pPage->pBt->usableSize ); |
| if( pc < (u32)get2byte(&data[hdr+5]) || pc+sz > pPage->pBt->usableSize ){ |
| *pRC = SQLITE_CORRUPT_BKPT; |
| return; |
| } |
| rc = freeSpace(pPage, pc, sz); |
| if( rc ){ |
| *pRC = rc; |
| return; |
| } |
| for(i=idx+1; i<pPage->nCell; i++, ptr+=2){ |
| ptr[0] = ptr[2]; |
| ptr[1] = ptr[3]; |
| } |
| pPage->nCell--; |
| put2byte(&data[hdr+3], pPage->nCell); |
| pPage->nFree += 2; |
| } |
| |
| /* |
| ** Insert a new cell on pPage at cell index "i". pCell points to the |
| ** content of the cell. |
| ** |
| ** If the cell content will fit on the page, then put it there. If it |
| ** will not fit, then make a copy of the cell content into pTemp if |
| ** pTemp is not null. Regardless of pTemp, allocate a new entry |
| ** in pPage->aOvfl[] and make it point to the cell content (either |
| ** in pTemp or the original pCell) and also record its index. |
| ** Allocating a new entry in pPage->aCell[] implies that |
| ** pPage->nOverflow is incremented. |
| ** |
| ** If nSkip is non-zero, then do not copy the first nSkip bytes of the |
| ** cell. The caller will overwrite them after this function returns. If |
| ** nSkip is non-zero, then pCell may not point to an invalid memory location |
| ** (but pCell+nSkip is always valid). |
| */ |
| static void insertCell( |
| MemPage *pPage, /* Page into which we are copying */ |
| int i, /* New cell becomes the i-th cell of the page */ |
| u8 *pCell, /* Content of the new cell */ |
| int sz, /* Bytes of content in pCell */ |
| u8 *pTemp, /* Temp storage space for pCell, if needed */ |
| Pgno iChild, /* If non-zero, replace first 4 bytes with this value */ |
| int *pRC /* Read and write return code from here */ |
| ){ |
| int idx = 0; /* Where to write new cell content in data[] */ |
| int j; /* Loop counter */ |
| int end; /* First byte past the last cell pointer in data[] */ |
| int ins; /* Index in data[] where new cell pointer is inserted */ |
| int cellOffset; /* Address of first cell pointer in data[] */ |
| u8 *data; /* The content of the whole page */ |
| u8 *ptr; /* Used for moving information around in data[] */ |
| |
| int nSkip = (iChild ? 4 : 0); |
| |
| if( *pRC ) return; |
| |
| assert( i>=0 && i<=pPage->nCell+pPage->nOverflow ); |
| assert( pPage->nCell<=MX_CELL(pPage->pBt) && MX_CELL(pPage->pBt)<=10921 ); |
| assert( pPage->nOverflow<=ArraySize(pPage->aOvfl) ); |
| assert( sqlite3_mutex_held(pPage->pBt->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(). */ |
| assert( sz==cellSizePtr(pPage, pCell) || (sz==8 && iChild>0) ); |
| if( pPage->nOverflow || sz+2>pPage->nFree ){ |
| if( pTemp ){ |
| memcpy(pTemp+nSkip, pCell+nSkip, sz-nSkip); |
| pCell = pTemp; |
| } |
| if( iChild ){ |
| put4byte(pCell, iChild); |
| } |
| j = pPage->nOverflow++; |
| assert( j<(int)(sizeof(pPage->aOvfl)/sizeof(pPage->aOvfl[0])) ); |
| pPage->aOvfl[j].pCell = pCell; |
| pPage->aOvfl[j].idx = (u16)i; |
| }else{ |
| int rc = sqlite3PagerWrite(pPage->pDbPage); |
| if( rc!=SQLITE_OK ){ |
| *pRC = rc; |
| return; |
| } |
| assert( sqlite3PagerIswriteable(pPage->pDbPage) ); |
| data = pPage->aData; |
| cellOffset = pPage->cellOffset; |
| end = cellOffset + 2*pPage->nCell; |
| ins = cellOffset + 2*i; |
| rc = allocateSpace(pPage, sz, &idx); |
| if( rc ){ *pRC = rc; return; } |
| /* The allocateSpace() routine guarantees the following two properties |
| ** if it returns success */ |
| assert( idx >= end+2 ); |
| assert( idx+sz <= (int)pPage->pBt->usableSize ); |
| pPage->nCell++; |
| pPage->nFree -= (u16)(2 + sz); |
| memcpy(&data[idx+nSkip], pCell+nSkip, sz-nSkip); |
| if( iChild ){ |
| put4byte(&data[idx], iChild); |
| } |
| for(j=end, ptr=&data[j]; j>ins; j-=2, ptr-=2){ |
| ptr[0] = ptr[-2]; |
| ptr[1] = ptr[-1]; |
| } |
| put2byte(&data[ins], idx); |
| put2byte(&data[pPage->hdrOffset+3], pPage->nCell); |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| if( pPage->pBt->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(pPage, pCell, pRC); |
| } |
| #endif |
| } |
| } |
| |
| /* |
| ** Add a list of cells to a page. The page should be initially empty. |
| ** The cells are guaranteed to fit on the page. |
| */ |
| static void assemblePage( |
| MemPage *pPage, /* The page to be assemblied */ |
| int nCell, /* The number of cells to add to this page */ |
| u8 **apCell, /* Pointers to cell bodies */ |
| u16 *aSize /* Sizes of the cells */ |
| ){ |
| int i; /* Loop counter */ |
| u8 *pCellptr; /* Address of next cell pointer */ |
| int cellbody; /* Address of next cell body */ |
| u8 * const data = pPage->aData; /* Pointer to data for pPage */ |
| const int hdr = pPage->hdrOffset; /* Offset of header on pPage */ |
| const int nUsable = pPage->pBt->usableSize; /* Usable size of page */ |
| |
| assert( pPage->nOverflow==0 ); |
| assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
| assert( nCell>=0 && nCell<=(int)MX_CELL(pPage->pBt) |
| && (int)MX_CELL(pPage->pBt)<=10921); |
| assert( sqlite3PagerIswriteable(pPage->pDbPage) ); |
| |
| /* Check that the page has just been zeroed by zeroPage() */ |
| assert( pPage->nCell==0 ); |
| assert( get2byteNotZero(&data[hdr+5])==nUsable ); |
| |
| pCellptr = &data[pPage->cellOffset + nCell*2]; |
| cellbody = nUsable; |
| for(i=nCell-1; i>=0; i--){ |
| pCellptr -= 2; |
| cellbody -= aSize[i]; |
| put2byte(pCellptr, cellbody); |
| memcpy(&data[cellbody], apCell[i], aSize[i]); |
| } |
| put2byte(&data[hdr+3], nCell); |
| put2byte(&data[hdr+5], cellbody); |
| pPage->nFree -= (nCell*2 + nUsable - cellbody); |
| pPage->nCell = (u16)nCell; |
| } |
| |
| /* |
| ** The following parameters determine how many adjacent pages get involved |
| ** in a balancing operation. NN is the number of neighbors on either side |
| ** of the page that participate in the balancing operation. NB is the |
| ** total number of pages that participate, including the target page and |
| ** NN neighbors on either side. |
| ** |
| ** The minimum value of NN is 1 (of course). Increasing NN above 1 |
| ** (to 2 or 3) gives a modest improvement in SELECT and DELETE performance |
| ** in exchange for a larger degradation in INSERT and UPDATE performance. |
| ** The value of NN appears to give the best results overall. |
| */ |
| #define NN 1 /* Number of neighbors on either side of pPage */ |
| #define NB (NN*2+1) /* Total pages involved in the balance */ |
| |
| |
| #ifndef SQLITE_OMIT_QUICKBALANCE |
| /* |
| ** This version of balance() handles the common special case where |
| ** a new entry is being inserted on the extreme right-end of the |
| ** tree, in other words, when the new entry will become the largest |
| ** entry in the tree. |
| ** |
| ** Instead of trying to balance the 3 right-most leaf pages, just add |
| ** a new page to the right-hand side and put the one new entry in |
| ** that page. This leaves the right side of the tree somewhat |
| ** unbalanced. But odds are that we will be inserting new entries |
| ** at the end soon afterwards so the nearly empty page will quickly |
| ** fill up. On average. |
| ** |
| ** pPage is the leaf page which is the right-most page in the tree. |
| ** pParent is its parent. pPage must have a single overflow entry |
| ** which is also the right-most entry on the page. |
| ** |
| ** The pSpace buffer is used to store a temporary copy of the divider |
| ** cell that will be inserted into pParent. Such a cell consists of a 4 |
| ** byte page number followed by a variable length integer. In other |
| ** words, at most 13 bytes. Hence the pSpace buffer must be at |
| ** least 13 bytes in size. |
| */ |
| static int balance_quick(MemPage *pParent, MemPage *pPage, u8 *pSpace){ |
| BtShared *const pBt = pPage->pBt; /* B-Tree Database */ |
| MemPage *pNew; /* Newly allocated page */ |
| int rc; /* Return Code */ |
| Pgno pgnoNew; /* Page number of pNew */ |
| |
| assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
| assert( sqlite3PagerIswriteable(pParent->pDbPage) ); |
| assert( pPage->nOverflow==1 ); |
| |
| /* This error condition is now caught prior to reaching this function */ |
| if( pPage->nCell<=0 ) return SQLITE_CORRUPT_BKPT; |
| |
| /* Allocate a new page. This page will become the right-sibling of |
| ** pPage. Make the parent page writable, so that the new divider cell |
| ** may be inserted. If both these operations are successful, proceed. |
| */ |
| rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0); |
| |
| if( rc==SQLITE_OK ){ |
| |
| u8 *pOut = &pSpace[4]; |
| u8 *pCell = pPage->aOvfl[0].pCell; |
| u16 szCell = cellSizePtr(pPage, pCell); |
| u8 *pStop; |
| |
| assert( sqlite3PagerIswriteable(pNew->pDbPage) ); |
| assert( pPage->aData[0]==(PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF) ); |
| zeroPage(pNew, PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF); |
| assemblePage(pNew, 1, &pCell, &szCell); |
| |
| /* If this is an auto-vacuum database, update the pointer map |
| ** with entries for the new page, and any pointer from the |
| ** cell on the page to an overflow page. If either of these |
| ** operations fails, the return code is set, but the contents |
| ** of the parent page are still manipulated by thh code below. |
| ** That is Ok, at this point the parent page is guaranteed to |
| ** be marked as dirty. Returning an error code will cause a |
| ** rollback, undoing any changes made to the parent page. |
| */ |
| if( ISAUTOVACUUM ){ |
| ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno, &rc); |
| if( szCell>pNew->minLocal ){ |
| ptrmapPutOvflPtr(pNew, pCell, &rc); |
| } |
| } |
| |
| /* Create a divider cell to insert into pParent. The divider cell |
| ** consists of a 4-byte page number (the page number of pPage) and |
| ** a variable length key value (which must be the same value as the |
| ** largest key on pPage). |
| ** |
| ** To find the largest key value on pPage, first find the right-most |
| ** cell on pPage. The first two fields of this cell are the |
| ** record-length (a variable length integer at most 32-bits in size) |
| ** and the key value (a variable length integer, may have any value). |
| ** The first of the while(...) loops below skips over the record-length |
| ** field. The second while(...) loop copies the key value from the |
| ** cell on pPage into the pSpace buffer. |
| */ |
| pCell = findCell(pPage, pPage->nCell-1); |
| pStop = &pCell[9]; |
| while( (*(pCell++)&0x80) && pCell<pStop ); |
| pStop = &pCell[9]; |
| while( ((*(pOut++) = *(pCell++))&0x80) && pCell<pStop ); |
| |
| /* Insert the new divider cell into pParent. */ |
| insertCell(pParent, pParent->nCell, pSpace, (int)(pOut-pSpace), |
| 0, pPage->pgno, &rc); |
| |
| /* Set the right-child pointer of pParent to point to the new page. */ |
| put4byte(&pParent->aData[pParent->hdrOffset+8], pgnoNew); |
| |
| /* Release the reference to the new page. */ |
| releasePage(pNew); |
| } |
| |
| return rc; |
| } |
| #endif /* SQLITE_OMIT_QUICKBALANCE */ |
| |
| #if 0 |
| /* |
| ** This function does not contribute anything to the operation of SQLite. |
| ** it is sometimes activated temporarily while debugging code responsible |
| ** for setting pointer-map entries. |
| */ |
| static int ptrmapCheckPages(MemPage **apPage, int nPage){ |
| int i, j; |
| for(i=0; i<nPage; i++){ |
| Pgno n; |
| u8 e; |
| MemPage *pPage = apPage[i]; |
| BtShared *pBt = pPage->pBt; |
| assert( pPage->isInit ); |
| |
| for(j=0; j<pPage->nCell; j++){ |
| CellInfo info; |
| u8 *z; |
| |
| z = findCell(pPage, j); |
| btreeParseCellPtr(pPage, z, &info); |
| if( info.iOverflow ){ |
| Pgno ovfl = get4byte(&z[info.iOverflow]); |
| ptrmapGet(pBt, ovfl, &e, &n); |
| assert( n==pPage->pgno && e==PTRMAP_OVERFLOW1 ); |
| } |
| if( !pPage->leaf ){ |
| Pgno child = get4byte(z); |
| ptrmapGet(pBt, child, &e, &n); |
| assert( n==pPage->pgno && e==PTRMAP_BTREE ); |
| } |
| } |
| if( !pPage->leaf ){ |
| Pgno child = get4byte(&pPage->aData[pPage->hdrOffset+8]); |
| ptrmapGet(pBt, child, &e, &n); |
| assert( n==pPage->pgno && e==PTRMAP_BTREE ); |
| } |
| } |
| return 1; |
| } |
| #endif |
| |
| /* |
| ** This function is used to copy the contents of the b-tree node stored |
| ** on page pFrom to page pTo. If page pFrom was not a leaf page, then |
| ** the pointer-map entries for each child page are updated so that the |
| ** parent page stored in the pointer map is page pTo. If pFrom contained |
| ** any cells with overflow page pointers, then the corresponding pointer |
| ** map entries are also updated so that the parent page is page pTo. |
| ** |
| ** If pFrom is currently carrying any overflow cells (entries in the |
| ** MemPage.aOvfl[] array), they are not copied to pTo. |
| ** |
| ** Before returning, page pTo is reinitialized using btreeInitPage(). |
| ** |
| ** The performance of this function is not critical. It is only used by |
| ** the balance_shallower() and balance_deeper() procedures, neither of |
| ** which are called often under normal circumstances. |
| */ |
| static void copyNodeContent(MemPage *pFrom, MemPage *pTo, int *pRC){ |
| if( (*pRC)==SQLITE_OK ){ |
| BtShared * const pBt = pFrom->pBt; |
| u8 * const aFrom = pFrom->aData; |
| u8 * const aTo = pTo->aData; |
| int const iFromHdr = pFrom->hdrOffset; |
| int const iToHdr = ((pTo->pgno==1) ? 100 : 0); |
| int rc; |
| int iData; |
| |
| |
| assert( pFrom->isInit ); |
| assert( pFrom->nFree>=iToHdr ); |
| assert( get2byte(&aFrom[iFromHdr+5]) <= (int)pBt->usableSize ); |
| |
| /* Copy the b-tree node content from page pFrom to page pTo. */ |
| iData = get2byte(&aFrom[iFromHdr+5]); |
| memcpy(&aTo[iData], &aFrom[iData], pBt->usableSize-iData); |
| memcpy(&aTo[iToHdr], &aFrom[iFromHdr], pFrom->cellOffset + 2*pFrom->nCell); |
| |
| /* Reinitialize page pTo so that the contents of the MemPage structure |
| ** match the new data. The initialization of pTo can actually fail under |
| ** fairly obscure circumstances, even though it is a copy of initialized |
| ** page pFrom. |
| */ |
| pTo->isInit = 0; |
| rc = btreeInitPage(pTo); |
| if( rc!=SQLITE_OK ){ |
| *pRC = rc; |
| return; |
| } |
| |
| /* If this is an auto-vacuum database, update the pointer-map entries |
| ** for any b-tree or overflow pages that pTo now contains the pointers to. |
| */ |
| if( ISAUTOVACUUM ){ |
| *pRC = setChildPtrmaps(pTo); |
| } |
| } |
| } |
| |
| /* |
| ** This routine redistributes cells on the iParentIdx'th child of pParent |
| ** (hereafter "the page") and up to 2 siblings so that all pages have about the |
| ** same amount of free space. Usually a single sibling on either side of the |
| ** page are used in the balancing, though both siblings might come from one |
| ** side if the page is the first or last child of its parent. If the page |
| ** has fewer than 2 siblings (something which can only happen if the page |
| ** is a root page or a child of a root page) then all available siblings |
| ** participate in the balancing. |
| ** |
| ** The number of siblings of the page might be increased or decreased by |
| ** one or two in an effort to keep pages nearly full but not over full. |
| ** |
| ** Note that when this routine is called, some of the cells on the page |
| ** might not actually be stored in MemPage.aData[]. This can happen |
| ** if the page is overfull. This routine ensures that all cells allocated |
| ** to the page and its siblings fit into MemPage.aData[] before returning. |
| ** |
| ** In the course of balancing the page and its siblings, cells may be |
| ** inserted into or removed from the parent page (pParent). Doing so |
| ** may cause the parent page to become overfull or underfull. If this |
| ** happens, it is the responsibility of the caller to invoke the correct |
| ** balancing routine to fix this problem (see the balance() routine). |
| ** |
| ** If this routine fails for any reason, it might leave the database |
| ** in a corrupted state. So if this routine fails, the database should |
| ** be rolled back. |
| ** |
| ** The third argument to this function, aOvflSpace, is a pointer to a |
| ** buffer big enough to hold one page. If while inserting cells into the parent |
| ** page (pParent) the parent page becomes overfull, this buffer is |
| ** used to store the parent's overflow cells. Because this function inserts |
| ** a maximum of four divider cells into the parent page, and the maximum |
| ** size of a cell stored within an internal node is always less than 1/4 |
| ** of the page-size, the aOvflSpace[] buffer is guaranteed to be large |
| ** enough for all overflow cells. |
| ** |
| ** If aOvflSpace is set to a null pointer, this function returns |
| ** SQLITE_NOMEM. |
| */ |
| static int balance_nonroot( |
| MemPage *pParent, /* Parent page of siblings being balanced */ |
| int iParentIdx, /* Index of "the page" in pParent */ |
| u8 *aOvflSpace, /* page-size bytes of space for parent ovfl */ |
| int isRoot /* True if pParent is a root-page */ |
| ){ |
| 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[] */ |
| int nOld; /* Number of pages in apOld[] */ |
| int i, j, k; /* Loop counters */ |
| int nxDiv; /* Next divider slot in pParent->aCell[] */ |
| int rc = SQLITE_OK; /* The return code */ |
| u16 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 iSpace1 = 0; /* First unused byte of aSpace1[] */ |
| int iOvflSpace = 0; /* First unused byte of aOvflSpace[] */ |
| int szScratch; /* Size of scratch memory requested */ |
| MemPage *apOld[NB]; /* pPage and up to two siblings */ |
| MemPage *apCopy[NB]; /* Private copies of apOld[] pages */ |
| MemPage *apNew[NB+2]; /* pPage and up to NB siblings after balancing */ |
| u8 *pRight; /* Location in parent of right-sibling pointer */ |
| u8 *apDiv[NB-1]; /* Divider cells in pParent */ |
| int cntNew[NB+2]; /* Index in aCell[] of cell after i-th page */ |
| int szNew[NB+2]; /* Combined size of cells place on i-th page */ |
| u8 **apCell = 0; /* All cells begin balanced */ |
| u16 *szCell; /* Local size of all cells in apCell[] */ |
| u8 *aSpace1; /* Space for copies of dividers cells */ |
| Pgno pgno; /* Temp var to store a page number in */ |
| |
| pBt = pParent->pBt; |
| assert( sqlite3_mutex_held(pBt->mutex) ); |
| assert( sqlite3PagerIswriteable(pParent->pDbPage) ); |
| |
| #if 0 |
| 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(). |
| */ |
| assert( pParent->nOverflow==0 || pParent->nOverflow==1 ); |
| assert( pParent->nOverflow==0 || pParent->aOvfl[0].idx==iParentIdx ); |
| |
| if( !aOvflSpace ){ |
| return SQLITE_NOMEM; |
| } |
| |
| /* 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. |
| */ |
| i = pParent->nOverflow + pParent->nCell; |
| 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; |
| } |
| if( (i+nxDiv-pParent->nOverflow)==pParent->nCell ){ |
| pRight = &pParent->aData[pParent->hdrOffset+8]; |
| }else{ |
| pRight = findCell(pParent, i+nxDiv-pParent->nOverflow); |
| } |
| pgno = get4byte(pRight); |
| while( 1 ){ |
| rc = getAndInitPage(pBt, pgno, &apOld[i]); |
| if( rc ){ |
| memset(apOld, 0, (i+1)*sizeof(MemPage*)); |
| goto balance_cleanup; |
| } |
| nMaxCells += 1+apOld[i]->nCell+apOld[i]->nOverflow; |
| if( (i--)==0 ) break; |
| |
| if( i+nxDiv==pParent->aOvfl[0].idx && pParent->nOverflow ){ |
| apDiv[i] = pParent->aOvfl[0].pCell; |
| pgno = get4byte(apDiv[i]); |
| szNew[i] = cellSizePtr(pParent, apDiv[i]); |
| pParent->nOverflow = 0; |
| }else{ |
| apDiv[i] = findCell(pParent, i+nxDiv-pParent->nOverflow); |
| pgno = get4byte(apDiv[i]); |
| szNew[i] = cellSizePtr(pParent, 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 = SQLITE_PTR_TO_INT(apDiv[i]) - SQLITE_PTR_TO_INT(pParent->aData); |
| if( (iOff+szNew[i])>(int)pBt->usableSize ){ |
| rc = SQLITE_CORRUPT_BKPT; |
| 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]; |
| } |
| } |
| dropCell(pParent, i+nxDiv-pParent->nOverflow, szNew[i], &rc); |
| } |
| } |
| |
| /* Make nMaxCells a multiple of 4 in order to preserve 8-byte |
| ** alignment */ |
| nMaxCells = (nMaxCells + 3)&~3; |
| |
| /* |
| ** Allocate space for memory structures |
| */ |
| k = pBt->pageSize + ROUND8(sizeof(MemPage)); |
| szScratch = |
| nMaxCells*sizeof(u8*) /* apCell */ |
| + nMaxCells*sizeof(u16) /* szCell */ |
| + pBt->pageSize /* aSpace1 */ |
| + k*nOld; /* Page copies (apCopy) */ |
| apCell = sqlite3ScratchMalloc( szScratch ); |
| if( apCell==0 ){ |
| rc = SQLITE_NOMEM; |
| goto balance_cleanup; |
| } |
| szCell = (u16*)&apCell[nMaxCells]; |
| aSpace1 = (u8*)&szCell[nMaxCells]; |
| assert( EIGHT_BYTE_ALIGNMENT(aSpace1) ); |
| |
| /* |
| ** 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 = apOld[0]->leaf*4; |
| leafData = apOld[0]->hasData; |
| for(i=0; i<nOld; i++){ |
| int limit; |
| |
| /* 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. */ |
| MemPage *pOld = apCopy[i] = (MemPage*)&aSpace1[pBt->pageSize + k*i]; |
| memcpy(pOld, apOld[i], sizeof(MemPage)); |
| pOld->aData = (void*)&pOld[1]; |
| memcpy(pOld->aData, apOld[i]->aData, pBt->pageSize); |
| |
| limit = pOld->nCell+pOld->nOverflow; |
| for(j=0; j<limit; j++){ |
| assert( nCell<nMaxCells ); |
| apCell[nCell] = findOverflowCell(pOld, j); |
| szCell[nCell] = cellSizePtr(pOld, apCell[nCell]); |
| nCell++; |
| } |
| if( i<nOld-1 && !leafData){ |
| u16 sz = (u16)szNew[i]; |
| u8 *pTemp; |
| assert( nCell<nMaxCells ); |
| szCell[nCell] = sz; |
| pTemp = &aSpace1[iSpace1]; |
| iSpace1 += sz; |
| assert( sz<=pBt->maxLocal+23 ); |
| assert( iSpace1 <= (int)pBt->pageSize ); |
| memcpy(pTemp, apDiv[i], sz); |
| apCell[nCell] = pTemp+leafCorrection; |
| assert( leafCorrection==0 || leafCorrection==4 ); |
| szCell[nCell] = szCell[nCell] - leafCorrection; |
| if( !pOld->leaf ){ |
| assert( leafCorrection==0 ); |
| assert( pOld->hdrOffset==0 ); |
| /* The right pointer of the child page pOld becomes the left |
| ** pointer of the divider cell */ |
| memcpy(apCell[nCell], &pOld->aData[8], 4); |
| }else{ |
| 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 = pBt->usableSize - 12 + leafCorrection; |
| for(subtotal=k=i=0; i<nCell; i++){ |
| assert( i<nMaxCells ); |
| subtotal += szCell[i] + 2; |
| if( subtotal > usableSpace ){ |
| szNew[k] = subtotal - szCell[i]; |
| cntNew[k] = i; |
| if( leafData ){ i--; } |
| subtotal = 0; |
| k++; |
| if( k>NB+1 ){ rc = 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--){ |
| int szRight = szNew[i]; /* Size of sibling on the right */ |
| int szLeft = szNew[i-1]; /* Size of sibling on the left */ |
| int r; /* Index of right-most cell in left sibling */ |
| int d; /* Index of first cell to the left of right sibling */ |
| |
| r = cntNew[i-1] - 1; |
| d = r + 1 - leafData; |
| assert( d<nMaxCells ); |
| 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. |
| */ |
| assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) ); |
| |
| TRACE(("BALANCE: old: %d %d %d ", |
| apOld[0]->pgno, |
| nOld>=2 ? apOld[1]->pgno : 0, |
| nOld>=3 ? apOld[2]->pgno : 0 |
| )); |
| |
| /* |
| ** Allocate k new pages. Reuse old pages where possible. |
| */ |
| if( apOld[0]->pgno<=1 ){ |
| rc = SQLITE_CORRUPT_BKPT; |
| goto balance_cleanup; |
| } |
| pageFlags = apOld[0]->aData[0]; |
| for(i=0; i<k; i++){ |
| MemPage *pNew; |
| if( i<nOld ){ |
| pNew = apNew[i] = apOld[i]; |
| apOld[i] = 0; |
| rc = sqlite3PagerWrite(pNew->pDbPage); |
| nNew++; |
| if( rc ) goto balance_cleanup; |
| }else{ |
| assert( i>0 ); |
| rc = allocateBtreePage(pBt, &pNew, &pgno, pgno, 0); |
| if( rc ) goto balance_cleanup; |
| apNew[i] = pNew; |
| nNew++; |
| |
| /* Set the pointer-map entry for the new sibling page. */ |
| if( ISAUTOVACUUM ){ |
| ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno, &rc); |
| if( rc!=SQLITE_OK ){ |
| goto balance_cleanup; |
| } |
| } |
| } |
| } |
| |
| /* Free any old pages that were not reused as new pages. |
| */ |
| while( i<nOld ){ |
| freePage(apOld[i], &rc); |
| if( rc ) goto balance_cleanup; |
| releasePage(apOld[i]); |
| apOld[i] = 0; |
| 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++){ |
| int minV = apNew[i]->pgno; |
| int minI = i; |
| for(j=i+1; j<k; j++){ |
| if( apNew[j]->pgno<(unsigned)minV ){ |
| minI = j; |
| minV = apNew[j]->pgno; |
| } |
| } |
| if( minI>i ){ |
| MemPage *pT; |
| pT = apNew[i]; |
| apNew[i] = apNew[minI]; |
| apNew[minI] = pT; |
| } |
| } |
| TRACE(("new: %d(%d) %d(%d) %d(%d) %d(%d) %d(%d)\n", |
| apNew[0]->pgno, szNew[0], |
| nNew>=2 ? apNew[1]->pgno : 0, nNew>=2 ? szNew[1] : 0, |
| nNew>=3 ? apNew[2]->pgno : 0, nNew>=3 ? szNew[2] : 0, |
| nNew>=4 ? apNew[3]->pgno : 0, nNew>=4 ? szNew[3] : 0, |
| nNew>=5 ? apNew[4]->pgno : 0, nNew>=5 ? szNew[4] : 0)); |
| |
| assert( sqlite3PagerIswriteable(pParent->pDbPage) ); |
| put4byte(pRight, apNew[nNew-1]->pgno); |
| |
| /* |
| ** 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]; |
| assert( j<nMaxCells ); |
| zeroPage(pNew, pageFlags); |
| assemblePage(pNew, cntNew[i]-j, &apCell[j], &szCell[j]); |
| assert( pNew->nCell>0 || (nNew==1 && cntNew[0]==0) ); |
| assert( pNew->nOverflow==0 ); |
| |
| j = cntNew[i]; |
| |
| /* If the sibling page assembled above was not the right-most sibling, |
| ** insert a divider cell into the parent page. |
| */ |
| assert( i<nNew-1 || j==nCell ); |
| if( j<nCell ){ |
| u8 *pCell; |
| u8 *pTemp; |
| int sz; |
| |
| assert( j<nMaxCells ); |
| pCell = apCell[j]; |
| sz = szCell[j] + leafCorrection; |
| pTemp = &aOvflSpace[iOvflSpace]; |
| if( !pNew->leaf ){ |
| memcpy(&pNew->aData[8], pCell, 4); |
| }else if( leafData ){ |
| /* 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. |
| */ |
| CellInfo info; |
| j--; |
| btreeParseCellPtr(pNew, apCell[j], &info); |
| pCell = pTemp; |
| sz = 4 + putVarint(&pCell[4], info.nKey); |
| pTemp = 0; |
| }else{ |
| 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 ){ |
| assert(leafCorrection==4); |
| sz = cellSizePtr(pParent, pCell); |
| } |
| } |
| iOvflSpace += sz; |
| assert( sz<=pBt->maxLocal+23 ); |
| assert( iOvflSpace <= (int)pBt->pageSize ); |
| insertCell(pParent, nxDiv, pCell, sz, pTemp, pNew->pgno, &rc); |
| if( rc!=SQLITE_OK ) goto balance_cleanup; |
| assert( sqlite3PagerIswriteable(pParent->pDbPage) ); |
| |
| j++; |
| nxDiv++; |
| } |
| } |
| assert( j==nCell ); |
| assert( nOld>0 ); |
| assert( nNew>0 ); |
| if( (pageFlags & PTF_LEAF)==0 ){ |
| u8 *zChild = &apCopy[nOld-1]->aData[8]; |
| memcpy(&apNew[nNew-1]->aData[8], zChild, 4); |
| } |
| |
| if( isRoot && pParent->nCell==0 && pParent->hdrOffset<=apNew[0]->nFree ){ |
| /* 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 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. */ |
| assert( nNew==1 ); |
| assert( apNew[0]->nFree == |
| (get2byte(&apNew[0]->aData[5])-apNew[0]->cellOffset-apNew[0]->nCell*2) |
| ); |
| copyNodeContent(apNew[0], pParent, &rc); |
| freePage(apNew[0], &rc); |
| }else if( ISAUTOVACUUM ){ |
| /* 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. */ |
| MemPage *pNew = apNew[0]; |
| MemPage *pOld = apCopy[0]; |
| int nOverflow = pOld->nOverflow; |
| int iNextOld = pOld->nCell + nOverflow; |
| int iOverflow = (nOverflow ? pOld->aOvfl[0].idx : -1); |
| j = 0; /* Current 'old' sibling page */ |
| k = 0; /* Current 'new' sibling page */ |
| for(i=0; i<nCell; i++){ |
| int 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 + !leafData + pOld->nCell + pOld->nOverflow; |
| if( pOld->nOverflow ){ |
| nOverflow = pOld->nOverflow; |
| iOverflow = i + !leafData + pOld->aOvfl[0].idx; |
| } |
| isDivider = !leafData; |
| } |
| |
| assert(nOverflow>0 || iOverflow<i ); |
| assert(nOverflow<2 || pOld->aOvfl[0].idx==pOld->aOvfl[1].idx-1); |
| assert(nOverflow<3 || pOld->aOvfl[1].idx==pOld->aOvfl[2].idx-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 ) continue; |
| } |
| assert( j<nOld ); |
| 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 || pOld->pgno!=pNew->pgno ){ |
| if( !leafCorrection ){ |
| ptrmapPut(pBt, get4byte(apCell[i]), PTRMAP_BTREE, pNew->pgno, &rc); |
| } |
| if( szCell[i]>pNew->minLocal ){ |
| ptrmapPutOvflPtr(pNew, apCell[i], &rc); |
| } |
| } |
| } |
| |
| if( !leafCorrection ){ |
| for(i=0; i<nNew; i++){ |
| u32 key = get4byte(&apNew[i]->aData[8]); |
| ptrmapPut(pBt, key, PTRMAP_BTREE, apNew[i]->pgno, &rc); |
| } |
| } |
| |
| #if 0 |
| /* The ptrmapCheckPages() contains 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 assert() statement to fail. */ |
| ptrmapCheckPages(apNew, nNew); |
| ptrmapCheckPages(&pParent, 1); |
| #endif |
| } |
| |
| assert( pParent->isInit ); |
| TRACE(("BALANCE: finished: old=%d new=%d cells=%d\n", |
| nOld, nNew, nCell)); |
| |
| /* |
| ** Cleanup before returning. |
| */ |
| balance_cleanup: |
| sqlite3ScratchFree(apCell); |
| for(i=0; i<nOld; i++){ |
| releasePage(apOld[i]); |
| } |
| for(i=0; i<nNew; i++){ |
| releasePage(apNew[i]); |
| } |
| |
| return rc; |
| } |
| |
| |
| /* |
| ** This function is called when the root page of a b-tree structure is |
| ** overfull (has one or more overflow pages). |
| ** |
| ** A new child page is allocated and the contents of the current root |
| ** page, including overflow cells, are copied into the child. The root |
| ** page is then overwritten to make it an empty page with the right-child |
| ** pointer pointing to the new page. |
| ** |
| ** Before returning, all pointer-map entries corresponding to pages |
| ** that the new child-page now contains pointers to are updated. The |
| ** entry corresponding to the new right-child pointer of the root |
| ** page is also updated. |
| ** |
| ** If successful, *ppChild is set to contain a reference to the child |
| ** page and SQLITE_OK is returned. In this case the caller is required |
| ** to call releasePage() on *ppChild exactly once. If an error occurs, |
| ** an error code is returned and *ppChild is set to 0. |
| */ |
| static int balance_deeper(MemPage *pRoot, MemPage **ppChild){ |
| int rc; /* Return value from subprocedures */ |
| MemPage *pChild = 0; /* Pointer to a new child page */ |
| Pgno pgnoChild = 0; /* Page number of the new child page */ |
| BtShared *pBt = pRoot->pBt; /* The BTree */ |
| |
| assert( pRoot->nOverflow>0 ); |
| assert( sqlite3_mutex_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. |
| */ |
| rc = sqlite3PagerWrite(pRoot->pDbPage); |
| if( rc==SQLITE_OK ){ |
| rc = allocateBtreePage(pBt,&pChild,&pgnoChild,pRoot->pgno,0); |
| copyNodeContent(pRoot, pChild, &rc); |
| if( ISAUTOVACUUM ){ |
| ptrmapPut(pBt, pgnoChild, PTRMAP_BTREE, pRoot->pgno, &rc); |
| } |
| } |
| if( rc ){ |
| *ppChild = 0; |
| releasePage(pChild); |
| return rc; |
| } |
| assert( sqlite3PagerIswriteable(pChild->pDbPage) ); |
| assert( sqlite3PagerIswriteable(pRoot->pDbPage) ); |
| assert( pChild->nCell==pRoot->nCell ); |
| |
| TRACE(("BALANCE: copy root %d into %d\n", pRoot->pgno, pChild->pgno)); |
| |
| /* Copy the overflow cells from pRoot to pChild */ |
| memcpy(pChild->aOvfl, pRoot->aOvfl, pRoot->nOverflow*sizeof(pRoot->aOvfl[0])); |
| pChild->nOverflow = pRoot->nOverflow; |
| |
| /* Zero the contents of pRoot. Then install pChild as the right-child. */ |
| zeroPage(pRoot, pChild->aData[0] & ~PTF_LEAF); |
| put4byte(&pRoot->aData[pRoot->hdrOffset+8], pgnoChild); |
| |
| *ppChild = pChild; |
| return SQLITE_OK; |
| } |
| |
| /* |
| ** The page that pCur currently points to has just been modified in |
| ** some way. This function figures out if this modification means the |
| ** tree needs to be balanced, and if so calls the appropriate balancing |
| ** routine. Balancing routines are: |
| ** |
| ** balance_quick() |
| ** balance_deeper() |
| ** balance_nonroot() |
| */ |
| static int balance(BtCursor *pCur){ |
| int rc = SQLITE_OK; |
| const int nMin = pCur->pBt->usableSize * 2 / 3; |
| u8 aBalanceQuickSpace[13]; |
| u8 *pFree = 0; |
| |
| TESTONLY( int balance_quick_called = 0 ); |
| TESTONLY( int balance_deeper_called = 0 ); |
| |
| do { |
| int iPage = pCur->iPage; |
| MemPage *pPage = pCur->apPage[iPage]; |
| |
| if( iPage==0 ){ |
| if( pPage->nOverflow ){ |
| /* 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. |
| */ |
| assert( (balance_deeper_called++)==0 ); |
| rc = balance_deeper(pPage, &pCur->apPage[1]); |
| if( rc==SQLITE_OK ){ |
| pCur->iPage = 1; |
| pCur->aiIdx[0] = 0; |
| pCur->aiIdx[1] = 0; |
| assert( pCur->apPage[1]->nOverflow ); |
| } |
| }else{ |
| break; |
| } |
| }else if( pPage->nOverflow==0 && pPage->nFree<=nMin ){ |
| break; |
| }else{ |
| MemPage * const pParent = pCur->apPage[iPage-1]; |
| int const iIdx = pCur->aiIdx[iPage-1]; |
| |
| rc = sqlite3PagerWrite(pParent->pDbPage); |
| if( rc==SQLITE_OK ){ |
| #ifndef SQLITE_OMIT_QUICKBALANCE |
| if( pPage->hasData |
| && pPage->nOverflow==1 |
| && pPage->aOvfl[0].idx==pPage->nCell |
| && pParent->pgno!=1 |
| && pParent->nCell==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 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. |
| */ |
| assert( (balance_quick_called++)==0 ); |
| rc = balance_quick(pParent, pPage, aBalanceQuickSpace); |
| }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(). |
| */ |
| u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize); |
| rc = balance_nonroot(pParent, iIdx, pSpace, iPage==1); |
| if( pFree ){ |
| /* If pFree is not NULL, it points to the pSpace buffer used |
| ** by a previous call to balance_nonroot(). Its contents are |
| ** now stored either on real database pages or within the |
| ** new pSpace buffer, so it may be safely freed here. */ |
| sqlite3PageFree(pFree); |
| } |
| |
| /* The pSpace buffer will be freed after the next call to |
| ** balance_nonroot(), or just before this function returns, whichever |
| ** comes first. */ |
| pFree = pSpace; |
| } |
| } |
| |
| pPage->nOverflow = 0; |
| |
| /* The next iteration of the do-loop balances the parent page. */ |
| releasePage(pPage); |
| pCur->iPage--; |
| } |
| }while( rc==SQLITE_OK ); |
| |
| if( pFree ){ |
| sqlite3PageFree(pFree); |
| } |
| return rc; |
| } |
| |
| |
| /* |
| ** Insert a new record into the BTree. The key is given by (pKey,nKey) |
| ** and the data is given by (pData,nData). The cursor is used only to |
| ** define what table the record should be inserted into. The cursor |
| ** is left pointing at a random location. |
| ** |
| ** For an INTKEY table, only the nKey value of the key is used. pKey is |
| ** ignored. For a ZERODATA table, the pData and nData are both ignored. |
| ** |
| ** If the seekResult parameter is non-zero, then a successful call to |
| ** MovetoUnpacked() to seek cursor pCur to (pKey, nKey) has already |
| ** been performed. seekResult is the search result returned (a negative |
| ** number if pCur points at an entry that is smaller than (pKey, nKey), or |
| ** a positive value if pCur points at an etry that is larger than |
| ** (pKey, nKey)). |
| ** |
| ** If the seekResult parameter is non-zero, then the caller guarantees that |
| ** cursor pCur is pointing at the existing copy of a row that is to be |
| ** overwritten. If the seekResult parameter is 0, then cursor pCur may |
| ** point to any entry or to no entry at all and so this function has to seek |
| ** the cursor before the new key can be inserted. |
| */ |
| int sqlite3BtreeInsert( |
| BtCursor *pCur, /* Insert data into the table of this cursor */ |
| const void *pKey, i64 nKey, /* The key of the new record */ |
| const void *pData, int nData, /* The data of the new record */ |
| int nZero, /* Number of extra 0 bytes to append to data */ |
| int appendBias, /* True if this is likely an append */ |
| int seekResult /* Result of prior MovetoUnpacked() call */ |
| ){ |
| int rc; |
| int loc = seekResult; /* -1: before desired location +1: after */ |
| int szNew = 0; |
| int idx; |
| MemPage *pPage; |
| Btree *p = pCur->pBtree; |
| BtShared *pBt = p->pBt; |
| unsigned char *oldCell; |
| unsigned char *newCell = 0; |
| |
| if( pCur->eState==CURSOR_FAULT ){ |
| assert( pCur->skipNext!=SQLITE_OK ); |
| return pCur->skipNext; |
| } |
| |
| assert( cursorHoldsMutex(pCur) ); |
| assert( pCur->wrFlag && pBt->inTransaction==TRANS_WRITE && !pBt->readOnly ); |
| assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) ); |
| |
| /* 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. */ |
| assert( (pKey==0)==(pCur->pKeyInfo==0) ); |
| |
| /* 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( pCur->pKeyInfo==0 ){ |
| invalidateIncrblobCursors(p, nKey, 0); |
| } |
| |
| /* 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. |
| */ |
| rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur); |
| if( rc ) return rc; |
| if( !loc ){ |
| rc = btreeMoveto(pCur, pKey, nKey, appendBias, &loc); |
| if( rc ) return rc; |
| } |
| assert( pCur->eState==CURSOR_VALID || (pCur->eState==CURSOR_INVALID && loc) ); |
| |
| pPage = pCur->apPage[pCur->iPage]; |
| assert( pPage->intKey || nKey>=0 ); |
| assert( pPage->leaf || !pPage->intKey ); |
| |
| TRACE(("INSERT: table=%d nkey=%lld ndata=%d page=%d %s\n", |
| pCur->pgnoRoot, nKey, nData, pPage->pgno, |
| loc==0 ? "overwrite" : "new entry")); |
| assert( pPage->isInit ); |
| allocateTempSpace(pBt); |
| newCell = pBt->pTmpSpace; |
| if( newCell==0 ) return SQLITE_NOMEM; |
| rc = fillInCell(pPage, newCell, pKey, nKey, pData, nData, nZero, &szNew); |
| if( rc ) goto end_insert; |
| assert( szNew==cellSizePtr(pPage, newCell) ); |
| assert( szNew <= MX_CELL_SIZE(pBt) ); |
| idx = pCur->aiIdx[pCur->iPage]; |
| if( loc==0 ){ |
| u16 szOld; |
| assert( idx<pPage->nCell ); |
| rc = sqlite3PagerWrite(pPage->pDbPage); |
| if( rc ){ |
| goto end_insert; |
| } |
| oldCell = findCell(pPage, idx); |
| if( !pPage->leaf ){ |
| memcpy(newCell, oldCell, 4); |
| } |
| szOld = cellSizePtr(pPage, oldCell); |
| rc = clearCell(pPage, oldCell); |
| dropCell(pPage, idx, szOld, &rc); |
| if( rc ) goto end_insert; |
| }else if( loc<0 && pPage->nCell>0 ){ |
| assert( pPage->leaf ); |
| idx = ++pCur->aiIdx[pCur->iPage]; |
| }else{ |
| assert( pPage->leaf ); |
| } |
| insertCell(pPage, idx, newCell, szNew, 0, 0, &rc); |
| assert( rc!=SQLITE_OK || pPage->nCell>0 || pPage->nOverflow>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. |
| */ |
| pCur->info.nSize = 0; |
| pCur->validNKey = 0; |
| if( rc==SQLITE_OK && pPage->nOverflow ){ |
| rc = balance(pCur); |
| |
| /* 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. */ |
| pCur->apPage[pCur->iPage]->nOverflow = 0; |
| pCur->eState = CURSOR_INVALID; |
| } |
| assert( pCur->apPage[pCur->iPage]->nOverflow==0 ); |
| |
| end_insert: |
| return rc; |
| } |
| |
| /* |
| ** Delete the entry that the cursor is pointing to. The cursor |
| ** is left pointing at a arbitrary location. |
| */ |
| int sqlite3BtreeDelete(BtCursor *pCur){ |
| Btree *p = pCur->pBtree; |
| BtShared *pBt = p->pBt; |
| int rc; /* Return code */ |
| MemPage *pPage; /* Page to delete cell from */ |
| unsigned char *pCell; /* Pointer to cell to delete */ |
| int iCellIdx; /* Index of cell to delete */ |
| int iCellDepth; /* Depth of node containing pCell */ |
| |
| assert( cursorHoldsMutex(pCur) ); |
| assert( pBt->inTransaction==TRANS_WRITE ); |
| assert( !pBt->readOnly ); |
| assert( pCur->wrFlag ); |
| assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) ); |
| assert( !hasReadConflicts(p, pCur->pgnoRoot) ); |
| |
| if( NEVER(pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell) |
| || NEVER(pCur->eState!=CURSOR_VALID) |
| ){ |
| return SQLITE_ERROR; /* Something has gone awry. */ |
| } |
| |
| /* 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( pCur->pKeyInfo==0 ){ |
| invalidateIncrblobCursors(p, pCur->info.nKey, 0); |
| } |
| |
| iCellDepth = pCur->iPage; |
| iCellIdx = pCur->aiIdx[iCellDepth]; |
| pPage = pCur->apPage[iCellDepth]; |
| pCell = findCell(pPage, 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. */ |
| if( !pPage->leaf ){ |
| int notUsed; |
| rc = sqlite3BtreePrevious(pCur, ¬Used); |
| if( rc ) 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 = saveAllCursors(pBt, pCur->pgnoRoot, pCur); |
| if( rc ) return rc; |
| rc = sqlite3PagerWrite(pPage->pDbPage); |
| if( rc ) return rc; |
| rc = clearCell(pPage, pCell); |
| dropCell(pPage, iCellIdx, cellSizePtr(pPage, pCell), &rc); |
| if( rc ) 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 ){ |
| MemPage *pLeaf = pCur->apPage[pCur->iPage]; |
| int nCell; |
| Pgno n = pCur->apPage[iCellDepth+1]->pgno; |
| unsigned char *pTmp; |
| |
| pCell = findCell(pLeaf, pLeaf->nCell-1); |
| nCell = cellSizePtr(pLeaf, pCell); |
| assert( MX_CELL_SIZE(pBt) >= nCell ); |
| |
| allocateTempSpace(pBt); |
| pTmp = pBt->pTmpSpace; |
| |
| rc = sqlite3PagerWrite(pLeaf->pDbPage); |
| insertCell(pPage, iCellIdx, pCell-4, nCell+4, pTmp, n, &rc); |
| dropCell(pLeaf, pLeaf->nCell-1, nCell, &rc); |
| if( rc ) 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(pCur); |
| if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){ |
| while( pCur->iPage>iCellDepth ){ |
| releasePage(pCur->apPage[pCur->iPage--]); |
| } |
| rc = balance(pCur); |
| } |
| |
| if( rc==SQLITE_OK ){ |
| moveToRoot(pCur); |
| } |
| return rc; |
| } |
| |
| /* |
| ** Create a new BTree table. Write into *piTable the page |
| ** number for the root page of the new table. |
| ** |
| ** The type of type is determined by the flags parameter. Only the |
| ** following values of flags are currently in use. Other values for |
| ** flags might not work: |
| ** |
| ** BTREE_INTKEY|BTREE_LEAFDATA Used for SQL tables with rowid keys |
| ** BTREE_ZERODATA Used for SQL indices |
| */ |
| static int btreeCreateTable(Btree *p, int *piTable, int createTabFlags){ |
| BtShared *pBt = p->pBt; |
| MemPage *pRoot; |
| Pgno pgnoRoot; |
| int rc; |
| int ptfFlags; /* Page-type flage for the root page of new table */ |
| |
| assert( sqlite3BtreeHoldsMutex(p) ); |
| assert( pBt->inTransaction==TRANS_WRITE ); |
| assert( !pBt->readOnly ); |
| |
| #ifdef SQLITE_OMIT_AUTOVACUUM |
| rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0); |
| if( rc ){ |
| return rc; |
| } |
| #else |
| if( pBt->autoVacuum ){ |
| Pgno pgnoMove; /* Move a page here to make room for the root-page */ |
| MemPage *pPageMove; /* 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). |
| */ |
| sqlite3BtreeGetMeta(p, BTREE_LARGEST_ROOT_PAGE, &pgnoRoot); |
| pgnoRoot++; |
| |
| /* The new root-page may not be allocated on a pointer-map page, or the |
| ** PENDING_BYTE page. |
| */ |
| while( pgnoRoot==PTRMAP_PAGENO(pBt, pgnoRoot) || |
| pgnoRoot==PENDING_BYTE_PAGE(pBt) ){ |
| pgnoRoot++; |
| } |
| 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 = allocateBtreePage(pBt, &pPageMove, &pgnoMove, pgnoRoot, 1); |
| if( rc!=SQLITE_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. |
| */ |
| u8 eType = 0; |
| Pgno iPtrPage = 0; |
| |
| releasePage(pPageMove); |
| |
| /* Move the page currently at pgnoRoot to pgnoMove. */ |
| rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0); |
| if( rc!=SQLITE_OK ){ |
| return rc; |
| } |
| rc = ptrmapGet(pBt, pgnoRoot, &eType, &iPtrPage); |
| if( eType==PTRMAP_ROOTPAGE || eType==PTRMAP_FREEPAGE ){ |
| rc = SQLITE_CORRUPT_BKPT; |
| } |
| if( rc!=SQLITE_OK ){ |
| releasePage(pRoot); |
| return rc; |
| } |
| assert( eType!=PTRMAP_ROOTPAGE ); |
| assert( eType!=PTRMAP_FREEPAGE ); |
| rc = relocatePage(pBt, pRoot, eType, iPtrPage, pgnoMove, 0); |
| releasePage(pRoot); |
| |
| /* Obtain the page at pgnoRoot */ |
| if( rc!=SQLITE_OK ){ |
| return rc; |
| } |
| rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0); |
| if( rc!=SQLITE_OK ){ |
| return rc; |
| } |
| rc = sqlite3PagerWrite(pRoot->pDbPage); |
| if( rc!=SQLITE_OK ){ |
| releasePage(pRoot); |
| return rc; |
| } |
| }else{ |
| pRoot = pPageMove; |
| } |
| |
| /* Update the pointer-map and meta-data with the new root-page number. */ |
| ptrmapPut(pBt, pgnoRoot, PTRMAP_ROOTPAGE, 0, &rc); |
| if( rc ){ |
| releasePage(pRoot); |
| 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. |
| */ |
| assert( sqlite3PagerIswriteable(pBt->pPage1->pDbPage) ); |
| rc = sqlite3BtreeUpdateMeta(p, 4, pgnoRoot); |
| if( NEVER(rc) ){ |
| releasePage(pRoot); |
| return rc; |
| } |
| |
| }else{ |
| rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0); |
| if( rc ) return rc; |
| } |
| #endif |
| assert( sqlite3PagerIswriteable(pRoot->pDbPage) ); |
| if( createTabFlags & BTREE_INTKEY ){ |
| ptfFlags = PTF_INTKEY | PTF_LEAFDATA | PTF_LEAF; |
| }else{ |
| ptfFlags = PTF_ZERODATA | PTF_LEAF; |
| } |
| zeroPage(pRoot, ptfFlags); |
| sqlite3PagerUnref(pRoot->pDbPage); |
| assert( (pBt->openFlags & BTREE_SINGLE)==0 || pgnoRoot==2 ); |
| *piTable = (int)pgnoRoot; |
| return SQLITE_OK; |
| } |
| int sqlite3BtreeCreateTable(Btree *p, int *piTable, int flags){ |
| int rc; |
| sqlite3BtreeEnter(p); |
| rc = btreeCreateTable(p, piTable, flags); |
| sqlite3BtreeLeave(p); |
| return rc; |
| } |
| |
| /* |
| ** Erase the given database page and all its children. Return |
| ** the page to the freelist. |
| */ |
| static int clearDatabasePage( |
| BtShared *pBt, /* The BTree that contains the table */ |
| Pgno pgno, /* Page number to clear */ |
| int freePageFlag, /* Deallocate page if true */ |
| int *pnChange /* Add number of Cells freed to this counter */ |
| ){ |
| MemPage *pPage; |
| int rc; |
| unsigned char *pCell; |
| int i; |
| |
| assert( sqlite3_mutex_held(pBt->mutex) ); |
| if( pgno>btreePagecount(pBt) ){ |
| return SQLITE_CORRUPT_BKPT; |
| } |
| |
| rc = getAndInitPage(pBt, pgno, &pPage); |
| if( rc ) return rc; |
| for(i=0; i<pPage->nCell; i++){ |
| pCell = findCell(pPage, i); |
| if( !pPage->leaf ){ |
| rc = clearDatabasePage(pBt, get4byte(pCell), 1, pnChange); |
| if( rc ) goto cleardatabasepage_out; |
| } |
| rc = clearCell(pPage, pCell); |
| if( rc ) goto cleardatabasepage_out; |
| } |
| if( !pPage->leaf ){ |
| rc = clearDatabasePage(pBt, get4byte(&pPage->aData[8]), 1, pnChange); |
| if( rc ) goto cleardatabasepage_out; |
| }else if( pnChange ){ |
| assert( pPage->intKey ); |
| *pnChange += pPage->nCell; |
| } |
| if( freePageFlag ){ |
| freePage(pPage, &rc); |
| }else if( (rc = sqlite3PagerWrite(pPage->pDbPage))==0 ){ |
| zeroPage(pPage, pPage->aData[0] | PTF_LEAF); |
| } |
| |
| cleardatabasepage_out: |
| releasePage(pPage); |
| return rc; |
| } |
| |
| /* |
| ** Delete all information from a single table in the database. iTable is |
| ** the page number of the root of the table. After this routine returns, |
| ** the root page is empty, but still exists. |
| ** |
| ** This routine will fail with SQLITE_LOCKED if there are any open |
| ** read cursors on the table. Open write cursors are moved to the |
| ** root of the table. |
| ** |
| ** If pnChange is not NULL, then table iTable must be an intkey table. The |
| ** integer value pointed to by pnChange is incremented by the number of |
| ** entries in the table. |
| */ |
| int sqlite3BtreeClearTable(Btree *p, int iTable, int *pnChange){ |
| int rc; |
| BtShared *pBt = p->pBt; |
| sqlite3BtreeEnter(p); |
| assert( p->inTrans==TRANS_WRITE ); |
| |
| /* Invalidate all incrblob cursors open on table iTable (assuming iTable |
| ** is the root of a table b-tree - if it is not, the following call is |
| ** a no-op). */ |
| invalidateIncrblobCursors(p, 0, 1); |
| |
| rc = saveAllCursors(pBt, (Pgno)iTable, 0); |
| if( SQLITE_OK==rc ){ |
| rc = clearDatabasePage(pBt, (Pgno)iTable, 0, pnChange); |
| } |
| sqlite3BtreeLeave(p); |
| return rc; |
| } |
| |
| /* |
| ** Erase all information in a table and add the root of the table to |
| ** the freelist. Except, the root of the principle table (the one on |
| ** page 1) is never added to the freelist. |
| ** |
| ** This routine will fail with SQLITE_LOCKED if there are any open |
| ** cursors on the table. |
| ** |
| ** If AUTOVACUUM is enabled and the page at iTable is not the last |
| ** root page in the database file, then the last root page |
| ** in the database file is moved into the slot formerly occupied by |
| ** iTable and that last slot formerly occupied by the last root page |
| ** is added to the freelist instead of iTable. In this say, all |
| ** root pages are kept at the beginning of the database file, which |
| ** is necessary for AUTOVACUUM to work right. *piMoved is set to the |
| ** page number that used to be the last root page in the file before |
| ** the move. If no page gets moved, *piMoved is set to 0. |
| ** The last root page is recorded in meta[3] and the value of |
| ** meta[3] is updated by this procedure. |
| */ |
| static int btreeDropTable(Btree *p, Pgno iTable, int *piMoved){ |
| int rc; |
| MemPage *pPage = 0; |
| BtShared *pBt = p->pBt; |
| |
| assert( sqlite3BtreeHoldsMutex(p) ); |
| assert( p->inTrans==TRANS_WRITE ); |
| |
| /* It is illegal to drop a table if any cursors are open on the |
| ** database. This is because in auto-vacuum mode the backend may |
| ** need to move another root-page to fill a gap left by the deleted |
| ** root page. If an open cursor was using this page a problem would |
| ** occur. |
| ** |
| ** This error is caught long before control reaches this point. |
| */ |
| if( NEVER(pBt->pCursor) ){ |
| sqlite3ConnectionBlocked(p->db, pBt->pCursor->pBtree->db); |
| return SQLITE_LOCKED_SHAREDCACHE; |
| } |
| |
| rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0); |
| if( rc ) return rc; |
| rc = sqlite3BtreeClearTable(p, iTable, 0); |
| if( rc ){ |
| releasePage(pPage); |
| return rc; |
| } |
| |
| *piMoved = 0; |
| |
| if( iTable>1 ){ |
| #ifdef SQLITE_OMIT_AUTOVACUUM |
| freePage(pPage, &rc); |
| releasePage(pPage); |
| #else |
| if( pBt->autoVacuum ){ |
| Pgno maxRootPgno; |
| sqlite3BtreeGetMeta(p, BTREE_LARGEST_ROOT_PAGE, &maxRootPgno); |
| |
| if( iTable==maxRootPgno ){ |
| /* If the table being dropped is the table with the largest root-page |
| ** number in the database, put the root page on the free list. |
| */ |
| freePage(pPage, &rc); |
| releasePage(pPage); |
| if( rc!=SQLITE_OK ){ |
| return rc; |
| } |
| }else{ |
| /* The table being dropped does not have the largest root-page |
| ** number in the database. So move the page that does into the |
| ** gap left by the deleted root-page. |
| */ |
| MemPage *pMove; |
| releasePage(pPage); |
| rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0); |
| if( rc!=SQLITE_OK ){ |
| return rc; |
| } |
| rc = relocatePage(pBt, pMove, PTRMAP_ROOTPAGE, 0, iTable, 0); |
| releasePage(pMove); |
| if( rc!=SQLITE_OK ){ |
| return rc; |
| } |
| pMove = 0; |
| rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0); |
| freePage(pMove, &rc); |
| releasePage(pMove); |
| if( rc!=SQLITE_OK ){ |
| return rc; |
| } |
| *piMoved = maxRootPgno; |
| } |
| |
| /* Set the new 'max-root-page' value in the database header. This |
| ** is the old value less one, less one more if that happens to |
| ** be a root-page number, less one again if that is the |
| ** PENDING_BYTE_PAGE. |
| */ |
| maxRootPgno--; |
| while( maxRootPgno==PENDING_BYTE_PAGE(pBt) |
| || PTRMAP_ISPAGE(pBt, maxRootPgno) ){ |
| maxRootPgno--; |
| } |
| assert( maxRootPgno!=PENDING_BYTE_PAGE(pBt) ); |
| |
| rc = sqlite3BtreeUpdateMeta(p, 4, maxRootPgno); |
| }else{ |
| freePage(pPage, &rc); |
| releasePage(pPage); |
| } |
| #endif |
| }else{ |
| /* If sqlite3BtreeDropTable was called on page 1. |
| ** This really never should happen except in a corrupt |
| ** database. |
| */ |
| zeroPage(pPage, PTF_INTKEY|PTF_LEAF ); |
| releasePage(pPage); |
| } |
| return rc; |
| } |
| int sqlite3BtreeDropTable(Btree *p, int iTable, int *piMoved){ |
| int rc; |
| sqlite3BtreeEnter(p); |
| rc = btreeDropTable(p, iTable, piMoved); |
| sqlite3BtreeLeave(p); |
| return rc; |
| } |
| |
| |
| /* |
| ** This function may only be called if the b-tree connection already |
| ** has a read or write transaction open on the database. |
| ** |
| ** Read the meta-information out of a database file. Meta[0] |
| ** is the number of free pages currently in the database. Meta[1] |
| ** through meta[15] are available for use by higher layers. Meta[0] |
| ** is read-only, the others are read/write. |
| ** |
| ** The schema layer numbers meta values differently. At the schema |
| ** layer (and the SetCookie and ReadCookie opcodes) the number of |
| ** free pages is not visible. So Cookie[0] is the same as Meta[1]. |
| */ |
| void sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){ |
| BtShared *pBt = p->pBt; |
| |
| sqlite3BtreeEnter(p); |
| assert( p->inTrans>TRANS_NONE ); |
| assert( SQLITE_OK==querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK) ); |
| assert( pBt->pPage1 ); |
| assert( idx>=0 && idx<=15 ); |
| |
| *pMeta = get4byte(&pBt->pPage1->aData[36 + idx*4]); |
| |
| /* If auto-vacuum is disabled in this build and this is an auto-vacuum |
| ** database, mark the database as read-only. */ |
| #ifdef SQLITE_OMIT_AUTOVACUUM |
| if( idx==BTREE_LARGEST_ROOT_PAGE && *pMeta>0 ) pBt->readOnly = 1; |
| #endif |
| |
| sqlite3BtreeLeave(p); |
| } |
| |
| /* |
| ** Write meta-information back into the database. Meta[0] is |
| ** read-only and may not be written. |
| */ |
| int sqlite3BtreeUpdateMeta(Btree *p, int idx, u32 iMeta){ |
| BtShared *pBt = p->pBt; |
| unsigned char *pP1; |
| int rc; |
| assert( idx>=1 && idx<=15 ); |
| sqlite3BtreeEnter(p); |
| assert( p->inTrans==TRANS_WRITE ); |
| assert( pBt->pPage1!=0 ); |
| pP1 = pBt->pPage1->aData; |
| rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); |
| if( rc==SQLITE_OK ){ |
| put4byte(&pP1[36 + idx*4], iMeta); |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| if( idx==BTREE_INCR_VACUUM ){ |
| assert( pBt->autoVacuum || iMeta==0 ); |
| assert( iMeta==0 || iMeta==1 ); |
| pBt->incrVacuum = (u8)iMeta; |
| } |
| #endif |
| } |
| sqlite3BtreeLeave(p); |
| return rc; |
| } |
| |
| #ifndef SQLITE_OMIT_BTREECOUNT |
| /* |
| ** The first argument, pCur, is a cursor opened on some b-tree. Count the |
| ** number of entries in the b-tree and write the result to *pnEntry. |
| ** |
| ** SQLITE_OK is returned if the operation is successfully executed. |
| ** Otherwise, if an error is encountered (i.e. an IO error or database |
| ** corruption) an SQLite error code is returned. |
| */ |
| int sqlite3BtreeCount(BtCursor *pCur, i64 *pnEntry){ |
| i64 nEntry = 0; /* Value to return in *pnEntry */ |
| int rc; /* Return code */ |
| rc = moveToRoot(pCur); |
| |
| /* Unless an error occurs, the following loop runs one iteration for each |
| ** page in the B-Tree structure (not including overflow pages). |
| */ |
| while( rc==SQLITE_OK ){ |
| int iIdx; /* Index of child node in parent */ |
| MemPage *pPage; /* Current page of the b-tree */ |
| |
| /* If this is a leaf page or the tree is not an int-key tree, then |
| ** this page contains countable entries. Increment the entry counter |
| ** accordingly. |
| */ |
| pPage = pCur->apPage[pCur->iPage]; |
| if( pPage->leaf || !pPage->intKey ){ |
| nEntry += pPage->nCell; |
| } |
| |
| /* pPage is a leaf node. This loop navigates the cursor so that it |
| ** points to the first interior cell that it points to the parent of |
| ** the next page in the tree that has not yet been visited. The |
| ** pCur->aiIdx[pCur->iPage] value is set to the index of the parent cell |
| ** of the page, or to the number of cells in the page if the next page |
| ** to visit is the right-child of its parent. |
| ** |
| ** If all pages in the tree have been visited, return SQLITE_OK to the |
| ** caller. |
| */ |
| if( pPage->leaf ){ |
| do { |
| if( pCur->iPage==0 ){ |
| /* All pages of the b-tree have been visited. Return successfully. */ |
| *pnEntry = nEntry; |
| return SQLITE_OK; |
| } |
| moveToParent(pCur); |
| }while ( pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell ); |
| |
| pCur->aiIdx[pCur->iPage]++; |
| pPage = pCur->apPage[pCur->iPage]; |
| } |
| |
| /* Descend to the child node of the cell that the cursor currently |
| ** points at. This is the right-child if (iIdx==pPage->nCell). |
| */ |
| iIdx = pCur->aiIdx[pCur->iPage]; |
| if( iIdx==pPage->nCell ){ |
| rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8])); |
| }else{ |
| rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx))); |
| } |
| } |
| |
| /* An error has occurred. Return an error code. */ |
| return rc; |
| } |
| #endif |
| |
| /* |
| ** Return the pager associated with a BTree. This routine is used for |
| ** testing and debugging only. |
| */ |
| Pager *sqlite3BtreePager(Btree *p){ |
| return p->pBt->pPager; |
| } |
| |
| #ifndef SQLITE_OMIT_INTEGRITY_CHECK |
| /* |
| ** Append a message to the error message string. |
| */ |
| static void checkAppendMsg( |
| IntegrityCk *pCheck, |
| char *zMsg1, |
| const char *zFormat, |
| ... |
| ){ |
| va_list ap; |
| if( !pCheck->mxErr ) return; |
| pCheck->mxErr--; |
| pCheck->nErr++; |
| va_start(ap, zFormat); |
| if( pCheck->errMsg.nChar ){ |
| sqlite3StrAccumAppend(&pCheck->errMsg, "\n", 1); |
| } |
| if( zMsg1 ){ |
| sqlite3StrAccumAppend(&pCheck->errMsg, zMsg1, -1); |
| } |
| sqlite3VXPrintf(&pCheck->errMsg, 1, zFormat, ap); |
| va_end(ap); |
| if( pCheck->errMsg.mallocFailed ){ |
| pCheck->mallocFailed = 1; |
| } |
| } |
| #endif /* SQLITE_OMIT_INTEGRITY_CHECK */ |
| |
| #ifndef SQLITE_OMIT_INTEGRITY_CHECK |
| /* |
| ** Add 1 to the reference count for page iPage. If this is the second |
| ** reference to the page, add an error message to pCheck->zErrMsg. |
| ** Return 1 if there are 2 ore more references to the page and 0 if |
| ** if this is the first reference to the page. |
| ** |
| ** Also check that the page number is in bounds. |
| */ |
| static int checkRef(IntegrityCk *pCheck, Pgno iPage, char *zContext){ |
| if( iPage==0 ) return 1; |
| if( iPage>pCheck->nPage ){ |
| checkAppendMsg(pCheck, zContext, "invalid page number %d", iPage); |
| return 1; |
| } |
| if( pCheck->anRef[iPage]==1 ){ |
| checkAppendMsg(pCheck, zContext, "2nd reference to page %d", iPage); |
| return 1; |
| } |
| return (pCheck->anRef[iPage]++)>1; |
| } |
| |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| /* |
| ** Check that the entry in the pointer-map for page iChild maps to |
| ** page iParent, pointer type ptrType. If not, append an error message |
| ** to pCheck. |
| */ |
| static void checkPtrmap( |
| IntegrityCk *pCheck, /* Integrity check context */ |
| Pgno iChild, /* Child page number */ |
| u8 eType, /* Expected pointer map type */ |
| Pgno iParent, /* Expected pointer map parent page number */ |
| char *zContext /* Context description (used for error msg) */ |
| ){ |
| int rc; |
| u8 ePtrmapType; |
| Pgno iPtrmapParent; |
| |
| rc = ptrmapGet(pCheck->pBt, iChild, &ePtrmapType, &iPtrmapParent); |
| if( rc!=SQLITE_OK ){ |
| if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ) pCheck->mallocFailed = 1; |
| checkAppendMsg(pCheck, zContext, "Failed to read ptrmap key=%d", iChild); |
| return; |
| } |
| |
| if( ePtrmapType!=eType || iPtrmapParent!=iParent ){ |
| checkAppendMsg(pCheck, zContext, |
| "Bad ptr map entry key=%d expected=(%d,%d) got=(%d,%d)", |
| iChild, eType, iParent, ePtrmapType, iPtrmapParent); |
| } |
| } |
| #endif |
| |
| /* |
| ** Check the integrity of the freelist or of an overflow page list. |
| ** Verify that the number of pages on the list is N. |
| */ |
| static void checkList( |
| IntegrityCk *pCheck, /* Integrity checking context */ |
| int isFreeList, /* True for a freelist. False for overflow page list */ |
| int iPage, /* Page number for first page in the list */ |
| int N, /* Expected number of pages in the list */ |
| char *zContext /* Context for error messages */ |
| ){ |
| int i; |
| int expected = N; |
| int iFirst = iPage; |
| while( N-- > 0 && pCheck->mxErr ){ |
| DbPage *pOvflPage; |
| unsigned char *pOvflData; |
| if( iPage<1 ){ |
| checkAppendMsg(pCheck, zContext, |
| "%d of %d pages missing from overflow list starting at %d", |
| N+1, expected, iFirst); |
| break; |
| } |
| if( checkRef(pCheck, iPage, zContext) ) break; |
| if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage) ){ |
| checkAppendMsg(pCheck, zContext, "failed to get page %d", iPage); |
| break; |
| } |
| pOvflData = (unsigned char *)sqlite3PagerGetData(pOvflPage); |
| if( isFreeList ){ |
| int n = get4byte(&pOvflData[4]); |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| if( pCheck->pBt->autoVacuum ){ |
| checkPtrmap(pCheck, iPage, PTRMAP_FREEPAGE, 0, zContext); |
| } |
| #endif |
| if( n>(int)pCheck->pBt->usableSize/4-2 ){ |
| checkAppendMsg(pCheck, zContext, |
| "freelist leaf count too big on page %d", iPage); |
| N--; |
| }else{ |
| for(i=0; i<n; i++){ |
| Pgno iFreePage = get4byte(&pOvflData[8+i*4]); |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| if( pCheck->pBt->autoVacuum ){ |
| checkPtrmap(pCheck, iFreePage, PTRMAP_FREEPAGE, 0, zContext); |
| } |
| #endif |
| checkRef(pCheck, iFreePage, zContext); |
| } |
| N -= n; |
| } |
| } |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| else{ |
| /* If this database supports auto-vacuum and iPage is not the last |
| ** page in this overflow list, check that the pointer-map entry for |
| ** the following page matches iPage. |
| */ |
| if( pCheck->pBt->autoVacuum && N>0 ){ |
| i = get4byte(pOvflData); |
| checkPtrmap(pCheck, i, PTRMAP_OVERFLOW2, iPage, zContext); |
| } |
| } |
| #endif |
| iPage = get4byte(pOvflData); |
| sqlite3PagerUnref(pOvflPage); |
| } |
| } |
| #endif /* SQLITE_OMIT_INTEGRITY_CHECK */ |
| |
| #ifndef SQLITE_OMIT_INTEGRITY_CHECK |
| /* |
| ** Do various sanity checks on a single page of a tree. Return |
| ** the tree depth. Root pages return 0. Parents of root pages |
| ** return 1, and so forth. |
| ** |
| ** These checks are done: |
| ** |
| ** 1. Make sure that cells and freeblocks do not overlap |
| ** but combine to completely cover the page. |
| ** NO 2. Make sure cell keys are in order. |
| ** NO 3. Make sure no key is less than or equal to zLowerBound. |
| ** NO 4. Make sure no key is greater than or equal to zUpperBound. |
| ** 5. Check the integrity of overflow pages. |
| ** 6. Recursively call checkTreePage on all children. |
| ** 7. Verify that the depth of all children is the same. |
| ** 8. Make sure this page is at least 33% full or else it is |
| ** the root of the tree. |
| */ |
| static int checkTreePage( |
| IntegrityCk *pCheck, /* Context for the sanity check */ |
| int iPage, /* Page number of the page to check */ |
| char *zParentContext, /* Parent context */ |
| i64 *pnParentMinKey, |
| i64 *pnParentMaxKey |
| ){ |
| MemPage *pPage; |
| int i, rc, depth, d2, pgno, cnt; |
| int hdr, cellStart; |
| int nCell; |
| u8 *data; |
| BtShared *pBt; |
| int usableSize; |
| char zContext[100]; |
| char *hit = 0; |
| i64 nMinKey = 0; |
| i64 nMaxKey = 0; |
| |
| sqlite3_snprintf(sizeof(zContext), zContext, "Page %d: ", iPage); |
| |
| /* Check that the page exists |
| */ |
| pBt = pCheck->pBt; |
| usableSize = pBt->usableSize; |
| if( iPage==0 ) return 0; |
| if( checkRef(pCheck, iPage, zParentContext) ) return 0; |
| if( (rc = btreeGetPage(pBt, (Pgno)iPage, &pPage, 0))!=0 ){ |
| checkAppendMsg(pCheck, zContext, |
| "unable to get the page. error code=%d", rc); |
| return 0; |
| } |
| |
| /* Clear MemPage.isInit to make sure the corruption detection code in |
| ** btreeInitPage() is executed. */ |
| pPage->isInit = 0; |
| if( (rc = btreeInitPage(pPage))!=0 ){ |
| assert( rc==SQLITE_CORRUPT ); /* The only possible error from InitPage */ |
| checkAppendMsg(pCheck, zContext, |
| "btreeInitPage() returns error code %d", rc); |
| releasePage(pPage); |
| return 0; |
| } |
| |
| /* Check out all the cells. |
| */ |
| depth = 0; |
| for(i=0; i<pPage->nCell && pCheck->mxErr; i++){ |
| u8 *pCell; |
| u32 sz; |
| CellInfo info; |
| |
| /* Check payload overflow pages |
| */ |
| sqlite3_snprintf(sizeof(zContext), zContext, |
| "On tree page %d cell %d: ", iPage, i); |
| pCell = findCell(pPage,i); |
| btreeParseCellPtr(pPage, pCell, &info); |
| sz = info.nData; |
| if( !pPage->intKey ) sz += (int)info.nKey; |
| /* For intKey pages, check that the keys are in order. |
| */ |
| else if( i==0 ) nMinKey = nMaxKey = info.nKey; |
| else{ |
| if( info.nKey <= nMaxKey ){ |
| checkAppendMsg(pCheck, zContext, |
| "Rowid %lld out of order (previous was %lld)", info.nKey, nMaxKey); |
| } |
| nMaxKey = info.nKey; |
| } |
| assert( sz==info.nPayload ); |
| if( (sz>info.nLocal) |
| && (&pCell[info.iOverflow]<=&pPage->aData[pBt->usableSize]) |
| ){ |
| int nPage = (sz - info.nLocal + usableSize - 5)/(usableSize - 4); |
| Pgno pgnoOvfl = get4byte(&pCell[info.iOverflow]); |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| if( pBt->autoVacuum ){ |
| checkPtrmap(pCheck, pgnoOvfl, PTRMAP_OVERFLOW1, iPage, zContext); |
| } |
| #endif |
| checkList(pCheck, 0, pgnoOvfl, nPage, zContext); |
| } |
| |
| /* Check sanity of left child page. |
| */ |
| if( !pPage->leaf ){ |
| pgno = get4byte(pCell); |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| if( pBt->autoVacuum ){ |
| checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, zContext); |
| } |
| #endif |
| d2 = checkTreePage(pCheck, pgno, zContext, &nMinKey, i==0 ? NULL : &nMaxKey); |
| if( i>0 && d2!=depth ){ |
| checkAppendMsg(pCheck, zContext, "Child page depth differs"); |
| } |
| depth = d2; |
| } |
| } |
| |
| if( !pPage->leaf ){ |
| pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]); |
| sqlite3_snprintf(sizeof(zContext), zContext, |
| "On page %d at right child: ", iPage); |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| if( pBt->autoVacuum ){ |
| checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, zContext); |
| } |
| #endif |
| checkTreePage(pCheck, pgno, zContext, NULL, !pPage->nCell ? NULL : &nMaxKey); |
| } |
| |
| /* For intKey leaf pages, check that the min/max keys are in order |
| ** with any left/parent/right pages. |
| */ |
| if( pPage->leaf && pPage->intKey ){ |
| /* if we are a left child page */ |
| if( pnParentMinKey ){ |
| /* if we are the left most child page */ |
| if( !pnParentMaxKey ){ |
| if( nMaxKey > *pnParentMinKey ){ |
| checkAppendMsg(pCheck, zContext, |
| "Rowid %lld out of order (max larger than parent min of %lld)", |
| nMaxKey, *pnParentMinKey); |
| } |
| }else{ |
| if( nMinKey <= *pnParentMinKey ){ |
| checkAppendMsg(pCheck, zContext, |
| "Rowid %lld out of order (min less than parent min of %lld)", |
| nMinKey, *pnParentMinKey); |
| } |
| if( nMaxKey > *pnParentMaxKey ){ |
| checkAppendMsg(pCheck, zContext, |
| "Rowid %lld out of order (max larger than parent max of %lld)", |
| nMaxKey, *pnParentMaxKey); |
| } |
| *pnParentMinKey = nMaxKey; |
| } |
| /* else if we're a right child page */ |
| } else if( pnParentMaxKey ){ |
| if( nMinKey <= *pnParentMaxKey ){ |
| checkAppendMsg(pCheck, zContext, |
| "Rowid %lld out of order (min less than parent max of %lld)", |
| nMinKey, *pnParentMaxKey); |
| } |
| } |
| } |
| |
| /* Check for complete coverage of the page |
| */ |
| data = pPage->aData; |
| hdr = pPage->hdrOffset; |
| hit = sqlite3PageMalloc( pBt->pageSize ); |
| if( hit==0 ){ |
| pCheck->mallocFailed = 1; |
| }else{ |
| int contentOffset = get2byteNotZero(&data[hdr+5]); |
| assert( contentOffset<=usableSize ); /* Enforced by btreeInitPage() */ |
| memset(hit+contentOffset, 0, usableSize-contentOffset); |
| memset(hit, 1, contentOffset); |
| nCell = get2byte(&data[hdr+3]); |
| cellStart = hdr + 12 - 4*pPage->leaf; |
| for(i=0; i<nCell; i++){ |
| int pc = get2byte(&data[cellStart+i*2]); |
| u32 size = 65536; |
| int j; |
| if( pc<=usableSize-4 ){ |
| size = cellSizePtr(pPage, &data[pc]); |
| } |
| if( (int)(pc+size-1)>=usableSize ){ |
| checkAppendMsg(pCheck, 0, |
| "Corruption detected in cell %d on page %d",i,iPage); |
| }else{ |
| for(j=pc+size-1; j>=pc; j--) hit[j]++; |
| } |
| } |
| i = get2byte(&data[hdr+1]); |
| while( i>0 ){ |
| int size, j; |
| assert( i<=usableSize-4 ); /* Enforced by btreeInitPage() */ |
| size = get2byte(&data[i+2]); |
| assert( i+size<=usableSize ); /* Enforced by btreeInitPage() */ |
| for(j=i+size-1; j>=i; j--) hit[j]++; |
| j = get2byte(&data[i]); |
| assert( j==0 || j>i+size ); /* Enforced by btreeInitPage() */ |
| assert( j<=usableSize-4 ); /* Enforced by btreeInitPage() */ |
| i = j; |
| } |
| for(i=cnt=0; i<usableSize; i++){ |
| if( hit[i]==0 ){ |
| cnt++; |
| }else if( hit[i]>1 ){ |
| checkAppendMsg(pCheck, 0, |
| "Multiple uses for byte %d of page %d", i, iPage); |
| break; |
| } |
| } |
| if( cnt!=data[hdr+7] ){ |
| checkAppendMsg(pCheck, 0, |
| "Fragmentation of %d bytes reported as %d on page %d", |
| cnt, data[hdr+7], iPage); |
| } |
| } |
| sqlite3PageFree(hit); |
| releasePage(pPage); |
| return depth+1; |
| } |
| #endif /* SQLITE_OMIT_INTEGRITY_CHECK */ |
| |
| #ifndef SQLITE_OMIT_INTEGRITY_CHECK |
| /* |
| ** This routine does a complete check of the given BTree file. aRoot[] is |
| ** an array of pages numbers were each page number is the root page of |
| ** a table. nRoot is the number of entries in aRoot. |
| ** |
| ** A read-only or read-write transaction must be opened before calling |
| ** this function. |
| ** |
| ** Write the number of error seen in *pnErr. Except for some memory |
| ** allocation errors, an error message held in memory obtained from |
| ** malloc is returned if *pnErr is non-zero. If *pnErr==0 then NULL is |
| ** returned. If a memory allocation error occurs, NULL is returned. |
| */ |
| char *sqlite3BtreeIntegrityCheck( |
| Btree *p, /* The btree to be checked */ |
| int *aRoot, /* An array of root pages numbers for individual trees */ |
| int nRoot, /* Number of entries in aRoot[] */ |
| int mxErr, /* Stop reporting errors after this many */ |
| int *pnErr /* Write number of errors seen to this variable */ |
| ){ |
| Pgno i; |
| int nRef; |
| IntegrityCk sCheck; |
| BtShared *pBt = p->pBt; |
| char zErr[100]; |
| |
| sqlite3BtreeEnter(p); |
| assert( p->inTrans>TRANS_NONE && pBt->inTransaction>TRANS_NONE ); |
| nRef = sqlite3PagerRefcount(pBt->pPager); |
| sCheck.pBt = pBt; |
| sCheck.pPager = pBt->pPager; |
| sCheck.nPage = btreePagecount(sCheck.pBt); |
| sCheck.mxErr = mxErr; |
| sCheck.nErr = 0; |
| sCheck.mallocFailed = 0; |
| *pnErr = 0; |
| if( sCheck.nPage==0 ){ |
| sqlite3BtreeLeave(p); |
| return 0; |
| } |
| sCheck.anRef = sqlite3Malloc( (sCheck.nPage+1)*sizeof(sCheck.anRef[0]) ); |
| if( !sCheck.anRef ){ |
| *pnErr = 1; |
| sqlite3BtreeLeave(p); |
| return 0; |
| } |
| for(i=0; i<=sCheck.nPage; i++){ sCheck.anRef[i] = 0; } |
| i = PENDING_BYTE_PAGE(pBt); |
| if( i<=sCheck.nPage ){ |
| sCheck.anRef[i] = 1; |
| } |
| sqlite3StrAccumInit(&sCheck.errMsg, zErr, sizeof(zErr), 20000); |
| sCheck.errMsg.useMalloc = 2; |
| |
| /* Check the integrity of the freelist |
| */ |
| checkList(&sCheck, 1, get4byte(&pBt->pPage1->aData[32]), |
| get4byte(&pBt->pPage1->aData[36]), "Main freelist: "); |
| |
| /* Check all the tables. |
| */ |
| for(i=0; (int)i<nRoot && sCheck.mxErr; i++){ |
| if( aRoot[i]==0 ) continue; |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| if( pBt->autoVacuum && aRoot[i]>1 ){ |
| checkPtrmap(&sCheck, aRoot[i], PTRMAP_ROOTPAGE, 0, 0); |
| } |
| #endif |
| checkTreePage(&sCheck, aRoot[i], "List of tree roots: ", NULL, NULL); |
| } |
| |
| /* Make sure every page in the file is referenced |
| */ |
| for(i=1; i<=sCheck.nPage && sCheck.mxErr; i++){ |
| #ifdef SQLITE_OMIT_AUTOVACUUM |
| if( sCheck.anRef[i]==0 ){ |
| checkAppendMsg(&sCheck, 0, "Page %d is never used", i); |
| } |
| #else |
| /* If the database supports auto-vacuum, make sure no tables contain |
| ** references to pointer-map pages. |
| */ |
| if( sCheck.anRef[i]==0 && |
| (PTRMAP_PAGENO(pBt, i)!=i || !pBt->autoVacuum) ){ |
| checkAppendMsg(&sCheck, 0, "Page %d is never used", i); |
| } |
| if( sCheck.anRef[i]!=0 && |
| (PTRMAP_PAGENO(pBt, i)==i && pBt->autoVacuum) ){ |
| checkAppendMsg(&sCheck, 0, "Pointer map page %d is referenced", i); |
| } |
| #endif |
| } |
| |
| /* Make sure this analysis did not leave any unref() pages. |
| ** This is an internal consistency check; an integrity check |
| ** of the integrity check. |
| */ |
| if( NEVER(nRef != sqlite3PagerRefcount(pBt->pPager)) ){ |
| checkAppendMsg(&sCheck, 0, |
| "Outstanding page count goes from %d to %d during this analysis", |
| nRef, sqlite3PagerRefcount(pBt->pPager) |
| ); |
| } |
| |
| /* Clean up and report errors. |
| */ |
| sqlite3BtreeLeave(p); |
| sqlite3_free(sCheck.anRef); |
| if( sCheck.mallocFailed ){ |
| sqlite3StrAccumReset(&sCheck.errMsg); |
| *pnErr = sCheck.nErr+1; |
| return 0; |
| } |
| *pnErr = sCheck.nErr; |
| if( sCheck.nErr==0 ) sqlite3StrAccumReset(&sCheck.errMsg); |
| return sqlite3StrAccumFinish(&sCheck.errMsg); |
| } |
| #endif /* SQLITE_OMIT_INTEGRITY_CHECK */ |
| |
| /* |
| ** Return the full pathname of the underlying database file. |
| ** |
| ** The pager filename is invariant as long as the pager is |
| ** open so it is safe to access without the BtShared mutex. |
| */ |
| const char *sqlite3BtreeGetFilename(Btree *p){ |
| assert( p->pBt->pPager!=0 ); |
| return sqlite3PagerFilename(p->pBt->pPager); |
| } |
| |
| /* |
| ** Return the pathname of the journal file for this database. The return |
| ** value of this routine is the same regardless of whether the journal file |
| ** has been created or not. |
| ** |
| ** The pager journal filename is invariant as long as the pager is |
| ** open so it is safe to access without the BtShared mutex. |
| */ |
| const char *sqlite3BtreeGetJournalname(Btree *p){ |
| assert( p->pBt->pPager!=0 ); |
| return sqlite3PagerJournalname(p->pBt->pPager); |
| } |
| |
| /* |
| ** Return non-zero if a transaction is active. |
| */ |
| int sqlite3BtreeIsInTrans(Btree *p){ |
| assert( p==0 || sqlite3_mutex_held(p->db->mutex) ); |
| return (p && (p->inTrans==TRANS_WRITE)); |
| } |
| |
| #ifndef SQLITE_OMIT_WAL |
| /* |
| ** Run a checkpoint on the Btree passed as the first argument. |
| ** |
| ** Return SQLITE_LOCKED if this or any other connection has an open |
| ** transaction on the shared-cache the argument Btree is connected to. |
| ** |
| ** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART. |
| */ |
| int sqlite3BtreeCheckpoint(Btree *p, int eMode, int *pnLog, int *pnCkpt){ |
| int rc = SQLITE_OK; |
| if( p ){ |
| BtShared *pBt = p->pBt; |
| sqlite3BtreeEnter(p); |
| if( pBt->inTransaction!=TRANS_NONE ){ |
| rc = SQLITE_LOCKED; |
| }else{ |
| rc = sqlite3PagerCheckpoint(pBt->pPager, eMode, pnLog, pnCkpt); |
| } |
| sqlite3BtreeLeave(p); |
| } |
| return rc; |
| } |
| #endif |
| |
| /* |
| ** Return non-zero if a read (or write) transaction is active. |
| */ |
| int sqlite3BtreeIsInReadTrans(Btree *p){ |
| assert( p ); |
| assert( sqlite3_mutex_held(p->db->mutex) ); |
| return p->inTrans!=TRANS_NONE; |
| } |
| |
| int sqlite3BtreeIsInBackup(Btree *p){ |
| assert( p ); |
| assert( sqlite3_mutex_held(p->db->mutex) ); |
| return p->nBackup!=0; |
| } |
| |
| /* |
| ** This function returns a pointer to a blob of memory associated with |
| ** a single shared-btree. The memory is used by client code for its own |
| ** purposes (for example, to store a high-level schema associated with |
| ** the shared-btree). The btree layer manages reference counting issues. |
| ** |
| ** The first time this is called on a shared-btree, nBytes bytes of memory |
| ** are allocated, zeroed, and returned to the caller. For each subsequent |
| ** call the nBytes parameter is ignored and a pointer to the same blob |
| ** of memory returned. |
| ** |
| ** If the nBytes parameter is 0 and the blob of memory has not yet been |
| ** allocated, a null pointer is returned. If the blob has already been |
| ** allocated, it is returned as normal. |
| ** |
| ** Just before the shared-btree is closed, the function passed as the |
| ** xFree argument when the memory allocation was made is invoked on the |
| ** blob of allocated memory. The xFree function should not call sqlite3_free() |
| ** on the memory, the btree layer does that. |
| */ |
| void *sqlite3BtreeSchema(Btree *p, int nBytes, void(*xFree)(void *)){ |
| BtShared *pBt = p->pBt; |
| sqlite3BtreeEnter(p); |
| if( !pBt->pSchema && nBytes ){ |
| pBt->pSchema = sqlite3DbMallocZero(0, nBytes); |
| pBt->xFreeSchema = xFree; |
| } |
| sqlite3BtreeLeave(p); |
| return pBt->pSchema; |
| } |
| |
| /* |
| ** Return SQLITE_LOCKED_SHAREDCACHE if another user of the same shared |
| ** btree as the argument handle holds an exclusive lock on the |
| ** sqlite_master table. Otherwise SQLITE_OK. |
| */ |
| int sqlite3BtreeSchemaLocked(Btree *p){ |
| int rc; |
| assert( sqlite3_mutex_held(p->db->mutex) ); |
| sqlite3BtreeEnter(p); |
| rc = querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK); |
| assert( rc==SQLITE_OK || rc==SQLITE_LOCKED_SHAREDCACHE ); |
| sqlite3BtreeLeave(p); |
| return rc; |
| } |
| |
| |
| #ifndef SQLITE_OMIT_SHARED_CACHE |
| /* |
| ** Obtain a lock on the table whose root page is iTab. The |
| ** lock is a write lock if isWritelock is true or a read lock |
| ** if it is false. |
| */ |
| int sqlite3BtreeLockTable(Btree *p, int iTab, u8 isWriteLock){ |
| int rc = SQLITE_OK; |
| assert( p->inTrans!=TRANS_NONE ); |
| if( p->sharable ){ |
| u8 lockType = READ_LOCK + isWriteLock; |
| assert( READ_LOCK+1==WRITE_LOCK ); |
| assert( isWriteLock==0 || isWriteLock==1 ); |
| |
| sqlite3BtreeEnter(p); |
| rc = querySharedCacheTableLock(p, iTab, lockType); |
| if( rc==SQLITE_OK ){ |
| rc = setSharedCacheTableLock(p, iTab, lockType); |
| } |
| sqlite3BtreeLeave(p); |
| } |
| return rc; |
| } |
| #endif |
| |
| #ifndef SQLITE_OMIT_INCRBLOB |
| /* |
| ** Argument pCsr must be a cursor opened for writing on an |
| ** INTKEY table currently pointing at a valid table entry. |
| ** This function modifies the data stored as part of that entry. |
| ** |
| ** Only the data content may only be modified, it is not possible to |
| ** change the length of the data stored. If this function is called with |
| ** parameters that attempt to write past the end of the existing data, |
| ** no modifications are made and SQLITE_CORRUPT is returned. |
| */ |
| int sqlite3BtreePutData(BtCursor *pCsr, u32 offset, u32 amt, void *z){ |
| int rc; |
| assert( cursorHoldsMutex(pCsr) ); |
| assert( sqlite3_mutex_held(pCsr->pBtree->db->mutex) ); |
| assert( pCsr->isIncrblobHandle ); |
| |
| rc = restoreCursorPosition(pCsr); |
| if( rc!=SQLITE_OK ){ |
| return rc; |
| } |
| assert( pCsr->eState!=CURSOR_REQUIRESEEK ); |
| if( pCsr->eState!=CURSOR_VALID ){ |
| return SQLITE_ABORT; |
| } |
| |
| /* Check some assumptions: |
| ** (a) the cursor is open for writing, |
| ** (b) there is a read/write transaction open, |
| ** (c) the connection holds a write-lock on the table (if required), |
| ** (d) there are no conflicting read-locks, and |
| ** (e) the cursor points at a valid row of an intKey table. |
| */ |
| if( !pCsr->wrFlag ){ |
| return SQLITE_READONLY; |
| } |
| assert( !pCsr->pBt->readOnly && pCsr->pBt->inTransaction==TRANS_WRITE ); |
| assert( hasSharedCacheTableLock(pCsr->pBtree, pCsr->pgnoRoot, 0, 2) ); |
| assert( !hasReadConflicts(pCsr->pBtree, pCsr->pgnoRoot) ); |
| assert( pCsr->apPage[pCsr->iPage]->intKey ); |
| |
| return accessPayload(pCsr, offset, amt, (unsigned char *)z, 1); |
| } |
| |
| /* |
| ** Set a flag on this cursor to cache the locations of pages from the |
| ** overflow list for the current row. This is used by cursors opened |
| ** for incremental blob IO only. |
| ** |
| ** This function sets a flag only. The actual page location cache |
| ** (stored in BtCursor.aOverflow[]) is allocated and used by function |
| ** accessPayload() (the worker function for sqlite3BtreeData() and |
| ** sqlite3BtreePutData()). |
| */ |
| void sqlite3BtreeCacheOverflow(BtCursor *pCur){ |
| assert( cursorHoldsMutex(pCur) ); |
| assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); |
| invalidateOverflowCache(pCur); |
| pCur->isIncrblobHandle = 1; |
| } |
| #endif |
| |
| /* |
| ** Set both the "read version" (single byte at byte offset 18) and |
| ** "write version" (single byte at byte offset 19) fields in the database |
| ** header to iVersion. |
| */ |
| int sqlite3BtreeSetVersion(Btree *pBtree, int iVersion){ |
| BtShared *pBt = pBtree->pBt; |
| int rc; /* Return code */ |
| |
| assert( pBtree->inTrans==TRANS_NONE ); |
| 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 = (u8)(iVersion==1); |
| |
| rc = sqlite3BtreeBeginTrans(pBtree, 0); |
| if( rc==SQLITE_OK ){ |
| u8 *aData = pBt->pPage1->aData; |
| if( aData[18]!=(u8)iVersion || aData[19]!=(u8)iVersion ){ |
| rc = sqlite3BtreeBeginTrans(pBtree, 2); |
| if( rc==SQLITE_OK ){ |
| rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); |
| if( rc==SQLITE_OK ){ |
| aData[18] = (u8)iVersion; |
| aData[19] = (u8)iVersion; |
| } |
| } |
| } |
| } |
| |
| pBt->doNotUseWAL = 0; |
| return rc; |
| } |