Index: third_party/sqlite/sqlite-src-3170000/src/btree.c |
diff --git a/third_party/sqlite/sqlite-src-3170000/src/btree.c b/third_party/sqlite/sqlite-src-3170000/src/btree.c |
new file mode 100644 |
index 0000000000000000000000000000000000000000..de553423b8847ff23b58c2ce3ec8218314c7a2e8 |
--- /dev/null |
+++ b/third_party/sqlite/sqlite-src-3170000/src/btree.c |
@@ -0,0 +1,9767 @@ |
+/* |
+** 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 an 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) |
+ |
+/* |
+** Values passed as the 5th argument to allocateBtreePage() |
+*/ |
+#define BTALLOC_ANY 0 /* Allocate any page */ |
+#define BTALLOC_EXACT 1 /* Allocate exact page if possible */ |
+#define BTALLOC_LE 2 /* Allocate any page <= the parameter */ |
+ |
+/* |
+** Macro IfNotOmitAV(x) returns (x) if SQLITE_OMIT_AUTOVACUUM is not |
+** defined, or 0 if it is. For example: |
+** |
+** bIncrVacuum = IfNotOmitAV(pBtShared->incrVacuum); |
+*/ |
+#ifndef SQLITE_OMIT_AUTOVACUUM |
+#define IfNotOmitAV(expr) (expr) |
+#else |
+#define IfNotOmitAV(expr) 0 |
+#endif |
+ |
+#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->schemaFlags&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 ){ |
+ if( iTab ){ |
+ /* Two or more indexes share the same root page. There must |
+ ** be imposter tables. So just return true. The assert is not |
+ ** useful in that case. */ |
+ return 1; |
+ } |
+ 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->btsFlags & BTS_EXCLUSIVE)!=0 ){ |
+ 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->btsFlags |= BTS_PENDING; |
+ } |
+ 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_BKPT; |
+ } |
+ 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 BTS_PENDING flag |
+** 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->btsFlags & BTS_EXCLUSIVE)==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->btsFlags & BTS_PENDING)==0 || pBt->pWriter ); |
+ if( pBt->pWriter==p ){ |
+ pBt->pWriter = 0; |
+ pBt->btsFlags &= ~(BTS_EXCLUSIVE|BTS_PENDING); |
+ }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 BTS_PENDING flag to 0. |
+ ** |
+ ** If there is not currently a writer, then BTS_PENDING must |
+ ** be zero already. So this next line is harmless in that case. |
+ */ |
+ pBt->btsFlags &= ~BTS_PENDING; |
+ } |
+} |
+ |
+/* |
+** 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->btsFlags &= ~(BTS_EXCLUSIVE|BTS_PENDING); |
+ 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); |
+} |
+ |
+/* Verify that the cursor and the BtShared agree about what is the current |
+** database connetion. This is important in shared-cache mode. If the database |
+** connection pointers get out-of-sync, it is possible for routines like |
+** btreeInitPage() to reference an stale connection pointer that references a |
+** a connection that has already closed. This routine is used inside assert() |
+** statements only and for the purpose of double-checking that the btree code |
+** does keep the database connection pointers up-to-date. |
+*/ |
+static int cursorOwnsBtShared(BtCursor *p){ |
+ assert( cursorHoldsMutex(p) ); |
+ return (p->pBtree->db==p->pBt->db); |
+} |
+#endif |
+ |
+/* |
+** Invalidate the overflow cache of the cursor passed as the first argument. |
+** on the shared btree structure pBt. |
+*/ |
+#define invalidateOverflowCache(pCur) (pCur->curFlags &= ~BTCF_ValidOvfl) |
+ |
+/* |
+** 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); |
+ } |
+} |
+ |
+#ifndef SQLITE_OMIT_INCRBLOB |
+/* |
+** 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; |
+ if( pBtree->hasIncrblobCur==0 ) return; |
+ assert( sqlite3BtreeHoldsMutex(pBtree) ); |
+ pBtree->hasIncrblobCur = 0; |
+ for(p=pBtree->pBt->pCursor; p; p=p->pNext){ |
+ if( (p->curFlags & BTCF_Incrblob)!=0 ){ |
+ pBtree->hasIncrblobCur = 1; |
+ if( isClearTable || p->info.nKey==iRow ){ |
+ p->eState = CURSOR_INVALID; |
+ } |
+ } |
+ } |
+} |
+ |
+#else |
+ /* Stub function when INCRBLOB is omitted */ |
+ #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_BKPT; |
+ } |
+ } |
+ 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; |
+} |
+ |
+/* |
+** Release all of the apPage[] pages for a cursor. |
+*/ |
+static void btreeReleaseAllCursorPages(BtCursor *pCur){ |
+ int i; |
+ for(i=0; i<=pCur->iPage; i++){ |
+ releasePage(pCur->apPage[i]); |
+ pCur->apPage[i] = 0; |
+ } |
+ pCur->iPage = -1; |
+} |
+ |
+/* |
+** The cursor passed as the only argument must point to a valid entry |
+** when this function is called (i.e. have eState==CURSOR_VALID). This |
+** function saves the current cursor key in variables pCur->nKey and |
+** pCur->pKey. SQLITE_OK is returned if successful or an SQLite error |
+** code otherwise. |
+** |
+** If the cursor is open on an intkey table, then the integer key |
+** (the rowid) is stored in pCur->nKey and pCur->pKey is left set to |
+** NULL. If the cursor is open on a non-intkey table, then pCur->pKey is |
+** set to point to a malloced buffer pCur->nKey bytes in size containing |
+** the key. |
+*/ |
+static int saveCursorKey(BtCursor *pCur){ |
+ int rc = SQLITE_OK; |
+ assert( CURSOR_VALID==pCur->eState ); |
+ assert( 0==pCur->pKey ); |
+ assert( cursorHoldsMutex(pCur) ); |
+ |
+ if( pCur->curIntKey ){ |
+ /* Only the rowid is required for a table btree */ |
+ pCur->nKey = sqlite3BtreeIntegerKey(pCur); |
+ }else{ |
+ /* For an index btree, save the complete key content */ |
+ void *pKey; |
+ pCur->nKey = sqlite3BtreePayloadSize(pCur); |
+ pKey = sqlite3Malloc( pCur->nKey ); |
+ if( pKey ){ |
+ rc = sqlite3BtreePayload(pCur, 0, (int)pCur->nKey, pKey); |
+ if( rc==SQLITE_OK ){ |
+ pCur->pKey = pKey; |
+ }else{ |
+ sqlite3_free(pKey); |
+ } |
+ }else{ |
+ rc = SQLITE_NOMEM_BKPT; |
+ } |
+ } |
+ assert( !pCur->curIntKey || !pCur->pKey ); |
+ return rc; |
+} |
+ |
+/* |
+** 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 || CURSOR_SKIPNEXT==pCur->eState ); |
+ assert( 0==pCur->pKey ); |
+ assert( cursorHoldsMutex(pCur) ); |
+ |
+ if( pCur->eState==CURSOR_SKIPNEXT ){ |
+ pCur->eState = CURSOR_VALID; |
+ }else{ |
+ pCur->skipNext = 0; |
+ } |
+ |
+ rc = saveCursorKey(pCur); |
+ if( rc==SQLITE_OK ){ |
+ btreeReleaseAllCursorPages(pCur); |
+ pCur->eState = CURSOR_REQUIRESEEK; |
+ } |
+ |
+ pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl|BTCF_AtLast); |
+ return rc; |
+} |
+ |
+/* Forward reference */ |
+static int SQLITE_NOINLINE saveCursorsOnList(BtCursor*,Pgno,BtCursor*); |
+ |
+/* |
+** Save the positions of all cursors (except pExcept) that are open on |
+** the table with root-page iRoot. "Saving the cursor position" means that |
+** the location in the btree is remembered in such a way that it can be |
+** moved back to the same spot after the btree has been modified. This |
+** routine is called just before cursor pExcept is used to modify the |
+** table, for example in BtreeDelete() or BtreeInsert(). |
+** |
+** If there are two or more cursors on the same btree, then all such |
+** cursors should have their BTCF_Multiple flag set. The btreeCursor() |
+** routine enforces that rule. This routine only needs to be called in |
+** the uncommon case when pExpect has the BTCF_Multiple flag set. |
+** |
+** If pExpect!=NULL and if no other cursors are found on the same root-page, |
+** then the BTCF_Multiple flag on pExpect is cleared, to avoid another |
+** pointless call to this routine. |
+** |
+** Implementation note: This routine merely checks to see if any cursors |
+** need to be saved. It calls out to saveCursorsOnList() in the (unusual) |
+** event that cursors are in need to being saved. |
+*/ |
+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) ) break; |
+ } |
+ if( p ) return saveCursorsOnList(p, iRoot, pExcept); |
+ if( pExcept ) pExcept->curFlags &= ~BTCF_Multiple; |
+ return SQLITE_OK; |
+} |
+ |
+/* This helper routine to saveAllCursors does the actual work of saving |
+** the cursors if and when a cursor is found that actually requires saving. |
+** The common case is that no cursors need to be saved, so this routine is |
+** broken out from its caller to avoid unnecessary stack pointer movement. |
+*/ |
+static int SQLITE_NOINLINE saveCursorsOnList( |
+ BtCursor *p, /* The first cursor that needs saving */ |
+ Pgno iRoot, /* Only save cursor with this iRoot. Save all if zero */ |
+ BtCursor *pExcept /* Do not save this cursor */ |
+){ |
+ do{ |
+ if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) ){ |
+ if( p->eState==CURSOR_VALID || p->eState==CURSOR_SKIPNEXT ){ |
+ int rc = saveCursorPosition(p); |
+ if( SQLITE_OK!=rc ){ |
+ return rc; |
+ } |
+ }else{ |
+ testcase( p->iPage>0 ); |
+ btreeReleaseAllCursorPages(p); |
+ } |
+ } |
+ p = p->pNext; |
+ }while( p ); |
+ 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 */ |
+ |
+ if( pKey ){ |
+ assert( nKey==(i64)(int)nKey ); |
+ pIdxKey = sqlite3VdbeAllocUnpackedRecord(pCur->pKeyInfo); |
+ if( pIdxKey==0 ) return SQLITE_NOMEM_BKPT; |
+ sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey, pIdxKey); |
+ if( pIdxKey->nField==0 ){ |
+ rc = SQLITE_CORRUPT_BKPT; |
+ goto moveto_done; |
+ } |
+ }else{ |
+ pIdxKey = 0; |
+ } |
+ rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes); |
+moveto_done: |
+ if( pIdxKey ){ |
+ sqlite3DbFree(pCur->pKeyInfo->db, 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; |
+ int skipNext; |
+ assert( cursorOwnsBtShared(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, &skipNext); |
+ if( rc==SQLITE_OK ){ |
+ sqlite3_free(pCur->pKey); |
+ pCur->pKey = 0; |
+ assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID ); |
+ pCur->skipNext |= skipNext; |
+ if( pCur->skipNext && pCur->eState==CURSOR_VALID ){ |
+ pCur->eState = CURSOR_SKIPNEXT; |
+ } |
+ } |
+ return rc; |
+} |
+ |
+#define restoreCursorPosition(p) \ |
+ (p->eState>=CURSOR_REQUIRESEEK ? \ |
+ btreeRestoreCursorPosition(p) : \ |
+ SQLITE_OK) |
+ |
+/* |
+** Determine whether or not a cursor has moved from the position where |
+** it was last placed, or has been invalidated for any other reason. |
+** Cursors can move when the row they are pointing at is deleted out |
+** from under them, for example. Cursor might also move if a btree |
+** is rebalanced. |
+** |
+** Calling this routine with a NULL cursor pointer returns false. |
+** |
+** Use the separate sqlite3BtreeCursorRestore() routine to restore a cursor |
+** back to where it ought to be if this routine returns true. |
+*/ |
+int sqlite3BtreeCursorHasMoved(BtCursor *pCur){ |
+ return pCur->eState!=CURSOR_VALID; |
+} |
+ |
+/* |
+** This routine restores a cursor back to its original position after it |
+** has been moved by some outside activity (such as a btree rebalance or |
+** a row having been deleted out from under the cursor). |
+** |
+** On success, the *pDifferentRow parameter is false if the cursor is left |
+** pointing at exactly the same row. *pDifferntRow is the row the cursor |
+** was pointing to has been deleted, forcing the cursor to point to some |
+** nearby row. |
+** |
+** This routine should only be called for a cursor that just returned |
+** TRUE from sqlite3BtreeCursorHasMoved(). |
+*/ |
+int sqlite3BtreeCursorRestore(BtCursor *pCur, int *pDifferentRow){ |
+ int rc; |
+ |
+ assert( pCur!=0 ); |
+ assert( pCur->eState!=CURSOR_VALID ); |
+ rc = restoreCursorPosition(pCur); |
+ if( rc ){ |
+ *pDifferentRow = 1; |
+ return rc; |
+ } |
+ if( pCur->eState!=CURSOR_VALID ){ |
+ *pDifferentRow = 1; |
+ }else{ |
+ assert( pCur->skipNext==0 ); |
+ *pDifferentRow = 0; |
+ } |
+ return SQLITE_OK; |
+} |
+ |
+#ifdef SQLITE_ENABLE_CURSOR_HINTS |
+/* |
+** Provide hints to the cursor. The particular hint given (and the type |
+** and number of the varargs parameters) is determined by the eHintType |
+** parameter. See the definitions of the BTREE_HINT_* macros for details. |
+*/ |
+void sqlite3BtreeCursorHint(BtCursor *pCur, int eHintType, ...){ |
+ /* Used only by system that substitute their own storage engine */ |
+} |
+#endif |
+ |
+/* |
+** Provide flag hints to the cursor. |
+*/ |
+void sqlite3BtreeCursorHintFlags(BtCursor *pCur, unsigned x){ |
+ assert( x==BTREE_SEEK_EQ || x==BTREE_BULKLOAD || x==0 ); |
+ pCur->hints = x; |
+} |
+ |
+ |
+#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, 0); |
+ if( rc!=SQLITE_OK ){ |
+ *pRC = rc; |
+ return; |
+ } |
+ offset = PTRMAP_PTROFFSET(iPtrmap, key); |
+ if( offset<0 ){ |
+ *pRC = SQLITE_CORRUPT_BKPT; |
+ goto ptrmap_exit; |
+ } |
+ assert( offset <= (int)pBt->usableSize-5 ); |
+ 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, 0); |
+ if( rc!=0 ){ |
+ return rc; |
+ } |
+ pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage); |
+ |
+ offset = PTRMAP_PTROFFSET(iPtrmap, key); |
+ if( offset<0 ){ |
+ sqlite3PagerUnref(pDbPage); |
+ return SQLITE_CORRUPT_BKPT; |
+ } |
+ assert( offset <= (int)pBt->usableSize-5 ); |
+ 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. |
+** |
+** findCellPastPtr() does the same except it skips past the initial |
+** 4-byte child pointer found on interior pages, if there is one. |
+** |
+** This routine works only for pages that do not contain overflow cells. |
+*/ |
+#define findCell(P,I) \ |
+ ((P)->aData + ((P)->maskPage & get2byteAligned(&(P)->aCellIdx[2*(I)]))) |
+#define findCellPastPtr(P,I) \ |
+ ((P)->aDataOfst + ((P)->maskPage & get2byteAligned(&(P)->aCellIdx[2*(I)]))) |
+ |
+ |
+/* |
+** This is common tail processing for btreeParseCellPtr() and |
+** btreeParseCellPtrIndex() for the case when the cell does not fit entirely |
+** on a single B-tree page. Make necessary adjustments to the CellInfo |
+** structure. |
+*/ |
+static SQLITE_NOINLINE void btreeParseCellAdjustSizeForOverflow( |
+ MemPage *pPage, /* Page containing the cell */ |
+ u8 *pCell, /* Pointer to the cell text. */ |
+ CellInfo *pInfo /* Fill in this structure */ |
+){ |
+ /* 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 + (pInfo->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->nSize = (u16)(&pInfo->pPayload[pInfo->nLocal] - pCell) + 4; |
+} |
+ |
+/* |
+** The following routines are implementations of the MemPage.xParseCell() |
+** method. |
+** |
+** Parse a cell content block and fill in the CellInfo structure. |
+** |
+** btreeParseCellPtr() => table btree leaf nodes |
+** btreeParseCellNoPayload() => table btree internal nodes |
+** btreeParseCellPtrIndex() => index btree nodes |
+** |
+** There is also a wrapper function btreeParseCell() that works for |
+** all MemPage types and that references the cell by index rather than |
+** by pointer. |
+*/ |
+static void btreeParseCellPtrNoPayload( |
+ MemPage *pPage, /* Page containing the cell */ |
+ u8 *pCell, /* Pointer to the cell text. */ |
+ CellInfo *pInfo /* Fill in this structure */ |
+){ |
+ assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
+ assert( pPage->leaf==0 ); |
+ assert( pPage->childPtrSize==4 ); |
+#ifndef SQLITE_DEBUG |
+ UNUSED_PARAMETER(pPage); |
+#endif |
+ pInfo->nSize = 4 + getVarint(&pCell[4], (u64*)&pInfo->nKey); |
+ pInfo->nPayload = 0; |
+ pInfo->nLocal = 0; |
+ pInfo->pPayload = 0; |
+ return; |
+} |
+static void btreeParseCellPtr( |
+ MemPage *pPage, /* Page containing the cell */ |
+ u8 *pCell, /* Pointer to the cell text. */ |
+ CellInfo *pInfo /* Fill in this structure */ |
+){ |
+ u8 *pIter; /* For scanning through pCell */ |
+ u32 nPayload; /* Number of bytes of cell payload */ |
+ u64 iKey; /* Extracted Key value */ |
+ |
+ assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
+ assert( pPage->leaf==0 || pPage->leaf==1 ); |
+ assert( pPage->intKeyLeaf ); |
+ assert( pPage->childPtrSize==0 ); |
+ pIter = pCell; |
+ |
+ /* The next block of code is equivalent to: |
+ ** |
+ ** pIter += getVarint32(pIter, nPayload); |
+ ** |
+ ** The code is inlined to avoid a function call. |
+ */ |
+ nPayload = *pIter; |
+ if( nPayload>=0x80 ){ |
+ u8 *pEnd = &pIter[8]; |
+ nPayload &= 0x7f; |
+ do{ |
+ nPayload = (nPayload<<7) | (*++pIter & 0x7f); |
+ }while( (*pIter)>=0x80 && pIter<pEnd ); |
+ } |
+ pIter++; |
+ |
+ /* The next block of code is equivalent to: |
+ ** |
+ ** pIter += getVarint(pIter, (u64*)&pInfo->nKey); |
+ ** |
+ ** The code is inlined to avoid a function call. |
+ */ |
+ iKey = *pIter; |
+ if( iKey>=0x80 ){ |
+ u8 *pEnd = &pIter[7]; |
+ iKey &= 0x7f; |
+ while(1){ |
+ iKey = (iKey<<7) | (*++pIter & 0x7f); |
+ if( (*pIter)<0x80 ) break; |
+ if( pIter>=pEnd ){ |
+ iKey = (iKey<<8) | *++pIter; |
+ break; |
+ } |
+ } |
+ } |
+ pIter++; |
+ |
+ pInfo->nKey = *(i64*)&iKey; |
+ pInfo->nPayload = nPayload; |
+ pInfo->pPayload = pIter; |
+ testcase( nPayload==pPage->maxLocal ); |
+ testcase( nPayload==pPage->maxLocal+1 ); |
+ if( nPayload<=pPage->maxLocal ){ |
+ /* This is the (easy) common case where the entire payload fits |
+ ** on the local page. No overflow is required. |
+ */ |
+ pInfo->nSize = nPayload + (u16)(pIter - pCell); |
+ if( pInfo->nSize<4 ) pInfo->nSize = 4; |
+ pInfo->nLocal = (u16)nPayload; |
+ }else{ |
+ btreeParseCellAdjustSizeForOverflow(pPage, pCell, pInfo); |
+ } |
+} |
+static void btreeParseCellPtrIndex( |
+ MemPage *pPage, /* Page containing the cell */ |
+ u8 *pCell, /* Pointer to the cell text. */ |
+ CellInfo *pInfo /* Fill in this structure */ |
+){ |
+ u8 *pIter; /* For scanning through pCell */ |
+ u32 nPayload; /* Number of bytes of cell payload */ |
+ |
+ assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
+ assert( pPage->leaf==0 || pPage->leaf==1 ); |
+ assert( pPage->intKeyLeaf==0 ); |
+ pIter = pCell + pPage->childPtrSize; |
+ nPayload = *pIter; |
+ if( nPayload>=0x80 ){ |
+ u8 *pEnd = &pIter[8]; |
+ nPayload &= 0x7f; |
+ do{ |
+ nPayload = (nPayload<<7) | (*++pIter & 0x7f); |
+ }while( *(pIter)>=0x80 && pIter<pEnd ); |
+ } |
+ pIter++; |
+ pInfo->nKey = nPayload; |
+ pInfo->nPayload = nPayload; |
+ pInfo->pPayload = pIter; |
+ testcase( nPayload==pPage->maxLocal ); |
+ testcase( nPayload==pPage->maxLocal+1 ); |
+ if( nPayload<=pPage->maxLocal ){ |
+ /* This is the (easy) common case where the entire payload fits |
+ ** on the local page. No overflow is required. |
+ */ |
+ pInfo->nSize = nPayload + (u16)(pIter - pCell); |
+ if( pInfo->nSize<4 ) pInfo->nSize = 4; |
+ pInfo->nLocal = (u16)nPayload; |
+ }else{ |
+ btreeParseCellAdjustSizeForOverflow(pPage, pCell, 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 */ |
+){ |
+ pPage->xParseCell(pPage, findCell(pPage, iCell), pInfo); |
+} |
+ |
+/* |
+** The following routines are implementations of the MemPage.xCellSize |
+** method. |
+** |
+** 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. |
+** |
+** cellSizePtrNoPayload() => table internal nodes |
+** cellSizePtr() => all index nodes & table leaf nodes |
+*/ |
+static u16 cellSizePtr(MemPage *pPage, u8 *pCell){ |
+ u8 *pIter = pCell + pPage->childPtrSize; /* For looping over bytes of pCell */ |
+ u8 *pEnd; /* End mark for a varint */ |
+ u32 nSize; /* Size value to return */ |
+ |
+#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; |
+ pPage->xParseCell(pPage, pCell, &debuginfo); |
+#endif |
+ |
+ nSize = *pIter; |
+ if( nSize>=0x80 ){ |
+ pEnd = &pIter[8]; |
+ nSize &= 0x7f; |
+ do{ |
+ nSize = (nSize<<7) | (*++pIter & 0x7f); |
+ }while( *(pIter)>=0x80 && pIter<pEnd ); |
+ } |
+ pIter++; |
+ if( pPage->intKey ){ |
+ /* 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 ); |
+ } |
+ testcase( nSize==pPage->maxLocal ); |
+ testcase( nSize==pPage->maxLocal+1 ); |
+ if( nSize<=pPage->maxLocal ){ |
+ nSize += (u32)(pIter - pCell); |
+ if( nSize<4 ) nSize = 4; |
+ }else{ |
+ 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 + (u16)(pIter - pCell); |
+ } |
+ assert( nSize==debuginfo.nSize || CORRUPT_DB ); |
+ return (u16)nSize; |
+} |
+static u16 cellSizePtrNoPayload(MemPage *pPage, u8 *pCell){ |
+ u8 *pIter = pCell + 4; /* For looping over bytes of pCell */ |
+ u8 *pEnd; /* End mark for a varint */ |
+ |
+#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; |
+ pPage->xParseCell(pPage, pCell, &debuginfo); |
+#else |
+ UNUSED_PARAMETER(pPage); |
+#endif |
+ |
+ assert( pPage->childPtrSize==4 ); |
+ pEnd = pIter + 9; |
+ while( (*pIter++)&0x80 && pIter<pEnd ); |
+ assert( debuginfo.nSize==(u16)(pIter - pCell) || CORRUPT_DB ); |
+ return (u16)(pIter - pCell); |
+} |
+ |
+ |
+#ifdef SQLITE_DEBUG |
+/* This variation on cellSizePtr() is used inside of assert() statements |
+** only. */ |
+static u16 cellSize(MemPage *pPage, int iCell){ |
+ return pPage->xCellSize(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 ); |
+ pPage->xParseCell(pPage, pCell, &info); |
+ if( info.nLocal<info.nPayload ){ |
+ Pgno ovfl = get4byte(&pCell[info.nSize-4]); |
+ 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. |
+** |
+** EVIDENCE-OF: R-44582-60138 SQLite may from time to time reorganize a |
+** b-tree page so that there are no freeblocks or fragment bytes, all |
+** unused bytes are contained in the unallocated space region, and all |
+** cells are packed tightly at the end of the page. |
+*/ |
+static int defragmentPage(MemPage *pPage){ |
+ int i; /* Loop counter */ |
+ int pc; /* Address of the 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 */ |
+ unsigned char *src; /* Source of 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 = 0; |
+ src = data = pPage->aData; |
+ hdr = pPage->hdrOffset; |
+ cellOffset = pPage->cellOffset; |
+ nCell = pPage->nCell; |
+ assert( nCell==get2byte(&data[hdr+3]) ); |
+ usableSize = pPage->pBt->usableSize; |
+ 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 ); |
+ /* These conditions have already been verified in btreeInitPage() |
+ ** if PRAGMA cell_size_check=ON. |
+ */ |
+ if( pc<iCellFirst || pc>iCellLast ){ |
+ return SQLITE_CORRUPT_BKPT; |
+ } |
+ assert( pc>=iCellFirst && pc<=iCellLast ); |
+ size = pPage->xCellSize(pPage, &src[pc]); |
+ cbrk -= size; |
+ if( cbrk<iCellFirst || pc+size>usableSize ){ |
+ return SQLITE_CORRUPT_BKPT; |
+ } |
+ assert( cbrk+size<=usableSize && cbrk>=iCellFirst ); |
+ testcase( cbrk+size==usableSize ); |
+ testcase( pc+size==usableSize ); |
+ put2byte(pAddr, cbrk); |
+ if( temp==0 ){ |
+ int x; |
+ if( cbrk==pc ) continue; |
+ temp = sqlite3PagerTempSpace(pPage->pBt->pPager); |
+ x = get2byte(&data[hdr+5]); |
+ memcpy(&temp[x], &data[x], (cbrk+size) - x); |
+ src = temp; |
+ } |
+ memcpy(&data[cbrk], &src[pc], size); |
+ } |
+ 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; |
+} |
+ |
+/* |
+** Search the free-list on page pPg for space to store a cell nByte bytes in |
+** size. If one can be found, return a pointer to the space and remove it |
+** from the free-list. |
+** |
+** If no suitable space can be found on the free-list, return NULL. |
+** |
+** This function may detect corruption within pPg. If corruption is |
+** detected then *pRc is set to SQLITE_CORRUPT and NULL is returned. |
+** |
+** Slots on the free list that are between 1 and 3 bytes larger than nByte |
+** will be ignored if adding the extra space to the fragmentation count |
+** causes the fragmentation count to exceed 60. |
+*/ |
+static u8 *pageFindSlot(MemPage *pPg, int nByte, int *pRc){ |
+ const int hdr = pPg->hdrOffset; |
+ u8 * const aData = pPg->aData; |
+ int iAddr = hdr + 1; |
+ int pc = get2byte(&aData[iAddr]); |
+ int x; |
+ int usableSize = pPg->pBt->usableSize; |
+ |
+ assert( pc>0 ); |
+ do{ |
+ int size; /* Size of the free slot */ |
+ /* EVIDENCE-OF: R-06866-39125 Freeblocks are always connected in order of |
+ ** increasing offset. */ |
+ if( pc>usableSize-4 || pc<iAddr+4 ){ |
+ *pRc = SQLITE_CORRUPT_BKPT; |
+ return 0; |
+ } |
+ /* EVIDENCE-OF: R-22710-53328 The third and fourth bytes of each |
+ ** freeblock form a big-endian integer which is the size of the freeblock |
+ ** in bytes, including the 4-byte header. */ |
+ size = get2byte(&aData[pc+2]); |
+ if( (x = size - nByte)>=0 ){ |
+ testcase( x==4 ); |
+ testcase( x==3 ); |
+ if( pc < pPg->cellOffset+2*pPg->nCell || size+pc > usableSize ){ |
+ *pRc = SQLITE_CORRUPT_BKPT; |
+ return 0; |
+ }else if( x<4 ){ |
+ /* EVIDENCE-OF: R-11498-58022 In a well-formed b-tree page, the total |
+ ** number of bytes in fragments may not exceed 60. */ |
+ if( aData[hdr+7]>57 ) return 0; |
+ |
+ /* Remove the slot from the free-list. Update the number of |
+ ** fragmented bytes within the page. */ |
+ memcpy(&aData[iAddr], &aData[pc], 2); |
+ aData[hdr+7] += (u8)x; |
+ }else{ |
+ /* The slot remains on the free-list. Reduce its size to account |
+ ** for the portion used by the new allocation. */ |
+ put2byte(&aData[pc+2], x); |
+ } |
+ return &aData[pc + x]; |
+ } |
+ iAddr = pc; |
+ pc = get2byte(&aData[pc]); |
+ }while( pc ); |
+ |
+ return 0; |
+} |
+ |
+/* |
+** 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 top; /* First byte of cell content area */ |
+ int rc = SQLITE_OK; /* Integer return code */ |
+ int gap; /* First byte of gap between cell pointers and cell content */ |
+ |
+ 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 ); |
+ assert( nByte < (int)(pPage->pBt->usableSize-8) ); |
+ |
+ assert( pPage->cellOffset == hdr + 12 - 4*pPage->leaf ); |
+ gap = pPage->cellOffset + 2*pPage->nCell; |
+ assert( gap<=65536 ); |
+ /* EVIDENCE-OF: R-29356-02391 If the database uses a 65536-byte page size |
+ ** and the reserved space is zero (the usual value for reserved space) |
+ ** then the cell content offset of an empty page wants to be 65536. |
+ ** However, that integer is too large to be stored in a 2-byte unsigned |
+ ** integer, so a value of 0 is used in its place. */ |
+ top = get2byte(&data[hdr+5]); |
+ assert( top<=(int)pPage->pBt->usableSize ); /* Prevent by getAndInitPage() */ |
+ if( gap>top ){ |
+ if( top==0 && pPage->pBt->usableSize==65536 ){ |
+ top = 65536; |
+ }else{ |
+ return SQLITE_CORRUPT_BKPT; |
+ } |
+ } |
+ |
+ /* If there is enough space between gap and top for one more cell pointer |
+ ** array entry offset, and if the freelist is not empty, then search the |
+ ** freelist looking for a free slot big enough to satisfy the request. |
+ */ |
+ testcase( gap+2==top ); |
+ testcase( gap+1==top ); |
+ testcase( gap==top ); |
+ if( (data[hdr+2] || data[hdr+1]) && gap+2<=top ){ |
+ u8 *pSpace = pageFindSlot(pPage, nByte, &rc); |
+ if( pSpace ){ |
+ assert( pSpace>=data && (pSpace - data)<65536 ); |
+ *pIdx = (int)(pSpace - data); |
+ return SQLITE_OK; |
+ }else if( rc ){ |
+ return rc; |
+ } |
+ } |
+ |
+ /* The request could not be fulfilled using a freelist slot. Check |
+ ** to see if defragmentation is necessary. |
+ */ |
+ testcase( gap+2+nByte==top ); |
+ if( gap+2+nByte>top ){ |
+ assert( pPage->nCell>0 || CORRUPT_DB ); |
+ 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->aData[iStart] |
+** and the size of the block is iSize bytes. |
+** |
+** Adjacent freeblocks are coalesced. |
+** |
+** Note that even though the freeblock list was checked by btreeInitPage(), |
+** that routine will not detect overlap between cells or freeblocks. Nor |
+** does it detect cells or freeblocks that encrouch into the reserved bytes |
+** at the end of the page. So do additional corruption checks inside this |
+** routine and return SQLITE_CORRUPT if any problems are found. |
+*/ |
+static int freeSpace(MemPage *pPage, u16 iStart, u16 iSize){ |
+ u16 iPtr; /* Address of ptr to next freeblock */ |
+ u16 iFreeBlk; /* Address of the next freeblock */ |
+ u8 hdr; /* Page header size. 0 or 100 */ |
+ u8 nFrag = 0; /* Reduction in fragmentation */ |
+ u16 iOrigSize = iSize; /* Original value of iSize */ |
+ u32 iLast = pPage->pBt->usableSize-4; /* Largest possible freeblock offset */ |
+ u32 iEnd = iStart + iSize; /* First byte past the iStart buffer */ |
+ unsigned char *data = pPage->aData; /* Page content */ |
+ |
+ assert( pPage->pBt!=0 ); |
+ assert( sqlite3PagerIswriteable(pPage->pDbPage) ); |
+ assert( CORRUPT_DB || iStart>=pPage->hdrOffset+6+pPage->childPtrSize ); |
+ assert( CORRUPT_DB || iEnd <= pPage->pBt->usableSize ); |
+ assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
+ assert( iSize>=4 ); /* Minimum cell size is 4 */ |
+ assert( iStart<=iLast ); |
+ |
+ /* Overwrite deleted information with zeros when the secure_delete |
+ ** option is enabled */ |
+ if( pPage->pBt->btsFlags & BTS_SECURE_DELETE ){ |
+ memset(&data[iStart], 0, iSize); |
+ } |
+ |
+ /* The list of freeblocks must be in ascending order. Find the |
+ ** spot on the list where iStart should be inserted. |
+ */ |
+ hdr = pPage->hdrOffset; |
+ iPtr = hdr + 1; |
+ if( data[iPtr+1]==0 && data[iPtr]==0 ){ |
+ iFreeBlk = 0; /* Shortcut for the case when the freelist is empty */ |
+ }else{ |
+ while( (iFreeBlk = get2byte(&data[iPtr]))<iStart ){ |
+ if( iFreeBlk<iPtr+4 ){ |
+ if( iFreeBlk==0 ) break; |
+ return SQLITE_CORRUPT_BKPT; |
+ } |
+ iPtr = iFreeBlk; |
+ } |
+ if( iFreeBlk>iLast ) return SQLITE_CORRUPT_BKPT; |
+ assert( iFreeBlk>iPtr || iFreeBlk==0 ); |
+ |
+ /* At this point: |
+ ** iFreeBlk: First freeblock after iStart, or zero if none |
+ ** iPtr: The address of a pointer to iFreeBlk |
+ ** |
+ ** Check to see if iFreeBlk should be coalesced onto the end of iStart. |
+ */ |
+ if( iFreeBlk && iEnd+3>=iFreeBlk ){ |
+ nFrag = iFreeBlk - iEnd; |
+ if( iEnd>iFreeBlk ) return SQLITE_CORRUPT_BKPT; |
+ iEnd = iFreeBlk + get2byte(&data[iFreeBlk+2]); |
+ if( iEnd > pPage->pBt->usableSize ) return SQLITE_CORRUPT_BKPT; |
+ iSize = iEnd - iStart; |
+ iFreeBlk = get2byte(&data[iFreeBlk]); |
+ } |
+ |
+ /* If iPtr is another freeblock (that is, if iPtr is not the freelist |
+ ** pointer in the page header) then check to see if iStart should be |
+ ** coalesced onto the end of iPtr. |
+ */ |
+ if( iPtr>hdr+1 ){ |
+ int iPtrEnd = iPtr + get2byte(&data[iPtr+2]); |
+ if( iPtrEnd+3>=iStart ){ |
+ if( iPtrEnd>iStart ) return SQLITE_CORRUPT_BKPT; |
+ nFrag += iStart - iPtrEnd; |
+ iSize = iEnd - iPtr; |
+ iStart = iPtr; |
+ } |
+ } |
+ if( nFrag>data[hdr+7] ) return SQLITE_CORRUPT_BKPT; |
+ data[hdr+7] -= nFrag; |
+ } |
+ if( iStart==get2byte(&data[hdr+5]) ){ |
+ /* The new freeblock is at the beginning of the cell content area, |
+ ** so just extend the cell content area rather than create another |
+ ** freelist entry */ |
+ if( iPtr!=hdr+1 ) return SQLITE_CORRUPT_BKPT; |
+ put2byte(&data[hdr+1], iFreeBlk); |
+ put2byte(&data[hdr+5], iEnd); |
+ }else{ |
+ /* Insert the new freeblock into the freelist */ |
+ put2byte(&data[iPtr], iStart); |
+ put2byte(&data[iStart], iFreeBlk); |
+ put2byte(&data[iStart+2], iSize); |
+ } |
+ pPage->nFree += iOrigSize; |
+ 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; |
+ pPage->xCellSize = cellSizePtr; |
+ pBt = pPage->pBt; |
+ if( flagByte==(PTF_LEAFDATA | PTF_INTKEY) ){ |
+ /* EVIDENCE-OF: R-07291-35328 A value of 5 (0x05) means the page is an |
+ ** interior table b-tree page. */ |
+ assert( (PTF_LEAFDATA|PTF_INTKEY)==5 ); |
+ /* EVIDENCE-OF: R-26900-09176 A value of 13 (0x0d) means the page is a |
+ ** leaf table b-tree page. */ |
+ assert( (PTF_LEAFDATA|PTF_INTKEY|PTF_LEAF)==13 ); |
+ pPage->intKey = 1; |
+ if( pPage->leaf ){ |
+ pPage->intKeyLeaf = 1; |
+ pPage->xParseCell = btreeParseCellPtr; |
+ }else{ |
+ pPage->intKeyLeaf = 0; |
+ pPage->xCellSize = cellSizePtrNoPayload; |
+ pPage->xParseCell = btreeParseCellPtrNoPayload; |
+ } |
+ pPage->maxLocal = pBt->maxLeaf; |
+ pPage->minLocal = pBt->minLeaf; |
+ }else if( flagByte==PTF_ZERODATA ){ |
+ /* EVIDENCE-OF: R-43316-37308 A value of 2 (0x02) means the page is an |
+ ** interior index b-tree page. */ |
+ assert( (PTF_ZERODATA)==2 ); |
+ /* EVIDENCE-OF: R-59615-42828 A value of 10 (0x0a) means the page is a |
+ ** leaf index b-tree page. */ |
+ assert( (PTF_ZERODATA|PTF_LEAF)==10 ); |
+ pPage->intKey = 0; |
+ pPage->intKeyLeaf = 0; |
+ pPage->xParseCell = btreeParseCellPtrIndex; |
+ pPage->maxLocal = pBt->maxLocal; |
+ pPage->minLocal = pBt->minLocal; |
+ }else{ |
+ /* EVIDENCE-OF: R-47608-56469 Any other value for the b-tree page type is |
+ ** an error. */ |
+ return SQLITE_CORRUPT_BKPT; |
+ } |
+ pPage->max1bytePayload = pBt->max1bytePayload; |
+ 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( pPage->pBt->db!=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 ){ |
+ int 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; |
+ /* EVIDENCE-OF: R-28594-02890 The one-byte flag at offset 0 indicating |
+ ** the b-tree page type. */ |
+ 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 + 8 + pPage->childPtrSize; |
+ pPage->aDataEnd = &data[usableSize]; |
+ pPage->aCellIdx = &data[cellOffset]; |
+ pPage->aDataOfst = &data[pPage->childPtrSize]; |
+ /* EVIDENCE-OF: R-58015-48175 The two-byte integer at offset 5 designates |
+ ** the start of the cell content area. A zero value for this integer is |
+ ** interpreted as 65536. */ |
+ top = get2byteNotZero(&data[hdr+5]); |
+ /* EVIDENCE-OF: R-37002-32774 The two-byte integer at offset 3 gives the |
+ ** number of cells on the page. */ |
+ 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) ); |
+ /* EVIDENCE-OF: R-24089-57979 If a page contains no cells (which is only |
+ ** possible for a root page of a table that contains no rows) then the |
+ ** offset to the cell content area will equal the page size minus the |
+ ** bytes of reserved space. */ |
+ assert( pPage->nCell>0 || top==usableSize || CORRUPT_DB ); |
+ |
+ /* 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( pBt->db->flags & SQLITE_CellSizeCk ){ |
+ 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 = get2byteAligned(&data[cellOffset+i*2]); |
+ testcase( pc==iCellFirst ); |
+ testcase( pc==iCellLast ); |
+ if( pc<iCellFirst || pc>iCellLast ){ |
+ return SQLITE_CORRUPT_BKPT; |
+ } |
+ sz = pPage->xCellSize(pPage, &data[pc]); |
+ testcase( pc+sz==usableSize ); |
+ if( pc+sz>usableSize ){ |
+ return SQLITE_CORRUPT_BKPT; |
+ } |
+ } |
+ if( !pPage->leaf ) iCellLast++; |
+ } |
+ |
+ /* Compute the total free space on the page |
+ ** EVIDENCE-OF: R-23588-34450 The two-byte integer at offset 1 gives the |
+ ** start of the first freeblock on the page, or is zero if there are no |
+ ** freeblocks. */ |
+ pc = get2byte(&data[hdr+1]); |
+ nFree = data[hdr+7] + top; /* Init nFree to non-freeblock free space */ |
+ if( pc>0 ){ |
+ u32 next, size; |
+ if( pc<iCellFirst ){ |
+ /* EVIDENCE-OF: R-55530-52930 In a well-formed b-tree page, there will |
+ ** always be at least one cell before the first freeblock. |
+ */ |
+ return SQLITE_CORRUPT_BKPT; |
+ } |
+ while( 1 ){ |
+ if( pc>iCellLast ){ |
+ return SQLITE_CORRUPT_BKPT; /* Freeblock off the end of the page */ |
+ } |
+ next = get2byte(&data[pc]); |
+ size = get2byte(&data[pc+2]); |
+ nFree = nFree + size; |
+ if( next<=pc+size+3 ) break; |
+ pc = next; |
+ } |
+ if( next>0 ){ |
+ return SQLITE_CORRUPT_BKPT; /* Freeblock not in ascending order */ |
+ } |
+ if( pc+size>(unsigned int)usableSize ){ |
+ return SQLITE_CORRUPT_BKPT; /* Last freeblock extends past page end */ |
+ } |
+ } |
+ |
+ /* 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->btsFlags & BTS_SECURE_DELETE ){ |
+ memset(&data[hdr], 0, pBt->usableSize - hdr); |
+ } |
+ data[hdr] = (char)flags; |
+ first = hdr + ((flags&PTF_LEAF)==0 ? 12 : 8); |
+ 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->cellOffset = first; |
+ pPage->aDataEnd = &data[pBt->usableSize]; |
+ pPage->aCellIdx = &data[first]; |
+ pPage->aDataOfst = &data[pPage->childPtrSize]; |
+ 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); |
+ if( pgno!=pPage->pgno ){ |
+ pPage->aData = sqlite3PagerGetData(pDbPage); |
+ pPage->pDbPage = pDbPage; |
+ pPage->pBt = pBt; |
+ pPage->pgno = pgno; |
+ pPage->hdrOffset = pgno==1 ? 100 : 0; |
+ } |
+ assert( pPage->aData==sqlite3PagerGetData(pDbPage) ); |
+ return pPage; |
+} |
+ |
+/* |
+** Get a page from the pager. Initialize the MemPage.pBt and |
+** MemPage.aData elements if needed. See also: btreeGetUnusedPage(). |
+** |
+** If the PAGER_GET_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 flags /* PAGER_GET_NOCONTENT or PAGER_GET_READONLY */ |
+){ |
+ int rc; |
+ DbPage *pDbPage; |
+ |
+ assert( flags==0 || flags==PAGER_GET_NOCONTENT || flags==PAGER_GET_READONLY ); |
+ assert( sqlite3_mutex_held(pBt->mutex) ); |
+ rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, flags); |
+ 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 btreePagecount(p->pBt); |
+} |
+ |
+/* |
+** Get a page from the pager and initialize it. |
+** |
+** If pCur!=0 then the page is being fetched as part of a moveToChild() |
+** call. Do additional sanity checking on the page in this case. |
+** And if the fetch fails, this routine must decrement pCur->iPage. |
+** |
+** The page is fetched as read-write unless pCur is not NULL and is |
+** a read-only cursor. |
+** |
+** If an error occurs, then *ppPage 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 */ |
+ BtCursor *pCur, /* Cursor to receive the page, or NULL */ |
+ int bReadOnly /* True for a read-only page */ |
+){ |
+ int rc; |
+ DbPage *pDbPage; |
+ assert( sqlite3_mutex_held(pBt->mutex) ); |
+ assert( pCur==0 || ppPage==&pCur->apPage[pCur->iPage] ); |
+ assert( pCur==0 || bReadOnly==pCur->curPagerFlags ); |
+ assert( pCur==0 || pCur->iPage>0 ); |
+ |
+ if( pgno>btreePagecount(pBt) ){ |
+ rc = SQLITE_CORRUPT_BKPT; |
+ goto getAndInitPage_error; |
+ } |
+ rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, bReadOnly); |
+ if( rc ){ |
+ goto getAndInitPage_error; |
+ } |
+ *ppPage = (MemPage*)sqlite3PagerGetExtra(pDbPage); |
+ if( (*ppPage)->isInit==0 ){ |
+ btreePageFromDbPage(pDbPage, pgno, pBt); |
+ rc = btreeInitPage(*ppPage); |
+ if( rc!=SQLITE_OK ){ |
+ releasePage(*ppPage); |
+ goto getAndInitPage_error; |
+ } |
+ } |
+ assert( (*ppPage)->pgno==pgno ); |
+ assert( (*ppPage)->aData==sqlite3PagerGetData(pDbPage) ); |
+ |
+ /* If obtaining a child page for a cursor, we must verify that the page is |
+ ** compatible with the root page. */ |
+ if( pCur && ((*ppPage)->nCell<1 || (*ppPage)->intKey!=pCur->curIntKey) ){ |
+ rc = SQLITE_CORRUPT_BKPT; |
+ releasePage(*ppPage); |
+ goto getAndInitPage_error; |
+ } |
+ return SQLITE_OK; |
+ |
+getAndInitPage_error: |
+ if( pCur ) pCur->iPage--; |
+ 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 releasePageNotNull(MemPage *pPage){ |
+ assert( pPage->aData ); |
+ assert( pPage->pBt ); |
+ assert( pPage->pDbPage!=0 ); |
+ assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage ); |
+ assert( sqlite3PagerGetData(pPage->pDbPage)==pPage->aData ); |
+ assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
+ sqlite3PagerUnrefNotNull(pPage->pDbPage); |
+} |
+static void releasePage(MemPage *pPage){ |
+ if( pPage ) releasePageNotNull(pPage); |
+} |
+ |
+/* |
+** Get an unused page. |
+** |
+** This works just like btreeGetPage() with the addition: |
+** |
+** * If the page is already in use for some other purpose, immediately |
+** release it and return an SQLITE_CURRUPT error. |
+** * Make sure the isInit flag is clear |
+*/ |
+static int btreeGetUnusedPage( |
+ BtShared *pBt, /* The btree */ |
+ Pgno pgno, /* Number of the page to fetch */ |
+ MemPage **ppPage, /* Return the page in this parameter */ |
+ int flags /* PAGER_GET_NOCONTENT or PAGER_GET_READONLY */ |
+){ |
+ int rc = btreeGetPage(pBt, pgno, ppPage, flags); |
+ if( rc==SQLITE_OK ){ |
+ if( sqlite3PagerPageRefcount((*ppPage)->pDbPage)>1 ){ |
+ releasePage(*ppPage); |
+ *ppPage = 0; |
+ return SQLITE_CORRUPT_BKPT; |
+ } |
+ (*ppPage)->isInit = 0; |
+ }else{ |
+ *ppPage = 0; |
+ } |
+ return rc; |
+} |
+ |
+ |
+/* |
+** 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 like |
+** BTREE_OMIT_JOURNAL and/or BTREE_MEMORY. |
+** |
+** 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( |
+ sqlite3_vfs *pVfs, /* VFS to use for this b-tree */ |
+ 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() */ |
+){ |
+ 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)) |
+ || (vfsFlags & SQLITE_OPEN_MEMORY)!=0; |
+#endif |
+ |
+ assert( db!=0 ); |
+ assert( pVfs!=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( isMemdb ){ |
+ flags |= BTREE_MEMORY; |
+ } |
+ if( (vfsFlags & SQLITE_OPEN_MAIN_DB)!=0 && (isMemdb || isTempDb) ){ |
+ vfsFlags = (vfsFlags & ~SQLITE_OPEN_MAIN_DB) | SQLITE_OPEN_TEMP_DB; |
+ } |
+ p = sqlite3MallocZero(sizeof(Btree)); |
+ if( !p ){ |
+ return SQLITE_NOMEM_BKPT; |
+ } |
+ 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( isTempDb==0 && (isMemdb==0 || (vfsFlags&SQLITE_OPEN_URI)!=0) ){ |
+ if( vfsFlags & SQLITE_OPEN_SHAREDCACHE ){ |
+ int nFilename = sqlite3Strlen30(zFilename)+1; |
+ int nFullPathname = pVfs->mxPathname+1; |
+ char *zFullPathname = sqlite3Malloc(MAX(nFullPathname,nFilename)); |
+ MUTEX_LOGIC( sqlite3_mutex *mutexShared; ) |
+ |
+ p->sharable = 1; |
+ if( !zFullPathname ){ |
+ sqlite3_free(p); |
+ return SQLITE_NOMEM_BKPT; |
+ } |
+ if( isMemdb ){ |
+ memcpy(zFullPathname, zFilename, nFilename); |
+ }else{ |
+ rc = sqlite3OsFullPathname(pVfs, zFilename, |
+ nFullPathname, zFullPathname); |
+ if( rc ){ |
+ sqlite3_free(zFullPathname); |
+ sqlite3_free(p); |
+ return rc; |
+ } |
+ } |
+#if SQLITE_THREADSAFE |
+ mutexOpen = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_OPEN); |
+ sqlite3_mutex_enter(mutexOpen); |
+ mutexShared = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); |
+ sqlite3_mutex_enter(mutexShared); |
+#endif |
+ for(pBt=GLOBAL(BtShared*,sqlite3SharedCacheList); pBt; pBt=pBt->pNext){ |
+ assert( pBt->nRef>0 ); |
+ if( 0==strcmp(zFullPathname, sqlite3PagerFilename(pBt->pPager, 0)) |
+ && 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 ); |
+ assert( sizeof(u64)==8 ); |
+ assert( sizeof(u32)==4 ); |
+ assert( sizeof(u16)==2 ); |
+ assert( sizeof(Pgno)==4 ); |
+ |
+ pBt = sqlite3MallocZero( sizeof(*pBt) ); |
+ if( pBt==0 ){ |
+ rc = SQLITE_NOMEM_BKPT; |
+ goto btree_open_out; |
+ } |
+ rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename, |
+ sizeof(MemPage), flags, vfsFlags, pageReinit); |
+ if( rc==SQLITE_OK ){ |
+ sqlite3PagerSetMmapLimit(pBt->pPager, db->szMmap); |
+ 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; |
+ if( sqlite3PagerIsreadonly(pBt->pPager) ) pBt->btsFlags |= BTS_READ_ONLY; |
+#ifdef SQLITE_SECURE_DELETE |
+ pBt->btsFlags |= BTS_SECURE_DELETE; |
+#endif |
+ /* EVIDENCE-OF: R-51873-39618 The page size for a database file is |
+ ** determined by the 2-byte integer located at an offset of 16 bytes from |
+ ** the beginning of the database file. */ |
+ 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{ |
+ /* EVIDENCE-OF: R-37497-42412 The size of the reserved region is |
+ ** determined by the one-byte unsigned integer found at an offset of 20 |
+ ** into the database file header. */ |
+ nReserve = zDbHeader[20]; |
+ pBt->btsFlags |= BTS_PAGESIZE_FIXED; |
+#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. |
+ */ |
+ pBt->nRef = 1; |
+ if( p->sharable ){ |
+ MUTEX_LOGIC( sqlite3_mutex *mutexShared; ) |
+ MUTEX_LOGIC( mutexShared = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);) |
+ if( SQLITE_THREADSAFE && sqlite3GlobalConfig.bCoreMutex ){ |
+ pBt->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_FAST); |
+ if( pBt->mutex==0 ){ |
+ rc = SQLITE_NOMEM_BKPT; |
+ 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( (uptr)p->pBt<(uptr)pSib->pBt ){ |
+ p->pNext = pSib; |
+ p->pPrev = 0; |
+ pSib->pPrev = p; |
+ }else{ |
+ while( pSib->pNext && (uptr)pSib->pNext->pBt<(uptr)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, 0); |
+ } |
+ sqlite3_free(pBt); |
+ sqlite3_free(p); |
+ *ppBtree = 0; |
+ }else{ |
+ sqlite3_file *pFile; |
+ |
+ /* 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); |
+ } |
+ |
+ pFile = sqlite3PagerFile(pBt->pPager); |
+ if( pFile->pMethods ){ |
+ sqlite3OsFileControlHint(pFile, SQLITE_FCNTL_PDB, (void*)&pBt->db); |
+ } |
+ } |
+ if( mutexOpen ){ |
+ assert( sqlite3_mutex_held(mutexOpen) ); |
+ sqlite3_mutex_leave(mutexOpen); |
+ } |
+ assert( rc!=SQLITE_OK || sqlite3BtreeConnectionCount(*ppBtree)>0 ); |
+ 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 |
+ MUTEX_LOGIC( sqlite3_mutex *pMaster; ) |
+ BtShared *pList; |
+ int removed = 0; |
+ |
+ assert( sqlite3_mutex_notheld(pBt->mutex) ); |
+ MUTEX_LOGIC( 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 with a 4-byte prefix for a left-child |
+** pointer. |
+*/ |
+static void allocateTempSpace(BtShared *pBt){ |
+ if( !pBt->pTmpSpace ){ |
+ pBt->pTmpSpace = sqlite3PageMalloc( pBt->pageSize ); |
+ |
+ /* One of the uses of pBt->pTmpSpace is to format cells before |
+ ** inserting them into a leaf page (function fillInCell()). If |
+ ** a cell is less than 4 bytes in size, it is rounded up to 4 bytes |
+ ** by the various routines that manipulate binary cells. Which |
+ ** can mean that fillInCell() only initializes the first 2 or 3 |
+ ** bytes of pTmpSpace, but that the first 4 bytes are copied from |
+ ** it into a database page. This is not actually a problem, but it |
+ ** does cause a valgrind error when the 1 or 2 bytes of unitialized |
+ ** data is passed to system call write(). So to avoid this error, |
+ ** zero the first 4 bytes of temp space here. |
+ ** |
+ ** Also: Provide four bytes of initialized space before the |
+ ** beginning of pTmpSpace as an area available to prepend the |
+ ** left-child pointer to the beginning of a cell. |
+ */ |
+ if( pBt->pTmpSpace ){ |
+ memset(pBt->pTmpSpace, 0, 8); |
+ pBt->pTmpSpace += 4; |
+ } |
+ } |
+} |
+ |
+/* |
+** Free the pBt->pTmpSpace allocation |
+*/ |
+static void freeTempSpace(BtShared *pBt){ |
+ if( pBt->pTmpSpace ){ |
+ pBt->pTmpSpace -= 4; |
+ 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, SQLITE_OK, 0); |
+ 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, p->db); |
+ 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 "soft" limit on the number of pages in the cache. |
+** Unused and unmodified pages will be recycled when the number of |
+** pages in the cache exceeds this soft limit. But the size of the |
+** cache is allowed to grow larger than this limit if it contains |
+** dirty pages or pages still in active use. |
+*/ |
+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 "spill" limit on the number of pages in the cache. |
+** If the number of pages exceeds this limit during a write transaction, |
+** the pager might attempt to "spill" pages to the journal early in |
+** order to free up memory. |
+** |
+** The value returned is the current spill size. If zero is passed |
+** as an argument, no changes are made to the spill size setting, so |
+** using mxPage of 0 is a way to query the current spill size. |
+*/ |
+int sqlite3BtreeSetSpillSize(Btree *p, int mxPage){ |
+ BtShared *pBt = p->pBt; |
+ int res; |
+ assert( sqlite3_mutex_held(p->db->mutex) ); |
+ sqlite3BtreeEnter(p); |
+ res = sqlite3PagerSetSpillsize(pBt->pPager, mxPage); |
+ sqlite3BtreeLeave(p); |
+ return res; |
+} |
+ |
+#if SQLITE_MAX_MMAP_SIZE>0 |
+/* |
+** Change the limit on the amount of the database file that may be |
+** memory mapped. |
+*/ |
+int sqlite3BtreeSetMmapLimit(Btree *p, sqlite3_int64 szMmap){ |
+ BtShared *pBt = p->pBt; |
+ assert( sqlite3_mutex_held(p->db->mutex) ); |
+ sqlite3BtreeEnter(p); |
+ sqlite3PagerSetMmapLimit(pBt->pPager, szMmap); |
+ sqlite3BtreeLeave(p); |
+ return SQLITE_OK; |
+} |
+#endif /* SQLITE_MAX_MMAP_SIZE>0 */ |
+ |
+/* |
+** 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 sqlite3BtreeSetPagerFlags( |
+ Btree *p, /* The btree to set the safety level on */ |
+ unsigned pgFlags /* Various PAGER_* flags */ |
+){ |
+ BtShared *pBt = p->pBt; |
+ assert( sqlite3_mutex_held(p->db->mutex) ); |
+ sqlite3BtreeEnter(p); |
+ sqlite3PagerSetFlags(pBt->pPager, pgFlags); |
+ sqlite3BtreeLeave(p); |
+ return SQLITE_OK; |
+} |
+#endif |
+ |
+/* |
+** 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 BTS_PAGESIZE_FIXED 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 SQLITE_HAS_CODEC |
+ if( nReserve>pBt->optimalReserve ) pBt->optimalReserve = (u8)nReserve; |
+#endif |
+ if( pBt->btsFlags & BTS_PAGESIZE_FIXED ){ |
+ 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->pCursor ); |
+ pBt->pageSize = (u32)pageSize; |
+ freeTempSpace(pBt); |
+ } |
+ rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve); |
+ pBt->usableSize = pBt->pageSize - (u16)nReserve; |
+ if( iFix ) pBt->btsFlags |= BTS_PAGESIZE_FIXED; |
+ sqlite3BtreeLeave(p); |
+ return rc; |
+} |
+ |
+/* |
+** Return the currently defined page size |
+*/ |
+int sqlite3BtreeGetPageSize(Btree *p){ |
+ return p->pBt->pageSize; |
+} |
+ |
+/* |
+** This function is similar to sqlite3BtreeGetReserve(), except that it |
+** may only be called if it is guaranteed that the b-tree mutex is already |
+** held. |
+** |
+** This is useful in one special case in the backup API code where it is |
+** known that the shared b-tree mutex is held, but the mutex on the |
+** database handle that owns *p is not. In this case if sqlite3BtreeEnter() |
+** were to be called, it might collide with some other operation on the |
+** database handle that owns *p, causing undefined behavior. |
+*/ |
+int sqlite3BtreeGetReserveNoMutex(Btree *p){ |
+ int n; |
+ assert( sqlite3_mutex_held(p->pBt->mutex) ); |
+ n = p->pBt->pageSize - p->pBt->usableSize; |
+ return n; |
+} |
+ |
+/* |
+** 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. |
+** |
+** If SQLITE_HAS_MUTEX is defined then the number returned is the |
+** greater of the current reserved space and the maximum requested |
+** reserve space. |
+*/ |
+int sqlite3BtreeGetOptimalReserve(Btree *p){ |
+ int n; |
+ sqlite3BtreeEnter(p); |
+ n = sqlite3BtreeGetReserveNoMutex(p); |
+#ifdef SQLITE_HAS_CODEC |
+ if( n<p->pBt->optimalReserve ) n = p->pBt->optimalReserve; |
+#endif |
+ 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 BTS_SECURE_DELETE flag if newFlag is 0 or 1. If newFlag is -1, |
+** then make no changes. Always return the value of the BTS_SECURE_DELETE |
+** setting after the change. |
+*/ |
+int sqlite3BtreeSecureDelete(Btree *p, int newFlag){ |
+ int b; |
+ if( p==0 ) return 0; |
+ sqlite3BtreeEnter(p); |
+ if( newFlag>=0 ){ |
+ p->pBt->btsFlags &= ~BTS_SECURE_DELETE; |
+ if( newFlag ) p->pBt->btsFlags |= BTS_SECURE_DELETE; |
+ } |
+ b = (p->pBt->btsFlags & BTS_SECURE_DELETE)!=0; |
+ sqlite3BtreeLeave(p); |
+ return b; |
+} |
+ |
+/* |
+** 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->btsFlags & BTS_PAGESIZE_FIXED)!=0 && (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; |
+ /* EVIDENCE-OF: R-43737-39999 Every valid SQLite database file begins |
+ ** with the following 16 bytes (in hex): 53 51 4c 69 74 65 20 66 6f 72 6d |
+ ** 61 74 20 33 00. */ |
+ if( memcmp(page1, zMagicHeader, 16)!=0 ){ |
+ goto page1_init_failed; |
+ } |
+ |
+#ifdef SQLITE_OMIT_WAL |
+ if( page1[18]>1 ){ |
+ pBt->btsFlags |= BTS_READ_ONLY; |
+ } |
+ if( page1[19]>1 ){ |
+ goto page1_init_failed; |
+ } |
+#else |
+ if( page1[18]>2 ){ |
+ pBt->btsFlags |= BTS_READ_ONLY; |
+ } |
+ 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->btsFlags & BTS_NO_WAL)==0 ){ |
+ int isOpen = 0; |
+ rc = sqlite3PagerOpenWal(pBt->pPager, &isOpen); |
+ if( rc!=SQLITE_OK ){ |
+ goto page1_init_failed; |
+ }else{ |
+#if SQLITE_DEFAULT_SYNCHRONOUS!=SQLITE_DEFAULT_WAL_SYNCHRONOUS |
+ sqlite3 *db; |
+ Db *pDb; |
+ if( (db=pBt->db)!=0 && (pDb=db->aDb)!=0 ){ |
+ while( pDb->pBt==0 || pDb->pBt->pBt!=pBt ){ pDb++; } |
+ if( pDb->bSyncSet==0 |
+ && pDb->safety_level==SQLITE_DEFAULT_SYNCHRONOUS+1 |
+ ){ |
+ pDb->safety_level = SQLITE_DEFAULT_WAL_SYNCHRONOUS+1; |
+ sqlite3PagerSetFlags(pBt->pPager, |
+ pDb->safety_level | (db->flags & PAGER_FLAGS_MASK)); |
+ } |
+ } |
+#endif |
+ if( isOpen==0 ){ |
+ releasePage(pPage1); |
+ return SQLITE_OK; |
+ } |
+ } |
+ rc = SQLITE_NOTADB; |
+ } |
+#endif |
+ |
+ /* EVIDENCE-OF: R-15465-20813 The maximum and minimum embedded payload |
+ ** fractions and the leaf payload fraction values must be 64, 32, and 32. |
+ ** |
+ ** 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; |
+ } |
+ /* EVIDENCE-OF: R-51873-39618 The page size for a database file is |
+ ** determined by the 2-byte integer located at an offset of 16 bytes from |
+ ** the beginning of the database file. */ |
+ pageSize = (page1[16]<<8) | (page1[17]<<16); |
+ /* EVIDENCE-OF: R-25008-21688 The size of a page is a power of two |
+ ** between 512 and 65536 inclusive. */ |
+ if( ((pageSize-1)&pageSize)!=0 |
+ || pageSize>SQLITE_MAX_PAGE_SIZE |
+ || pageSize<=256 |
+ ){ |
+ goto page1_init_failed; |
+ } |
+ assert( (pageSize & 7)==0 ); |
+ /* EVIDENCE-OF: R-59310-51205 The "reserved space" size in the 1-byte |
+ ** integer at offset 20 is the number of bytes of space at the end of |
+ ** each page to reserve for extensions. |
+ ** |
+ ** EVIDENCE-OF: R-37497-42412 The size of the reserved region is |
+ ** determined by the one-byte unsigned integer found at an offset of 20 |
+ ** into the database file header. */ |
+ 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; |
+ } |
+ /* EVIDENCE-OF: R-28312-64704 However, the usable size is not allowed to |
+ ** be less than 480. In other words, if the page size is 512, then the |
+ ** reserved space size cannot exceed 32. */ |
+ 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); |
+ if( pBt->maxLocal>127 ){ |
+ pBt->max1bytePayload = 127; |
+ }else{ |
+ pBt->max1bytePayload = (u8)pBt->maxLocal; |
+ } |
+ 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; |
+} |
+ |
+#ifndef NDEBUG |
+/* |
+** Return the number of cursors open on pBt. This is for use |
+** in assert() expressions, so it is only compiled if NDEBUG is not |
+** defined. |
+** |
+** Only write cursors are counted if wrOnly is true. If wrOnly is |
+** false then all cursors are counted. |
+** |
+** For the purposes of this routine, a cursor is any cursor that |
+** is capable of reading or writing to the database. Cursors that |
+** have been tripped into the CURSOR_FAULT state are not counted. |
+*/ |
+static int countValidCursors(BtShared *pBt, int wrOnly){ |
+ BtCursor *pCur; |
+ int r = 0; |
+ for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){ |
+ if( (wrOnly==0 || (pCur->curFlags & BTCF_WriteFlag)!=0) |
+ && pCur->eState!=CURSOR_FAULT ) r++; |
+ } |
+ return r; |
+} |
+#endif |
+ |
+/* |
+** 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( countValidCursors(pBt,0)==0 || pBt->inTransaction>TRANS_NONE ); |
+ if( pBt->inTransaction==TRANS_NONE && pBt->pPage1!=0 ){ |
+ MemPage *pPage1 = pBt->pPage1; |
+ assert( pPage1->aData ); |
+ assert( sqlite3PagerRefcount(pBt->pPager)==1 ); |
+ pBt->pPage1 = 0; |
+ releasePageNotNull(pPage1); |
+ } |
+} |
+ |
+/* |
+** 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->btsFlags |= BTS_PAGESIZE_FIXED; |
+#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; |
+} |
+ |
+/* |
+** Initialize the first page of the database file (creating a database |
+** consisting of a single page and no schema objects). Return SQLITE_OK |
+** if successful, or an SQLite error code otherwise. |
+*/ |
+int sqlite3BtreeNewDb(Btree *p){ |
+ int rc; |
+ sqlite3BtreeEnter(p); |
+ p->pBt->nPage = 0; |
+ rc = newDatabase(p->pBt); |
+ sqlite3BtreeLeave(p); |
+ return rc; |
+} |
+ |
+/* |
+** 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){ |
+ 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; |
+ } |
+ assert( pBt->inTransaction==TRANS_WRITE || IfNotOmitAV(pBt->bDoTruncate)==0 ); |
+ |
+ /* Write transactions are not possible on a read-only database */ |
+ if( (pBt->btsFlags & BTS_READ_ONLY)!=0 && wrflag ){ |
+ rc = SQLITE_READONLY; |
+ goto trans_begun; |
+ } |
+ |
+#ifndef SQLITE_OMIT_SHARED_CACHE |
+ { |
+ sqlite3 *pBlock = 0; |
+ /* 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->btsFlags & BTS_PENDING)!=0 |
+ ){ |
+ 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->btsFlags &= ~BTS_INITIALLY_EMPTY; |
+ if( pBt->nPage==0 ) pBt->btsFlags |= BTS_INITIALLY_EMPTY; |
+ 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->btsFlags & BTS_READ_ONLY)!=0 ){ |
+ 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->btsFlags &= ~BTS_EXCLUSIVE; |
+ if( wrflag>1 ) pBt->btsFlags |= BTS_EXCLUSIVE; |
+#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; |
+ Pgno pgno = pPage->pgno; |
+ |
+ assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
+ rc = btreeInitPage(pPage); |
+ if( rc!=SQLITE_OK ) return rc; |
+ 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); |
+ } |
+ |
+ 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{ |
+ int i; |
+ int nCell; |
+ int rc; |
+ |
+ rc = btreeInitPage(pPage); |
+ if( rc ) return rc; |
+ nCell = pPage->nCell; |
+ |
+ for(i=0; i<nCell; i++){ |
+ u8 *pCell = findCell(pPage, i); |
+ if( eType==PTRMAP_OVERFLOW1 ){ |
+ CellInfo info; |
+ pPage->xParseCell(pPage, pCell, &info); |
+ if( info.nLocal<info.nPayload ){ |
+ if( pCell+info.nSize > pPage->aData+pPage->pBt->usableSize ){ |
+ return SQLITE_CORRUPT_BKPT; |
+ } |
+ if( iFrom==get4byte(pCell+info.nSize-4) ){ |
+ put4byte(pCell+info.nSize-4, 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); |
+ } |
+ } |
+ 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. Or, if an error |
+** occurs, return some other error code. |
+** |
+** More specifically, this function attempts to re-organize the database so |
+** that the last page of the file currently in use is no longer in use. |
+** |
+** Parameter nFin is the number of pages that this database would contain |
+** were this function called until it returns SQLITE_DONE. |
+** |
+** If the bCommit parameter is non-zero, this function assumes that the |
+** caller will keep calling incrVacuumStep() until it returns SQLITE_DONE |
+** or an error. bCommit is passed true for an auto-vacuum-on-commit |
+** operation, or false for an incremental vacuum. |
+*/ |
+static int incrVacuumStep(BtShared *pBt, Pgno nFin, Pgno iLastPg, int bCommit){ |
+ 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( bCommit==0 ){ |
+ /* Remove the page from the files free-list. This is not required |
+ ** if bCommit 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, BTALLOC_EXACT); |
+ if( rc!=SQLITE_OK ){ |
+ return rc; |
+ } |
+ assert( iFreePg==iLastPg ); |
+ releasePage(pFreePg); |
+ } |
+ } else { |
+ Pgno iFreePg; /* Index of free page to move pLastPg to */ |
+ MemPage *pLastPg; |
+ u8 eMode = BTALLOC_ANY; /* Mode parameter for allocateBtreePage() */ |
+ Pgno iNear = 0; /* nearby parameter for allocateBtreePage() */ |
+ |
+ rc = btreeGetPage(pBt, iLastPg, &pLastPg, 0); |
+ if( rc!=SQLITE_OK ){ |
+ return rc; |
+ } |
+ |
+ /* If bCommit 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 bCommit is greater than zero, then keep |
+ ** looping until a free-page located within the first nFin pages |
+ ** of the file is found. |
+ */ |
+ if( bCommit==0 ){ |
+ eMode = BTALLOC_LE; |
+ iNear = nFin; |
+ } |
+ do { |
+ MemPage *pFreePg; |
+ rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, iNear, eMode); |
+ if( rc!=SQLITE_OK ){ |
+ releasePage(pLastPg); |
+ return rc; |
+ } |
+ releasePage(pFreePg); |
+ }while( bCommit && iFreePg>nFin ); |
+ assert( iFreePg<iLastPg ); |
+ |
+ rc = relocatePage(pBt, pLastPg, eType, iPtrPage, iFreePg, bCommit); |
+ releasePage(pLastPg); |
+ if( rc!=SQLITE_OK ){ |
+ return rc; |
+ } |
+ } |
+ } |
+ |
+ if( bCommit==0 ){ |
+ do { |
+ iLastPg--; |
+ }while( iLastPg==PENDING_BYTE_PAGE(pBt) || PTRMAP_ISPAGE(pBt, iLastPg) ); |
+ pBt->bDoTruncate = 1; |
+ pBt->nPage = iLastPg; |
+ } |
+ return SQLITE_OK; |
+} |
+ |
+/* |
+** The database opened by the first argument is an auto-vacuum database |
+** nOrig pages in size containing nFree free pages. Return the expected |
+** size of the database in pages following an auto-vacuum operation. |
+*/ |
+static Pgno finalDbSize(BtShared *pBt, Pgno nOrig, Pgno nFree){ |
+ int nEntry; /* Number of entries on one ptrmap page */ |
+ Pgno nPtrmap; /* Number of PtrMap pages to be freed */ |
+ Pgno nFin; /* Return value */ |
+ |
+ 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--; |
+ } |
+ |
+ return nFin; |
+} |
+ |
+/* |
+** 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{ |
+ Pgno nOrig = btreePagecount(pBt); |
+ Pgno nFree = get4byte(&pBt->pPage1->aData[36]); |
+ Pgno nFin = finalDbSize(pBt, nOrig, nFree); |
+ |
+ if( nOrig<nFin ){ |
+ rc = SQLITE_CORRUPT_BKPT; |
+ }else if( nFree>0 ){ |
+ rc = saveAllCursors(pBt, 0, 0); |
+ if( rc==SQLITE_OK ){ |
+ invalidateAllOverflowCache(pBt); |
+ rc = incrVacuumStep(pBt, nFin, nOrig, 0); |
+ } |
+ if( rc==SQLITE_OK ){ |
+ rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); |
+ put4byte(&pBt->pPage1->aData[28], pBt->nPage); |
+ } |
+ }else{ |
+ rc = SQLITE_DONE; |
+ } |
+ } |
+ sqlite3BtreeLeave(p); |
+ return rc; |
+} |
+ |
+/* |
+** This routine is called prior to sqlite3PagerCommit when a transaction |
+** is committed 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 iFree; /* The next page to be freed */ |
+ 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]); |
+ nFin = finalDbSize(pBt, nOrig, nFree); |
+ if( nFin>nOrig ) return SQLITE_CORRUPT_BKPT; |
+ if( nFin<nOrig ){ |
+ rc = saveAllCursors(pBt, 0, 0); |
+ } |
+ for(iFree=nOrig; iFree>nFin && rc==SQLITE_OK; iFree--){ |
+ rc = incrVacuumStep(pBt, nFin, iFree, 1); |
+ } |
+ 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); |
+ pBt->bDoTruncate = 1; |
+ 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; |
+ } |
+ } |
+ if( pBt->bDoTruncate ){ |
+ sqlite3PagerTruncateImage(pBt->pPager, pBt->nPage); |
+ } |
+#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; |
+ sqlite3 *db = p->db; |
+ assert( sqlite3BtreeHoldsMutex(p) ); |
+ |
+#ifndef SQLITE_OMIT_AUTOVACUUM |
+ pBt->bDoTruncate = 0; |
+#endif |
+ if( p->inTrans>TRANS_NONE && db->nVdbeRead>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; |
+ } |
+ p->iDataVersion--; /* Compensate for pPager->iDataVersion++; */ |
+ pBt->inTransaction = TRANS_READ; |
+ btreeClearHasContent(pBt); |
+ } |
+ |
+ 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; |
+} |
+ |
+/* |
+** This routine sets the state to CURSOR_FAULT and the error |
+** code to errCode for every cursor on any BtShared that pBtree |
+** references. Or if the writeOnly flag is set to 1, then only |
+** trip write cursors and leave read cursors unchanged. |
+** |
+** Every cursor is a candidate to be 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. If the writeOnly |
+** flag is true, then only write-cursors need be tripped - read-only |
+** cursors save their current positions so that they may continue |
+** following the rollback. Or, if writeOnly is false, all cursors are |
+** tripped. In general, writeOnly is false if the transaction being |
+** rolled back modified the database schema. In this case b-tree root |
+** pages may be moved or deleted from the database altogether, making |
+** it unsafe for read cursors to continue. |
+** |
+** If the writeOnly flag is true and an error is encountered while |
+** saving the current position of a read-only cursor, all cursors, |
+** including all read-cursors are tripped. |
+** |
+** SQLITE_OK is returned if successful, or if an error occurs while |
+** saving a cursor position, an SQLite error code. |
+*/ |
+int sqlite3BtreeTripAllCursors(Btree *pBtree, int errCode, int writeOnly){ |
+ BtCursor *p; |
+ int rc = SQLITE_OK; |
+ |
+ assert( (writeOnly==0 || writeOnly==1) && BTCF_WriteFlag==1 ); |
+ if( pBtree ){ |
+ sqlite3BtreeEnter(pBtree); |
+ for(p=pBtree->pBt->pCursor; p; p=p->pNext){ |
+ int i; |
+ if( writeOnly && (p->curFlags & BTCF_WriteFlag)==0 ){ |
+ if( p->eState==CURSOR_VALID || p->eState==CURSOR_SKIPNEXT ){ |
+ rc = saveCursorPosition(p); |
+ if( rc!=SQLITE_OK ){ |
+ (void)sqlite3BtreeTripAllCursors(pBtree, rc, 0); |
+ break; |
+ } |
+ } |
+ }else{ |
+ 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); |
+ } |
+ return rc; |
+} |
+ |
+/* |
+** Rollback the transaction in progress. |
+** |
+** If tripCode is not SQLITE_OK then cursors will be invalidated (tripped). |
+** Only write cursors are tripped if writeOnly is true but all cursors are |
+** tripped if writeOnly is false. Any attempt to use |
+** a tripped cursor 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 tripCode, int writeOnly){ |
+ int rc; |
+ BtShared *pBt = p->pBt; |
+ MemPage *pPage1; |
+ |
+ assert( writeOnly==1 || writeOnly==0 ); |
+ assert( tripCode==SQLITE_ABORT_ROLLBACK || tripCode==SQLITE_OK ); |
+ sqlite3BtreeEnter(p); |
+ if( tripCode==SQLITE_OK ){ |
+ rc = tripCode = saveAllCursors(pBt, 0, 0); |
+ if( rc ) writeOnly = 0; |
+ }else{ |
+ rc = SQLITE_OK; |
+ } |
+ if( tripCode ){ |
+ int rc2 = sqlite3BtreeTripAllCursors(p, tripCode, writeOnly); |
+ assert( rc==SQLITE_OK || (writeOnly==0 && rc2==SQLITE_OK) ); |
+ if( rc2!=SQLITE_OK ) rc = rc2; |
+ } |
+ 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( countValidCursors(pBt, 1)==0 ); |
+ pBt->inTransaction = TRANS_READ; |
+ btreeClearHasContent(pBt); |
+ } |
+ |
+ btreeEndTransaction(p); |
+ sqlite3BtreeLeave(p); |
+ return rc; |
+} |
+ |
+/* |
+** Start a statement subtransaction. The subtransaction 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->btsFlags & BTS_READ_ONLY)==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); |
+ if( op==SAVEPOINT_ROLLBACK ){ |
+ rc = saveAllCursors(pBt, 0, 0); |
+ } |
+ if( rc==SQLITE_OK ){ |
+ rc = sqlite3PagerSavepoint(pBt->pPager, op, iSavepoint); |
+ } |
+ if( rc==SQLITE_OK ){ |
+ if( iSavepoint<0 && (pBt->btsFlags & BTS_INITIALLY_EMPTY)!=0 ){ |
+ 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 the BTREE_WRCSR bit of wrFlag is clear, then the cursor can only |
+** be used for reading. If the BTREE_WRCSR bit is set, 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 containing BTREE_WRCSR |
+** |
+** 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. |
+** |
+** The BTREE_FORDELETE bit of wrFlag may optionally be set if BTREE_WRCSR |
+** is set. If FORDELETE is set, that is a hint to the implementation that |
+** this cursor will only be used to seek to and delete entries of an index |
+** as part of a larger DELETE statement. The FORDELETE hint is not used by |
+** this implementation. But in a hypothetical alternative storage engine |
+** in which index entries are automatically deleted when corresponding table |
+** rows are deleted, the FORDELETE flag is a hint that all SEEK and DELETE |
+** operations on this cursor can be no-ops and all READ operations can |
+** return a null row (2-bytes: 0x01 0x00). |
+** |
+** 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 */ |
+ BtCursor *pX; /* Looping over other all cursors */ |
+ |
+ assert( sqlite3BtreeHoldsMutex(p) ); |
+ assert( wrFlag==0 |
+ || wrFlag==BTREE_WRCSR |
+ || wrFlag==(BTREE_WRCSR|BTREE_FORDELETE) |
+ ); |
+ |
+ /* 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?2: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 ); |
+ assert( wrFlag==0 || (pBt->btsFlags & BTS_READ_ONLY)==0 ); |
+ |
+ if( wrFlag ){ |
+ allocateTempSpace(pBt); |
+ if( pBt->pTmpSpace==0 ) return SQLITE_NOMEM_BKPT; |
+ } |
+ if( iTable==1 && btreePagecount(pBt)==0 ){ |
+ assert( wrFlag==0 ); |
+ iTable = 0; |
+ } |
+ |
+ /* 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->curFlags = wrFlag ? BTCF_WriteFlag : 0; |
+ pCur->curPagerFlags = wrFlag ? 0 : PAGER_GET_READONLY; |
+ /* If there are two or more cursors on the same btree, then all such |
+ ** cursors *must* have the BTCF_Multiple flag set. */ |
+ for(pX=pBt->pCursor; pX; pX=pX->pNext){ |
+ if( pX->pgnoRoot==(Pgno)iTable ){ |
+ pX->curFlags |= BTCF_Multiple; |
+ pCur->curFlags |= BTCF_Multiple; |
+ } |
+ } |
+ pCur->pNext = pBt->pCursor; |
+ pBt->pCursor = pCur; |
+ pCur->eState = CURSOR_INVALID; |
+ 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; |
+ if( iTable<1 ){ |
+ rc = SQLITE_CORRUPT_BKPT; |
+ }else{ |
+ 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)); |
+} |
+ |
+/* |
+** 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); |
+ assert( pBt->pCursor!=0 ); |
+ if( pBt->pCursor==pCur ){ |
+ pBt->pCursor = pCur->pNext; |
+ }else{ |
+ BtCursor *pPrev = pBt->pCursor; |
+ do{ |
+ if( pPrev->pNext==pCur ){ |
+ pPrev->pNext = pCur->pNext; |
+ break; |
+ } |
+ pPrev = pPrev->pNext; |
+ }while( ALWAYS(pPrev) ); |
+ } |
+ for(i=0; i<=pCur->iPage; i++){ |
+ releasePage(pCur->apPage[i]); |
+ } |
+ unlockBtreeIfUnused(pBt); |
+ sqlite3_free(pCur->aOverflow); |
+ /* 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(). |
+*/ |
+#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( CORRUPT_DB || memcmp(&info, &pCur->info, sizeof(info))==0 ); |
+ } |
+#else |
+ #define assertCellInfo(x) |
+#endif |
+static SQLITE_NOINLINE void getCellInfo(BtCursor *pCur){ |
+ if( pCur->info.nSize==0 ){ |
+ int iPage = pCur->iPage; |
+ pCur->curFlags |= BTCF_ValidNKey; |
+ btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info); |
+ }else{ |
+ assertCellInfo(pCur); |
+ } |
+} |
+ |
+#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 */ |
+int sqlite3BtreeCursorIsValidNN(BtCursor *pCur){ |
+ assert( pCur!=0 ); |
+ return pCur->eState==CURSOR_VALID; |
+} |
+ |
+/* |
+** Return the value of the integer key or "rowid" for a table btree. |
+** This routine is only valid for a cursor that is pointing into a |
+** ordinary table btree. If the cursor points to an index btree or |
+** is invalid, the result of this routine is undefined. |
+*/ |
+i64 sqlite3BtreeIntegerKey(BtCursor *pCur){ |
+ assert( cursorHoldsMutex(pCur) ); |
+ assert( pCur->eState==CURSOR_VALID ); |
+ assert( pCur->curIntKey ); |
+ getCellInfo(pCur); |
+ return pCur->info.nKey; |
+} |
+ |
+/* |
+** Return the number of bytes of payload for the entry that pCur is |
+** currently pointing to. For table btrees, this will be the amount |
+** of data. For index btrees, this will be the size of the key. |
+** |
+** 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. |
+*/ |
+u32 sqlite3BtreePayloadSize(BtCursor *pCur){ |
+ assert( cursorHoldsMutex(pCur) ); |
+ assert( pCur->eState==CURSOR_VALID ); |
+ getCellInfo(pCur); |
+ return pCur->info.nPayload; |
+} |
+ |
+/* |
+** 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, (ppPage==0) ? PAGER_GET_READONLY : 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. The eOp |
+** argument is interpreted as follows: |
+** |
+** 0: The operation is a read. Populate the overflow cache. |
+** 1: The operation is a write. Populate the overflow cache. |
+** |
+** 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 current cursor entry uses one or more overflow pages |
+** this function may allocate space for and lazily populate |
+** 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 must 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; |
+ int iIdx = 0; |
+ MemPage *pPage = pCur->apPage[pCur->iPage]; /* Btree page of current entry */ |
+ BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */ |
+#ifdef SQLITE_DIRECT_OVERFLOW_READ |
+ unsigned char * const pBufStart = pBuf; /* Start of original out buffer */ |
+#endif |
+ |
+ assert( pPage ); |
+ assert( eOp==0 || eOp==1 ); |
+ assert( pCur->eState==CURSOR_VALID ); |
+ assert( pCur->aiIdx[pCur->iPage]<pPage->nCell ); |
+ assert( cursorHoldsMutex(pCur) ); |
+ |
+ getCellInfo(pCur); |
+ aPayload = pCur->info.pPayload; |
+ assert( offset+amt <= pCur->info.nPayload ); |
+ |
+ assert( aPayload > pPage->aData ); |
+ if( (uptr)(aPayload - pPage->aData) > (pBt->usableSize - pCur->info.nLocal) ){ |
+ /* Trying to read or write past the end of the data is an error. The |
+ ** conditional above is really: |
+ ** &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize] |
+ ** but is recast into its current form to avoid integer overflow problems |
+ */ |
+ 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]); |
+ |
+ /* If the BtCursor.aOverflow[] has not been allocated, allocate it now. |
+ ** |
+ ** The aOverflow[] 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->curFlags & BTCF_ValidOvfl)==0 ){ |
+ int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize; |
+ if( nOvfl>pCur->nOvflAlloc ){ |
+ Pgno *aNew = (Pgno*)sqlite3Realloc( |
+ pCur->aOverflow, nOvfl*2*sizeof(Pgno) |
+ ); |
+ if( aNew==0 ){ |
+ return SQLITE_NOMEM_BKPT; |
+ }else{ |
+ pCur->nOvflAlloc = nOvfl*2; |
+ pCur->aOverflow = aNew; |
+ } |
+ } |
+ memset(pCur->aOverflow, 0, nOvfl*sizeof(Pgno)); |
+ pCur->curFlags |= BTCF_ValidOvfl; |
+ }else{ |
+ /* 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[offset/ovflSize] ){ |
+ iIdx = (offset/ovflSize); |
+ nextPage = pCur->aOverflow[iIdx]; |
+ offset = (offset%ovflSize); |
+ } |
+ } |
+ |
+ assert( rc==SQLITE_OK && amt>0 ); |
+ while( nextPage ){ |
+ /* If required, populate the overflow page-list cache. */ |
+ assert( pCur->aOverflow[iIdx]==0 |
+ || pCur->aOverflow[iIdx]==nextPage |
+ || CORRUPT_DB ); |
+ pCur->aOverflow[iIdx] = nextPage; |
+ |
+ 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. |
+ */ |
+ assert( pCur->curFlags & BTCF_ValidOvfl ); |
+ assert( pCur->pBtree->db==pBt->db ); |
+ if( pCur->aOverflow[iIdx+1] ){ |
+ nextPage = pCur->aOverflow[iIdx+1]; |
+ }else{ |
+ 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). |
+ */ |
+#ifdef SQLITE_DIRECT_OVERFLOW_READ |
+ sqlite3_file *fd; /* File from which to do direct overflow read */ |
+#endif |
+ int a = amt; |
+ if( a + offset > ovflSize ){ |
+ a = ovflSize - offset; |
+ } |
+ |
+#ifdef SQLITE_DIRECT_OVERFLOW_READ |
+ /* If all the following are true: |
+ ** |
+ ** 1) this is a read operation, and |
+ ** 2) data is required from the start of this overflow page, and |
+ ** 3) there is no open write-transaction, and |
+ ** 4) the database is file-backed, and |
+ ** 5) the page is not in the WAL file |
+ ** 6) at least 4 bytes have already been read into the output buffer |
+ ** |
+ ** then data can be read directly from the database file into the |
+ ** output buffer, bypassing the page-cache altogether. This speeds |
+ ** up loading large records that span many overflow pages. |
+ */ |
+ if( eOp==0 /* (1) */ |
+ && offset==0 /* (2) */ |
+ && pBt->inTransaction==TRANS_READ /* (3) */ |
+ && (fd = sqlite3PagerFile(pBt->pPager))->pMethods /* (4) */ |
+ && 0==sqlite3PagerUseWal(pBt->pPager, nextPage) /* (5) */ |
+ && &pBuf[-4]>=pBufStart /* (6) */ |
+ ){ |
+ u8 aSave[4]; |
+ u8 *aWrite = &pBuf[-4]; |
+ assert( aWrite>=pBufStart ); /* due to (6) */ |
+ memcpy(aSave, aWrite, 4); |
+ rc = sqlite3OsRead(fd, aWrite, a+4, (i64)pBt->pageSize*(nextPage-1)); |
+ nextPage = get4byte(aWrite); |
+ memcpy(aWrite, aSave, 4); |
+ }else |
+#endif |
+ |
+ { |
+ DbPage *pDbPage; |
+ rc = sqlite3PagerGet(pBt->pPager, nextPage, &pDbPage, |
+ (eOp==0 ? PAGER_GET_READONLY : 0) |
+ ); |
+ if( rc==SQLITE_OK ){ |
+ aPayload = sqlite3PagerGetData(pDbPage); |
+ nextPage = get4byte(aPayload); |
+ rc = copyPayload(&aPayload[offset+4], pBuf, a, eOp, pDbPage); |
+ sqlite3PagerUnref(pDbPage); |
+ offset = 0; |
+ } |
+ } |
+ amt -= a; |
+ if( amt==0 ) return rc; |
+ pBuf += a; |
+ } |
+ if( rc ) break; |
+ iIdx++; |
+ } |
+ } |
+ |
+ if( rc==SQLITE_OK && amt>0 ){ |
+ return SQLITE_CORRUPT_BKPT; /* Overflow chain ends prematurely */ |
+ } |
+ return rc; |
+} |
+ |
+/* |
+** Read part of the payload for the row at which that cursor pCur is currently |
+** pointing. "amt" bytes will be transferred into pBuf[]. The transfer |
+** begins at "offset". |
+** |
+** pCur can be pointing to either a table or an index b-tree. |
+** If pointing to a table btree, then the content section is read. If |
+** pCur is pointing to an index b-tree then the key section is read. |
+** |
+** For sqlite3BtreePayload(), the caller must ensure that pCur is pointing |
+** to a valid row in the table. For sqlite3BtreePayloadChecked(), the |
+** cursor might be invalid or might need to be restored before being read. |
+** |
+** 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 sqlite3BtreePayload(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); |
+} |
+ |
+/* |
+** This variant of sqlite3BtreePayload() works even if the cursor has not |
+** in the CURSOR_VALID state. It is only used by the sqlite3_blob_read() |
+** interface. |
+*/ |
+#ifndef SQLITE_OMIT_INCRBLOB |
+static SQLITE_NOINLINE int accessPayloadChecked( |
+ BtCursor *pCur, |
+ u32 offset, |
+ u32 amt, |
+ void *pBuf |
+){ |
+ int rc; |
+ if ( pCur->eState==CURSOR_INVALID ){ |
+ return SQLITE_ABORT; |
+ } |
+ assert( cursorOwnsBtShared(pCur) ); |
+ rc = btreeRestoreCursorPosition(pCur); |
+ return rc ? rc : accessPayload(pCur, offset, amt, pBuf, 0); |
+} |
+int sqlite3BtreePayloadChecked(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){ |
+ if( pCur->eState==CURSOR_VALID ){ |
+ assert( cursorOwnsBtShared(pCur) ); |
+ return accessPayload(pCur, offset, amt, pBuf, 0); |
+ }else{ |
+ return accessPayloadChecked(pCur, offset, amt, pBuf); |
+ } |
+} |
+#endif /* SQLITE_OMIT_INCRBLOB */ |
+ |
+/* |
+** 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 index btrees (pPage->intKey==0) and is the data for |
+** table btrees (pPage->intKey==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 void *fetchPayload( |
+ BtCursor *pCur, /* Cursor pointing to entry to read from */ |
+ u32 *pAmt /* Write the number of available bytes here */ |
+){ |
+ u32 amt; |
+ assert( pCur!=0 && pCur->iPage>=0 && pCur->apPage[pCur->iPage]); |
+ assert( pCur->eState==CURSOR_VALID ); |
+ assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); |
+ assert( cursorOwnsBtShared(pCur) ); |
+ assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell ); |
+ assert( pCur->info.nSize>0 ); |
+ assert( pCur->info.pPayload>pCur->apPage[pCur->iPage]->aData || CORRUPT_DB ); |
+ assert( pCur->info.pPayload<pCur->apPage[pCur->iPage]->aDataEnd ||CORRUPT_DB); |
+ amt = (int)(pCur->apPage[pCur->iPage]->aDataEnd - pCur->info.pPayload); |
+ if( pCur->info.nLocal<amt ) amt = pCur->info.nLocal; |
+ *pAmt = amt; |
+ return (void*)pCur->info.pPayload; |
+} |
+ |
+ |
+/* |
+** 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 *sqlite3BtreePayloadFetch(BtCursor *pCur, u32 *pAmt){ |
+ return fetchPayload(pCur, pAmt); |
+} |
+ |
+ |
+/* |
+** 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){ |
+ BtShared *pBt = pCur->pBt; |
+ |
+ assert( cursorOwnsBtShared(pCur) ); |
+ assert( pCur->eState==CURSOR_VALID ); |
+ assert( pCur->iPage<BTCURSOR_MAX_DEPTH ); |
+ assert( pCur->iPage>=0 ); |
+ if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){ |
+ return SQLITE_CORRUPT_BKPT; |
+ } |
+ pCur->info.nSize = 0; |
+ pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl); |
+ pCur->iPage++; |
+ pCur->aiIdx[pCur->iPage] = 0; |
+ return getAndInitPage(pBt, newPgno, &pCur->apPage[pCur->iPage], |
+ pCur, pCur->curPagerFlags); |
+} |
+ |
+#if SQLITE_DEBUG |
+/* |
+** 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){ |
+ if( CORRUPT_DB ) return; /* The conditions tested below might not be true |
+ ** in a corrupt database */ |
+ 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( cursorOwnsBtShared(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 |
+ ); |
+ testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell ); |
+ pCur->info.nSize = 0; |
+ pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl); |
+ releasePageNotNull(pCur->apPage[pCur->iPage--]); |
+} |
+ |
+/* |
+** 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; |
+ |
+ assert( cursorOwnsBtShared(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 ){ |
+ if( pCur->iPage ){ |
+ do{ |
+ assert( pCur->apPage[pCur->iPage]!=0 ); |
+ releasePageNotNull(pCur->apPage[pCur->iPage--]); |
+ }while( pCur->iPage); |
+ goto skip_init; |
+ } |
+ }else if( pCur->pgnoRoot==0 ){ |
+ pCur->eState = CURSOR_INVALID; |
+ return SQLITE_OK; |
+ }else{ |
+ assert( pCur->iPage==(-1) ); |
+ rc = getAndInitPage(pCur->pBtree->pBt, pCur->pgnoRoot, &pCur->apPage[0], |
+ 0, pCur->curPagerFlags); |
+ if( rc!=SQLITE_OK ){ |
+ pCur->eState = CURSOR_INVALID; |
+ return rc; |
+ } |
+ pCur->iPage = 0; |
+ pCur->curIntKey = pCur->apPage[0]->intKey; |
+ } |
+ pRoot = pCur->apPage[0]; |
+ assert( pRoot->pgno==pCur->pgnoRoot ); |
+ |
+ /* 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. |
+ ** |
+ ** Earlier versions of SQLite assumed that this test could not fail |
+ ** if the root page was already loaded when this function was called (i.e. |
+ ** if pCur->iPage>=0). But this is not so if the database is corrupted |
+ ** in such a way that page pRoot is linked into a second b-tree table |
+ ** (or the freelist). */ |
+ assert( pRoot->intKey==1 || pRoot->intKey==0 ); |
+ if( pRoot->isInit==0 || (pCur->pKeyInfo==0)!=pRoot->intKey ){ |
+ return SQLITE_CORRUPT_BKPT; |
+ } |
+ |
+skip_init: |
+ pCur->aiIdx[0] = 0; |
+ pCur->info.nSize = 0; |
+ pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidNKey|BTCF_ValidOvfl); |
+ |
+ pRoot = pCur->apPage[0]; |
+ if( pRoot->nCell>0 ){ |
+ pCur->eState = CURSOR_VALID; |
+ }else if( !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 = 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( cursorOwnsBtShared(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( cursorOwnsBtShared(pCur) ); |
+ assert( pCur->eState==CURSOR_VALID ); |
+ while( !(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 ) return rc; |
+ } |
+ pCur->aiIdx[pCur->iPage] = pPage->nCell-1; |
+ assert( pCur->info.nSize==0 ); |
+ assert( (pCur->curFlags & BTCF_ValidNKey)==0 ); |
+ return SQLITE_OK; |
+} |
+ |
+/* 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( cursorOwnsBtShared(pCur) ); |
+ assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); |
+ rc = moveToRoot(pCur); |
+ if( rc==SQLITE_OK ){ |
+ if( pCur->eState==CURSOR_INVALID ){ |
+ assert( pCur->pgnoRoot==0 || 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( cursorOwnsBtShared(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->curFlags & BTCF_AtLast)!=0 ){ |
+#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->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 ); |
+ *pRes = 1; |
+ }else{ |
+ assert( pCur->eState==CURSOR_VALID ); |
+ *pRes = 0; |
+ rc = moveToRightmost(pCur); |
+ if( rc==SQLITE_OK ){ |
+ pCur->curFlags |= BTCF_AtLast; |
+ }else{ |
+ pCur->curFlags &= ~BTCF_AtLast; |
+ } |
+ |
+ } |
+ } |
+ 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. |
+** |
+** For index tables, the pIdxKey->eqSeen field is set to 1 if there |
+** exists an entry in the table that exactly matches 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; |
+ RecordCompare xRecordCompare; |
+ |
+ assert( cursorOwnsBtShared(pCur) ); |
+ assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); |
+ assert( pRes ); |
+ assert( (pIdxKey==0)==(pCur->pKeyInfo==0) ); |
+ assert( pCur->eState!=CURSOR_VALID || (pIdxKey==0)==(pCur->curIntKey!=0) ); |
+ |
+ /* If the cursor is already positioned at the point we are trying |
+ ** to move to, then just return without doing any work */ |
+ if( pIdxKey==0 |
+ && pCur->eState==CURSOR_VALID && (pCur->curFlags & BTCF_ValidNKey)!=0 |
+ ){ |
+ if( pCur->info.nKey==intKey ){ |
+ *pRes = 0; |
+ return SQLITE_OK; |
+ } |
+ if( pCur->info.nKey<intKey ){ |
+ if( (pCur->curFlags & BTCF_AtLast)!=0 ){ |
+ *pRes = -1; |
+ return SQLITE_OK; |
+ } |
+ /* If the requested key is one more than the previous key, then |
+ ** try to get there using sqlite3BtreeNext() rather than a full |
+ ** binary search. This is an optimization only. The correct answer |
+ ** is still obtained without this ase, only a little more slowely */ |
+ if( pCur->info.nKey+1==intKey && !pCur->skipNext ){ |
+ *pRes = 0; |
+ rc = sqlite3BtreeNext(pCur, pRes); |
+ if( rc ) return rc; |
+ if( *pRes==0 ){ |
+ getCellInfo(pCur); |
+ if( pCur->info.nKey==intKey ){ |
+ return SQLITE_OK; |
+ } |
+ } |
+ } |
+ } |
+ } |
+ |
+ if( pIdxKey ){ |
+ xRecordCompare = sqlite3VdbeFindCompare(pIdxKey); |
+ pIdxKey->errCode = 0; |
+ assert( pIdxKey->default_rc==1 |
+ || pIdxKey->default_rc==0 |
+ || pIdxKey->default_rc==-1 |
+ ); |
+ }else{ |
+ xRecordCompare = 0; /* All keys are integers */ |
+ } |
+ |
+ rc = moveToRoot(pCur); |
+ if( rc ){ |
+ return rc; |
+ } |
+ assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage] ); |
+ assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->isInit ); |
+ assert( pCur->eState==CURSOR_INVALID || pCur->apPage[pCur->iPage]->nCell>0 ); |
+ if( pCur->eState==CURSOR_INVALID ){ |
+ *pRes = -1; |
+ assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 ); |
+ return SQLITE_OK; |
+ } |
+ assert( pCur->apPage[0]->intKey==pCur->curIntKey ); |
+ assert( pCur->curIntKey || pIdxKey ); |
+ for(;;){ |
+ int lwr, upr, idx, c; |
+ Pgno chldPg; |
+ MemPage *pPage = pCur->apPage[pCur->iPage]; |
+ u8 *pCell; /* Pointer to current cell in pPage */ |
+ |
+ /* 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; |
+ assert( biasRight==0 || biasRight==1 ); |
+ idx = upr>>(1-biasRight); /* idx = biasRight ? upr : (lwr+upr)/2; */ |
+ pCur->aiIdx[pCur->iPage] = (u16)idx; |
+ if( xRecordCompare==0 ){ |
+ for(;;){ |
+ i64 nCellKey; |
+ pCell = findCellPastPtr(pPage, idx); |
+ if( pPage->intKeyLeaf ){ |
+ while( 0x80 <= *(pCell++) ){ |
+ if( pCell>=pPage->aDataEnd ) return SQLITE_CORRUPT_BKPT; |
+ } |
+ } |
+ getVarint(pCell, (u64*)&nCellKey); |
+ if( nCellKey<intKey ){ |
+ lwr = idx+1; |
+ if( lwr>upr ){ c = -1; break; } |
+ }else if( nCellKey>intKey ){ |
+ upr = idx-1; |
+ if( lwr>upr ){ c = +1; break; } |
+ }else{ |
+ assert( nCellKey==intKey ); |
+ pCur->aiIdx[pCur->iPage] = (u16)idx; |
+ if( !pPage->leaf ){ |
+ lwr = idx; |
+ goto moveto_next_layer; |
+ }else{ |
+ pCur->curFlags |= BTCF_ValidNKey; |
+ pCur->info.nKey = nCellKey; |
+ pCur->info.nSize = 0; |
+ *pRes = 0; |
+ return SQLITE_OK; |
+ } |
+ } |
+ assert( lwr+upr>=0 ); |
+ idx = (lwr+upr)>>1; /* idx = (lwr+upr)/2; */ |
+ } |
+ }else{ |
+ for(;;){ |
+ int nCell; /* Size of the pCell cell in bytes */ |
+ pCell = findCellPastPtr(pPage, idx); |
+ |
+ /* 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. |
+ */ |
+ nCell = pCell[0]; |
+ if( nCell<=pPage->max1bytePayload ){ |
+ /* 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. */ |
+ testcase( pCell+nCell+1==pPage->aDataEnd ); |
+ c = xRecordCompare(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. */ |
+ testcase( pCell+nCell+2==pPage->aDataEnd ); |
+ c = xRecordCompare(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. |
+ ** |
+ ** If the record is corrupt, the xRecordCompare routine may read |
+ ** up to two varints past the end of the buffer. An extra 18 |
+ ** bytes of padding is allocated at the end of the buffer in |
+ ** case this happens. */ |
+ void *pCellKey; |
+ u8 * const pCellBody = pCell - pPage->childPtrSize; |
+ pPage->xParseCell(pPage, pCellBody, &pCur->info); |
+ nCell = (int)pCur->info.nKey; |
+ testcase( nCell<0 ); /* True if key size is 2^32 or more */ |
+ testcase( nCell==0 ); /* Invalid key size: 0x80 0x80 0x00 */ |
+ testcase( nCell==1 ); /* Invalid key size: 0x80 0x80 0x01 */ |
+ testcase( nCell==2 ); /* Minimum legal index key size */ |
+ if( nCell<2 ){ |
+ rc = SQLITE_CORRUPT_BKPT; |
+ goto moveto_finish; |
+ } |
+ pCellKey = sqlite3Malloc( nCell+18 ); |
+ if( pCellKey==0 ){ |
+ rc = SQLITE_NOMEM_BKPT; |
+ goto moveto_finish; |
+ } |
+ pCur->aiIdx[pCur->iPage] = (u16)idx; |
+ rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0); |
+ pCur->curFlags &= ~BTCF_ValidOvfl; |
+ if( rc ){ |
+ sqlite3_free(pCellKey); |
+ goto moveto_finish; |
+ } |
+ c = xRecordCompare(nCell, pCellKey, pIdxKey); |
+ sqlite3_free(pCellKey); |
+ } |
+ assert( |
+ (pIdxKey->errCode!=SQLITE_CORRUPT || c==0) |
+ && (pIdxKey->errCode!=SQLITE_NOMEM || pCur->pBtree->db->mallocFailed) |
+ ); |
+ if( c<0 ){ |
+ lwr = idx+1; |
+ }else if( c>0 ){ |
+ upr = idx-1; |
+ }else{ |
+ assert( c==0 ); |
+ *pRes = 0; |
+ rc = SQLITE_OK; |
+ pCur->aiIdx[pCur->iPage] = (u16)idx; |
+ if( pIdxKey->errCode ) rc = SQLITE_CORRUPT; |
+ goto moveto_finish; |
+ } |
+ if( lwr>upr ) break; |
+ assert( lwr+upr>=0 ); |
+ idx = (lwr+upr)>>1; /* idx = (lwr+upr)/2 */ |
+ } |
+ } |
+ assert( lwr==upr+1 || (pPage->intKey && !pPage->leaf) ); |
+ assert( pPage->isInit ); |
+ if( pPage->leaf ){ |
+ assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell ); |
+ pCur->aiIdx[pCur->iPage] = (u16)idx; |
+ *pRes = c; |
+ rc = SQLITE_OK; |
+ goto moveto_finish; |
+ } |
+moveto_next_layer: |
+ if( lwr>=pPage->nCell ){ |
+ chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]); |
+ }else{ |
+ chldPg = get4byte(findCell(pPage, lwr)); |
+ } |
+ pCur->aiIdx[pCur->iPage] = (u16)lwr; |
+ rc = moveToChild(pCur, chldPg); |
+ if( rc ) break; |
+ } |
+moveto_finish: |
+ pCur->info.nSize = 0; |
+ assert( (pCur->curFlags & BTCF_ValidOvfl)==0 ); |
+ 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. |
+** |
+** The main entry point is sqlite3BtreeNext(). That routine is optimized |
+** for the common case of merely incrementing the cell counter BtCursor.aiIdx |
+** to the next cell on the current page. The (slower) btreeNext() helper |
+** routine is called when it is necessary to move to a different page or |
+** to restore the cursor. |
+** |
+** The calling function will set *pRes to 0 or 1. The initial *pRes value |
+** will be 1 if the cursor being stepped corresponds to an SQL index and |
+** if this routine could have been skipped if that SQL index had been |
+** a unique index. Otherwise the caller will have set *pRes to zero. |
+** Zero is the common case. The btree implementation is free to use the |
+** initial *pRes value as a hint to improve performance, but the current |
+** SQLite btree implementation does not. (Note that the comdb2 btree |
+** implementation does use this hint, however.) |
+*/ |
+static SQLITE_NOINLINE int btreeNext(BtCursor *pCur, int *pRes){ |
+ int rc; |
+ int idx; |
+ MemPage *pPage; |
+ |
+ assert( cursorOwnsBtShared(pCur) ); |
+ assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID ); |
+ assert( *pRes==0 ); |
+ if( pCur->eState!=CURSOR_VALID ){ |
+ assert( (pCur->curFlags & BTCF_ValidOvfl)==0 ); |
+ rc = restoreCursorPosition(pCur); |
+ if( rc!=SQLITE_OK ){ |
+ return rc; |
+ } |
+ if( CURSOR_INVALID==pCur->eState ){ |
+ *pRes = 1; |
+ return SQLITE_OK; |
+ } |
+ if( pCur->skipNext ){ |
+ assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_SKIPNEXT ); |
+ pCur->eState = CURSOR_VALID; |
+ if( pCur->skipNext>0 ){ |
+ pCur->skipNext = 0; |
+ return SQLITE_OK; |
+ } |
+ pCur->skipNext = 0; |
+ } |
+ } |
+ |
+ pPage = pCur->apPage[pCur->iPage]; |
+ idx = ++pCur->aiIdx[pCur->iPage]; |
+ assert( pPage->isInit ); |
+ |
+ /* If the database file is corrupt, it is possible for the value of idx |
+ ** to be invalid here. This can only occur if a second cursor modifies |
+ ** the page while cursor pCur is holding a reference to it. Which can |
+ ** only happen if the database is corrupt in such a way as to link the |
+ ** page into more than one b-tree structure. */ |
+ testcase( idx>pPage->nCell ); |
+ |
+ if( idx>=pPage->nCell ){ |
+ if( !pPage->leaf ){ |
+ rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8])); |
+ if( rc ) return rc; |
+ return moveToLeftmost(pCur); |
+ } |
+ 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 ); |
+ if( pPage->intKey ){ |
+ return sqlite3BtreeNext(pCur, pRes); |
+ }else{ |
+ return SQLITE_OK; |
+ } |
+ } |
+ if( pPage->leaf ){ |
+ return SQLITE_OK; |
+ }else{ |
+ return moveToLeftmost(pCur); |
+ } |
+} |
+int sqlite3BtreeNext(BtCursor *pCur, int *pRes){ |
+ MemPage *pPage; |
+ assert( cursorOwnsBtShared(pCur) ); |
+ assert( pRes!=0 ); |
+ assert( *pRes==0 || *pRes==1 ); |
+ assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID ); |
+ pCur->info.nSize = 0; |
+ pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl); |
+ *pRes = 0; |
+ if( pCur->eState!=CURSOR_VALID ) return btreeNext(pCur, pRes); |
+ pPage = pCur->apPage[pCur->iPage]; |
+ if( (++pCur->aiIdx[pCur->iPage])>=pPage->nCell ){ |
+ pCur->aiIdx[pCur->iPage]--; |
+ return btreeNext(pCur, pRes); |
+ } |
+ if( pPage->leaf ){ |
+ return SQLITE_OK; |
+ }else{ |
+ return moveToLeftmost(pCur); |
+ } |
+} |
+ |
+/* |
+** 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. |
+** |
+** The main entry point is sqlite3BtreePrevious(). That routine is optimized |
+** for the common case of merely decrementing the cell counter BtCursor.aiIdx |
+** to the previous cell on the current page. The (slower) btreePrevious() |
+** helper routine is called when it is necessary to move to a different page |
+** or to restore the cursor. |
+** |
+** The calling function will set *pRes to 0 or 1. The initial *pRes value |
+** will be 1 if the cursor being stepped corresponds to an SQL index and |
+** if this routine could have been skipped if that SQL index had been |
+** a unique index. Otherwise the caller will have set *pRes to zero. |
+** Zero is the common case. The btree implementation is free to use the |
+** initial *pRes value as a hint to improve performance, but the current |
+** SQLite btree implementation does not. (Note that the comdb2 btree |
+** implementation does use this hint, however.) |
+*/ |
+static SQLITE_NOINLINE int btreePrevious(BtCursor *pCur, int *pRes){ |
+ int rc; |
+ MemPage *pPage; |
+ |
+ assert( cursorOwnsBtShared(pCur) ); |
+ assert( pRes!=0 ); |
+ assert( *pRes==0 ); |
+ assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID ); |
+ assert( (pCur->curFlags & (BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey))==0 ); |
+ assert( pCur->info.nSize==0 ); |
+ if( pCur->eState!=CURSOR_VALID ){ |
+ rc = restoreCursorPosition(pCur); |
+ if( rc!=SQLITE_OK ){ |
+ return rc; |
+ } |
+ if( CURSOR_INVALID==pCur->eState ){ |
+ *pRes = 1; |
+ return SQLITE_OK; |
+ } |
+ if( pCur->skipNext ){ |
+ assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_SKIPNEXT ); |
+ pCur->eState = CURSOR_VALID; |
+ if( pCur->skipNext<0 ){ |
+ pCur->skipNext = 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); |
+ } |
+ assert( pCur->info.nSize==0 ); |
+ assert( (pCur->curFlags & (BTCF_ValidOvfl))==0 ); |
+ |
+ pCur->aiIdx[pCur->iPage]--; |
+ pPage = pCur->apPage[pCur->iPage]; |
+ if( pPage->intKey && !pPage->leaf ){ |
+ rc = sqlite3BtreePrevious(pCur, pRes); |
+ }else{ |
+ rc = SQLITE_OK; |
+ } |
+ } |
+ return rc; |
+} |
+int sqlite3BtreePrevious(BtCursor *pCur, int *pRes){ |
+ assert( cursorOwnsBtShared(pCur) ); |
+ assert( pRes!=0 ); |
+ assert( *pRes==0 || *pRes==1 ); |
+ assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID ); |
+ *pRes = 0; |
+ pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey); |
+ pCur->info.nSize = 0; |
+ if( pCur->eState!=CURSOR_VALID |
+ || pCur->aiIdx[pCur->iPage]==0 |
+ || pCur->apPage[pCur->iPage]->leaf==0 |
+ ){ |
+ return btreePrevious(pCur, pRes); |
+ } |
+ pCur->aiIdx[pCur->iPage]--; |
+ return SQLITE_OK; |
+} |
+ |
+/* |
+** 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 is set to NULL in the event of an error. |
+** |
+** If the "nearby" parameter is not 0, then an 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 eMode parameter is BTALLOC_EXACT and the nearby page exists |
+** anywhere on the free-list, then it is guaranteed to be returned. If |
+** eMode is BTALLOC_LT then the page returned will be less than or equal |
+** to nearby if any such page exists. If eMode is BTALLOC_ANY then there |
+** are no restrictions on which page is returned. |
+*/ |
+static int allocateBtreePage( |
+ BtShared *pBt, /* The btree */ |
+ MemPage **ppPage, /* Store pointer to the allocated page here */ |
+ Pgno *pPgno, /* Store the page number here */ |
+ Pgno nearby, /* Search for a page near this one */ |
+ u8 eMode /* BTALLOC_EXACT, BTALLOC_LT, or BTALLOC_ANY */ |
+){ |
+ 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) ); |
+ assert( eMode==BTALLOC_ANY || (nearby>0 && IfNotOmitAV(pBt->autoVacuum)) ); |
+ pPage1 = pBt->pPage1; |
+ mxPage = btreePagecount(pBt); |
+ /* EVIDENCE-OF: R-05119-02637 The 4-byte big-endian integer at offset 36 |
+ ** stores stores the total number of pages on the freelist. */ |
+ 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' */ |
+ u32 nSearch = 0; /* Count of the number of search attempts */ |
+ |
+ /* If eMode==BTALLOC_EXACT 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( eMode==BTALLOC_EXACT ){ |
+ if( 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; |
+ } |
+ } |
+ }else if( eMode==BTALLOC_LE ){ |
+ searchList = 1; |
+ } |
+#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 (eMode==BTALLOC_EXACT) |
+ ** or until a page less than 'nearby' is located (eMode==BTALLOC_LT) |
+ */ |
+ do { |
+ pPrevTrunk = pTrunk; |
+ if( pPrevTrunk ){ |
+ /* EVIDENCE-OF: R-01506-11053 The first integer on a freelist trunk page |
+ ** is the page number of the next freelist trunk page in the list or |
+ ** zero if this is the last freelist trunk page. */ |
+ iTrunk = get4byte(&pPrevTrunk->aData[0]); |
+ }else{ |
+ /* EVIDENCE-OF: R-59841-13798 The 4-byte big-endian integer at offset 32 |
+ ** stores the page number of the first page of the freelist, or zero if |
+ ** the freelist is empty. */ |
+ iTrunk = get4byte(&pPage1->aData[32]); |
+ } |
+ testcase( iTrunk==mxPage ); |
+ if( iTrunk>mxPage || nSearch++ > n ){ |
+ rc = SQLITE_CORRUPT_BKPT; |
+ }else{ |
+ rc = btreeGetUnusedPage(pBt, iTrunk, &pTrunk, 0); |
+ } |
+ if( rc ){ |
+ pTrunk = 0; |
+ goto end_allocate_page; |
+ } |
+ assert( pTrunk!=0 ); |
+ assert( pTrunk->aData!=0 ); |
+ /* EVIDENCE-OF: R-13523-04394 The second integer on a freelist trunk page |
+ ** is the number of leaf page pointers to follow. */ |
+ k = get4byte(&pTrunk->aData[4]); |
+ 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 || (iTrunk<nearby && eMode==BTALLOC_LE)) |
+ ){ |
+ /* The list is being searched and this trunk page is the page |
+ ** to allocate, regardless of whether it has leaves. |
+ */ |
+ *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 = btreeGetUnusedPage(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; |
+ closest = 0; |
+ if( eMode==BTALLOC_LE ){ |
+ for(i=0; i<k; i++){ |
+ iPage = get4byte(&aData[8+i*4]); |
+ if( iPage<=nearby ){ |
+ closest = i; |
+ break; |
+ } |
+ } |
+ }else{ |
+ int dist; |
+ 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 || (iPage<nearby && eMode==BTALLOC_LE)) |
+ ){ |
+ 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)? PAGER_GET_NOCONTENT : 0; |
+ rc = btreeGetUnusedPage(pBt, *pPgno, ppPage, noContent); |
+ if( rc==SQLITE_OK ){ |
+ rc = sqlite3PagerWrite((*ppPage)->pDbPage); |
+ if( rc!=SQLITE_OK ){ |
+ releasePage(*ppPage); |
+ *ppPage = 0; |
+ } |
+ } |
+ searchList = 0; |
+ } |
+ } |
+ releasePage(pPrevTrunk); |
+ pPrevTrunk = 0; |
+ }while( searchList ); |
+ }else{ |
+ /* There are no pages on the freelist, so append a new page to the |
+ ** database image. |
+ ** |
+ ** Normally, new pages allocated by this block can be requested from the |
+ ** pager layer with the 'no-content' flag set. This prevents the pager |
+ ** from trying to read the pages content from disk. However, if the |
+ ** current transaction has already run one or more incremental-vacuum |
+ ** steps, then the page we are about to allocate may contain content |
+ ** that is required in the event of a rollback. In this case, do |
+ ** not set the no-content flag. This causes the pager to load and journal |
+ ** the current page content before overwriting it. |
+ ** |
+ ** Note that the pager will not actually attempt to load or journal |
+ ** content for any page that really does lie past the end of the database |
+ ** file on disk. So the effects of disabling the no-content optimization |
+ ** here are confined to those pages that lie between the end of the |
+ ** database image and the end of the database file. |
+ */ |
+ int bNoContent = (0==IfNotOmitAV(pBt->bDoTruncate))? PAGER_GET_NOCONTENT:0; |
+ |
+ 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 = btreeGetUnusedPage(pBt, pBt->nPage, &pPg, bNoContent); |
+ 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 = btreeGetUnusedPage(pBt, *pPgno, ppPage, bNoContent); |
+ if( rc ) return rc; |
+ rc = sqlite3PagerWrite((*ppPage)->pDbPage); |
+ if( rc!=SQLITE_OK ){ |
+ releasePage(*ppPage); |
+ *ppPage = 0; |
+ } |
+ TRACE(("ALLOCATE: %d from end of file\n", *pPgno)); |
+ } |
+ |
+ assert( *pPgno!=PENDING_BYTE_PAGE(pBt) ); |
+ |
+end_allocate_page: |
+ releasePage(pTrunk); |
+ releasePage(pPrevTrunk); |
+ assert( rc!=SQLITE_OK || sqlite3PagerPageRefcount((*ppPage)->pDbPage)<=1 ); |
+ assert( rc!=SQLITE_OK || (*ppPage)->isInit==0 ); |
+ 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( CORRUPT_DB || iPage>1 ); |
+ assert( !pMemPage || pMemPage->pgno==iPage ); |
+ |
+ if( iPage<2 ) return SQLITE_CORRUPT_BKPT; |
+ 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->btsFlags & BTS_SECURE_DELETE ){ |
+ /* 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". |
+ ** |
+ ** EVIDENCE-OF: R-19920-11576 However, newer versions of SQLite still |
+ ** avoid using the last six entries in the freelist trunk page array in |
+ ** order that database files created by newer versions of SQLite can be |
+ ** read by older versions of SQLite. |
+ */ |
+ rc = sqlite3PagerWrite(pTrunk->pDbPage); |
+ if( rc==SQLITE_OK ){ |
+ put4byte(&pTrunk->aData[4], nLeaf+1); |
+ put4byte(&pTrunk->aData[8+nLeaf*4], iPage); |
+ if( pPage && (pBt->btsFlags & BTS_SECURE_DELETE)==0 ){ |
+ 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. Write the |
+** local Cell size (the number of bytes on the original page, omitting |
+** overflow) into *pnSize. |
+*/ |
+static int clearCell( |
+ MemPage *pPage, /* The page that contains the Cell */ |
+ unsigned char *pCell, /* First byte of the Cell */ |
+ CellInfo *pInfo /* Size information about the cell */ |
+){ |
+ BtShared *pBt = pPage->pBt; |
+ Pgno ovflPgno; |
+ int rc; |
+ int nOvfl; |
+ u32 ovflPageSize; |
+ |
+ assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
+ pPage->xParseCell(pPage, pCell, pInfo); |
+ if( pInfo->nLocal==pInfo->nPayload ){ |
+ return SQLITE_OK; /* No overflow pages. Return without doing anything */ |
+ } |
+ if( pCell+pInfo->nSize-1 > pPage->aData+pPage->maskPage ){ |
+ return SQLITE_CORRUPT_BKPT; /* Cell extends past end of page */ |
+ } |
+ ovflPgno = get4byte(pCell + pInfo->nSize - 4); |
+ assert( pBt->usableSize > 4 ); |
+ ovflPageSize = pBt->usableSize - 4; |
+ nOvfl = (pInfo->nPayload - pInfo->nLocal + ovflPageSize - 1)/ovflPageSize; |
+ assert( nOvfl>0 || |
+ (CORRUPT_DB && (pInfo->nPayload + ovflPageSize)<ovflPageSize) |
+ ); |
+ 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 BtreePayload *pX, /* Payload with which to construct the cell */ |
+ 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; |
+ |
+ 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 = pPage->childPtrSize; |
+ if( pPage->intKey ){ |
+ nPayload = pX->nData + pX->nZero; |
+ pSrc = pX->pData; |
+ nSrc = pX->nData; |
+ assert( pPage->intKeyLeaf ); /* fillInCell() only called for leaves */ |
+ nHeader += putVarint32(&pCell[nHeader], nPayload); |
+ nHeader += putVarint(&pCell[nHeader], *(u64*)&pX->nKey); |
+ }else{ |
+ assert( pX->nKey<=0x7fffffff && pX->pKey!=0 ); |
+ nSrc = nPayload = (int)pX->nKey; |
+ pSrc = pX->pKey; |
+ nHeader += putVarint32(&pCell[nHeader], nPayload); |
+ } |
+ |
+ /* Fill in the payload */ |
+ if( nPayload<=pPage->maxLocal ){ |
+ n = nHeader + nPayload; |
+ testcase( n==3 ); |
+ testcase( n==4 ); |
+ if( n<4 ) n = 4; |
+ *pnSize = n; |
+ spaceLeft = nPayload; |
+ pPrior = pCell; |
+ }else{ |
+ int mn = pPage->minLocal; |
+ n = mn + (nPayload - mn) % (pPage->pBt->usableSize - 4); |
+ testcase( n==pPage->maxLocal ); |
+ testcase( n==pPage->maxLocal+1 ); |
+ if( n > pPage->maxLocal ) n = mn; |
+ spaceLeft = n; |
+ *pnSize = n + nHeader + 4; |
+ pPrior = &pCell[nHeader+n]; |
+ } |
+ pPayload = &pCell[nHeader]; |
+ |
+ /* At this point variables should be set as follows: |
+ ** |
+ ** nPayload Total payload size in bytes |
+ ** pPayload Begin writing payload here |
+ ** spaceLeft Space available at pPayload. If nPayload>spaceLeft, |
+ ** that means content must spill into overflow pages. |
+ ** *pnSize Size of the local cell (not counting overflow pages) |
+ ** pPrior Where to write the pgno of the first overflow page |
+ ** |
+ ** Use a call to btreeParseCellPtr() to verify that the values above |
+ ** were computed correctly. |
+ */ |
+#if SQLITE_DEBUG |
+ { |
+ CellInfo info; |
+ pPage->xParseCell(pPage, pCell, &info); |
+ assert( nHeader==(int)(info.pPayload - pCell) ); |
+ assert( info.nKey==pX->nKey ); |
+ assert( *pnSize == info.nSize ); |
+ assert( spaceLeft == info.nLocal ); |
+ } |
+#endif |
+ |
+ /* Write the payload into the local Cell and any extra into overflow pages */ |
+ 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 uninitialized 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; |
+ } |
+ 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){ |
+ 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( CORRUPT_DB || sz==cellSize(pPage, idx) ); |
+ assert( sqlite3PagerIswriteable(pPage->pDbPage) ); |
+ assert( sqlite3_mutex_held(pPage->pBt->mutex) ); |
+ data = pPage->aData; |
+ ptr = &pPage->aCellIdx[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; |
+ } |
+ pPage->nCell--; |
+ if( pPage->nCell==0 ){ |
+ memset(&data[hdr+1], 0, 4); |
+ data[hdr+7] = 0; |
+ put2byte(&data[hdr+5], pPage->pBt->usableSize); |
+ pPage->nFree = pPage->pBt->usableSize - pPage->hdrOffset |
+ - pPage->childPtrSize - 8; |
+ }else{ |
+ memmove(ptr, ptr+2, 2*(pPage->nCell - idx)); |
+ 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->apOvfl[] 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. |
+** |
+** *pRC must be SQLITE_OK when this routine is called. |
+*/ |
+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 */ |
+ u8 *data; /* The content of the whole page */ |
+ u8 *pIns; /* The point in pPage->aCellIdx[] where no cell inserted */ |
+ |
+ assert( *pRC==SQLITE_OK ); |
+ assert( i>=0 && i<=pPage->nCell+pPage->nOverflow ); |
+ assert( MX_CELL(pPage->pBt)<=10921 ); |
+ assert( pPage->nCell<=MX_CELL(pPage->pBt) || CORRUPT_DB ); |
+ assert( pPage->nOverflow<=ArraySize(pPage->apOvfl) ); |
+ assert( ArraySize(pPage->apOvfl)==ArraySize(pPage->aiOvfl) ); |
+ 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==pPage->xCellSize(pPage, pCell) || (sz==8 && iChild>0) ); |
+ if( pPage->nOverflow || sz+2>pPage->nFree ){ |
+ if( pTemp ){ |
+ memcpy(pTemp, pCell, sz); |
+ pCell = pTemp; |
+ } |
+ if( iChild ){ |
+ put4byte(pCell, iChild); |
+ } |
+ j = pPage->nOverflow++; |
+ /* Comparison against ArraySize-1 since we hold back one extra slot |
+ ** as a contingency. In other words, never need more than 3 overflow |
+ ** slots but 4 are allocated, just to be safe. */ |
+ assert( j < ArraySize(pPage->apOvfl)-1 ); |
+ pPage->apOvfl[j] = pCell; |
+ pPage->aiOvfl[j] = (u16)i; |
+ |
+ /* When multiple overflows occur, they are always sequential and in |
+ ** sorted order. This invariants arise because multiple overflows can |
+ ** only occur when inserting divider cells into the parent page during |
+ ** balancing, and the dividers are adjacent and sorted. |
+ */ |
+ assert( j==0 || pPage->aiOvfl[j-1]<(u16)i ); /* Overflows in sorted order */ |
+ assert( j==0 || i==pPage->aiOvfl[j-1]+1 ); /* Overflows are sequential */ |
+ }else{ |
+ int rc = sqlite3PagerWrite(pPage->pDbPage); |
+ if( rc!=SQLITE_OK ){ |
+ *pRC = rc; |
+ return; |
+ } |
+ assert( sqlite3PagerIswriteable(pPage->pDbPage) ); |
+ data = pPage->aData; |
+ assert( &data[pPage->cellOffset]==pPage->aCellIdx ); |
+ rc = allocateSpace(pPage, sz, &idx); |
+ if( rc ){ *pRC = rc; return; } |
+ /* The allocateSpace() routine guarantees the following properties |
+ ** if it returns successfully */ |
+ assert( idx >= 0 ); |
+ assert( idx >= pPage->cellOffset+2*pPage->nCell+2 || CORRUPT_DB ); |
+ assert( idx+sz <= (int)pPage->pBt->usableSize ); |
+ pPage->nFree -= (u16)(2 + sz); |
+ memcpy(&data[idx], pCell, sz); |
+ if( iChild ){ |
+ put4byte(&data[idx], iChild); |
+ } |
+ pIns = pPage->aCellIdx + i*2; |
+ memmove(pIns+2, pIns, 2*(pPage->nCell - i)); |
+ put2byte(pIns, idx); |
+ pPage->nCell++; |
+ /* increment the cell count */ |
+ if( (++data[pPage->hdrOffset+4])==0 ) data[pPage->hdrOffset+3]++; |
+ assert( get2byte(&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 |
+ } |
+} |
+ |
+/* |
+** A CellArray object contains a cache of pointers and sizes for a |
+** consecutive sequence of cells that might be held on multiple pages. |
+*/ |
+typedef struct CellArray CellArray; |
+struct CellArray { |
+ int nCell; /* Number of cells in apCell[] */ |
+ MemPage *pRef; /* Reference page */ |
+ u8 **apCell; /* All cells begin balanced */ |
+ u16 *szCell; /* Local size of all cells in apCell[] */ |
+}; |
+ |
+/* |
+** Make sure the cell sizes at idx, idx+1, ..., idx+N-1 have been |
+** computed. |
+*/ |
+static void populateCellCache(CellArray *p, int idx, int N){ |
+ assert( idx>=0 && idx+N<=p->nCell ); |
+ while( N>0 ){ |
+ assert( p->apCell[idx]!=0 ); |
+ if( p->szCell[idx]==0 ){ |
+ p->szCell[idx] = p->pRef->xCellSize(p->pRef, p->apCell[idx]); |
+ }else{ |
+ assert( CORRUPT_DB || |
+ p->szCell[idx]==p->pRef->xCellSize(p->pRef, p->apCell[idx]) ); |
+ } |
+ idx++; |
+ N--; |
+ } |
+} |
+ |
+/* |
+** Return the size of the Nth element of the cell array |
+*/ |
+static SQLITE_NOINLINE u16 computeCellSize(CellArray *p, int N){ |
+ assert( N>=0 && N<p->nCell ); |
+ assert( p->szCell[N]==0 ); |
+ p->szCell[N] = p->pRef->xCellSize(p->pRef, p->apCell[N]); |
+ return p->szCell[N]; |
+} |
+static u16 cachedCellSize(CellArray *p, int N){ |
+ assert( N>=0 && N<p->nCell ); |
+ if( p->szCell[N] ) return p->szCell[N]; |
+ return computeCellSize(p, N); |
+} |
+ |
+/* |
+** Array apCell[] contains pointers to nCell b-tree page cells. The |
+** szCell[] array contains the size in bytes of each cell. This function |
+** replaces the current contents of page pPg with the contents of the cell |
+** array. |
+** |
+** Some of the cells in apCell[] may currently be stored in pPg. This |
+** function works around problems caused by this by making a copy of any |
+** such cells before overwriting the page data. |
+** |
+** The MemPage.nFree field is invalidated by this function. It is the |
+** responsibility of the caller to set it correctly. |
+*/ |
+static int rebuildPage( |
+ MemPage *pPg, /* Edit this page */ |
+ int nCell, /* Final number of cells on page */ |
+ u8 **apCell, /* Array of cells */ |
+ u16 *szCell /* Array of cell sizes */ |
+){ |
+ const int hdr = pPg->hdrOffset; /* Offset of header on pPg */ |
+ u8 * const aData = pPg->aData; /* Pointer to data for pPg */ |
+ const int usableSize = pPg->pBt->usableSize; |
+ u8 * const pEnd = &aData[usableSize]; |
+ int i; |
+ u8 *pCellptr = pPg->aCellIdx; |
+ u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager); |
+ u8 *pData; |
+ |
+ i = get2byte(&aData[hdr+5]); |
+ memcpy(&pTmp[i], &aData[i], usableSize - i); |
+ |
+ pData = pEnd; |
+ for(i=0; i<nCell; i++){ |
+ u8 *pCell = apCell[i]; |
+ if( SQLITE_WITHIN(pCell,aData,pEnd) ){ |
+ pCell = &pTmp[pCell - aData]; |
+ } |
+ pData -= szCell[i]; |
+ put2byte(pCellptr, (pData - aData)); |
+ pCellptr += 2; |
+ if( pData < pCellptr ) return SQLITE_CORRUPT_BKPT; |
+ memcpy(pData, pCell, szCell[i]); |
+ assert( szCell[i]==pPg->xCellSize(pPg, pCell) || CORRUPT_DB ); |
+ testcase( szCell[i]!=pPg->xCellSize(pPg,pCell) ); |
+ } |
+ |
+ /* The pPg->nFree field is now set incorrectly. The caller will fix it. */ |
+ pPg->nCell = nCell; |
+ pPg->nOverflow = 0; |
+ |
+ put2byte(&aData[hdr+1], 0); |
+ put2byte(&aData[hdr+3], pPg->nCell); |
+ put2byte(&aData[hdr+5], pData - aData); |
+ aData[hdr+7] = 0x00; |
+ return SQLITE_OK; |
+} |
+ |
+/* |
+** Array apCell[] contains nCell pointers to b-tree cells. Array szCell |
+** contains the size in bytes of each such cell. This function attempts to |
+** add the cells stored in the array to page pPg. If it cannot (because |
+** the page needs to be defragmented before the cells will fit), non-zero |
+** is returned. Otherwise, if the cells are added successfully, zero is |
+** returned. |
+** |
+** Argument pCellptr points to the first entry in the cell-pointer array |
+** (part of page pPg) to populate. After cell apCell[0] is written to the |
+** page body, a 16-bit offset is written to pCellptr. And so on, for each |
+** cell in the array. It is the responsibility of the caller to ensure |
+** that it is safe to overwrite this part of the cell-pointer array. |
+** |
+** When this function is called, *ppData points to the start of the |
+** content area on page pPg. If the size of the content area is extended, |
+** *ppData is updated to point to the new start of the content area |
+** before returning. |
+** |
+** Finally, argument pBegin points to the byte immediately following the |
+** end of the space required by this page for the cell-pointer area (for |
+** all cells - not just those inserted by the current call). If the content |
+** area must be extended to before this point in order to accomodate all |
+** cells in apCell[], then the cells do not fit and non-zero is returned. |
+*/ |
+static int pageInsertArray( |
+ MemPage *pPg, /* Page to add cells to */ |
+ u8 *pBegin, /* End of cell-pointer array */ |
+ u8 **ppData, /* IN/OUT: Page content -area pointer */ |
+ u8 *pCellptr, /* Pointer to cell-pointer area */ |
+ int iFirst, /* Index of first cell to add */ |
+ int nCell, /* Number of cells to add to pPg */ |
+ CellArray *pCArray /* Array of cells */ |
+){ |
+ int i; |
+ u8 *aData = pPg->aData; |
+ u8 *pData = *ppData; |
+ int iEnd = iFirst + nCell; |
+ assert( CORRUPT_DB || pPg->hdrOffset==0 ); /* Never called on page 1 */ |
+ for(i=iFirst; i<iEnd; i++){ |
+ int sz, rc; |
+ u8 *pSlot; |
+ sz = cachedCellSize(pCArray, i); |
+ if( (aData[1]==0 && aData[2]==0) || (pSlot = pageFindSlot(pPg,sz,&rc))==0 ){ |
+ if( (pData - pBegin)<sz ) return 1; |
+ pData -= sz; |
+ pSlot = pData; |
+ } |
+ /* pSlot and pCArray->apCell[i] will never overlap on a well-formed |
+ ** database. But they might for a corrupt database. Hence use memmove() |
+ ** since memcpy() sends SIGABORT with overlapping buffers on OpenBSD */ |
+ assert( (pSlot+sz)<=pCArray->apCell[i] |
+ || pSlot>=(pCArray->apCell[i]+sz) |
+ || CORRUPT_DB ); |
+ memmove(pSlot, pCArray->apCell[i], sz); |
+ put2byte(pCellptr, (pSlot - aData)); |
+ pCellptr += 2; |
+ } |
+ *ppData = pData; |
+ return 0; |
+} |
+ |
+/* |
+** Array apCell[] contains nCell pointers to b-tree cells. Array szCell |
+** contains the size in bytes of each such cell. This function adds the |
+** space associated with each cell in the array that is currently stored |
+** within the body of pPg to the pPg free-list. The cell-pointers and other |
+** fields of the page are not updated. |
+** |
+** This function returns the total number of cells added to the free-list. |
+*/ |
+static int pageFreeArray( |
+ MemPage *pPg, /* Page to edit */ |
+ int iFirst, /* First cell to delete */ |
+ int nCell, /* Cells to delete */ |
+ CellArray *pCArray /* Array of cells */ |
+){ |
+ u8 * const aData = pPg->aData; |
+ u8 * const pEnd = &aData[pPg->pBt->usableSize]; |
+ u8 * const pStart = &aData[pPg->hdrOffset + 8 + pPg->childPtrSize]; |
+ int nRet = 0; |
+ int i; |
+ int iEnd = iFirst + nCell; |
+ u8 *pFree = 0; |
+ int szFree = 0; |
+ |
+ for(i=iFirst; i<iEnd; i++){ |
+ u8 *pCell = pCArray->apCell[i]; |
+ if( SQLITE_WITHIN(pCell, pStart, pEnd) ){ |
+ int sz; |
+ /* No need to use cachedCellSize() here. The sizes of all cells that |
+ ** are to be freed have already been computing while deciding which |
+ ** cells need freeing */ |
+ sz = pCArray->szCell[i]; assert( sz>0 ); |
+ if( pFree!=(pCell + sz) ){ |
+ if( pFree ){ |
+ assert( pFree>aData && (pFree - aData)<65536 ); |
+ freeSpace(pPg, (u16)(pFree - aData), szFree); |
+ } |
+ pFree = pCell; |
+ szFree = sz; |
+ if( pFree+sz>pEnd ) return 0; |
+ }else{ |
+ pFree = pCell; |
+ szFree += sz; |
+ } |
+ nRet++; |
+ } |
+ } |
+ if( pFree ){ |
+ assert( pFree>aData && (pFree - aData)<65536 ); |
+ freeSpace(pPg, (u16)(pFree - aData), szFree); |
+ } |
+ return nRet; |
+} |
+ |
+/* |
+** apCell[] and szCell[] contains pointers to and sizes of all cells in the |
+** pages being balanced. The current page, pPg, has pPg->nCell cells starting |
+** with apCell[iOld]. After balancing, this page should hold nNew cells |
+** starting at apCell[iNew]. |
+** |
+** This routine makes the necessary adjustments to pPg so that it contains |
+** the correct cells after being balanced. |
+** |
+** The pPg->nFree field is invalid when this function returns. It is the |
+** responsibility of the caller to set it correctly. |
+*/ |
+static int editPage( |
+ MemPage *pPg, /* Edit this page */ |
+ int iOld, /* Index of first cell currently on page */ |
+ int iNew, /* Index of new first cell on page */ |
+ int nNew, /* Final number of cells on page */ |
+ CellArray *pCArray /* Array of cells and sizes */ |
+){ |
+ u8 * const aData = pPg->aData; |
+ const int hdr = pPg->hdrOffset; |
+ u8 *pBegin = &pPg->aCellIdx[nNew * 2]; |
+ int nCell = pPg->nCell; /* Cells stored on pPg */ |
+ u8 *pData; |
+ u8 *pCellptr; |
+ int i; |
+ int iOldEnd = iOld + pPg->nCell + pPg->nOverflow; |
+ int iNewEnd = iNew + nNew; |
+ |
+#ifdef SQLITE_DEBUG |
+ u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager); |
+ memcpy(pTmp, aData, pPg->pBt->usableSize); |
+#endif |
+ |
+ /* Remove cells from the start and end of the page */ |
+ if( iOld<iNew ){ |
+ int nShift = pageFreeArray(pPg, iOld, iNew-iOld, pCArray); |
+ memmove(pPg->aCellIdx, &pPg->aCellIdx[nShift*2], nCell*2); |
+ nCell -= nShift; |
+ } |
+ if( iNewEnd < iOldEnd ){ |
+ nCell -= pageFreeArray(pPg, iNewEnd, iOldEnd - iNewEnd, pCArray); |
+ } |
+ |
+ pData = &aData[get2byteNotZero(&aData[hdr+5])]; |
+ if( pData<pBegin ) goto editpage_fail; |
+ |
+ /* Add cells to the start of the page */ |
+ if( iNew<iOld ){ |
+ int nAdd = MIN(nNew,iOld-iNew); |
+ assert( (iOld-iNew)<nNew || nCell==0 || CORRUPT_DB ); |
+ pCellptr = pPg->aCellIdx; |
+ memmove(&pCellptr[nAdd*2], pCellptr, nCell*2); |
+ if( pageInsertArray( |
+ pPg, pBegin, &pData, pCellptr, |
+ iNew, nAdd, pCArray |
+ ) ) goto editpage_fail; |
+ nCell += nAdd; |
+ } |
+ |
+ /* Add any overflow cells */ |
+ for(i=0; i<pPg->nOverflow; i++){ |
+ int iCell = (iOld + pPg->aiOvfl[i]) - iNew; |
+ if( iCell>=0 && iCell<nNew ){ |
+ pCellptr = &pPg->aCellIdx[iCell * 2]; |
+ memmove(&pCellptr[2], pCellptr, (nCell - iCell) * 2); |
+ nCell++; |
+ if( pageInsertArray( |
+ pPg, pBegin, &pData, pCellptr, |
+ iCell+iNew, 1, pCArray |
+ ) ) goto editpage_fail; |
+ } |
+ } |
+ |
+ /* Append cells to the end of the page */ |
+ pCellptr = &pPg->aCellIdx[nCell*2]; |
+ if( pageInsertArray( |
+ pPg, pBegin, &pData, pCellptr, |
+ iNew+nCell, nNew-nCell, pCArray |
+ ) ) goto editpage_fail; |
+ |
+ pPg->nCell = nNew; |
+ pPg->nOverflow = 0; |
+ |
+ put2byte(&aData[hdr+3], pPg->nCell); |
+ put2byte(&aData[hdr+5], pData - aData); |
+ |
+#ifdef SQLITE_DEBUG |
+ for(i=0; i<nNew && !CORRUPT_DB; i++){ |
+ u8 *pCell = pCArray->apCell[i+iNew]; |
+ int iOff = get2byteAligned(&pPg->aCellIdx[i*2]); |
+ if( SQLITE_WITHIN(pCell, aData, &aData[pPg->pBt->usableSize]) ){ |
+ pCell = &pTmp[pCell - aData]; |
+ } |
+ assert( 0==memcmp(pCell, &aData[iOff], |
+ pCArray->pRef->xCellSize(pCArray->pRef, pCArray->apCell[i+iNew])) ); |
+ } |
+#endif |
+ |
+ return SQLITE_OK; |
+ editpage_fail: |
+ /* Unable to edit this page. Rebuild it from scratch instead. */ |
+ populateCellCache(pCArray, iNew, nNew); |
+ return rebuildPage(pPg, nNew, &pCArray->apCell[iNew], &pCArray->szCell[iNew]); |
+} |
+ |
+/* |
+** 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( NEVER(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->apOvfl[0]; |
+ u16 szCell = pPage->xCellSize(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); |
+ rc = rebuildPage(pNew, 1, &pCell, &szCell); |
+ if( NEVER(rc) ) return rc; |
+ pNew->nFree = pBt->usableSize - pNew->cellOffset - 2 - 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. */ |
+ if( rc==SQLITE_OK ){ |
+ 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); |
+ pPage->xParseCell(pPage, z, &info); |
+ if( info.nLocal<info.nPayload ){ |
+ Pgno ovfl = get4byte(&z[info.nSize-4]); |
+ 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.apOvfl[] 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 */ |
+ int bBulk /* True if this call is part of a bulk load */ |
+){ |
+ BtShared *pBt; /* The whole database */ |
+ 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 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 *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 b.paCell[] of cell after i-th page */ |
+ int cntOld[NB+2]; /* Old index in b.apCell[] */ |
+ int szNew[NB+2]; /* Combined size of cells placed on i-th page */ |
+ u8 *aSpace1; /* Space for copies of dividers cells */ |
+ Pgno pgno; /* Temp var to store a page number in */ |
+ u8 abDone[NB+2]; /* True after i'th new page is populated */ |
+ Pgno aPgno[NB+2]; /* Page numbers of new pages before shuffling */ |
+ Pgno aPgOrder[NB+2]; /* Copy of aPgno[] used for sorting pages */ |
+ u16 aPgFlags[NB+2]; /* flags field of new pages before shuffling */ |
+ CellArray b; /* Parsed information on cells being balanced */ |
+ |
+ memset(abDone, 0, sizeof(abDone)); |
+ b.nCell = 0; |
+ b.apCell = 0; |
+ 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->aiOvfl[0]==iParentIdx ); |
+ |
+ if( !aOvflSpace ){ |
+ return SQLITE_NOMEM_BKPT; |
+ } |
+ |
+ /* 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; |
+ }else{ |
+ assert( bBulk==0 || bBulk==1 ); |
+ if( iParentIdx==0 ){ |
+ nxDiv = 0; |
+ }else if( iParentIdx==i ){ |
+ nxDiv = i-2+bBulk; |
+ }else{ |
+ nxDiv = iParentIdx-1; |
+ } |
+ i = 2-bBulk; |
+ } |
+ nOld = i+1; |
+ 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], 0, 0); |
+ 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( pParent->nOverflow && i+nxDiv==pParent->aiOvfl[0] ){ |
+ apDiv[i] = pParent->apOvfl[0]; |
+ pgno = get4byte(apDiv[i]); |
+ szNew[i] = pParent->xCellSize(pParent, apDiv[i]); |
+ pParent->nOverflow = 0; |
+ }else{ |
+ apDiv[i] = findCell(pParent, i+nxDiv-pParent->nOverflow); |
+ pgno = get4byte(apDiv[i]); |
+ szNew[i] = pParent->xCellSize(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. |
+ ** |
+ ** But not if we are in secure-delete mode. In secure-delete mode, |
+ ** 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->btsFlags & BTS_SECURE_DELETE ){ |
+ int iOff; |
+ |
+ 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 |
+ */ |
+ szScratch = |
+ nMaxCells*sizeof(u8*) /* b.apCell */ |
+ + nMaxCells*sizeof(u16) /* b.szCell */ |
+ + pBt->pageSize; /* aSpace1 */ |
+ |
+ /* EVIDENCE-OF: R-28375-38319 SQLite will never request a scratch buffer |
+ ** that is more than 6 times the database page size. */ |
+ assert( szScratch<=6*(int)pBt->pageSize ); |
+ b.apCell = sqlite3ScratchMalloc( szScratch ); |
+ if( b.apCell==0 ){ |
+ rc = SQLITE_NOMEM_BKPT; |
+ goto balance_cleanup; |
+ } |
+ b.szCell = (u16*)&b.apCell[nMaxCells]; |
+ aSpace1 = (u8*)&b.szCell[nMaxCells]; |
+ assert( EIGHT_BYTE_ALIGNMENT(aSpace1) ); |
+ |
+ /* |
+ ** Load pointers to all cells on sibling pages and the divider cells |
+ ** into the local b.apCell[] array. Make copies of the divider cells |
+ ** into space obtained from aSpace1[]. The divider cells have already |
+ ** been removed 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 b.apCell[] are without |
+ ** child pointers. If siblings are not leaves, then all cell in |
+ ** b.apCell[] include child pointers. Either way, all cells in b.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. |
+ */ |
+ b.pRef = apOld[0]; |
+ leafCorrection = b.pRef->leaf*4; |
+ leafData = b.pRef->intKeyLeaf; |
+ for(i=0; i<nOld; i++){ |
+ MemPage *pOld = apOld[i]; |
+ int limit = pOld->nCell; |
+ u8 *aData = pOld->aData; |
+ u16 maskPage = pOld->maskPage; |
+ u8 *piCell = aData + pOld->cellOffset; |
+ u8 *piEnd; |
+ |
+ /* Verify that all sibling pages are of the same "type" (table-leaf, |
+ ** table-interior, index-leaf, or index-interior). |
+ */ |
+ if( pOld->aData[0]!=apOld[0]->aData[0] ){ |
+ rc = SQLITE_CORRUPT_BKPT; |
+ goto balance_cleanup; |
+ } |
+ |
+ /* Load b.apCell[] with pointers to all cells in pOld. If pOld |
+ ** constains overflow cells, include them in the b.apCell[] array |
+ ** in the correct spot. |
+ ** |
+ ** Note that when there are multiple overflow cells, it is always the |
+ ** case that they are sequential and adjacent. This invariant arises |
+ ** because multiple overflows can only occurs when inserting divider |
+ ** cells into a parent on a prior balance, and divider cells are always |
+ ** adjacent and are inserted in order. There is an assert() tagged |
+ ** with "NOTE 1" in the overflow cell insertion loop to prove this |
+ ** invariant. |
+ ** |
+ ** This must be done in advance. Once the balance starts, the cell |
+ ** offset section of the btree page will be overwritten and we will no |
+ ** long be able to find the cells if a pointer to each cell is not saved |
+ ** first. |
+ */ |
+ memset(&b.szCell[b.nCell], 0, sizeof(b.szCell[0])*(limit+pOld->nOverflow)); |
+ if( pOld->nOverflow>0 ){ |
+ limit = pOld->aiOvfl[0]; |
+ for(j=0; j<limit; j++){ |
+ b.apCell[b.nCell] = aData + (maskPage & get2byteAligned(piCell)); |
+ piCell += 2; |
+ b.nCell++; |
+ } |
+ for(k=0; k<pOld->nOverflow; k++){ |
+ assert( k==0 || pOld->aiOvfl[k-1]+1==pOld->aiOvfl[k] );/* NOTE 1 */ |
+ b.apCell[b.nCell] = pOld->apOvfl[k]; |
+ b.nCell++; |
+ } |
+ } |
+ piEnd = aData + pOld->cellOffset + 2*pOld->nCell; |
+ while( piCell<piEnd ){ |
+ assert( b.nCell<nMaxCells ); |
+ b.apCell[b.nCell] = aData + (maskPage & get2byteAligned(piCell)); |
+ piCell += 2; |
+ b.nCell++; |
+ } |
+ |
+ cntOld[i] = b.nCell; |
+ if( i<nOld-1 && !leafData){ |
+ u16 sz = (u16)szNew[i]; |
+ u8 *pTemp; |
+ assert( b.nCell<nMaxCells ); |
+ b.szCell[b.nCell] = sz; |
+ pTemp = &aSpace1[iSpace1]; |
+ iSpace1 += sz; |
+ assert( sz<=pBt->maxLocal+23 ); |
+ assert( iSpace1 <= (int)pBt->pageSize ); |
+ memcpy(pTemp, apDiv[i], sz); |
+ b.apCell[b.nCell] = pTemp+leafCorrection; |
+ assert( leafCorrection==0 || leafCorrection==4 ); |
+ b.szCell[b.nCell] = b.szCell[b.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(b.apCell[b.nCell], &pOld->aData[8], 4); |
+ }else{ |
+ assert( leafCorrection==4 ); |
+ while( b.szCell[b.nCell]<4 ){ |
+ /* Do not allow any cells smaller than 4 bytes. If a smaller cell |
+ ** does exist, pad it with 0x00 bytes. */ |
+ assert( b.szCell[b.nCell]==3 || CORRUPT_DB ); |
+ assert( b.apCell[b.nCell]==&aSpace1[iSpace1-3] || CORRUPT_DB ); |
+ aSpace1[iSpace1++] = 0x00; |
+ b.szCell[b.nCell]++; |
+ } |
+ } |
+ b.nCell++; |
+ } |
+ } |
+ |
+ /* |
+ ** Figure out the number of pages needed to hold all b.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 b.apCell[] of the cell that divides page i from page i+1. |
+ ** cntNew[k] should equal b.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 b.apCell[] and b.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(i=0; i<nOld; i++){ |
+ MemPage *p = apOld[i]; |
+ szNew[i] = usableSpace - p->nFree; |
+ for(j=0; j<p->nOverflow; j++){ |
+ szNew[i] += 2 + p->xCellSize(p, p->apOvfl[j]); |
+ } |
+ cntNew[i] = cntOld[i]; |
+ } |
+ k = nOld; |
+ for(i=0; i<k; i++){ |
+ int sz; |
+ while( szNew[i]>usableSpace ){ |
+ if( i+1>=k ){ |
+ k = i+2; |
+ if( k>NB+2 ){ rc = SQLITE_CORRUPT_BKPT; goto balance_cleanup; } |
+ szNew[k-1] = 0; |
+ cntNew[k-1] = b.nCell; |
+ } |
+ sz = 2 + cachedCellSize(&b, cntNew[i]-1); |
+ szNew[i] -= sz; |
+ if( !leafData ){ |
+ if( cntNew[i]<b.nCell ){ |
+ sz = 2 + cachedCellSize(&b, cntNew[i]); |
+ }else{ |
+ sz = 0; |
+ } |
+ } |
+ szNew[i+1] += sz; |
+ cntNew[i]--; |
+ } |
+ while( cntNew[i]<b.nCell ){ |
+ sz = 2 + cachedCellSize(&b, cntNew[i]); |
+ if( szNew[i]+sz>usableSpace ) break; |
+ szNew[i] += sz; |
+ cntNew[i]++; |
+ if( !leafData ){ |
+ if( cntNew[i]<b.nCell ){ |
+ sz = 2 + cachedCellSize(&b, cntNew[i]); |
+ }else{ |
+ sz = 0; |
+ } |
+ } |
+ szNew[i+1] -= sz; |
+ } |
+ if( cntNew[i]>=b.nCell ){ |
+ k = i+1; |
+ }else if( cntNew[i] <= (i>0 ? cntNew[i-1] : 0) ){ |
+ rc = SQLITE_CORRUPT_BKPT; |
+ goto balance_cleanup; |
+ } |
+ } |
+ |
+ /* |
+ ** The packing computed by the previous block is biased toward the siblings |
+ ** on the left side (siblings with smaller keys). The left siblings are |
+ ** always nearly full, while the right-most sibling might be nearly empty. |
+ ** The next 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; |
+ (void)cachedCellSize(&b, d); |
+ do{ |
+ assert( d<nMaxCells ); |
+ assert( r<nMaxCells ); |
+ (void)cachedCellSize(&b, r); |
+ if( szRight!=0 |
+ && (bBulk || szRight+b.szCell[d]+2 > szLeft-(b.szCell[r]+(i==k-1?0:2)))){ |
+ break; |
+ } |
+ szRight += b.szCell[d] + 2; |
+ szLeft -= b.szCell[r] + 2; |
+ cntNew[i-1] = r; |
+ r--; |
+ d--; |
+ }while( r>=0 ); |
+ szNew[i] = szRight; |
+ szNew[i-1] = szLeft; |
+ if( cntNew[i-1] <= (i>1 ? cntNew[i-2] : 0) ){ |
+ rc = SQLITE_CORRUPT_BKPT; |
+ goto balance_cleanup; |
+ } |
+ } |
+ |
+ /* Sanity check: For a non-corrupt database file one of the follwing |
+ ** must be true: |
+ ** (1) We found one or more cells (cntNew[0])>0), or |
+ ** (2) 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) || CORRUPT_DB); |
+ TRACE(("BALANCE: old: %d(nc=%d) %d(nc=%d) %d(nc=%d)\n", |
+ apOld[0]->pgno, apOld[0]->nCell, |
+ nOld>=2 ? apOld[1]->pgno : 0, nOld>=2 ? apOld[1]->nCell : 0, |
+ nOld>=3 ? apOld[2]->pgno : 0, nOld>=3 ? apOld[2]->nCell : 0 |
+ )); |
+ |
+ /* |
+ ** Allocate k new pages. Reuse old pages where possible. |
+ */ |
+ 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, (bBulk ? 1 : pgno), 0); |
+ if( rc ) goto balance_cleanup; |
+ zeroPage(pNew, pageFlags); |
+ apNew[i] = pNew; |
+ nNew++; |
+ cntOld[i] = b.nCell; |
+ |
+ /* 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; |
+ } |
+ } |
+ } |
+ } |
+ |
+ /* |
+ ** Reassign page numbers so that the new pages are in ascending order. |
+ ** This helps to keep entries in the disk file in order so that a scan |
+ ** of the table is closer to 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+2) (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<nNew; i++){ |
+ aPgOrder[i] = aPgno[i] = apNew[i]->pgno; |
+ aPgFlags[i] = apNew[i]->pDbPage->flags; |
+ for(j=0; j<i; j++){ |
+ if( aPgno[j]==aPgno[i] ){ |
+ /* This branch is taken if the set of sibling pages somehow contains |
+ ** duplicate entries. This can happen if the database is corrupt. |
+ ** It would be simpler to detect this as part of the loop below, but |
+ ** we do the detection here in order to avoid populating the pager |
+ ** cache with two separate objects associated with the same |
+ ** page number. */ |
+ assert( CORRUPT_DB ); |
+ rc = SQLITE_CORRUPT_BKPT; |
+ goto balance_cleanup; |
+ } |
+ } |
+ } |
+ for(i=0; i<nNew; i++){ |
+ int iBest = 0; /* aPgno[] index of page number to use */ |
+ for(j=1; j<nNew; j++){ |
+ if( aPgOrder[j]<aPgOrder[iBest] ) iBest = j; |
+ } |
+ pgno = aPgOrder[iBest]; |
+ aPgOrder[iBest] = 0xffffffff; |
+ if( iBest!=i ){ |
+ if( iBest>i ){ |
+ sqlite3PagerRekey(apNew[iBest]->pDbPage, pBt->nPage+iBest+1, 0); |
+ } |
+ sqlite3PagerRekey(apNew[i]->pDbPage, pgno, aPgFlags[iBest]); |
+ apNew[i]->pgno = pgno; |
+ } |
+ } |
+ |
+ TRACE(("BALANCE: new: %d(%d nc=%d) %d(%d nc=%d) %d(%d nc=%d) " |
+ "%d(%d nc=%d) %d(%d nc=%d)\n", |
+ apNew[0]->pgno, szNew[0], cntNew[0], |
+ nNew>=2 ? apNew[1]->pgno : 0, nNew>=2 ? szNew[1] : 0, |
+ nNew>=2 ? cntNew[1] - cntNew[0] - !leafData : 0, |
+ nNew>=3 ? apNew[2]->pgno : 0, nNew>=3 ? szNew[2] : 0, |
+ nNew>=3 ? cntNew[2] - cntNew[1] - !leafData : 0, |
+ nNew>=4 ? apNew[3]->pgno : 0, nNew>=4 ? szNew[3] : 0, |
+ nNew>=4 ? cntNew[3] - cntNew[2] - !leafData : 0, |
+ nNew>=5 ? apNew[4]->pgno : 0, nNew>=5 ? szNew[4] : 0, |
+ nNew>=5 ? cntNew[4] - cntNew[3] - !leafData : 0 |
+ )); |
+ |
+ assert( sqlite3PagerIswriteable(pParent->pDbPage) ); |
+ put4byte(pRight, apNew[nNew-1]->pgno); |
+ |
+ /* If the sibling pages are not leaves, ensure that the right-child pointer |
+ ** of the right-most new sibling page is set to the value that was |
+ ** originally in the same field of the right-most old sibling page. */ |
+ if( (pageFlags & PTF_LEAF)==0 && nOld!=nNew ){ |
+ MemPage *pOld = (nNew>nOld ? apNew : apOld)[nOld-1]; |
+ memcpy(&apNew[nNew-1]->aData[8], &pOld->aData[8], 4); |
+ } |
+ |
+ /* Make any required updates to pointer map entries associated with |
+ ** cells stored on sibling pages following the balance operation. Pointer |
+ ** map entries associated with divider cells are set by the insertCell() |
+ ** routine. The associated pointer map entries are: |
+ ** |
+ ** a) if the cell contains a reference to an overflow chain, the |
+ ** entry associated with the first page in the overflow chain, and |
+ ** |
+ ** b) if the sibling pages are not leaves, the child page associated |
+ ** with the cell. |
+ ** |
+ ** If the sibling pages are not leaves, then the pointer map entry |
+ ** associated with the right-child of each sibling may also need to be |
+ ** updated. This happens below, after the sibling pages have been |
+ ** populated, not here. |
+ */ |
+ if( ISAUTOVACUUM ){ |
+ MemPage *pNew = apNew[0]; |
+ u8 *aOld = pNew->aData; |
+ int cntOldNext = pNew->nCell + pNew->nOverflow; |
+ int usableSize = pBt->usableSize; |
+ int iNew = 0; |
+ int iOld = 0; |
+ |
+ for(i=0; i<b.nCell; i++){ |
+ u8 *pCell = b.apCell[i]; |
+ if( i==cntOldNext ){ |
+ MemPage *pOld = (++iOld)<nNew ? apNew[iOld] : apOld[iOld]; |
+ cntOldNext += pOld->nCell + pOld->nOverflow + !leafData; |
+ aOld = pOld->aData; |
+ } |
+ if( i==cntNew[iNew] ){ |
+ pNew = apNew[++iNew]; |
+ if( !leafData ) continue; |
+ } |
+ |
+ /* Cell pCell is destined for new sibling page pNew. Originally, it |
+ ** was either part of sibling page iOld (possibly an overflow cell), |
+ ** or else the divider cell to the left of sibling page iOld. So, |
+ ** if sibling page iOld had the same page number as pNew, and if |
+ ** pCell really was a part of sibling page iOld (not a divider or |
+ ** overflow cell), we can skip updating the pointer map entries. */ |
+ if( iOld>=nNew |
+ || pNew->pgno!=aPgno[iOld] |
+ || !SQLITE_WITHIN(pCell,aOld,&aOld[usableSize]) |
+ ){ |
+ if( !leafCorrection ){ |
+ ptrmapPut(pBt, get4byte(pCell), PTRMAP_BTREE, pNew->pgno, &rc); |
+ } |
+ if( cachedCellSize(&b,i)>pNew->minLocal ){ |
+ ptrmapPutOvflPtr(pNew, pCell, &rc); |
+ } |
+ if( rc ) goto balance_cleanup; |
+ } |
+ } |
+ } |
+ |
+ /* Insert new divider cells into pParent. */ |
+ for(i=0; i<nNew-1; i++){ |
+ u8 *pCell; |
+ u8 *pTemp; |
+ int sz; |
+ MemPage *pNew = apNew[i]; |
+ j = cntNew[i]; |
+ |
+ assert( j<nMaxCells ); |
+ assert( b.apCell[j]!=0 ); |
+ pCell = b.apCell[j]; |
+ sz = b.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 b.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--; |
+ pNew->xParseCell(pNew, b.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. |
+ ** |
+ ** This can only happen for b-trees used to evaluate "IN (SELECT ...)" |
+ ** and WITHOUT ROWID tables with exactly one column which is the |
+ ** primary key. |
+ */ |
+ if( b.szCell[j]==4 ){ |
+ assert(leafCorrection==4); |
+ sz = pParent->xCellSize(pParent, pCell); |
+ } |
+ } |
+ iOvflSpace += sz; |
+ assert( sz<=pBt->maxLocal+23 ); |
+ assert( iOvflSpace <= (int)pBt->pageSize ); |
+ insertCell(pParent, nxDiv+i, pCell, sz, pTemp, pNew->pgno, &rc); |
+ if( rc!=SQLITE_OK ) goto balance_cleanup; |
+ assert( sqlite3PagerIswriteable(pParent->pDbPage) ); |
+ } |
+ |
+ /* Now update the actual sibling pages. The order in which they are updated |
+ ** is important, as this code needs to avoid disrupting any page from which |
+ ** cells may still to be read. In practice, this means: |
+ ** |
+ ** (1) If cells are moving left (from apNew[iPg] to apNew[iPg-1]) |
+ ** then it is not safe to update page apNew[iPg] until after |
+ ** the left-hand sibling apNew[iPg-1] has been updated. |
+ ** |
+ ** (2) If cells are moving right (from apNew[iPg] to apNew[iPg+1]) |
+ ** then it is not safe to update page apNew[iPg] until after |
+ ** the right-hand sibling apNew[iPg+1] has been updated. |
+ ** |
+ ** If neither of the above apply, the page is safe to update. |
+ ** |
+ ** The iPg value in the following loop starts at nNew-1 goes down |
+ ** to 0, then back up to nNew-1 again, thus making two passes over |
+ ** the pages. On the initial downward pass, only condition (1) above |
+ ** needs to be tested because (2) will always be true from the previous |
+ ** step. On the upward pass, both conditions are always true, so the |
+ ** upwards pass simply processes pages that were missed on the downward |
+ ** pass. |
+ */ |
+ for(i=1-nNew; i<nNew; i++){ |
+ int iPg = i<0 ? -i : i; |
+ assert( iPg>=0 && iPg<nNew ); |
+ if( abDone[iPg] ) continue; /* Skip pages already processed */ |
+ if( i>=0 /* On the upwards pass, or... */ |
+ || cntOld[iPg-1]>=cntNew[iPg-1] /* Condition (1) is true */ |
+ ){ |
+ int iNew; |
+ int iOld; |
+ int nNewCell; |
+ |
+ /* Verify condition (1): If cells are moving left, update iPg |
+ ** only after iPg-1 has already been updated. */ |
+ assert( iPg==0 || cntOld[iPg-1]>=cntNew[iPg-1] || abDone[iPg-1] ); |
+ |
+ /* Verify condition (2): If cells are moving right, update iPg |
+ ** only after iPg+1 has already been updated. */ |
+ assert( cntNew[iPg]>=cntOld[iPg] || abDone[iPg+1] ); |
+ |
+ if( iPg==0 ){ |
+ iNew = iOld = 0; |
+ nNewCell = cntNew[0]; |
+ }else{ |
+ iOld = iPg<nOld ? (cntOld[iPg-1] + !leafData) : b.nCell; |
+ iNew = cntNew[iPg-1] + !leafData; |
+ nNewCell = cntNew[iPg] - iNew; |
+ } |
+ |
+ rc = editPage(apNew[iPg], iOld, iNew, nNewCell, &b); |
+ if( rc ) goto balance_cleanup; |
+ abDone[iPg]++; |
+ apNew[iPg]->nFree = usableSpace-szNew[iPg]; |
+ assert( apNew[iPg]->nOverflow==0 ); |
+ assert( apNew[iPg]->nCell==nNewCell ); |
+ } |
+ } |
+ |
+ /* All pages have been processed exactly once */ |
+ assert( memcmp(abDone, "\01\01\01\01\01", nNew)==0 ); |
+ |
+ assert( nOld>0 ); |
+ assert( nNew>0 ); |
+ |
+ 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. |
+ ** |
+ ** It is critical that the child page be defragmented before being |
+ ** copied into the parent, because if the parent is page 1 then it will |
+ ** by smaller than the child due to the database header, and so all the |
+ ** free space needs to be up front. |
+ */ |
+ assert( nNew==1 || CORRUPT_DB ); |
+ rc = defragmentPage(apNew[0]); |
+ testcase( rc!=SQLITE_OK ); |
+ assert( apNew[0]->nFree == |
+ (get2byte(&apNew[0]->aData[5])-apNew[0]->cellOffset-apNew[0]->nCell*2) |
+ || rc!=SQLITE_OK |
+ ); |
+ copyNodeContent(apNew[0], pParent, &rc); |
+ freePage(apNew[0], &rc); |
+ }else if( ISAUTOVACUUM && !leafCorrection ){ |
+ /* Fix the pointer map entries associated with the right-child of each |
+ ** sibling page. All other pointer map entries have already been taken |
+ ** care of. */ |
+ for(i=0; i<nNew; i++){ |
+ u32 key = get4byte(&apNew[i]->aData[8]); |
+ ptrmapPut(pBt, key, PTRMAP_BTREE, apNew[i]->pgno, &rc); |
+ } |
+ } |
+ |
+ assert( pParent->isInit ); |
+ TRACE(("BALANCE: finished: old=%d new=%d cells=%d\n", |
+ nOld, nNew, b.nCell)); |
+ |
+ /* Free any old pages that were not reused as new pages. |
+ */ |
+ for(i=nNew; i<nOld; i++){ |
+ freePage(apOld[i], &rc); |
+ } |
+ |
+#if 0 |
+ if( ISAUTOVACUUM && rc==SQLITE_OK && apNew[0]->isInit ){ |
+ /* 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 |
+ |
+ /* |
+ ** Cleanup before returning. |
+ */ |
+balance_cleanup: |
+ sqlite3ScratchFree(b.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->aiOvfl, pRoot->aiOvfl, |
+ pRoot->nOverflow*sizeof(pRoot->aiOvfl[0])); |
+ memcpy(pChild->apOvfl, pRoot->apOvfl, |
+ pRoot->nOverflow*sizeof(pRoot->apOvfl[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; |
+ |
+ VVA_ONLY( int balance_quick_called = 0 ); |
+ VVA_ONLY( 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 ); |
+ VVA_ONLY( balance_deeper_called++ ); |
+ 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->intKeyLeaf |
+ && pPage->nOverflow==1 |
+ && pPage->aiOvfl[0]==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 iteration 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 ); |
+ VVA_ONLY( balance_quick_called++ ); |
+ 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, |
+ pCur->hints&BTREE_BULKLOAD); |
+ 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--; |
+ assert( pCur->iPage>=0 ); |
+ } |
+ }while( rc==SQLITE_OK ); |
+ |
+ if( pFree ){ |
+ sqlite3PageFree(pFree); |
+ } |
+ return rc; |
+} |
+ |
+ |
+/* |
+** Insert a new record into the BTree. The content of the new record |
+** is described by the pX object. The pCur cursor is used only to |
+** define what table the record should be inserted into, and is left |
+** pointing at a random location. |
+** |
+** For a table btree (used for rowid tables), only the pX.nKey value of |
+** the key is used. The pX.pKey value must be NULL. The pX.nKey is the |
+** rowid or INTEGER PRIMARY KEY of the row. The pX.nData,pData,nZero fields |
+** hold the content of the row. |
+** |
+** For an index btree (used for indexes and WITHOUT ROWID tables), the |
+** key is an arbitrary byte sequence stored in pX.pKey,nKey. The |
+** pX.pData,nData,nZero fields must be zero. |
+** |
+** If the seekResult parameter is non-zero, then a successful call to |
+** MovetoUnpacked() to seek cursor pCur to (pKey,nKey) has already |
+** been performed. In other words, if seekResult!=0 then the cursor |
+** is currently pointing to a cell that will be adjacent to the cell |
+** to be inserted. If seekResult<0 then pCur points to a cell that is |
+** smaller then (pKey,nKey). If seekResult>0 then pCur points to a cell |
+** that is larger than (pKey,nKey). |
+** |
+** If seekResult==0, that means pCur is pointing at some unknown location. |
+** In that case, this routine must seek the cursor to the correct insertion |
+** point for (pKey,nKey) before doing the insertion. For index btrees, |
+** if pX->nMem is non-zero, then pX->aMem contains pointers to the unpacked |
+** key values and pX->aMem can be used instead of pX->pKey to avoid having |
+** to decode the key. |
+*/ |
+int sqlite3BtreeInsert( |
+ BtCursor *pCur, /* Insert data into the table of this cursor */ |
+ const BtreePayload *pX, /* Content of the row to be inserted */ |
+ int flags, /* 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; |
+ |
+ assert( (flags & (BTREE_SAVEPOSITION|BTREE_APPEND))==flags ); |
+ |
+ if( pCur->eState==CURSOR_FAULT ){ |
+ assert( pCur->skipNext!=SQLITE_OK ); |
+ return pCur->skipNext; |
+ } |
+ |
+ assert( cursorOwnsBtShared(pCur) ); |
+ assert( (pCur->curFlags & BTCF_WriteFlag)!=0 |
+ && pBt->inTransaction==TRANS_WRITE |
+ && (pBt->btsFlags & BTS_READ_ONLY)==0 ); |
+ 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( (pX->pKey==0)==(pCur->pKeyInfo==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. |
+ */ |
+ if( pCur->curFlags & BTCF_Multiple ){ |
+ rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur); |
+ if( rc ) return rc; |
+ } |
+ |
+ if( pCur->pKeyInfo==0 ){ |
+ assert( pX->pKey==0 ); |
+ /* If this is an insert into a table b-tree, invalidate any incrblob |
+ ** cursors open on the row being replaced */ |
+ invalidateIncrblobCursors(p, pX->nKey, 0); |
+ |
+ /* If BTREE_SAVEPOSITION is set, the cursor must already be pointing |
+ ** to a row with the same key as the new entry being inserted. */ |
+ assert( (flags & BTREE_SAVEPOSITION)==0 || |
+ ((pCur->curFlags&BTCF_ValidNKey)!=0 && pX->nKey==pCur->info.nKey) ); |
+ |
+ /* If the cursor is currently on the last row and we are appending a |
+ ** new row onto the end, set the "loc" to avoid an unnecessary |
+ ** btreeMoveto() call */ |
+ if( (pCur->curFlags&BTCF_ValidNKey)!=0 && pX->nKey==pCur->info.nKey ){ |
+ loc = 0; |
+ }else if( (pCur->curFlags&BTCF_ValidNKey)!=0 && pX->nKey>0 |
+ && pCur->info.nKey==pX->nKey-1 ){ |
+ loc = -1; |
+ }else if( loc==0 ){ |
+ rc = sqlite3BtreeMovetoUnpacked(pCur, 0, pX->nKey, flags!=0, &loc); |
+ if( rc ) return rc; |
+ } |
+ }else if( loc==0 && (flags & BTREE_SAVEPOSITION)==0 ){ |
+ if( pX->nMem ){ |
+ UnpackedRecord r; |
+ r.pKeyInfo = pCur->pKeyInfo; |
+ r.aMem = pX->aMem; |
+ r.nField = pX->nMem; |
+ r.default_rc = 0; |
+ r.errCode = 0; |
+ r.r1 = 0; |
+ r.r2 = 0; |
+ r.eqSeen = 0; |
+ rc = sqlite3BtreeMovetoUnpacked(pCur, &r, 0, flags!=0, &loc); |
+ }else{ |
+ rc = btreeMoveto(pCur, pX->pKey, pX->nKey, flags!=0, &loc); |
+ } |
+ if( rc ) return rc; |
+ } |
+ assert( pCur->eState==CURSOR_VALID || (pCur->eState==CURSOR_INVALID && loc) ); |
+ |
+ pPage = pCur->apPage[pCur->iPage]; |
+ assert( pPage->intKey || pX->nKey>=0 ); |
+ assert( pPage->leaf || !pPage->intKey ); |
+ |
+ TRACE(("INSERT: table=%d nkey=%lld ndata=%d page=%d %s\n", |
+ pCur->pgnoRoot, pX->nKey, pX->nData, pPage->pgno, |
+ loc==0 ? "overwrite" : "new entry")); |
+ assert( pPage->isInit ); |
+ newCell = pBt->pTmpSpace; |
+ assert( newCell!=0 ); |
+ rc = fillInCell(pPage, newCell, pX, &szNew); |
+ if( rc ) goto end_insert; |
+ assert( szNew==pPage->xCellSize(pPage, newCell) ); |
+ assert( szNew <= MX_CELL_SIZE(pBt) ); |
+ idx = pCur->aiIdx[pCur->iPage]; |
+ if( loc==0 ){ |
+ CellInfo info; |
+ assert( idx<pPage->nCell ); |
+ rc = sqlite3PagerWrite(pPage->pDbPage); |
+ if( rc ){ |
+ goto end_insert; |
+ } |
+ oldCell = findCell(pPage, idx); |
+ if( !pPage->leaf ){ |
+ memcpy(newCell, oldCell, 4); |
+ } |
+ rc = clearCell(pPage, oldCell, &info); |
+ if( info.nSize==szNew && info.nLocal==info.nPayload ){ |
+ /* Overwrite the old cell with the new if they are the same size. |
+ ** We could also try to do this if the old cell is smaller, then add |
+ ** the leftover space to the free list. But experiments show that |
+ ** doing that is no faster then skipping this optimization and just |
+ ** calling dropCell() and insertCell(). */ |
+ assert( rc==SQLITE_OK ); /* clearCell never fails when nLocal==nPayload */ |
+ if( oldCell+szNew > pPage->aDataEnd ) return SQLITE_CORRUPT_BKPT; |
+ memcpy(oldCell, newCell, szNew); |
+ return SQLITE_OK; |
+ } |
+ dropCell(pPage, idx, info.nSize, &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( pPage->nOverflow==0 || rc==SQLITE_OK ); |
+ assert( rc!=SQLITE_OK || pPage->nCell>0 || pPage->nOverflow>0 ); |
+ |
+ /* If no error has occurred 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 BTCF_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; |
+ if( pPage->nOverflow ){ |
+ assert( rc==SQLITE_OK ); |
+ pCur->curFlags &= ~(BTCF_ValidNKey); |
+ 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; |
+ if( (flags & BTREE_SAVEPOSITION) && rc==SQLITE_OK ){ |
+ rc = moveToRoot(pCur); |
+ if( pCur->pKeyInfo ){ |
+ assert( pCur->pKey==0 ); |
+ pCur->pKey = sqlite3Malloc( pX->nKey ); |
+ if( pCur->pKey==0 ){ |
+ rc = SQLITE_NOMEM; |
+ }else{ |
+ memcpy(pCur->pKey, pX->pKey, pX->nKey); |
+ } |
+ } |
+ pCur->eState = CURSOR_REQUIRESEEK; |
+ pCur->nKey = pX->nKey; |
+ } |
+ } |
+ assert( pCur->apPage[pCur->iPage]->nOverflow==0 ); |
+ |
+end_insert: |
+ return rc; |
+} |
+ |
+/* |
+** Delete the entry that the cursor is pointing to. |
+** |
+** If the BTREE_SAVEPOSITION bit of the flags parameter is zero, then |
+** the cursor is left pointing at an arbitrary location after the delete. |
+** But if that bit is set, then the cursor is left in a state such that |
+** the next call to BtreeNext() or BtreePrev() moves it to the same row |
+** as it would have been on if the call to BtreeDelete() had been omitted. |
+** |
+** The BTREE_AUXDELETE bit of flags indicates that is one of several deletes |
+** associated with a single table entry and its indexes. Only one of those |
+** deletes is considered the "primary" delete. The primary delete occurs |
+** on a cursor that is not a BTREE_FORDELETE cursor. All but one delete |
+** operation on non-FORDELETE cursors is tagged with the AUXDELETE flag. |
+** The BTREE_AUXDELETE bit is a hint that is not used by this implementation, |
+** but which might be used by alternative storage engines. |
+*/ |
+int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){ |
+ 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 */ |
+ CellInfo info; /* Size of the cell being deleted */ |
+ int bSkipnext = 0; /* Leaf cursor in SKIPNEXT state */ |
+ u8 bPreserve = flags & BTREE_SAVEPOSITION; /* Keep cursor valid */ |
+ |
+ assert( cursorOwnsBtShared(pCur) ); |
+ assert( pBt->inTransaction==TRANS_WRITE ); |
+ assert( (pBt->btsFlags & BTS_READ_ONLY)==0 ); |
+ assert( pCur->curFlags & BTCF_WriteFlag ); |
+ assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) ); |
+ assert( !hasReadConflicts(p, pCur->pgnoRoot) ); |
+ assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell ); |
+ assert( pCur->eState==CURSOR_VALID ); |
+ assert( (flags & ~(BTREE_SAVEPOSITION | BTREE_AUXDELETE))==0 ); |
+ |
+ iCellDepth = pCur->iPage; |
+ iCellIdx = pCur->aiIdx[iCellDepth]; |
+ pPage = pCur->apPage[iCellDepth]; |
+ pCell = findCell(pPage, iCellIdx); |
+ |
+ /* If the bPreserve flag is set to true, then the cursor position must |
+ ** be preserved following this delete operation. If the current delete |
+ ** will cause a b-tree rebalance, then this is done by saving the cursor |
+ ** key and leaving the cursor in CURSOR_REQUIRESEEK state before |
+ ** returning. |
+ ** |
+ ** Or, if the current delete will not cause a rebalance, then the cursor |
+ ** will be left in CURSOR_SKIPNEXT state pointing to the entry immediately |
+ ** before or after the deleted entry. In this case set bSkipnext to true. */ |
+ if( bPreserve ){ |
+ if( !pPage->leaf |
+ || (pPage->nFree+cellSizePtr(pPage,pCell)+2)>(int)(pBt->usableSize*2/3) |
+ ){ |
+ /* A b-tree rebalance will be required after deleting this entry. |
+ ** Save the cursor key. */ |
+ rc = saveCursorKey(pCur); |
+ if( rc ) return rc; |
+ }else{ |
+ bSkipnext = 1; |
+ } |
+ } |
+ |
+ /* 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 = 0; |
+ rc = sqlite3BtreePrevious(pCur, ¬Used); |
+ if( rc ) return rc; |
+ } |
+ |
+ /* Save the positions of any other cursors open on this table before |
+ ** making any modifications. */ |
+ if( pCur->curFlags & BTCF_Multiple ){ |
+ rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur); |
+ if( rc ) return rc; |
+ } |
+ |
+ /* 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); |
+ } |
+ |
+ /* 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 = sqlite3PagerWrite(pPage->pDbPage); |
+ if( rc ) return rc; |
+ rc = clearCell(pPage, pCell, &info); |
+ dropCell(pPage, iCellIdx, info.nSize, &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); |
+ if( pCell<&pLeaf->aData[4] ) return SQLITE_CORRUPT_BKPT; |
+ nCell = pLeaf->xCellSize(pLeaf, pCell); |
+ assert( MX_CELL_SIZE(pBt) >= nCell ); |
+ pTmp = pBt->pTmpSpace; |
+ assert( pTmp!=0 ); |
+ rc = sqlite3PagerWrite(pLeaf->pDbPage); |
+ if( rc==SQLITE_OK ){ |
+ 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 ){ |
+ if( bSkipnext ){ |
+ assert( bPreserve && (pCur->iPage==iCellDepth || CORRUPT_DB) ); |
+ assert( pPage==pCur->apPage[pCur->iPage] || CORRUPT_DB ); |
+ assert( (pPage->nCell>0 || CORRUPT_DB) && iCellIdx<=pPage->nCell ); |
+ pCur->eState = CURSOR_SKIPNEXT; |
+ if( iCellIdx>=pPage->nCell ){ |
+ pCur->skipNext = -1; |
+ pCur->aiIdx[iCellDepth] = pPage->nCell-1; |
+ }else{ |
+ pCur->skipNext = 1; |
+ } |
+ }else{ |
+ rc = moveToRoot(pCur); |
+ if( bPreserve ){ |
+ pCur->eState = CURSOR_REQUIRESEEK; |
+ } |
+ } |
+ } |
+ 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->btsFlags & BTS_READ_ONLY)==0 ); |
+ |
+#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 || CORRUPT_DB ); |
+ testcase( 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, BTALLOC_EXACT); |
+ 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; |
+ |
+ /* Save the positions of any open cursors. This is required in |
+ ** case they are holding a reference to an xFetch reference |
+ ** corresponding to page pgnoRoot. */ |
+ rc = saveAllCursors(pBt, 0, 0); |
+ releasePage(pPageMove); |
+ if( rc!=SQLITE_OK ){ |
+ return rc; |
+ } |
+ |
+ /* 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; |
+ int hdr; |
+ CellInfo info; |
+ |
+ assert( sqlite3_mutex_held(pBt->mutex) ); |
+ if( pgno>btreePagecount(pBt) ){ |
+ return SQLITE_CORRUPT_BKPT; |
+ } |
+ rc = getAndInitPage(pBt, pgno, &pPage, 0, 0); |
+ if( rc ) return rc; |
+ if( pPage->bBusy ){ |
+ rc = SQLITE_CORRUPT_BKPT; |
+ goto cleardatabasepage_out; |
+ } |
+ pPage->bBusy = 1; |
+ hdr = pPage->hdrOffset; |
+ 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, &info); |
+ if( rc ) goto cleardatabasepage_out; |
+ } |
+ if( !pPage->leaf ){ |
+ rc = clearDatabasePage(pBt, get4byte(&pPage->aData[hdr+8]), 1, pnChange); |
+ if( rc ) goto cleardatabasepage_out; |
+ }else if( pnChange ){ |
+ assert( pPage->intKey || CORRUPT_DB ); |
+ testcase( !pPage->intKey ); |
+ *pnChange += pPage->nCell; |
+ } |
+ if( freePageFlag ){ |
+ freePage(pPage, &rc); |
+ }else if( (rc = sqlite3PagerWrite(pPage->pDbPage))==0 ){ |
+ zeroPage(pPage, pPage->aData[hdr] | PTF_LEAF); |
+ } |
+ |
+cleardatabasepage_out: |
+ pPage->bBusy = 0; |
+ 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 ); |
+ |
+ rc = saveAllCursors(pBt, (Pgno)iTable, 0); |
+ |
+ if( SQLITE_OK==rc ){ |
+ /* 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 = clearDatabasePage(pBt, (Pgno)iTable, 0, pnChange); |
+ } |
+ sqlite3BtreeLeave(p); |
+ return rc; |
+} |
+ |
+/* |
+** Delete all information from the single table that pCur is open on. |
+** |
+** This routine only work for pCur on an ephemeral table. |
+*/ |
+int sqlite3BtreeClearTableOfCursor(BtCursor *pCur){ |
+ return sqlite3BtreeClearTable(pCur->pBtree, pCur->pgnoRoot, 0); |
+} |
+ |
+/* |
+** 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 ); |
+ assert( iTable>=2 ); |
+ |
+ rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0); |
+ if( rc ) return rc; |
+ rc = sqlite3BtreeClearTable(p, iTable, 0); |
+ if( rc ){ |
+ releasePage(pPage); |
+ return rc; |
+ } |
+ |
+ *piMoved = 0; |
+ |
+#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 |
+ 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]. |
+** |
+** This routine treats Meta[BTREE_DATA_VERSION] as a special case. Instead |
+** of reading the value out of the header, it instead loads the "DataVersion" |
+** from the pager. The BTREE_DATA_VERSION value is not actually stored in the |
+** database file. It is a number computed by the pager. But its access |
+** pattern is the same as header meta values, and so it is convenient to |
+** read it from this routine. |
+*/ |
+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 ); |
+ |
+ if( idx==BTREE_DATA_VERSION ){ |
+ *pMeta = sqlite3PagerDataVersion(pBt->pPager) + p->iDataVersion; |
+ }else{ |
+ *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->btsFlags |= BTS_READ_ONLY; |
+ } |
+#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 */ |
+ |
+ if( pCur->pgnoRoot==0 ){ |
+ *pnEntry = 0; |
+ return SQLITE_OK; |
+ } |
+ 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 moveToRoot(pCur); |
+ } |
+ 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, |
+ 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( pCheck->zPfx ){ |
+ sqlite3XPrintf(&pCheck->errMsg, pCheck->zPfx, pCheck->v1, pCheck->v2); |
+ } |
+ sqlite3VXPrintf(&pCheck->errMsg, zFormat, ap); |
+ va_end(ap); |
+ if( pCheck->errMsg.accError==STRACCUM_NOMEM ){ |
+ pCheck->mallocFailed = 1; |
+ } |
+} |
+#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ |
+ |
+#ifndef SQLITE_OMIT_INTEGRITY_CHECK |
+ |
+/* |
+** Return non-zero if the bit in the IntegrityCk.aPgRef[] array that |
+** corresponds to page iPg is already set. |
+*/ |
+static int getPageReferenced(IntegrityCk *pCheck, Pgno iPg){ |
+ assert( iPg<=pCheck->nPage && sizeof(pCheck->aPgRef[0])==1 ); |
+ return (pCheck->aPgRef[iPg/8] & (1 << (iPg & 0x07))); |
+} |
+ |
+/* |
+** Set the bit in the IntegrityCk.aPgRef[] array that corresponds to page iPg. |
+*/ |
+static void setPageReferenced(IntegrityCk *pCheck, Pgno iPg){ |
+ assert( iPg<=pCheck->nPage && sizeof(pCheck->aPgRef[0])==1 ); |
+ pCheck->aPgRef[iPg/8] |= (1 << (iPg & 0x07)); |
+} |
+ |
+ |
+/* |
+** 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 or 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){ |
+ if( iPage==0 ) return 1; |
+ if( iPage>pCheck->nPage ){ |
+ checkAppendMsg(pCheck, "invalid page number %d", iPage); |
+ return 1; |
+ } |
+ if( getPageReferenced(pCheck, iPage) ){ |
+ checkAppendMsg(pCheck, "2nd reference to page %d", iPage); |
+ return 1; |
+ } |
+ setPageReferenced(pCheck, iPage); |
+ return 0; |
+} |
+ |
+#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 */ |
+){ |
+ 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, "Failed to read ptrmap key=%d", iChild); |
+ return; |
+ } |
+ |
+ if( ePtrmapType!=eType || iPtrmapParent!=iParent ){ |
+ checkAppendMsg(pCheck, |
+ "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 */ |
+){ |
+ int i; |
+ int expected = N; |
+ int iFirst = iPage; |
+ while( N-- > 0 && pCheck->mxErr ){ |
+ DbPage *pOvflPage; |
+ unsigned char *pOvflData; |
+ if( iPage<1 ){ |
+ checkAppendMsg(pCheck, |
+ "%d of %d pages missing from overflow list starting at %d", |
+ N+1, expected, iFirst); |
+ break; |
+ } |
+ if( checkRef(pCheck, iPage) ) break; |
+ if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage, 0) ){ |
+ checkAppendMsg(pCheck, "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); |
+ } |
+#endif |
+ if( n>(int)pCheck->pBt->usableSize/4-2 ){ |
+ checkAppendMsg(pCheck, |
+ "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); |
+ } |
+#endif |
+ checkRef(pCheck, iFreePage); |
+ } |
+ 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); |
+ } |
+ } |
+#endif |
+ iPage = get4byte(pOvflData); |
+ sqlite3PagerUnref(pOvflPage); |
+ |
+ if( isFreeList && N<(iPage!=0) ){ |
+ checkAppendMsg(pCheck, "free-page count in header is too small"); |
+ } |
+ } |
+} |
+#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ |
+ |
+/* |
+** An implementation of a min-heap. |
+** |
+** aHeap[0] is the number of elements on the heap. aHeap[1] is the |
+** root element. The daughter nodes of aHeap[N] are aHeap[N*2] |
+** and aHeap[N*2+1]. |
+** |
+** The heap property is this: Every node is less than or equal to both |
+** of its daughter nodes. A consequence of the heap property is that the |
+** root node aHeap[1] is always the minimum value currently in the heap. |
+** |
+** The btreeHeapInsert() routine inserts an unsigned 32-bit number onto |
+** the heap, preserving the heap property. The btreeHeapPull() routine |
+** removes the root element from the heap (the minimum value in the heap) |
+** and then moves other nodes around as necessary to preserve the heap |
+** property. |
+** |
+** This heap is used for cell overlap and coverage testing. Each u32 |
+** entry represents the span of a cell or freeblock on a btree page. |
+** The upper 16 bits are the index of the first byte of a range and the |
+** lower 16 bits are the index of the last byte of that range. |
+*/ |
+static void btreeHeapInsert(u32 *aHeap, u32 x){ |
+ u32 j, i = ++aHeap[0]; |
+ aHeap[i] = x; |
+ while( (j = i/2)>0 && aHeap[j]>aHeap[i] ){ |
+ x = aHeap[j]; |
+ aHeap[j] = aHeap[i]; |
+ aHeap[i] = x; |
+ i = j; |
+ } |
+} |
+static int btreeHeapPull(u32 *aHeap, u32 *pOut){ |
+ u32 j, i, x; |
+ if( (x = aHeap[0])==0 ) return 0; |
+ *pOut = aHeap[1]; |
+ aHeap[1] = aHeap[x]; |
+ aHeap[x] = 0xffffffff; |
+ aHeap[0]--; |
+ i = 1; |
+ while( (j = i*2)<=aHeap[0] ){ |
+ if( aHeap[j]>aHeap[j+1] ) j++; |
+ if( aHeap[i]<aHeap[j] ) break; |
+ x = aHeap[i]; |
+ aHeap[i] = aHeap[j]; |
+ aHeap[j] = x; |
+ i = j; |
+ } |
+ return 1; |
+} |
+ |
+#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. |
+** 2. Make sure integer cell keys are in order. |
+** 3. Check the integrity of overflow pages. |
+** 4. Recursively call checkTreePage on all children. |
+** 5. Verify that the depth of all children is the same. |
+*/ |
+static int checkTreePage( |
+ IntegrityCk *pCheck, /* Context for the sanity check */ |
+ int iPage, /* Page number of the page to check */ |
+ i64 *piMinKey, /* Write minimum integer primary key here */ |
+ i64 maxKey /* Error if integer primary key greater than this */ |
+){ |
+ MemPage *pPage = 0; /* The page being analyzed */ |
+ int i; /* Loop counter */ |
+ int rc; /* Result code from subroutine call */ |
+ int depth = -1, d2; /* Depth of a subtree */ |
+ int pgno; /* Page number */ |
+ int nFrag; /* Number of fragmented bytes on the page */ |
+ int hdr; /* Offset to the page header */ |
+ int cellStart; /* Offset to the start of the cell pointer array */ |
+ int nCell; /* Number of cells */ |
+ int doCoverageCheck = 1; /* True if cell coverage checking should be done */ |
+ int keyCanBeEqual = 1; /* True if IPK can be equal to maxKey |
+ ** False if IPK must be strictly less than maxKey */ |
+ u8 *data; /* Page content */ |
+ u8 *pCell; /* Cell content */ |
+ u8 *pCellIdx; /* Next element of the cell pointer array */ |
+ BtShared *pBt; /* The BtShared object that owns pPage */ |
+ u32 pc; /* Address of a cell */ |
+ u32 usableSize; /* Usable size of the page */ |
+ u32 contentOffset; /* Offset to the start of the cell content area */ |
+ u32 *heap = 0; /* Min-heap used for checking cell coverage */ |
+ u32 x, prev = 0; /* Next and previous entry on the min-heap */ |
+ const char *saved_zPfx = pCheck->zPfx; |
+ int saved_v1 = pCheck->v1; |
+ int saved_v2 = pCheck->v2; |
+ u8 savedIsInit = 0; |
+ |
+ /* Check that the page exists |
+ */ |
+ pBt = pCheck->pBt; |
+ usableSize = pBt->usableSize; |
+ if( iPage==0 ) return 0; |
+ if( checkRef(pCheck, iPage) ) return 0; |
+ pCheck->zPfx = "Page %d: "; |
+ pCheck->v1 = iPage; |
+ if( (rc = btreeGetPage(pBt, (Pgno)iPage, &pPage, 0))!=0 ){ |
+ checkAppendMsg(pCheck, |
+ "unable to get the page. error code=%d", rc); |
+ goto end_of_check; |
+ } |
+ |
+ /* Clear MemPage.isInit to make sure the corruption detection code in |
+ ** btreeInitPage() is executed. */ |
+ savedIsInit = pPage->isInit; |
+ pPage->isInit = 0; |
+ if( (rc = btreeInitPage(pPage))!=0 ){ |
+ assert( rc==SQLITE_CORRUPT ); /* The only possible error from InitPage */ |
+ checkAppendMsg(pCheck, |
+ "btreeInitPage() returns error code %d", rc); |
+ goto end_of_check; |
+ } |
+ data = pPage->aData; |
+ hdr = pPage->hdrOffset; |
+ |
+ /* Set up for cell analysis */ |
+ pCheck->zPfx = "On tree page %d cell %d: "; |
+ contentOffset = get2byteNotZero(&data[hdr+5]); |
+ assert( contentOffset<=usableSize ); /* Enforced by btreeInitPage() */ |
+ |
+ /* EVIDENCE-OF: R-37002-32774 The two-byte integer at offset 3 gives the |
+ ** number of cells on the page. */ |
+ nCell = get2byte(&data[hdr+3]); |
+ assert( pPage->nCell==nCell ); |
+ |
+ /* EVIDENCE-OF: R-23882-45353 The cell pointer array of a b-tree page |
+ ** immediately follows the b-tree page header. */ |
+ cellStart = hdr + 12 - 4*pPage->leaf; |
+ assert( pPage->aCellIdx==&data[cellStart] ); |
+ pCellIdx = &data[cellStart + 2*(nCell-1)]; |
+ |
+ if( !pPage->leaf ){ |
+ /* Analyze the right-child page of internal pages */ |
+ pgno = get4byte(&data[hdr+8]); |
+#ifndef SQLITE_OMIT_AUTOVACUUM |
+ if( pBt->autoVacuum ){ |
+ pCheck->zPfx = "On page %d at right child: "; |
+ checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage); |
+ } |
+#endif |
+ depth = checkTreePage(pCheck, pgno, &maxKey, maxKey); |
+ keyCanBeEqual = 0; |
+ }else{ |
+ /* For leaf pages, the coverage check will occur in the same loop |
+ ** as the other cell checks, so initialize the heap. */ |
+ heap = pCheck->heap; |
+ heap[0] = 0; |
+ } |
+ |
+ /* EVIDENCE-OF: R-02776-14802 The cell pointer array consists of K 2-byte |
+ ** integer offsets to the cell contents. */ |
+ for(i=nCell-1; i>=0 && pCheck->mxErr; i--){ |
+ CellInfo info; |
+ |
+ /* Check cell size */ |
+ pCheck->v2 = i; |
+ assert( pCellIdx==&data[cellStart + i*2] ); |
+ pc = get2byteAligned(pCellIdx); |
+ pCellIdx -= 2; |
+ if( pc<contentOffset || pc>usableSize-4 ){ |
+ checkAppendMsg(pCheck, "Offset %d out of range %d..%d", |
+ pc, contentOffset, usableSize-4); |
+ doCoverageCheck = 0; |
+ continue; |
+ } |
+ pCell = &data[pc]; |
+ pPage->xParseCell(pPage, pCell, &info); |
+ if( pc+info.nSize>usableSize ){ |
+ checkAppendMsg(pCheck, "Extends off end of page"); |
+ doCoverageCheck = 0; |
+ continue; |
+ } |
+ |
+ /* Check for integer primary key out of range */ |
+ if( pPage->intKey ){ |
+ if( keyCanBeEqual ? (info.nKey > maxKey) : (info.nKey >= maxKey) ){ |
+ checkAppendMsg(pCheck, "Rowid %lld out of order", info.nKey); |
+ } |
+ maxKey = info.nKey; |
+ } |
+ |
+ /* Check the content overflow list */ |
+ if( info.nPayload>info.nLocal ){ |
+ int nPage; /* Number of pages on the overflow chain */ |
+ Pgno pgnoOvfl; /* First page of the overflow chain */ |
+ assert( pc + info.nSize - 4 <= usableSize ); |
+ nPage = (info.nPayload - info.nLocal + usableSize - 5)/(usableSize - 4); |
+ pgnoOvfl = get4byte(&pCell[info.nSize - 4]); |
+#ifndef SQLITE_OMIT_AUTOVACUUM |
+ if( pBt->autoVacuum ){ |
+ checkPtrmap(pCheck, pgnoOvfl, PTRMAP_OVERFLOW1, iPage); |
+ } |
+#endif |
+ checkList(pCheck, 0, pgnoOvfl, nPage); |
+ } |
+ |
+ if( !pPage->leaf ){ |
+ /* Check sanity of left child page for internal pages */ |
+ pgno = get4byte(pCell); |
+#ifndef SQLITE_OMIT_AUTOVACUUM |
+ if( pBt->autoVacuum ){ |
+ checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage); |
+ } |
+#endif |
+ d2 = checkTreePage(pCheck, pgno, &maxKey, maxKey); |
+ keyCanBeEqual = 0; |
+ if( d2!=depth ){ |
+ checkAppendMsg(pCheck, "Child page depth differs"); |
+ depth = d2; |
+ } |
+ }else{ |
+ /* Populate the coverage-checking heap for leaf pages */ |
+ btreeHeapInsert(heap, (pc<<16)|(pc+info.nSize-1)); |
+ } |
+ } |
+ *piMinKey = maxKey; |
+ |
+ /* Check for complete coverage of the page |
+ */ |
+ pCheck->zPfx = 0; |
+ if( doCoverageCheck && pCheck->mxErr>0 ){ |
+ /* For leaf pages, the min-heap has already been initialized and the |
+ ** cells have already been inserted. But for internal pages, that has |
+ ** not yet been done, so do it now */ |
+ if( !pPage->leaf ){ |
+ heap = pCheck->heap; |
+ heap[0] = 0; |
+ for(i=nCell-1; i>=0; i--){ |
+ u32 size; |
+ pc = get2byteAligned(&data[cellStart+i*2]); |
+ size = pPage->xCellSize(pPage, &data[pc]); |
+ btreeHeapInsert(heap, (pc<<16)|(pc+size-1)); |
+ } |
+ } |
+ /* Add the freeblocks to the min-heap |
+ ** |
+ ** EVIDENCE-OF: R-20690-50594 The second field of the b-tree page header |
+ ** is the offset of the first freeblock, or zero if there are no |
+ ** freeblocks on the page. |
+ */ |
+ i = get2byte(&data[hdr+1]); |
+ while( i>0 ){ |
+ int size, j; |
+ assert( (u32)i<=usableSize-4 ); /* Enforced by btreeInitPage() */ |
+ size = get2byte(&data[i+2]); |
+ assert( (u32)(i+size)<=usableSize ); /* Enforced by btreeInitPage() */ |
+ btreeHeapInsert(heap, (((u32)i)<<16)|(i+size-1)); |
+ /* EVIDENCE-OF: R-58208-19414 The first 2 bytes of a freeblock are a |
+ ** big-endian integer which is the offset in the b-tree page of the next |
+ ** freeblock in the chain, or zero if the freeblock is the last on the |
+ ** chain. */ |
+ j = get2byte(&data[i]); |
+ /* EVIDENCE-OF: R-06866-39125 Freeblocks are always connected in order of |
+ ** increasing offset. */ |
+ assert( j==0 || j>i+size ); /* Enforced by btreeInitPage() */ |
+ assert( (u32)j<=usableSize-4 ); /* Enforced by btreeInitPage() */ |
+ i = j; |
+ } |
+ /* Analyze the min-heap looking for overlap between cells and/or |
+ ** freeblocks, and counting the number of untracked bytes in nFrag. |
+ ** |
+ ** Each min-heap entry is of the form: (start_address<<16)|end_address. |
+ ** There is an implied first entry the covers the page header, the cell |
+ ** pointer index, and the gap between the cell pointer index and the start |
+ ** of cell content. |
+ ** |
+ ** The loop below pulls entries from the min-heap in order and compares |
+ ** the start_address against the previous end_address. If there is an |
+ ** overlap, that means bytes are used multiple times. If there is a gap, |
+ ** that gap is added to the fragmentation count. |
+ */ |
+ nFrag = 0; |
+ prev = contentOffset - 1; /* Implied first min-heap entry */ |
+ while( btreeHeapPull(heap,&x) ){ |
+ if( (prev&0xffff)>=(x>>16) ){ |
+ checkAppendMsg(pCheck, |
+ "Multiple uses for byte %u of page %d", x>>16, iPage); |
+ break; |
+ }else{ |
+ nFrag += (x>>16) - (prev&0xffff) - 1; |
+ prev = x; |
+ } |
+ } |
+ nFrag += usableSize - (prev&0xffff) - 1; |
+ /* EVIDENCE-OF: R-43263-13491 The total number of bytes in all fragments |
+ ** is stored in the fifth field of the b-tree page header. |
+ ** EVIDENCE-OF: R-07161-27322 The one-byte integer at offset 7 gives the |
+ ** number of fragmented free bytes within the cell content area. |
+ */ |
+ if( heap[0]==0 && nFrag!=data[hdr+7] ){ |
+ checkAppendMsg(pCheck, |
+ "Fragmentation of %d bytes reported as %d on page %d", |
+ nFrag, data[hdr+7], iPage); |
+ } |
+ } |
+ |
+end_of_check: |
+ if( !doCoverageCheck ) pPage->isInit = savedIsInit; |
+ releasePage(pPage); |
+ pCheck->zPfx = saved_zPfx; |
+ pCheck->v1 = saved_v1; |
+ pCheck->v2 = saved_v2; |
+ 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; |
+ IntegrityCk sCheck; |
+ BtShared *pBt = p->pBt; |
+ int savedDbFlags = pBt->db->flags; |
+ char zErr[100]; |
+ VVA_ONLY( int nRef ); |
+ |
+ sqlite3BtreeEnter(p); |
+ assert( p->inTrans>TRANS_NONE && pBt->inTransaction>TRANS_NONE ); |
+ VVA_ONLY( nRef = sqlite3PagerRefcount(pBt->pPager) ); |
+ assert( nRef>=0 ); |
+ sCheck.pBt = pBt; |
+ sCheck.pPager = pBt->pPager; |
+ sCheck.nPage = btreePagecount(sCheck.pBt); |
+ sCheck.mxErr = mxErr; |
+ sCheck.nErr = 0; |
+ sCheck.mallocFailed = 0; |
+ sCheck.zPfx = 0; |
+ sCheck.v1 = 0; |
+ sCheck.v2 = 0; |
+ sCheck.aPgRef = 0; |
+ sCheck.heap = 0; |
+ sqlite3StrAccumInit(&sCheck.errMsg, 0, zErr, sizeof(zErr), SQLITE_MAX_LENGTH); |
+ sCheck.errMsg.printfFlags = SQLITE_PRINTF_INTERNAL; |
+ if( sCheck.nPage==0 ){ |
+ goto integrity_ck_cleanup; |
+ } |
+ |
+ sCheck.aPgRef = sqlite3MallocZero((sCheck.nPage / 8)+ 1); |
+ if( !sCheck.aPgRef ){ |
+ sCheck.mallocFailed = 1; |
+ goto integrity_ck_cleanup; |
+ } |
+ sCheck.heap = (u32*)sqlite3PageMalloc( pBt->pageSize ); |
+ if( sCheck.heap==0 ){ |
+ sCheck.mallocFailed = 1; |
+ goto integrity_ck_cleanup; |
+ } |
+ |
+ i = PENDING_BYTE_PAGE(pBt); |
+ if( i<=sCheck.nPage ) setPageReferenced(&sCheck, i); |
+ |
+ /* Check the integrity of the freelist |
+ */ |
+ sCheck.zPfx = "Main freelist: "; |
+ checkList(&sCheck, 1, get4byte(&pBt->pPage1->aData[32]), |
+ get4byte(&pBt->pPage1->aData[36])); |
+ sCheck.zPfx = 0; |
+ |
+ /* Check all the tables. |
+ */ |
+ testcase( pBt->db->flags & SQLITE_CellSizeCk ); |
+ pBt->db->flags &= ~SQLITE_CellSizeCk; |
+ for(i=0; (int)i<nRoot && sCheck.mxErr; i++){ |
+ i64 notUsed; |
+ if( aRoot[i]==0 ) continue; |
+#ifndef SQLITE_OMIT_AUTOVACUUM |
+ if( pBt->autoVacuum && aRoot[i]>1 ){ |
+ checkPtrmap(&sCheck, aRoot[i], PTRMAP_ROOTPAGE, 0); |
+ } |
+#endif |
+ checkTreePage(&sCheck, aRoot[i], ¬Used, LARGEST_INT64); |
+ } |
+ pBt->db->flags = savedDbFlags; |
+ |
+ /* Make sure every page in the file is referenced |
+ */ |
+ for(i=1; i<=sCheck.nPage && sCheck.mxErr; i++){ |
+#ifdef SQLITE_OMIT_AUTOVACUUM |
+ if( getPageReferenced(&sCheck, i)==0 ){ |
+ checkAppendMsg(&sCheck, "Page %d is never used", i); |
+ } |
+#else |
+ /* If the database supports auto-vacuum, make sure no tables contain |
+ ** references to pointer-map pages. |
+ */ |
+ if( getPageReferenced(&sCheck, i)==0 && |
+ (PTRMAP_PAGENO(pBt, i)!=i || !pBt->autoVacuum) ){ |
+ checkAppendMsg(&sCheck, "Page %d is never used", i); |
+ } |
+ if( getPageReferenced(&sCheck, i)!=0 && |
+ (PTRMAP_PAGENO(pBt, i)==i && pBt->autoVacuum) ){ |
+ checkAppendMsg(&sCheck, "Pointer map page %d is referenced", i); |
+ } |
+#endif |
+ } |
+ |
+ /* Clean up and report errors. |
+ */ |
+integrity_ck_cleanup: |
+ sqlite3PageFree(sCheck.heap); |
+ sqlite3_free(sCheck.aPgRef); |
+ if( sCheck.mallocFailed ){ |
+ sqlite3StrAccumReset(&sCheck.errMsg); |
+ sCheck.nErr++; |
+ } |
+ *pnErr = sCheck.nErr; |
+ if( sCheck.nErr==0 ) sqlite3StrAccumReset(&sCheck.errMsg); |
+ /* Make sure this analysis did not leave any unref() pages. */ |
+ assert( nRef==sqlite3PagerRefcount(pBt->pPager) ); |
+ sqlite3BtreeLeave(p); |
+ return sqlite3StrAccumFinish(&sCheck.errMsg); |
+} |
+#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ |
+ |
+/* |
+** Return the full pathname of the underlying database file. Return |
+** an empty string if the database is in-memory or a TEMP database. |
+** |
+** 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, 1); |
+} |
+ |
+/* |
+** 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, p->db, 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( cursorOwnsBtShared(pCsr) ); |
+ assert( sqlite3_mutex_held(pCsr->pBtree->db->mutex) ); |
+ assert( pCsr->curFlags & BTCF_Incrblob ); |
+ |
+ rc = restoreCursorPosition(pCsr); |
+ if( rc!=SQLITE_OK ){ |
+ return rc; |
+ } |
+ assert( pCsr->eState!=CURSOR_REQUIRESEEK ); |
+ if( pCsr->eState!=CURSOR_VALID ){ |
+ return SQLITE_ABORT; |
+ } |
+ |
+ /* Save the positions of all other cursors open on this table. This is |
+ ** required in case any of them are holding references to an xFetch |
+ ** version of the b-tree page modified by the accessPayload call below. |
+ ** |
+ ** Note that pCsr must be open on a INTKEY table and saveCursorPosition() |
+ ** and hence saveAllCursors() cannot fail on a BTREE_INTKEY table, hence |
+ ** saveAllCursors can only return SQLITE_OK. |
+ */ |
+ VVA_ONLY(rc =) saveAllCursors(pCsr->pBt, pCsr->pgnoRoot, pCsr); |
+ assert( rc==SQLITE_OK ); |
+ |
+ /* 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->curFlags & BTCF_WriteFlag)==0 ){ |
+ return SQLITE_READONLY; |
+ } |
+ assert( (pCsr->pBt->btsFlags & BTS_READ_ONLY)==0 |
+ && 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); |
+} |
+ |
+/* |
+** Mark this cursor as an incremental blob cursor. |
+*/ |
+void sqlite3BtreeIncrblobCursor(BtCursor *pCur){ |
+ pCur->curFlags |= BTCF_Incrblob; |
+ pCur->pBtree->hasIncrblobCur = 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( 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->btsFlags &= ~BTS_NO_WAL; |
+ if( iVersion==1 ) pBt->btsFlags |= BTS_NO_WAL; |
+ |
+ 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->btsFlags &= ~BTS_NO_WAL; |
+ return rc; |
+} |
+ |
+/* |
+** Return true if the cursor has a hint specified. This routine is |
+** only used from within assert() statements |
+*/ |
+int sqlite3BtreeCursorHasHint(BtCursor *pCsr, unsigned int mask){ |
+ return (pCsr->hints & mask)!=0; |
+} |
+ |
+/* |
+** Return true if the given Btree is read-only. |
+*/ |
+int sqlite3BtreeIsReadonly(Btree *p){ |
+ return (p->pBt->btsFlags & BTS_READ_ONLY)!=0; |
+} |
+ |
+/* |
+** Return the size of the header added to each page by this module. |
+*/ |
+int sqlite3HeaderSizeBtree(void){ return ROUND8(sizeof(MemPage)); } |
+ |
+#if !defined(SQLITE_OMIT_SHARED_CACHE) |
+/* |
+** Return true if the Btree passed as the only argument is sharable. |
+*/ |
+int sqlite3BtreeSharable(Btree *p){ |
+ return p->sharable; |
+} |
+ |
+/* |
+** Return the number of connections to the BtShared object accessed by |
+** the Btree handle passed as the only argument. For private caches |
+** this is always 1. For shared caches it may be 1 or greater. |
+*/ |
+int sqlite3BtreeConnectionCount(Btree *p){ |
+ testcase( p->sharable ); |
+ return p->pBt->nRef; |
+} |
+#endif |