4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
7 ** May you do good and not evil.
8 ** May you find forgiveness for yourself and forgive others.
9 ** May you share freely, never taking more than you give.
11 *************************************************************************
12 ** This file implements an external (disk-based) database using BTrees.
13 ** See the header comment on "btreeInt.h" for additional information.
14 ** Including a description of file format and an overview of operation.
19 ** The header string that appears at the beginning of every
22 static const char zMagicHeader
[] = SQLITE_FILE_HEADER
;
25 ** Set this global variable to 1 to enable tracing using the TRACE
29 int sqlite3BtreeTrace
=1; /* True to enable tracing */
30 # define TRACE(X) if(sqlite3BtreeTrace){printf X;fflush(stdout);}
36 ** Extract a 2-byte big-endian integer from an array of unsigned bytes.
37 ** But if the value is zero, make it 65536.
39 ** This routine is used to extract the "offset to cell content area" value
40 ** from the header of a btree page. If the page size is 65536 and the page
41 ** is empty, the offset should be 65536, but the 2-byte value stores zero.
42 ** This routine makes the necessary adjustment to 65536.
44 #define get2byteNotZero(X) (((((int)get2byte(X))-1)&0xffff)+1)
47 ** Values passed as the 5th argument to allocateBtreePage()
49 #define BTALLOC_ANY 0 /* Allocate any page */
50 #define BTALLOC_EXACT 1 /* Allocate exact page if possible */
51 #define BTALLOC_LE 2 /* Allocate any page <= the parameter */
54 ** Macro IfNotOmitAV(x) returns (x) if SQLITE_OMIT_AUTOVACUUM is not
55 ** defined, or 0 if it is. For example:
57 ** bIncrVacuum = IfNotOmitAV(pBtShared->incrVacuum);
59 #ifndef SQLITE_OMIT_AUTOVACUUM
60 #define IfNotOmitAV(expr) (expr)
62 #define IfNotOmitAV(expr) 0
65 #ifndef SQLITE_OMIT_SHARED_CACHE
67 ** A list of BtShared objects that are eligible for participation
68 ** in shared cache. This variable has file scope during normal builds,
69 ** but the test harness needs to access it so we make it global for
72 ** Access to this variable is protected by SQLITE_MUTEX_STATIC_MASTER.
75 BtShared
*SQLITE_WSD sqlite3SharedCacheList
= 0;
77 static BtShared
*SQLITE_WSD sqlite3SharedCacheList
= 0;
79 #endif /* SQLITE_OMIT_SHARED_CACHE */
81 #ifndef SQLITE_OMIT_SHARED_CACHE
83 ** Enable or disable the shared pager and schema features.
85 ** This routine has no effect on existing database connections.
86 ** The shared cache setting effects only future calls to
87 ** sqlite3_open(), sqlite3_open16(), or sqlite3_open_v2().
89 int sqlite3_enable_shared_cache(int enable
){
90 sqlite3GlobalConfig
.sharedCacheEnabled
= enable
;
97 #ifdef SQLITE_OMIT_SHARED_CACHE
99 ** The functions querySharedCacheTableLock(), setSharedCacheTableLock(),
100 ** and clearAllSharedCacheTableLocks()
101 ** manipulate entries in the BtShared.pLock linked list used to store
102 ** shared-cache table level locks. If the library is compiled with the
103 ** shared-cache feature disabled, then there is only ever one user
104 ** of each BtShared structure and so this locking is not necessary.
105 ** So define the lock related functions as no-ops.
107 #define querySharedCacheTableLock(a,b,c) SQLITE_OK
108 #define setSharedCacheTableLock(a,b,c) SQLITE_OK
109 #define clearAllSharedCacheTableLocks(a)
110 #define downgradeAllSharedCacheTableLocks(a)
111 #define hasSharedCacheTableLock(a,b,c,d) 1
112 #define hasReadConflicts(a, b) 0
116 ** Implementation of the SQLITE_CORRUPT_PAGE() macro. Takes a single
117 ** (MemPage*) as an argument. The (MemPage*) must not be NULL.
119 ** If SQLITE_DEBUG is not defined, then this macro is equivalent to
120 ** SQLITE_CORRUPT_BKPT. Or, if SQLITE_DEBUG is set, then the log message
121 ** normally produced as a side-effect of SQLITE_CORRUPT_BKPT is augmented
122 ** with the page number and filename associated with the (MemPage*).
125 int corruptPageError(int lineno
, MemPage
*p
){
127 sqlite3BeginBenignMalloc();
128 zMsg
= sqlite3_mprintf("database corruption page %d of %s",
129 (int)p
->pgno
, sqlite3PagerFilename(p
->pBt
->pPager
, 0)
131 sqlite3EndBenignMalloc();
133 sqlite3ReportError(SQLITE_CORRUPT
, lineno
, zMsg
);
136 return SQLITE_CORRUPT_BKPT
;
138 # define SQLITE_CORRUPT_PAGE(pMemPage) corruptPageError(__LINE__, pMemPage)
140 # define SQLITE_CORRUPT_PAGE(pMemPage) SQLITE_CORRUPT_PGNO(pMemPage->pgno)
143 #ifndef SQLITE_OMIT_SHARED_CACHE
147 **** This function is only used as part of an assert() statement. ***
149 ** Check to see if pBtree holds the required locks to read or write to the
150 ** table with root page iRoot. Return 1 if it does and 0 if not.
152 ** For example, when writing to a table with root-page iRoot via
153 ** Btree connection pBtree:
155 ** assert( hasSharedCacheTableLock(pBtree, iRoot, 0, WRITE_LOCK) );
157 ** When writing to an index that resides in a sharable database, the
158 ** caller should have first obtained a lock specifying the root page of
159 ** the corresponding table. This makes things a bit more complicated,
160 ** as this module treats each table as a separate structure. To determine
161 ** the table corresponding to the index being written, this
162 ** function has to search through the database schema.
164 ** Instead of a lock on the table/index rooted at page iRoot, the caller may
165 ** hold a write-lock on the schema table (root page 1). This is also
168 static int hasSharedCacheTableLock(
169 Btree
*pBtree
, /* Handle that must hold lock */
170 Pgno iRoot
, /* Root page of b-tree */
171 int isIndex
, /* True if iRoot is the root of an index b-tree */
172 int eLockType
/* Required lock type (READ_LOCK or WRITE_LOCK) */
174 Schema
*pSchema
= (Schema
*)pBtree
->pBt
->pSchema
;
178 /* If this database is not shareable, or if the client is reading
179 ** and has the read-uncommitted flag set, then no lock is required.
180 ** Return true immediately.
182 if( (pBtree
->sharable
==0)
183 || (eLockType
==READ_LOCK
&& (pBtree
->db
->flags
& SQLITE_ReadUncommit
))
188 /* If the client is reading or writing an index and the schema is
189 ** not loaded, then it is too difficult to actually check to see if
190 ** the correct locks are held. So do not bother - just return true.
191 ** This case does not come up very often anyhow.
193 if( isIndex
&& (!pSchema
|| (pSchema
->schemaFlags
&DB_SchemaLoaded
)==0) ){
197 /* Figure out the root-page that the lock should be held on. For table
198 ** b-trees, this is just the root page of the b-tree being read or
199 ** written. For index b-trees, it is the root page of the associated
203 for(p
=sqliteHashFirst(&pSchema
->idxHash
); p
; p
=sqliteHashNext(p
)){
204 Index
*pIdx
= (Index
*)sqliteHashData(p
);
205 if( pIdx
->tnum
==(int)iRoot
){
207 /* Two or more indexes share the same root page. There must
208 ** be imposter tables. So just return true. The assert is not
209 ** useful in that case. */
212 iTab
= pIdx
->pTable
->tnum
;
219 /* Search for the required lock. Either a write-lock on root-page iTab, a
220 ** write-lock on the schema table, or (if the client is reading) a
221 ** read-lock on iTab will suffice. Return 1 if any of these are found. */
222 for(pLock
=pBtree
->pBt
->pLock
; pLock
; pLock
=pLock
->pNext
){
223 if( pLock
->pBtree
==pBtree
224 && (pLock
->iTable
==iTab
|| (pLock
->eLock
==WRITE_LOCK
&& pLock
->iTable
==1))
225 && pLock
->eLock
>=eLockType
231 /* Failed to find the required lock. */
234 #endif /* SQLITE_DEBUG */
238 **** This function may be used as part of assert() statements only. ****
240 ** Return true if it would be illegal for pBtree to write into the
241 ** table or index rooted at iRoot because other shared connections are
242 ** simultaneously reading that same table or index.
244 ** It is illegal for pBtree to write if some other Btree object that
245 ** shares the same BtShared object is currently reading or writing
246 ** the iRoot table. Except, if the other Btree object has the
247 ** read-uncommitted flag set, then it is OK for the other object to
248 ** have a read cursor.
250 ** For example, before writing to any part of the table or index
251 ** rooted at page iRoot, one should call:
253 ** assert( !hasReadConflicts(pBtree, iRoot) );
255 static int hasReadConflicts(Btree
*pBtree
, Pgno iRoot
){
257 for(p
=pBtree
->pBt
->pCursor
; p
; p
=p
->pNext
){
258 if( p
->pgnoRoot
==iRoot
260 && 0==(p
->pBtree
->db
->flags
& SQLITE_ReadUncommit
)
267 #endif /* #ifdef SQLITE_DEBUG */
270 ** Query to see if Btree handle p may obtain a lock of type eLock
271 ** (READ_LOCK or WRITE_LOCK) on the table with root-page iTab. Return
272 ** SQLITE_OK if the lock may be obtained (by calling
273 ** setSharedCacheTableLock()), or SQLITE_LOCKED if not.
275 static int querySharedCacheTableLock(Btree
*p
, Pgno iTab
, u8 eLock
){
276 BtShared
*pBt
= p
->pBt
;
279 assert( sqlite3BtreeHoldsMutex(p
) );
280 assert( eLock
==READ_LOCK
|| eLock
==WRITE_LOCK
);
282 assert( !(p
->db
->flags
&SQLITE_ReadUncommit
)||eLock
==WRITE_LOCK
||iTab
==1 );
284 /* If requesting a write-lock, then the Btree must have an open write
285 ** transaction on this file. And, obviously, for this to be so there
286 ** must be an open write transaction on the file itself.
288 assert( eLock
==READ_LOCK
|| (p
==pBt
->pWriter
&& p
->inTrans
==TRANS_WRITE
) );
289 assert( eLock
==READ_LOCK
|| pBt
->inTransaction
==TRANS_WRITE
);
291 /* This routine is a no-op if the shared-cache is not enabled */
296 /* If some other connection is holding an exclusive lock, the
297 ** requested lock may not be obtained.
299 if( pBt
->pWriter
!=p
&& (pBt
->btsFlags
& BTS_EXCLUSIVE
)!=0 ){
300 sqlite3ConnectionBlocked(p
->db
, pBt
->pWriter
->db
);
301 return SQLITE_LOCKED_SHAREDCACHE
;
304 for(pIter
=pBt
->pLock
; pIter
; pIter
=pIter
->pNext
){
305 /* The condition (pIter->eLock!=eLock) in the following if(...)
306 ** statement is a simplification of:
308 ** (eLock==WRITE_LOCK || pIter->eLock==WRITE_LOCK)
310 ** since we know that if eLock==WRITE_LOCK, then no other connection
311 ** may hold a WRITE_LOCK on any table in this file (since there can
312 ** only be a single writer).
314 assert( pIter
->eLock
==READ_LOCK
|| pIter
->eLock
==WRITE_LOCK
);
315 assert( eLock
==READ_LOCK
|| pIter
->pBtree
==p
|| pIter
->eLock
==READ_LOCK
);
316 if( pIter
->pBtree
!=p
&& pIter
->iTable
==iTab
&& pIter
->eLock
!=eLock
){
317 sqlite3ConnectionBlocked(p
->db
, pIter
->pBtree
->db
);
318 if( eLock
==WRITE_LOCK
){
319 assert( p
==pBt
->pWriter
);
320 pBt
->btsFlags
|= BTS_PENDING
;
322 return SQLITE_LOCKED_SHAREDCACHE
;
327 #endif /* !SQLITE_OMIT_SHARED_CACHE */
329 #ifndef SQLITE_OMIT_SHARED_CACHE
331 ** Add a lock on the table with root-page iTable to the shared-btree used
332 ** by Btree handle p. Parameter eLock must be either READ_LOCK or
335 ** This function assumes the following:
337 ** (a) The specified Btree object p is connected to a sharable
338 ** database (one with the BtShared.sharable flag set), and
340 ** (b) No other Btree objects hold a lock that conflicts
341 ** with the requested lock (i.e. querySharedCacheTableLock() has
342 ** already been called and returned SQLITE_OK).
344 ** SQLITE_OK is returned if the lock is added successfully. SQLITE_NOMEM
345 ** is returned if a malloc attempt fails.
347 static int setSharedCacheTableLock(Btree
*p
, Pgno iTable
, u8 eLock
){
348 BtShared
*pBt
= p
->pBt
;
352 assert( sqlite3BtreeHoldsMutex(p
) );
353 assert( eLock
==READ_LOCK
|| eLock
==WRITE_LOCK
);
356 /* A connection with the read-uncommitted flag set will never try to
357 ** obtain a read-lock using this function. The only read-lock obtained
358 ** by a connection in read-uncommitted mode is on the sqlite_master
359 ** table, and that lock is obtained in BtreeBeginTrans(). */
360 assert( 0==(p
->db
->flags
&SQLITE_ReadUncommit
) || eLock
==WRITE_LOCK
);
362 /* This function should only be called on a sharable b-tree after it
363 ** has been determined that no other b-tree holds a conflicting lock. */
364 assert( p
->sharable
);
365 assert( SQLITE_OK
==querySharedCacheTableLock(p
, iTable
, eLock
) );
367 /* First search the list for an existing lock on this table. */
368 for(pIter
=pBt
->pLock
; pIter
; pIter
=pIter
->pNext
){
369 if( pIter
->iTable
==iTable
&& pIter
->pBtree
==p
){
375 /* If the above search did not find a BtLock struct associating Btree p
376 ** with table iTable, allocate one and link it into the list.
379 pLock
= (BtLock
*)sqlite3MallocZero(sizeof(BtLock
));
381 return SQLITE_NOMEM_BKPT
;
383 pLock
->iTable
= iTable
;
385 pLock
->pNext
= pBt
->pLock
;
389 /* Set the BtLock.eLock variable to the maximum of the current lock
390 ** and the requested lock. This means if a write-lock was already held
391 ** and a read-lock requested, we don't incorrectly downgrade the lock.
393 assert( WRITE_LOCK
>READ_LOCK
);
394 if( eLock
>pLock
->eLock
){
395 pLock
->eLock
= eLock
;
400 #endif /* !SQLITE_OMIT_SHARED_CACHE */
402 #ifndef SQLITE_OMIT_SHARED_CACHE
404 ** Release all the table locks (locks obtained via calls to
405 ** the setSharedCacheTableLock() procedure) held by Btree object p.
407 ** This function assumes that Btree p has an open read or write
408 ** transaction. If it does not, then the BTS_PENDING flag
409 ** may be incorrectly cleared.
411 static void clearAllSharedCacheTableLocks(Btree
*p
){
412 BtShared
*pBt
= p
->pBt
;
413 BtLock
**ppIter
= &pBt
->pLock
;
415 assert( sqlite3BtreeHoldsMutex(p
) );
416 assert( p
->sharable
|| 0==*ppIter
);
417 assert( p
->inTrans
>0 );
420 BtLock
*pLock
= *ppIter
;
421 assert( (pBt
->btsFlags
& BTS_EXCLUSIVE
)==0 || pBt
->pWriter
==pLock
->pBtree
);
422 assert( pLock
->pBtree
->inTrans
>=pLock
->eLock
);
423 if( pLock
->pBtree
==p
){
424 *ppIter
= pLock
->pNext
;
425 assert( pLock
->iTable
!=1 || pLock
==&p
->lock
);
426 if( pLock
->iTable
!=1 ){
430 ppIter
= &pLock
->pNext
;
434 assert( (pBt
->btsFlags
& BTS_PENDING
)==0 || pBt
->pWriter
);
435 if( pBt
->pWriter
==p
){
437 pBt
->btsFlags
&= ~(BTS_EXCLUSIVE
|BTS_PENDING
);
438 }else if( pBt
->nTransaction
==2 ){
439 /* This function is called when Btree p is concluding its
440 ** transaction. If there currently exists a writer, and p is not
441 ** that writer, then the number of locks held by connections other
442 ** than the writer must be about to drop to zero. In this case
443 ** set the BTS_PENDING flag to 0.
445 ** If there is not currently a writer, then BTS_PENDING must
446 ** be zero already. So this next line is harmless in that case.
448 pBt
->btsFlags
&= ~BTS_PENDING
;
453 ** This function changes all write-locks held by Btree p into read-locks.
455 static void downgradeAllSharedCacheTableLocks(Btree
*p
){
456 BtShared
*pBt
= p
->pBt
;
457 if( pBt
->pWriter
==p
){
460 pBt
->btsFlags
&= ~(BTS_EXCLUSIVE
|BTS_PENDING
);
461 for(pLock
=pBt
->pLock
; pLock
; pLock
=pLock
->pNext
){
462 assert( pLock
->eLock
==READ_LOCK
|| pLock
->pBtree
==p
);
463 pLock
->eLock
= READ_LOCK
;
468 #endif /* SQLITE_OMIT_SHARED_CACHE */
470 static void releasePage(MemPage
*pPage
); /* Forward reference */
471 static void releasePageOne(MemPage
*pPage
); /* Forward reference */
472 static void releasePageNotNull(MemPage
*pPage
); /* Forward reference */
475 ***** This routine is used inside of assert() only ****
477 ** Verify that the cursor holds the mutex on its BtShared
480 static int cursorHoldsMutex(BtCursor
*p
){
481 return sqlite3_mutex_held(p
->pBt
->mutex
);
484 /* Verify that the cursor and the BtShared agree about what is the current
485 ** database connetion. This is important in shared-cache mode. If the database
486 ** connection pointers get out-of-sync, it is possible for routines like
487 ** btreeInitPage() to reference an stale connection pointer that references a
488 ** a connection that has already closed. This routine is used inside assert()
489 ** statements only and for the purpose of double-checking that the btree code
490 ** does keep the database connection pointers up-to-date.
492 static int cursorOwnsBtShared(BtCursor
*p
){
493 assert( cursorHoldsMutex(p
) );
494 return (p
->pBtree
->db
==p
->pBt
->db
);
499 ** Invalidate the overflow cache of the cursor passed as the first argument.
500 ** on the shared btree structure pBt.
502 #define invalidateOverflowCache(pCur) (pCur->curFlags &= ~BTCF_ValidOvfl)
505 ** Invalidate the overflow page-list cache for all cursors opened
506 ** on the shared btree structure pBt.
508 static void invalidateAllOverflowCache(BtShared
*pBt
){
510 assert( sqlite3_mutex_held(pBt
->mutex
) );
511 for(p
=pBt
->pCursor
; p
; p
=p
->pNext
){
512 invalidateOverflowCache(p
);
516 #ifndef SQLITE_OMIT_INCRBLOB
518 ** This function is called before modifying the contents of a table
519 ** to invalidate any incrblob cursors that are open on the
520 ** row or one of the rows being modified.
522 ** If argument isClearTable is true, then the entire contents of the
523 ** table is about to be deleted. In this case invalidate all incrblob
524 ** cursors open on any row within the table with root-page pgnoRoot.
526 ** Otherwise, if argument isClearTable is false, then the row with
527 ** rowid iRow is being replaced or deleted. In this case invalidate
528 ** only those incrblob cursors open on that specific row.
530 static void invalidateIncrblobCursors(
531 Btree
*pBtree
, /* The database file to check */
532 Pgno pgnoRoot
, /* The table that might be changing */
533 i64 iRow
, /* The rowid that might be changing */
534 int isClearTable
/* True if all rows are being deleted */
537 if( pBtree
->hasIncrblobCur
==0 ) return;
538 assert( sqlite3BtreeHoldsMutex(pBtree
) );
539 pBtree
->hasIncrblobCur
= 0;
540 for(p
=pBtree
->pBt
->pCursor
; p
; p
=p
->pNext
){
541 if( (p
->curFlags
& BTCF_Incrblob
)!=0 ){
542 pBtree
->hasIncrblobCur
= 1;
543 if( p
->pgnoRoot
==pgnoRoot
&& (isClearTable
|| p
->info
.nKey
==iRow
) ){
544 p
->eState
= CURSOR_INVALID
;
551 /* Stub function when INCRBLOB is omitted */
552 #define invalidateIncrblobCursors(w,x,y,z)
553 #endif /* SQLITE_OMIT_INCRBLOB */
556 ** Set bit pgno of the BtShared.pHasContent bitvec. This is called
557 ** when a page that previously contained data becomes a free-list leaf
560 ** The BtShared.pHasContent bitvec exists to work around an obscure
561 ** bug caused by the interaction of two useful IO optimizations surrounding
562 ** free-list leaf pages:
564 ** 1) When all data is deleted from a page and the page becomes
565 ** a free-list leaf page, the page is not written to the database
566 ** (as free-list leaf pages contain no meaningful data). Sometimes
567 ** such a page is not even journalled (as it will not be modified,
568 ** why bother journalling it?).
570 ** 2) When a free-list leaf page is reused, its content is not read
571 ** from the database or written to the journal file (why should it
572 ** be, if it is not at all meaningful?).
574 ** By themselves, these optimizations work fine and provide a handy
575 ** performance boost to bulk delete or insert operations. However, if
576 ** a page is moved to the free-list and then reused within the same
577 ** transaction, a problem comes up. If the page is not journalled when
578 ** it is moved to the free-list and it is also not journalled when it
579 ** is extracted from the free-list and reused, then the original data
580 ** may be lost. In the event of a rollback, it may not be possible
581 ** to restore the database to its original configuration.
583 ** The solution is the BtShared.pHasContent bitvec. Whenever a page is
584 ** moved to become a free-list leaf page, the corresponding bit is
585 ** set in the bitvec. Whenever a leaf page is extracted from the free-list,
586 ** optimization 2 above is omitted if the corresponding bit is already
587 ** set in BtShared.pHasContent. The contents of the bitvec are cleared
588 ** at the end of every transaction.
590 static int btreeSetHasContent(BtShared
*pBt
, Pgno pgno
){
592 if( !pBt
->pHasContent
){
593 assert( pgno
<=pBt
->nPage
);
594 pBt
->pHasContent
= sqlite3BitvecCreate(pBt
->nPage
);
595 if( !pBt
->pHasContent
){
596 rc
= SQLITE_NOMEM_BKPT
;
599 if( rc
==SQLITE_OK
&& pgno
<=sqlite3BitvecSize(pBt
->pHasContent
) ){
600 rc
= sqlite3BitvecSet(pBt
->pHasContent
, pgno
);
606 ** Query the BtShared.pHasContent vector.
608 ** This function is called when a free-list leaf page is removed from the
609 ** free-list for reuse. It returns false if it is safe to retrieve the
610 ** page from the pager layer with the 'no-content' flag set. True otherwise.
612 static int btreeGetHasContent(BtShared
*pBt
, Pgno pgno
){
613 Bitvec
*p
= pBt
->pHasContent
;
614 return (p
&& (pgno
>sqlite3BitvecSize(p
) || sqlite3BitvecTest(p
, pgno
)));
618 ** Clear (destroy) the BtShared.pHasContent bitvec. This should be
619 ** invoked at the conclusion of each write-transaction.
621 static void btreeClearHasContent(BtShared
*pBt
){
622 sqlite3BitvecDestroy(pBt
->pHasContent
);
623 pBt
->pHasContent
= 0;
627 ** Release all of the apPage[] pages for a cursor.
629 static void btreeReleaseAllCursorPages(BtCursor
*pCur
){
631 if( pCur
->iPage
>=0 ){
632 for(i
=0; i
<pCur
->iPage
; i
++){
633 releasePageNotNull(pCur
->apPage
[i
]);
635 releasePageNotNull(pCur
->pPage
);
641 ** The cursor passed as the only argument must point to a valid entry
642 ** when this function is called (i.e. have eState==CURSOR_VALID). This
643 ** function saves the current cursor key in variables pCur->nKey and
644 ** pCur->pKey. SQLITE_OK is returned if successful or an SQLite error
647 ** If the cursor is open on an intkey table, then the integer key
648 ** (the rowid) is stored in pCur->nKey and pCur->pKey is left set to
649 ** NULL. If the cursor is open on a non-intkey table, then pCur->pKey is
650 ** set to point to a malloced buffer pCur->nKey bytes in size containing
653 static int saveCursorKey(BtCursor
*pCur
){
655 assert( CURSOR_VALID
==pCur
->eState
);
656 assert( 0==pCur
->pKey
);
657 assert( cursorHoldsMutex(pCur
) );
659 if( pCur
->curIntKey
){
660 /* Only the rowid is required for a table btree */
661 pCur
->nKey
= sqlite3BtreeIntegerKey(pCur
);
663 /* For an index btree, save the complete key content. It is possible
664 ** that the current key is corrupt. In that case, it is possible that
665 ** the sqlite3VdbeRecordUnpack() function may overread the buffer by
666 ** up to the size of 1 varint plus 1 8-byte value when the cursor
667 ** position is restored. Hence the 17 bytes of padding allocated
670 pCur
->nKey
= sqlite3BtreePayloadSize(pCur
);
671 pKey
= sqlite3Malloc( pCur
->nKey
+ 9 + 8 );
673 rc
= sqlite3BtreePayload(pCur
, 0, (int)pCur
->nKey
, pKey
);
675 memset(((u8
*)pKey
)+pCur
->nKey
, 0, 9+8);
681 rc
= SQLITE_NOMEM_BKPT
;
684 assert( !pCur
->curIntKey
|| !pCur
->pKey
);
689 ** Save the current cursor position in the variables BtCursor.nKey
690 ** and BtCursor.pKey. The cursor's state is set to CURSOR_REQUIRESEEK.
692 ** The caller must ensure that the cursor is valid (has eState==CURSOR_VALID)
693 ** prior to calling this routine.
695 static int saveCursorPosition(BtCursor
*pCur
){
698 assert( CURSOR_VALID
==pCur
->eState
|| CURSOR_SKIPNEXT
==pCur
->eState
);
699 assert( 0==pCur
->pKey
);
700 assert( cursorHoldsMutex(pCur
) );
702 if( pCur
->curFlags
& BTCF_Pinned
){
703 return SQLITE_CONSTRAINT_PINNED
;
705 if( pCur
->eState
==CURSOR_SKIPNEXT
){
706 pCur
->eState
= CURSOR_VALID
;
711 rc
= saveCursorKey(pCur
);
713 btreeReleaseAllCursorPages(pCur
);
714 pCur
->eState
= CURSOR_REQUIRESEEK
;
717 pCur
->curFlags
&= ~(BTCF_ValidNKey
|BTCF_ValidOvfl
|BTCF_AtLast
);
721 /* Forward reference */
722 static int SQLITE_NOINLINE
saveCursorsOnList(BtCursor
*,Pgno
,BtCursor
*);
725 ** Save the positions of all cursors (except pExcept) that are open on
726 ** the table with root-page iRoot. "Saving the cursor position" means that
727 ** the location in the btree is remembered in such a way that it can be
728 ** moved back to the same spot after the btree has been modified. This
729 ** routine is called just before cursor pExcept is used to modify the
730 ** table, for example in BtreeDelete() or BtreeInsert().
732 ** If there are two or more cursors on the same btree, then all such
733 ** cursors should have their BTCF_Multiple flag set. The btreeCursor()
734 ** routine enforces that rule. This routine only needs to be called in
735 ** the uncommon case when pExpect has the BTCF_Multiple flag set.
737 ** If pExpect!=NULL and if no other cursors are found on the same root-page,
738 ** then the BTCF_Multiple flag on pExpect is cleared, to avoid another
739 ** pointless call to this routine.
741 ** Implementation note: This routine merely checks to see if any cursors
742 ** need to be saved. It calls out to saveCursorsOnList() in the (unusual)
743 ** event that cursors are in need to being saved.
745 static int saveAllCursors(BtShared
*pBt
, Pgno iRoot
, BtCursor
*pExcept
){
747 assert( sqlite3_mutex_held(pBt
->mutex
) );
748 assert( pExcept
==0 || pExcept
->pBt
==pBt
);
749 for(p
=pBt
->pCursor
; p
; p
=p
->pNext
){
750 if( p
!=pExcept
&& (0==iRoot
|| p
->pgnoRoot
==iRoot
) ) break;
752 if( p
) return saveCursorsOnList(p
, iRoot
, pExcept
);
753 if( pExcept
) pExcept
->curFlags
&= ~BTCF_Multiple
;
757 /* This helper routine to saveAllCursors does the actual work of saving
758 ** the cursors if and when a cursor is found that actually requires saving.
759 ** The common case is that no cursors need to be saved, so this routine is
760 ** broken out from its caller to avoid unnecessary stack pointer movement.
762 static int SQLITE_NOINLINE
saveCursorsOnList(
763 BtCursor
*p
, /* The first cursor that needs saving */
764 Pgno iRoot
, /* Only save cursor with this iRoot. Save all if zero */
765 BtCursor
*pExcept
/* Do not save this cursor */
768 if( p
!=pExcept
&& (0==iRoot
|| p
->pgnoRoot
==iRoot
) ){
769 if( p
->eState
==CURSOR_VALID
|| p
->eState
==CURSOR_SKIPNEXT
){
770 int rc
= saveCursorPosition(p
);
775 testcase( p
->iPage
>=0 );
776 btreeReleaseAllCursorPages(p
);
785 ** Clear the current cursor position.
787 void sqlite3BtreeClearCursor(BtCursor
*pCur
){
788 assert( cursorHoldsMutex(pCur
) );
789 sqlite3_free(pCur
->pKey
);
791 pCur
->eState
= CURSOR_INVALID
;
795 ** In this version of BtreeMoveto, pKey is a packed index record
796 ** such as is generated by the OP_MakeRecord opcode. Unpack the
797 ** record and then call BtreeMovetoUnpacked() to do the work.
799 static int btreeMoveto(
800 BtCursor
*pCur
, /* Cursor open on the btree to be searched */
801 const void *pKey
, /* Packed key if the btree is an index */
802 i64 nKey
, /* Integer key for tables. Size of pKey for indices */
803 int bias
, /* Bias search to the high end */
804 int *pRes
/* Write search results here */
806 int rc
; /* Status code */
807 UnpackedRecord
*pIdxKey
; /* Unpacked index key */
810 KeyInfo
*pKeyInfo
= pCur
->pKeyInfo
;
811 assert( nKey
==(i64
)(int)nKey
);
812 pIdxKey
= sqlite3VdbeAllocUnpackedRecord(pKeyInfo
);
813 if( pIdxKey
==0 ) return SQLITE_NOMEM_BKPT
;
814 sqlite3VdbeRecordUnpack(pKeyInfo
, (int)nKey
, pKey
, pIdxKey
);
815 if( pIdxKey
->nField
==0 || pIdxKey
->nField
>pKeyInfo
->nAllField
){
816 rc
= SQLITE_CORRUPT_BKPT
;
822 rc
= sqlite3BtreeMovetoUnpacked(pCur
, pIdxKey
, nKey
, bias
, pRes
);
825 sqlite3DbFree(pCur
->pKeyInfo
->db
, pIdxKey
);
831 ** Restore the cursor to the position it was in (or as close to as possible)
832 ** when saveCursorPosition() was called. Note that this call deletes the
833 ** saved position info stored by saveCursorPosition(), so there can be
834 ** at most one effective restoreCursorPosition() call after each
835 ** saveCursorPosition().
837 static int btreeRestoreCursorPosition(BtCursor
*pCur
){
840 assert( cursorOwnsBtShared(pCur
) );
841 assert( pCur
->eState
>=CURSOR_REQUIRESEEK
);
842 if( pCur
->eState
==CURSOR_FAULT
){
843 return pCur
->skipNext
;
845 pCur
->eState
= CURSOR_INVALID
;
846 if( sqlite3FaultSim(410) ){
849 rc
= btreeMoveto(pCur
, pCur
->pKey
, pCur
->nKey
, 0, &skipNext
);
852 sqlite3_free(pCur
->pKey
);
854 assert( pCur
->eState
==CURSOR_VALID
|| pCur
->eState
==CURSOR_INVALID
);
855 if( skipNext
) pCur
->skipNext
= skipNext
;
856 if( pCur
->skipNext
&& pCur
->eState
==CURSOR_VALID
){
857 pCur
->eState
= CURSOR_SKIPNEXT
;
863 #define restoreCursorPosition(p) \
864 (p->eState>=CURSOR_REQUIRESEEK ? \
865 btreeRestoreCursorPosition(p) : \
869 ** Determine whether or not a cursor has moved from the position where
870 ** it was last placed, or has been invalidated for any other reason.
871 ** Cursors can move when the row they are pointing at is deleted out
872 ** from under them, for example. Cursor might also move if a btree
875 ** Calling this routine with a NULL cursor pointer returns false.
877 ** Use the separate sqlite3BtreeCursorRestore() routine to restore a cursor
878 ** back to where it ought to be if this routine returns true.
880 int sqlite3BtreeCursorHasMoved(BtCursor
*pCur
){
881 assert( EIGHT_BYTE_ALIGNMENT(pCur
)
882 || pCur
==sqlite3BtreeFakeValidCursor() );
883 assert( offsetof(BtCursor
, eState
)==0 );
884 assert( sizeof(pCur
->eState
)==1 );
885 return CURSOR_VALID
!= *(u8
*)pCur
;
889 ** Return a pointer to a fake BtCursor object that will always answer
890 ** false to the sqlite3BtreeCursorHasMoved() routine above. The fake
891 ** cursor returned must not be used with any other Btree interface.
893 BtCursor
*sqlite3BtreeFakeValidCursor(void){
894 static u8 fakeCursor
= CURSOR_VALID
;
895 assert( offsetof(BtCursor
, eState
)==0 );
896 return (BtCursor
*)&fakeCursor
;
900 ** This routine restores a cursor back to its original position after it
901 ** has been moved by some outside activity (such as a btree rebalance or
902 ** a row having been deleted out from under the cursor).
904 ** On success, the *pDifferentRow parameter is false if the cursor is left
905 ** pointing at exactly the same row. *pDifferntRow is the row the cursor
906 ** was pointing to has been deleted, forcing the cursor to point to some
909 ** This routine should only be called for a cursor that just returned
910 ** TRUE from sqlite3BtreeCursorHasMoved().
912 int sqlite3BtreeCursorRestore(BtCursor
*pCur
, int *pDifferentRow
){
916 assert( pCur
->eState
!=CURSOR_VALID
);
917 rc
= restoreCursorPosition(pCur
);
922 if( pCur
->eState
!=CURSOR_VALID
){
930 #ifdef SQLITE_ENABLE_CURSOR_HINTS
932 ** Provide hints to the cursor. The particular hint given (and the type
933 ** and number of the varargs parameters) is determined by the eHintType
934 ** parameter. See the definitions of the BTREE_HINT_* macros for details.
936 void sqlite3BtreeCursorHint(BtCursor
*pCur
, int eHintType
, ...){
937 /* Used only by system that substitute their own storage engine */
942 ** Provide flag hints to the cursor.
944 void sqlite3BtreeCursorHintFlags(BtCursor
*pCur
, unsigned x
){
945 assert( x
==BTREE_SEEK_EQ
|| x
==BTREE_BULKLOAD
|| x
==0 );
950 #ifndef SQLITE_OMIT_AUTOVACUUM
952 ** Given a page number of a regular database page, return the page
953 ** number for the pointer-map page that contains the entry for the
954 ** input page number.
956 ** Return 0 (not a valid page) for pgno==1 since there is
957 ** no pointer map associated with page 1. The integrity_check logic
958 ** requires that ptrmapPageno(*,1)!=1.
960 static Pgno
ptrmapPageno(BtShared
*pBt
, Pgno pgno
){
961 int nPagesPerMapPage
;
963 assert( sqlite3_mutex_held(pBt
->mutex
) );
964 if( pgno
<2 ) return 0;
965 nPagesPerMapPage
= (pBt
->usableSize
/5)+1;
966 iPtrMap
= (pgno
-2)/nPagesPerMapPage
;
967 ret
= (iPtrMap
*nPagesPerMapPage
) + 2;
968 if( ret
==PENDING_BYTE_PAGE(pBt
) ){
975 ** Write an entry into the pointer map.
977 ** This routine updates the pointer map entry for page number 'key'
978 ** so that it maps to type 'eType' and parent page number 'pgno'.
980 ** If *pRC is initially non-zero (non-SQLITE_OK) then this routine is
981 ** a no-op. If an error occurs, the appropriate error code is written
984 static void ptrmapPut(BtShared
*pBt
, Pgno key
, u8 eType
, Pgno parent
, int *pRC
){
985 DbPage
*pDbPage
; /* The pointer map page */
986 u8
*pPtrmap
; /* The pointer map data */
987 Pgno iPtrmap
; /* The pointer map page number */
988 int offset
; /* Offset in pointer map page */
989 int rc
; /* Return code from subfunctions */
993 assert( sqlite3_mutex_held(pBt
->mutex
) );
994 /* The master-journal page number must never be used as a pointer map page */
995 assert( 0==PTRMAP_ISPAGE(pBt
, PENDING_BYTE_PAGE(pBt
)) );
997 assert( pBt
->autoVacuum
);
999 *pRC
= SQLITE_CORRUPT_BKPT
;
1002 iPtrmap
= PTRMAP_PAGENO(pBt
, key
);
1003 rc
= sqlite3PagerGet(pBt
->pPager
, iPtrmap
, &pDbPage
, 0);
1004 if( rc
!=SQLITE_OK
){
1008 if( ((char*)sqlite3PagerGetExtra(pDbPage
))[0]!=0 ){
1009 /* The first byte of the extra data is the MemPage.isInit byte.
1010 ** If that byte is set, it means this page is also being used
1011 ** as a btree page. */
1012 *pRC
= SQLITE_CORRUPT_BKPT
;
1015 offset
= PTRMAP_PTROFFSET(iPtrmap
, key
);
1017 *pRC
= SQLITE_CORRUPT_BKPT
;
1020 assert( offset
<= (int)pBt
->usableSize
-5 );
1021 pPtrmap
= (u8
*)sqlite3PagerGetData(pDbPage
);
1023 if( eType
!=pPtrmap
[offset
] || get4byte(&pPtrmap
[offset
+1])!=parent
){
1024 TRACE(("PTRMAP_UPDATE: %d->(%d,%d)\n", key
, eType
, parent
));
1025 *pRC
= rc
= sqlite3PagerWrite(pDbPage
);
1026 if( rc
==SQLITE_OK
){
1027 pPtrmap
[offset
] = eType
;
1028 put4byte(&pPtrmap
[offset
+1], parent
);
1033 sqlite3PagerUnref(pDbPage
);
1037 ** Read an entry from the pointer map.
1039 ** This routine retrieves the pointer map entry for page 'key', writing
1040 ** the type and parent page number to *pEType and *pPgno respectively.
1041 ** An error code is returned if something goes wrong, otherwise SQLITE_OK.
1043 static int ptrmapGet(BtShared
*pBt
, Pgno key
, u8
*pEType
, Pgno
*pPgno
){
1044 DbPage
*pDbPage
; /* The pointer map page */
1045 int iPtrmap
; /* Pointer map page index */
1046 u8
*pPtrmap
; /* Pointer map page data */
1047 int offset
; /* Offset of entry in pointer map */
1050 assert( sqlite3_mutex_held(pBt
->mutex
) );
1052 iPtrmap
= PTRMAP_PAGENO(pBt
, key
);
1053 rc
= sqlite3PagerGet(pBt
->pPager
, iPtrmap
, &pDbPage
, 0);
1057 pPtrmap
= (u8
*)sqlite3PagerGetData(pDbPage
);
1059 offset
= PTRMAP_PTROFFSET(iPtrmap
, key
);
1061 sqlite3PagerUnref(pDbPage
);
1062 return SQLITE_CORRUPT_BKPT
;
1064 assert( offset
<= (int)pBt
->usableSize
-5 );
1065 assert( pEType
!=0 );
1066 *pEType
= pPtrmap
[offset
];
1067 if( pPgno
) *pPgno
= get4byte(&pPtrmap
[offset
+1]);
1069 sqlite3PagerUnref(pDbPage
);
1070 if( *pEType
<1 || *pEType
>5 ) return SQLITE_CORRUPT_PGNO(iPtrmap
);
1074 #else /* if defined SQLITE_OMIT_AUTOVACUUM */
1075 #define ptrmapPut(w,x,y,z,rc)
1076 #define ptrmapGet(w,x,y,z) SQLITE_OK
1077 #define ptrmapPutOvflPtr(x, y, z, rc)
1081 ** Given a btree page and a cell index (0 means the first cell on
1082 ** the page, 1 means the second cell, and so forth) return a pointer
1083 ** to the cell content.
1085 ** findCellPastPtr() does the same except it skips past the initial
1086 ** 4-byte child pointer found on interior pages, if there is one.
1088 ** This routine works only for pages that do not contain overflow cells.
1090 #define findCell(P,I) \
1091 ((P)->aData + ((P)->maskPage & get2byteAligned(&(P)->aCellIdx[2*(I)])))
1092 #define findCellPastPtr(P,I) \
1093 ((P)->aDataOfst + ((P)->maskPage & get2byteAligned(&(P)->aCellIdx[2*(I)])))
1097 ** This is common tail processing for btreeParseCellPtr() and
1098 ** btreeParseCellPtrIndex() for the case when the cell does not fit entirely
1099 ** on a single B-tree page. Make necessary adjustments to the CellInfo
1102 static SQLITE_NOINLINE
void btreeParseCellAdjustSizeForOverflow(
1103 MemPage
*pPage
, /* Page containing the cell */
1104 u8
*pCell
, /* Pointer to the cell text. */
1105 CellInfo
*pInfo
/* Fill in this structure */
1107 /* If the payload will not fit completely on the local page, we have
1108 ** to decide how much to store locally and how much to spill onto
1109 ** overflow pages. The strategy is to minimize the amount of unused
1110 ** space on overflow pages while keeping the amount of local storage
1111 ** in between minLocal and maxLocal.
1113 ** Warning: changing the way overflow payload is distributed in any
1114 ** way will result in an incompatible file format.
1116 int minLocal
; /* Minimum amount of payload held locally */
1117 int maxLocal
; /* Maximum amount of payload held locally */
1118 int surplus
; /* Overflow payload available for local storage */
1120 minLocal
= pPage
->minLocal
;
1121 maxLocal
= pPage
->maxLocal
;
1122 surplus
= minLocal
+ (pInfo
->nPayload
- minLocal
)%(pPage
->pBt
->usableSize
-4);
1123 testcase( surplus
==maxLocal
);
1124 testcase( surplus
==maxLocal
+1 );
1125 if( surplus
<= maxLocal
){
1126 pInfo
->nLocal
= (u16
)surplus
;
1128 pInfo
->nLocal
= (u16
)minLocal
;
1130 pInfo
->nSize
= (u16
)(&pInfo
->pPayload
[pInfo
->nLocal
] - pCell
) + 4;
1134 ** The following routines are implementations of the MemPage.xParseCell()
1137 ** Parse a cell content block and fill in the CellInfo structure.
1139 ** btreeParseCellPtr() => table btree leaf nodes
1140 ** btreeParseCellNoPayload() => table btree internal nodes
1141 ** btreeParseCellPtrIndex() => index btree nodes
1143 ** There is also a wrapper function btreeParseCell() that works for
1144 ** all MemPage types and that references the cell by index rather than
1147 static void btreeParseCellPtrNoPayload(
1148 MemPage
*pPage
, /* Page containing the cell */
1149 u8
*pCell
, /* Pointer to the cell text. */
1150 CellInfo
*pInfo
/* Fill in this structure */
1152 assert( sqlite3_mutex_held(pPage
->pBt
->mutex
) );
1153 assert( pPage
->leaf
==0 );
1154 assert( pPage
->childPtrSize
==4 );
1155 #ifndef SQLITE_DEBUG
1156 UNUSED_PARAMETER(pPage
);
1158 pInfo
->nSize
= 4 + getVarint(&pCell
[4], (u64
*)&pInfo
->nKey
);
1159 pInfo
->nPayload
= 0;
1161 pInfo
->pPayload
= 0;
1164 static void btreeParseCellPtr(
1165 MemPage
*pPage
, /* Page containing the cell */
1166 u8
*pCell
, /* Pointer to the cell text. */
1167 CellInfo
*pInfo
/* Fill in this structure */
1169 u8
*pIter
; /* For scanning through pCell */
1170 u32 nPayload
; /* Number of bytes of cell payload */
1171 u64 iKey
; /* Extracted Key value */
1173 assert( sqlite3_mutex_held(pPage
->pBt
->mutex
) );
1174 assert( pPage
->leaf
==0 || pPage
->leaf
==1 );
1175 assert( pPage
->intKeyLeaf
);
1176 assert( pPage
->childPtrSize
==0 );
1179 /* The next block of code is equivalent to:
1181 ** pIter += getVarint32(pIter, nPayload);
1183 ** The code is inlined to avoid a function call.
1186 if( nPayload
>=0x80 ){
1187 u8
*pEnd
= &pIter
[8];
1190 nPayload
= (nPayload
<<7) | (*++pIter
& 0x7f);
1191 }while( (*pIter
)>=0x80 && pIter
<pEnd
);
1195 /* The next block of code is equivalent to:
1197 ** pIter += getVarint(pIter, (u64*)&pInfo->nKey);
1199 ** The code is inlined to avoid a function call.
1203 u8
*pEnd
= &pIter
[7];
1206 iKey
= (iKey
<<7) | (*++pIter
& 0x7f);
1207 if( (*pIter
)<0x80 ) break;
1209 iKey
= (iKey
<<8) | *++pIter
;
1216 pInfo
->nKey
= *(i64
*)&iKey
;
1217 pInfo
->nPayload
= nPayload
;
1218 pInfo
->pPayload
= pIter
;
1219 testcase( nPayload
==pPage
->maxLocal
);
1220 testcase( nPayload
==pPage
->maxLocal
+1 );
1221 if( nPayload
<=pPage
->maxLocal
){
1222 /* This is the (easy) common case where the entire payload fits
1223 ** on the local page. No overflow is required.
1225 pInfo
->nSize
= nPayload
+ (u16
)(pIter
- pCell
);
1226 if( pInfo
->nSize
<4 ) pInfo
->nSize
= 4;
1227 pInfo
->nLocal
= (u16
)nPayload
;
1229 btreeParseCellAdjustSizeForOverflow(pPage
, pCell
, pInfo
);
1232 static void btreeParseCellPtrIndex(
1233 MemPage
*pPage
, /* Page containing the cell */
1234 u8
*pCell
, /* Pointer to the cell text. */
1235 CellInfo
*pInfo
/* Fill in this structure */
1237 u8
*pIter
; /* For scanning through pCell */
1238 u32 nPayload
; /* Number of bytes of cell payload */
1240 assert( sqlite3_mutex_held(pPage
->pBt
->mutex
) );
1241 assert( pPage
->leaf
==0 || pPage
->leaf
==1 );
1242 assert( pPage
->intKeyLeaf
==0 );
1243 pIter
= pCell
+ pPage
->childPtrSize
;
1245 if( nPayload
>=0x80 ){
1246 u8
*pEnd
= &pIter
[8];
1249 nPayload
= (nPayload
<<7) | (*++pIter
& 0x7f);
1250 }while( *(pIter
)>=0x80 && pIter
<pEnd
);
1253 pInfo
->nKey
= nPayload
;
1254 pInfo
->nPayload
= nPayload
;
1255 pInfo
->pPayload
= pIter
;
1256 testcase( nPayload
==pPage
->maxLocal
);
1257 testcase( nPayload
==pPage
->maxLocal
+1 );
1258 if( nPayload
<=pPage
->maxLocal
){
1259 /* This is the (easy) common case where the entire payload fits
1260 ** on the local page. No overflow is required.
1262 pInfo
->nSize
= nPayload
+ (u16
)(pIter
- pCell
);
1263 if( pInfo
->nSize
<4 ) pInfo
->nSize
= 4;
1264 pInfo
->nLocal
= (u16
)nPayload
;
1266 btreeParseCellAdjustSizeForOverflow(pPage
, pCell
, pInfo
);
1269 static void btreeParseCell(
1270 MemPage
*pPage
, /* Page containing the cell */
1271 int iCell
, /* The cell index. First cell is 0 */
1272 CellInfo
*pInfo
/* Fill in this structure */
1274 pPage
->xParseCell(pPage
, findCell(pPage
, iCell
), pInfo
);
1278 ** The following routines are implementations of the MemPage.xCellSize
1281 ** Compute the total number of bytes that a Cell needs in the cell
1282 ** data area of the btree-page. The return number includes the cell
1283 ** data header and the local payload, but not any overflow page or
1284 ** the space used by the cell pointer.
1286 ** cellSizePtrNoPayload() => table internal nodes
1287 ** cellSizePtr() => all index nodes & table leaf nodes
1289 static u16
cellSizePtr(MemPage
*pPage
, u8
*pCell
){
1290 u8
*pIter
= pCell
+ pPage
->childPtrSize
; /* For looping over bytes of pCell */
1291 u8
*pEnd
; /* End mark for a varint */
1292 u32 nSize
; /* Size value to return */
1295 /* The value returned by this function should always be the same as
1296 ** the (CellInfo.nSize) value found by doing a full parse of the
1297 ** cell. If SQLITE_DEBUG is defined, an assert() at the bottom of
1298 ** this function verifies that this invariant is not violated. */
1300 pPage
->xParseCell(pPage
, pCell
, &debuginfo
);
1308 nSize
= (nSize
<<7) | (*++pIter
& 0x7f);
1309 }while( *(pIter
)>=0x80 && pIter
<pEnd
);
1312 if( pPage
->intKey
){
1313 /* pIter now points at the 64-bit integer key value, a variable length
1314 ** integer. The following block moves pIter to point at the first byte
1315 ** past the end of the key value. */
1317 while( (*pIter
++)&0x80 && pIter
<pEnd
);
1319 testcase( nSize
==pPage
->maxLocal
);
1320 testcase( nSize
==pPage
->maxLocal
+1 );
1321 if( nSize
<=pPage
->maxLocal
){
1322 nSize
+= (u32
)(pIter
- pCell
);
1323 if( nSize
<4 ) nSize
= 4;
1325 int minLocal
= pPage
->minLocal
;
1326 nSize
= minLocal
+ (nSize
- minLocal
) % (pPage
->pBt
->usableSize
- 4);
1327 testcase( nSize
==pPage
->maxLocal
);
1328 testcase( nSize
==pPage
->maxLocal
+1 );
1329 if( nSize
>pPage
->maxLocal
){
1332 nSize
+= 4 + (u16
)(pIter
- pCell
);
1334 assert( nSize
==debuginfo
.nSize
|| CORRUPT_DB
);
1337 static u16
cellSizePtrNoPayload(MemPage
*pPage
, u8
*pCell
){
1338 u8
*pIter
= pCell
+ 4; /* For looping over bytes of pCell */
1339 u8
*pEnd
; /* End mark for a varint */
1342 /* The value returned by this function should always be the same as
1343 ** the (CellInfo.nSize) value found by doing a full parse of the
1344 ** cell. If SQLITE_DEBUG is defined, an assert() at the bottom of
1345 ** this function verifies that this invariant is not violated. */
1347 pPage
->xParseCell(pPage
, pCell
, &debuginfo
);
1349 UNUSED_PARAMETER(pPage
);
1352 assert( pPage
->childPtrSize
==4 );
1354 while( (*pIter
++)&0x80 && pIter
<pEnd
);
1355 assert( debuginfo
.nSize
==(u16
)(pIter
- pCell
) || CORRUPT_DB
);
1356 return (u16
)(pIter
- pCell
);
1361 /* This variation on cellSizePtr() is used inside of assert() statements
1363 static u16
cellSize(MemPage
*pPage
, int iCell
){
1364 return pPage
->xCellSize(pPage
, findCell(pPage
, iCell
));
1368 #ifndef SQLITE_OMIT_AUTOVACUUM
1370 ** The cell pCell is currently part of page pSrc but will ultimately be part
1371 ** of pPage. (pSrc and pPager are often the same.) If pCell contains a
1372 ** pointer to an overflow page, insert an entry into the pointer-map for
1373 ** the overflow page that will be valid after pCell has been moved to pPage.
1375 static void ptrmapPutOvflPtr(MemPage
*pPage
, MemPage
*pSrc
, u8
*pCell
,int *pRC
){
1379 pPage
->xParseCell(pPage
, pCell
, &info
);
1380 if( info
.nLocal
<info
.nPayload
){
1382 if( SQLITE_WITHIN(pSrc
->aDataEnd
, pCell
, pCell
+info
.nLocal
) ){
1383 testcase( pSrc
!=pPage
);
1384 *pRC
= SQLITE_CORRUPT_BKPT
;
1387 ovfl
= get4byte(&pCell
[info
.nSize
-4]);
1388 ptrmapPut(pPage
->pBt
, ovfl
, PTRMAP_OVERFLOW1
, pPage
->pgno
, pRC
);
1395 ** Defragment the page given. This routine reorganizes cells within the
1396 ** page so that there are no free-blocks on the free-block list.
1398 ** Parameter nMaxFrag is the maximum amount of fragmented space that may be
1399 ** present in the page after this routine returns.
1401 ** EVIDENCE-OF: R-44582-60138 SQLite may from time to time reorganize a
1402 ** b-tree page so that there are no freeblocks or fragment bytes, all
1403 ** unused bytes are contained in the unallocated space region, and all
1404 ** cells are packed tightly at the end of the page.
1406 static int defragmentPage(MemPage
*pPage
, int nMaxFrag
){
1407 int i
; /* Loop counter */
1408 int pc
; /* Address of the i-th cell */
1409 int hdr
; /* Offset to the page header */
1410 int size
; /* Size of a cell */
1411 int usableSize
; /* Number of usable bytes on a page */
1412 int cellOffset
; /* Offset to the cell pointer array */
1413 int cbrk
; /* Offset to the cell content area */
1414 int nCell
; /* Number of cells on the page */
1415 unsigned char *data
; /* The page data */
1416 unsigned char *temp
; /* Temp area for cell content */
1417 unsigned char *src
; /* Source of content */
1418 int iCellFirst
; /* First allowable cell index */
1419 int iCellLast
; /* Last possible cell index */
1421 assert( sqlite3PagerIswriteable(pPage
->pDbPage
) );
1422 assert( pPage
->pBt
!=0 );
1423 assert( pPage
->pBt
->usableSize
<= SQLITE_MAX_PAGE_SIZE
);
1424 assert( pPage
->nOverflow
==0 );
1425 assert( sqlite3_mutex_held(pPage
->pBt
->mutex
) );
1427 src
= data
= pPage
->aData
;
1428 hdr
= pPage
->hdrOffset
;
1429 cellOffset
= pPage
->cellOffset
;
1430 nCell
= pPage
->nCell
;
1431 assert( nCell
==get2byte(&data
[hdr
+3]) || CORRUPT_DB
);
1432 iCellFirst
= cellOffset
+ 2*nCell
;
1433 usableSize
= pPage
->pBt
->usableSize
;
1435 /* This block handles pages with two or fewer free blocks and nMaxFrag
1436 ** or fewer fragmented bytes. In this case it is faster to move the
1437 ** two (or one) blocks of cells using memmove() and add the required
1438 ** offsets to each pointer in the cell-pointer array than it is to
1439 ** reconstruct the entire page. */
1440 if( (int)data
[hdr
+7]<=nMaxFrag
){
1441 int iFree
= get2byte(&data
[hdr
+1]);
1442 if( iFree
>usableSize
-4 ) return SQLITE_CORRUPT_PAGE(pPage
);
1444 int iFree2
= get2byte(&data
[iFree
]);
1445 if( iFree2
>usableSize
-4 ) return SQLITE_CORRUPT_PAGE(pPage
);
1446 if( 0==iFree2
|| (data
[iFree2
]==0 && data
[iFree2
+1]==0) ){
1447 u8
*pEnd
= &data
[cellOffset
+ nCell
*2];
1450 int sz
= get2byte(&data
[iFree
+2]);
1451 int top
= get2byte(&data
[hdr
+5]);
1452 if( NEVER(top
>=iFree
) ){
1453 return SQLITE_CORRUPT_PAGE(pPage
);
1456 if( iFree
+sz
>iFree2
) return SQLITE_CORRUPT_PAGE(pPage
);
1457 sz2
= get2byte(&data
[iFree2
+2]);
1458 if( iFree2
+sz2
> usableSize
) return SQLITE_CORRUPT_PAGE(pPage
);
1459 memmove(&data
[iFree
+sz
+sz2
], &data
[iFree
+sz
], iFree2
-(iFree
+sz
));
1461 }else if( NEVER(iFree
+sz
>usableSize
) ){
1462 return SQLITE_CORRUPT_PAGE(pPage
);
1466 assert( cbrk
+(iFree
-top
) <= usableSize
);
1467 memmove(&data
[cbrk
], &data
[top
], iFree
-top
);
1468 for(pAddr
=&data
[cellOffset
]; pAddr
<pEnd
; pAddr
+=2){
1469 pc
= get2byte(pAddr
);
1470 if( pc
<iFree
){ put2byte(pAddr
, pc
+sz
); }
1471 else if( pc
<iFree2
){ put2byte(pAddr
, pc
+sz2
); }
1473 goto defragment_out
;
1479 iCellLast
= usableSize
- 4;
1480 for(i
=0; i
<nCell
; i
++){
1481 u8
*pAddr
; /* The i-th cell pointer */
1482 pAddr
= &data
[cellOffset
+ i
*2];
1483 pc
= get2byte(pAddr
);
1484 testcase( pc
==iCellFirst
);
1485 testcase( pc
==iCellLast
);
1486 /* These conditions have already been verified in btreeInitPage()
1487 ** if PRAGMA cell_size_check=ON.
1489 if( pc
<iCellFirst
|| pc
>iCellLast
){
1490 return SQLITE_CORRUPT_PAGE(pPage
);
1492 assert( pc
>=iCellFirst
&& pc
<=iCellLast
);
1493 size
= pPage
->xCellSize(pPage
, &src
[pc
]);
1495 if( cbrk
<iCellFirst
|| pc
+size
>usableSize
){
1496 return SQLITE_CORRUPT_PAGE(pPage
);
1498 assert( cbrk
+size
<=usableSize
&& cbrk
>=iCellFirst
);
1499 testcase( cbrk
+size
==usableSize
);
1500 testcase( pc
+size
==usableSize
);
1501 put2byte(pAddr
, cbrk
);
1504 if( cbrk
==pc
) continue;
1505 temp
= sqlite3PagerTempSpace(pPage
->pBt
->pPager
);
1506 x
= get2byte(&data
[hdr
+5]);
1507 memcpy(&temp
[x
], &data
[x
], (cbrk
+size
) - x
);
1510 memcpy(&data
[cbrk
], &src
[pc
], size
);
1515 assert( pPage
->nFree
>=0 );
1516 if( data
[hdr
+7]+cbrk
-iCellFirst
!=pPage
->nFree
){
1517 return SQLITE_CORRUPT_PAGE(pPage
);
1519 assert( cbrk
>=iCellFirst
);
1520 put2byte(&data
[hdr
+5], cbrk
);
1523 memset(&data
[iCellFirst
], 0, cbrk
-iCellFirst
);
1524 assert( sqlite3PagerIswriteable(pPage
->pDbPage
) );
1529 ** Search the free-list on page pPg for space to store a cell nByte bytes in
1530 ** size. If one can be found, return a pointer to the space and remove it
1531 ** from the free-list.
1533 ** If no suitable space can be found on the free-list, return NULL.
1535 ** This function may detect corruption within pPg. If corruption is
1536 ** detected then *pRc is set to SQLITE_CORRUPT and NULL is returned.
1538 ** Slots on the free list that are between 1 and 3 bytes larger than nByte
1539 ** will be ignored if adding the extra space to the fragmentation count
1540 ** causes the fragmentation count to exceed 60.
1542 static u8
*pageFindSlot(MemPage
*pPg
, int nByte
, int *pRc
){
1543 const int hdr
= pPg
->hdrOffset
; /* Offset to page header */
1544 u8
* const aData
= pPg
->aData
; /* Page data */
1545 int iAddr
= hdr
+ 1; /* Address of ptr to pc */
1546 int pc
= get2byte(&aData
[iAddr
]); /* Address of a free slot */
1547 int x
; /* Excess size of the slot */
1548 int maxPC
= pPg
->pBt
->usableSize
- nByte
; /* Max address for a usable slot */
1549 int size
; /* Size of the free slot */
1553 /* EVIDENCE-OF: R-22710-53328 The third and fourth bytes of each
1554 ** freeblock form a big-endian integer which is the size of the freeblock
1555 ** in bytes, including the 4-byte header. */
1556 size
= get2byte(&aData
[pc
+2]);
1557 if( (x
= size
- nByte
)>=0 ){
1561 /* EVIDENCE-OF: R-11498-58022 In a well-formed b-tree page, the total
1562 ** number of bytes in fragments may not exceed 60. */
1563 if( aData
[hdr
+7]>57 ) return 0;
1565 /* Remove the slot from the free-list. Update the number of
1566 ** fragmented bytes within the page. */
1567 memcpy(&aData
[iAddr
], &aData
[pc
], 2);
1568 aData
[hdr
+7] += (u8
)x
;
1569 }else if( x
+pc
> maxPC
){
1570 /* This slot extends off the end of the usable part of the page */
1571 *pRc
= SQLITE_CORRUPT_PAGE(pPg
);
1574 /* The slot remains on the free-list. Reduce its size to account
1575 ** for the portion used by the new allocation. */
1576 put2byte(&aData
[pc
+2], x
);
1578 return &aData
[pc
+ x
];
1581 pc
= get2byte(&aData
[pc
]);
1582 if( pc
<=iAddr
+size
){
1584 /* The next slot in the chain is not past the end of the current slot */
1585 *pRc
= SQLITE_CORRUPT_PAGE(pPg
);
1590 if( pc
>maxPC
+nByte
-4 ){
1591 /* The free slot chain extends off the end of the page */
1592 *pRc
= SQLITE_CORRUPT_PAGE(pPg
);
1598 ** Allocate nByte bytes of space from within the B-Tree page passed
1599 ** as the first argument. Write into *pIdx the index into pPage->aData[]
1600 ** of the first byte of allocated space. Return either SQLITE_OK or
1601 ** an error code (usually SQLITE_CORRUPT).
1603 ** The caller guarantees that there is sufficient space to make the
1604 ** allocation. This routine might need to defragment in order to bring
1605 ** all the space together, however. This routine will avoid using
1606 ** the first two bytes past the cell pointer area since presumably this
1607 ** allocation is being made in order to insert a new cell, so we will
1608 ** also end up needing a new cell pointer.
1610 static int allocateSpace(MemPage
*pPage
, int nByte
, int *pIdx
){
1611 const int hdr
= pPage
->hdrOffset
; /* Local cache of pPage->hdrOffset */
1612 u8
* const data
= pPage
->aData
; /* Local cache of pPage->aData */
1613 int top
; /* First byte of cell content area */
1614 int rc
= SQLITE_OK
; /* Integer return code */
1615 int gap
; /* First byte of gap between cell pointers and cell content */
1617 assert( sqlite3PagerIswriteable(pPage
->pDbPage
) );
1618 assert( pPage
->pBt
);
1619 assert( sqlite3_mutex_held(pPage
->pBt
->mutex
) );
1620 assert( nByte
>=0 ); /* Minimum cell size is 4 */
1621 assert( pPage
->nFree
>=nByte
);
1622 assert( pPage
->nOverflow
==0 );
1623 assert( nByte
< (int)(pPage
->pBt
->usableSize
-8) );
1625 assert( pPage
->cellOffset
== hdr
+ 12 - 4*pPage
->leaf
);
1626 gap
= pPage
->cellOffset
+ 2*pPage
->nCell
;
1627 assert( gap
<=65536 );
1628 /* EVIDENCE-OF: R-29356-02391 If the database uses a 65536-byte page size
1629 ** and the reserved space is zero (the usual value for reserved space)
1630 ** then the cell content offset of an empty page wants to be 65536.
1631 ** However, that integer is too large to be stored in a 2-byte unsigned
1632 ** integer, so a value of 0 is used in its place. */
1633 top
= get2byte(&data
[hdr
+5]);
1634 assert( top
<=(int)pPage
->pBt
->usableSize
); /* by btreeComputeFreeSpace() */
1636 if( top
==0 && pPage
->pBt
->usableSize
==65536 ){
1639 return SQLITE_CORRUPT_PAGE(pPage
);
1643 /* If there is enough space between gap and top for one more cell pointer,
1644 ** and if the freelist is not empty, then search the
1645 ** freelist looking for a slot big enough to satisfy the request.
1647 testcase( gap
+2==top
);
1648 testcase( gap
+1==top
);
1649 testcase( gap
==top
);
1650 if( (data
[hdr
+2] || data
[hdr
+1]) && gap
+2<=top
){
1651 u8
*pSpace
= pageFindSlot(pPage
, nByte
, &rc
);
1654 assert( pSpace
+nByte
<=data
+pPage
->pBt
->usableSize
);
1655 *pIdx
= g2
= (int)(pSpace
-data
);
1656 if( NEVER(g2
<=gap
) ){
1657 return SQLITE_CORRUPT_PAGE(pPage
);
1666 /* The request could not be fulfilled using a freelist slot. Check
1667 ** to see if defragmentation is necessary.
1669 testcase( gap
+2+nByte
==top
);
1670 if( gap
+2+nByte
>top
){
1671 assert( pPage
->nCell
>0 || CORRUPT_DB
);
1672 assert( pPage
->nFree
>=0 );
1673 rc
= defragmentPage(pPage
, MIN(4, pPage
->nFree
- (2+nByte
)));
1675 top
= get2byteNotZero(&data
[hdr
+5]);
1676 assert( gap
+2+nByte
<=top
);
1680 /* Allocate memory from the gap in between the cell pointer array
1681 ** and the cell content area. The btreeComputeFreeSpace() call has already
1682 ** validated the freelist. Given that the freelist is valid, there
1683 ** is no way that the allocation can extend off the end of the page.
1684 ** The assert() below verifies the previous sentence.
1687 put2byte(&data
[hdr
+5], top
);
1688 assert( top
+nByte
<= (int)pPage
->pBt
->usableSize
);
1694 ** Return a section of the pPage->aData to the freelist.
1695 ** The first byte of the new free block is pPage->aData[iStart]
1696 ** and the size of the block is iSize bytes.
1698 ** Adjacent freeblocks are coalesced.
1700 ** Even though the freeblock list was checked by btreeComputeFreeSpace(),
1701 ** that routine will not detect overlap between cells or freeblocks. Nor
1702 ** does it detect cells or freeblocks that encrouch into the reserved bytes
1703 ** at the end of the page. So do additional corruption checks inside this
1704 ** routine and return SQLITE_CORRUPT if any problems are found.
1706 static int freeSpace(MemPage
*pPage
, u16 iStart
, u16 iSize
){
1707 u16 iPtr
; /* Address of ptr to next freeblock */
1708 u16 iFreeBlk
; /* Address of the next freeblock */
1709 u8 hdr
; /* Page header size. 0 or 100 */
1710 u8 nFrag
= 0; /* Reduction in fragmentation */
1711 u16 iOrigSize
= iSize
; /* Original value of iSize */
1712 u16 x
; /* Offset to cell content area */
1713 u32 iEnd
= iStart
+ iSize
; /* First byte past the iStart buffer */
1714 unsigned char *data
= pPage
->aData
; /* Page content */
1716 assert( pPage
->pBt
!=0 );
1717 assert( sqlite3PagerIswriteable(pPage
->pDbPage
) );
1718 assert( CORRUPT_DB
|| iStart
>=pPage
->hdrOffset
+6+pPage
->childPtrSize
);
1719 assert( CORRUPT_DB
|| iEnd
<= pPage
->pBt
->usableSize
);
1720 assert( sqlite3_mutex_held(pPage
->pBt
->mutex
) );
1721 assert( iSize
>=4 ); /* Minimum cell size is 4 */
1722 assert( iStart
<=pPage
->pBt
->usableSize
-4 );
1724 /* The list of freeblocks must be in ascending order. Find the
1725 ** spot on the list where iStart should be inserted.
1727 hdr
= pPage
->hdrOffset
;
1729 if( data
[iPtr
+1]==0 && data
[iPtr
]==0 ){
1730 iFreeBlk
= 0; /* Shortcut for the case when the freelist is empty */
1732 while( (iFreeBlk
= get2byte(&data
[iPtr
]))<iStart
){
1733 if( iFreeBlk
<iPtr
+4 ){
1734 if( iFreeBlk
==0 ) break; /* TH3: corrupt082.100 */
1735 return SQLITE_CORRUPT_PAGE(pPage
);
1739 if( iFreeBlk
>pPage
->pBt
->usableSize
-4 ){ /* TH3: corrupt081.100 */
1740 return SQLITE_CORRUPT_PAGE(pPage
);
1742 assert( iFreeBlk
>iPtr
|| iFreeBlk
==0 );
1745 ** iFreeBlk: First freeblock after iStart, or zero if none
1746 ** iPtr: The address of a pointer to iFreeBlk
1748 ** Check to see if iFreeBlk should be coalesced onto the end of iStart.
1750 if( iFreeBlk
&& iEnd
+3>=iFreeBlk
){
1751 nFrag
= iFreeBlk
- iEnd
;
1752 if( iEnd
>iFreeBlk
) return SQLITE_CORRUPT_PAGE(pPage
);
1753 iEnd
= iFreeBlk
+ get2byte(&data
[iFreeBlk
+2]);
1754 if( NEVER(iEnd
> pPage
->pBt
->usableSize
) ){
1755 return SQLITE_CORRUPT_PAGE(pPage
);
1757 iSize
= iEnd
- iStart
;
1758 iFreeBlk
= get2byte(&data
[iFreeBlk
]);
1761 /* If iPtr is another freeblock (that is, if iPtr is not the freelist
1762 ** pointer in the page header) then check to see if iStart should be
1763 ** coalesced onto the end of iPtr.
1766 int iPtrEnd
= iPtr
+ get2byte(&data
[iPtr
+2]);
1767 if( iPtrEnd
+3>=iStart
){
1768 if( iPtrEnd
>iStart
) return SQLITE_CORRUPT_PAGE(pPage
);
1769 nFrag
+= iStart
- iPtrEnd
;
1770 iSize
= iEnd
- iPtr
;
1774 if( nFrag
>data
[hdr
+7] ) return SQLITE_CORRUPT_PAGE(pPage
);
1775 data
[hdr
+7] -= nFrag
;
1777 x
= get2byte(&data
[hdr
+5]);
1779 /* The new freeblock is at the beginning of the cell content area,
1780 ** so just extend the cell content area rather than create another
1781 ** freelist entry */
1782 if( iStart
<x
) return SQLITE_CORRUPT_PAGE(pPage
);
1783 if( NEVER(iPtr
!=hdr
+1) ) return SQLITE_CORRUPT_PAGE(pPage
);
1784 put2byte(&data
[hdr
+1], iFreeBlk
);
1785 put2byte(&data
[hdr
+5], iEnd
);
1787 /* Insert the new freeblock into the freelist */
1788 put2byte(&data
[iPtr
], iStart
);
1790 if( pPage
->pBt
->btsFlags
& BTS_FAST_SECURE
){
1791 /* Overwrite deleted information with zeros when the secure_delete
1792 ** option is enabled */
1793 memset(&data
[iStart
], 0, iSize
);
1795 put2byte(&data
[iStart
], iFreeBlk
);
1796 put2byte(&data
[iStart
+2], iSize
);
1797 pPage
->nFree
+= iOrigSize
;
1802 ** Decode the flags byte (the first byte of the header) for a page
1803 ** and initialize fields of the MemPage structure accordingly.
1805 ** Only the following combinations are supported. Anything different
1806 ** indicates a corrupt database files:
1809 ** PTF_ZERODATA | PTF_LEAF
1810 ** PTF_LEAFDATA | PTF_INTKEY
1811 ** PTF_LEAFDATA | PTF_INTKEY | PTF_LEAF
1813 static int decodeFlags(MemPage
*pPage
, int flagByte
){
1814 BtShared
*pBt
; /* A copy of pPage->pBt */
1816 assert( pPage
->hdrOffset
==(pPage
->pgno
==1 ? 100 : 0) );
1817 assert( sqlite3_mutex_held(pPage
->pBt
->mutex
) );
1818 pPage
->leaf
= (u8
)(flagByte
>>3); assert( PTF_LEAF
== 1<<3 );
1819 flagByte
&= ~PTF_LEAF
;
1820 pPage
->childPtrSize
= 4-4*pPage
->leaf
;
1821 pPage
->xCellSize
= cellSizePtr
;
1823 if( flagByte
==(PTF_LEAFDATA
| PTF_INTKEY
) ){
1824 /* EVIDENCE-OF: R-07291-35328 A value of 5 (0x05) means the page is an
1825 ** interior table b-tree page. */
1826 assert( (PTF_LEAFDATA
|PTF_INTKEY
)==5 );
1827 /* EVIDENCE-OF: R-26900-09176 A value of 13 (0x0d) means the page is a
1828 ** leaf table b-tree page. */
1829 assert( (PTF_LEAFDATA
|PTF_INTKEY
|PTF_LEAF
)==13 );
1832 pPage
->intKeyLeaf
= 1;
1833 pPage
->xParseCell
= btreeParseCellPtr
;
1835 pPage
->intKeyLeaf
= 0;
1836 pPage
->xCellSize
= cellSizePtrNoPayload
;
1837 pPage
->xParseCell
= btreeParseCellPtrNoPayload
;
1839 pPage
->maxLocal
= pBt
->maxLeaf
;
1840 pPage
->minLocal
= pBt
->minLeaf
;
1841 }else if( flagByte
==PTF_ZERODATA
){
1842 /* EVIDENCE-OF: R-43316-37308 A value of 2 (0x02) means the page is an
1843 ** interior index b-tree page. */
1844 assert( (PTF_ZERODATA
)==2 );
1845 /* EVIDENCE-OF: R-59615-42828 A value of 10 (0x0a) means the page is a
1846 ** leaf index b-tree page. */
1847 assert( (PTF_ZERODATA
|PTF_LEAF
)==10 );
1849 pPage
->intKeyLeaf
= 0;
1850 pPage
->xParseCell
= btreeParseCellPtrIndex
;
1851 pPage
->maxLocal
= pBt
->maxLocal
;
1852 pPage
->minLocal
= pBt
->minLocal
;
1854 /* EVIDENCE-OF: R-47608-56469 Any other value for the b-tree page type is
1856 return SQLITE_CORRUPT_PAGE(pPage
);
1858 pPage
->max1bytePayload
= pBt
->max1bytePayload
;
1863 ** Compute the amount of freespace on the page. In other words, fill
1864 ** in the pPage->nFree field.
1866 static int btreeComputeFreeSpace(MemPage
*pPage
){
1867 int pc
; /* Address of a freeblock within pPage->aData[] */
1868 u8 hdr
; /* Offset to beginning of page header */
1869 u8
*data
; /* Equal to pPage->aData */
1870 int usableSize
; /* Amount of usable space on each page */
1871 int nFree
; /* Number of unused bytes on the page */
1872 int top
; /* First byte of the cell content area */
1873 int iCellFirst
; /* First allowable cell or freeblock offset */
1874 int iCellLast
; /* Last possible cell or freeblock offset */
1876 assert( pPage
->pBt
!=0 );
1877 assert( pPage
->pBt
->db
!=0 );
1878 assert( sqlite3_mutex_held(pPage
->pBt
->mutex
) );
1879 assert( pPage
->pgno
==sqlite3PagerPagenumber(pPage
->pDbPage
) );
1880 assert( pPage
== sqlite3PagerGetExtra(pPage
->pDbPage
) );
1881 assert( pPage
->aData
== sqlite3PagerGetData(pPage
->pDbPage
) );
1882 assert( pPage
->isInit
==1 );
1883 assert( pPage
->nFree
<0 );
1885 usableSize
= pPage
->pBt
->usableSize
;
1886 hdr
= pPage
->hdrOffset
;
1887 data
= pPage
->aData
;
1888 /* EVIDENCE-OF: R-58015-48175 The two-byte integer at offset 5 designates
1889 ** the start of the cell content area. A zero value for this integer is
1890 ** interpreted as 65536. */
1891 top
= get2byteNotZero(&data
[hdr
+5]);
1892 iCellFirst
= hdr
+ 8 + pPage
->childPtrSize
+ 2*pPage
->nCell
;
1893 iCellLast
= usableSize
- 4;
1895 /* Compute the total free space on the page
1896 ** EVIDENCE-OF: R-23588-34450 The two-byte integer at offset 1 gives the
1897 ** start of the first freeblock on the page, or is zero if there are no
1899 pc
= get2byte(&data
[hdr
+1]);
1900 nFree
= data
[hdr
+7] + top
; /* Init nFree to non-freeblock free space */
1904 /* EVIDENCE-OF: R-55530-52930 In a well-formed b-tree page, there will
1905 ** always be at least one cell before the first freeblock.
1907 return SQLITE_CORRUPT_PAGE(pPage
);
1911 /* Freeblock off the end of the page */
1912 return SQLITE_CORRUPT_PAGE(pPage
);
1914 next
= get2byte(&data
[pc
]);
1915 size
= get2byte(&data
[pc
+2]);
1916 nFree
= nFree
+ size
;
1917 if( next
<=pc
+size
+3 ) break;
1921 /* Freeblock not in ascending order */
1922 return SQLITE_CORRUPT_PAGE(pPage
);
1924 if( pc
+size
>(unsigned int)usableSize
){
1925 /* Last freeblock extends past page end */
1926 return SQLITE_CORRUPT_PAGE(pPage
);
1930 /* At this point, nFree contains the sum of the offset to the start
1931 ** of the cell-content area plus the number of free bytes within
1932 ** the cell-content area. If this is greater than the usable-size
1933 ** of the page, then the page must be corrupted. This check also
1934 ** serves to verify that the offset to the start of the cell-content
1935 ** area, according to the page header, lies within the page.
1937 if( nFree
>usableSize
|| nFree
<iCellFirst
){
1938 return SQLITE_CORRUPT_PAGE(pPage
);
1940 pPage
->nFree
= (u16
)(nFree
- iCellFirst
);
1945 ** Do additional sanity check after btreeInitPage() if
1946 ** PRAGMA cell_size_check=ON
1948 static SQLITE_NOINLINE
int btreeCellSizeCheck(MemPage
*pPage
){
1949 int iCellFirst
; /* First allowable cell or freeblock offset */
1950 int iCellLast
; /* Last possible cell or freeblock offset */
1951 int i
; /* Index into the cell pointer array */
1952 int sz
; /* Size of a cell */
1953 int pc
; /* Address of a freeblock within pPage->aData[] */
1954 u8
*data
; /* Equal to pPage->aData */
1955 int usableSize
; /* Maximum usable space on the page */
1956 int cellOffset
; /* Start of cell content area */
1958 iCellFirst
= pPage
->cellOffset
+ 2*pPage
->nCell
;
1959 usableSize
= pPage
->pBt
->usableSize
;
1960 iCellLast
= usableSize
- 4;
1961 data
= pPage
->aData
;
1962 cellOffset
= pPage
->cellOffset
;
1963 if( !pPage
->leaf
) iCellLast
--;
1964 for(i
=0; i
<pPage
->nCell
; i
++){
1965 pc
= get2byteAligned(&data
[cellOffset
+i
*2]);
1966 testcase( pc
==iCellFirst
);
1967 testcase( pc
==iCellLast
);
1968 if( pc
<iCellFirst
|| pc
>iCellLast
){
1969 return SQLITE_CORRUPT_PAGE(pPage
);
1971 sz
= pPage
->xCellSize(pPage
, &data
[pc
]);
1972 testcase( pc
+sz
==usableSize
);
1973 if( pc
+sz
>usableSize
){
1974 return SQLITE_CORRUPT_PAGE(pPage
);
1981 ** Initialize the auxiliary information for a disk block.
1983 ** Return SQLITE_OK on success. If we see that the page does
1984 ** not contain a well-formed database page, then return
1985 ** SQLITE_CORRUPT. Note that a return of SQLITE_OK does not
1986 ** guarantee that the page is well-formed. It only shows that
1987 ** we failed to detect any corruption.
1989 static int btreeInitPage(MemPage
*pPage
){
1990 u8
*data
; /* Equal to pPage->aData */
1991 BtShared
*pBt
; /* The main btree structure */
1993 assert( pPage
->pBt
!=0 );
1994 assert( pPage
->pBt
->db
!=0 );
1995 assert( sqlite3_mutex_held(pPage
->pBt
->mutex
) );
1996 assert( pPage
->pgno
==sqlite3PagerPagenumber(pPage
->pDbPage
) );
1997 assert( pPage
== sqlite3PagerGetExtra(pPage
->pDbPage
) );
1998 assert( pPage
->aData
== sqlite3PagerGetData(pPage
->pDbPage
) );
1999 assert( pPage
->isInit
==0 );
2002 data
= pPage
->aData
+ pPage
->hdrOffset
;
2003 /* EVIDENCE-OF: R-28594-02890 The one-byte flag at offset 0 indicating
2004 ** the b-tree page type. */
2005 if( decodeFlags(pPage
, data
[0]) ){
2006 return SQLITE_CORRUPT_PAGE(pPage
);
2008 assert( pBt
->pageSize
>=512 && pBt
->pageSize
<=65536 );
2009 pPage
->maskPage
= (u16
)(pBt
->pageSize
- 1);
2010 pPage
->nOverflow
= 0;
2011 pPage
->cellOffset
= pPage
->hdrOffset
+ 8 + pPage
->childPtrSize
;
2012 pPage
->aCellIdx
= data
+ pPage
->childPtrSize
+ 8;
2013 pPage
->aDataEnd
= pPage
->aData
+ pBt
->usableSize
;
2014 pPage
->aDataOfst
= pPage
->aData
+ pPage
->childPtrSize
;
2015 /* EVIDENCE-OF: R-37002-32774 The two-byte integer at offset 3 gives the
2016 ** number of cells on the page. */
2017 pPage
->nCell
= get2byte(&data
[3]);
2018 if( pPage
->nCell
>MX_CELL(pBt
) ){
2019 /* To many cells for a single page. The page must be corrupt */
2020 return SQLITE_CORRUPT_PAGE(pPage
);
2022 testcase( pPage
->nCell
==MX_CELL(pBt
) );
2023 /* EVIDENCE-OF: R-24089-57979 If a page contains no cells (which is only
2024 ** possible for a root page of a table that contains no rows) then the
2025 ** offset to the cell content area will equal the page size minus the
2026 ** bytes of reserved space. */
2027 assert( pPage
->nCell
>0
2028 || get2byteNotZero(&data
[5])==(int)pBt
->usableSize
2030 pPage
->nFree
= -1; /* Indicate that this value is yet uncomputed */
2032 if( pBt
->db
->flags
& SQLITE_CellSizeCk
){
2033 return btreeCellSizeCheck(pPage
);
2039 ** Set up a raw page so that it looks like a database page holding
2042 static void zeroPage(MemPage
*pPage
, int flags
){
2043 unsigned char *data
= pPage
->aData
;
2044 BtShared
*pBt
= pPage
->pBt
;
2045 u8 hdr
= pPage
->hdrOffset
;
2048 assert( sqlite3PagerPagenumber(pPage
->pDbPage
)==pPage
->pgno
);
2049 assert( sqlite3PagerGetExtra(pPage
->pDbPage
) == (void*)pPage
);
2050 assert( sqlite3PagerGetData(pPage
->pDbPage
) == data
);
2051 assert( sqlite3PagerIswriteable(pPage
->pDbPage
) );
2052 assert( sqlite3_mutex_held(pBt
->mutex
) );
2053 if( pBt
->btsFlags
& BTS_FAST_SECURE
){
2054 memset(&data
[hdr
], 0, pBt
->usableSize
- hdr
);
2056 data
[hdr
] = (char)flags
;
2057 first
= hdr
+ ((flags
&PTF_LEAF
)==0 ? 12 : 8);
2058 memset(&data
[hdr
+1], 0, 4);
2060 put2byte(&data
[hdr
+5], pBt
->usableSize
);
2061 pPage
->nFree
= (u16
)(pBt
->usableSize
- first
);
2062 decodeFlags(pPage
, flags
);
2063 pPage
->cellOffset
= first
;
2064 pPage
->aDataEnd
= &data
[pBt
->usableSize
];
2065 pPage
->aCellIdx
= &data
[first
];
2066 pPage
->aDataOfst
= &data
[pPage
->childPtrSize
];
2067 pPage
->nOverflow
= 0;
2068 assert( pBt
->pageSize
>=512 && pBt
->pageSize
<=65536 );
2069 pPage
->maskPage
= (u16
)(pBt
->pageSize
- 1);
2076 ** Convert a DbPage obtained from the pager into a MemPage used by
2079 static MemPage
*btreePageFromDbPage(DbPage
*pDbPage
, Pgno pgno
, BtShared
*pBt
){
2080 MemPage
*pPage
= (MemPage
*)sqlite3PagerGetExtra(pDbPage
);
2081 if( pgno
!=pPage
->pgno
){
2082 pPage
->aData
= sqlite3PagerGetData(pDbPage
);
2083 pPage
->pDbPage
= pDbPage
;
2086 pPage
->hdrOffset
= pgno
==1 ? 100 : 0;
2088 assert( pPage
->aData
==sqlite3PagerGetData(pDbPage
) );
2093 ** Get a page from the pager. Initialize the MemPage.pBt and
2094 ** MemPage.aData elements if needed. See also: btreeGetUnusedPage().
2096 ** If the PAGER_GET_NOCONTENT flag is set, it means that we do not care
2097 ** about the content of the page at this time. So do not go to the disk
2098 ** to fetch the content. Just fill in the content with zeros for now.
2099 ** If in the future we call sqlite3PagerWrite() on this page, that
2100 ** means we have started to be concerned about content and the disk
2101 ** read should occur at that point.
2103 static int btreeGetPage(
2104 BtShared
*pBt
, /* The btree */
2105 Pgno pgno
, /* Number of the page to fetch */
2106 MemPage
**ppPage
, /* Return the page in this parameter */
2107 int flags
/* PAGER_GET_NOCONTENT or PAGER_GET_READONLY */
2112 assert( flags
==0 || flags
==PAGER_GET_NOCONTENT
|| flags
==PAGER_GET_READONLY
);
2113 assert( sqlite3_mutex_held(pBt
->mutex
) );
2114 rc
= sqlite3PagerGet(pBt
->pPager
, pgno
, (DbPage
**)&pDbPage
, flags
);
2116 *ppPage
= btreePageFromDbPage(pDbPage
, pgno
, pBt
);
2121 ** Retrieve a page from the pager cache. If the requested page is not
2122 ** already in the pager cache return NULL. Initialize the MemPage.pBt and
2123 ** MemPage.aData elements if needed.
2125 static MemPage
*btreePageLookup(BtShared
*pBt
, Pgno pgno
){
2127 assert( sqlite3_mutex_held(pBt
->mutex
) );
2128 pDbPage
= sqlite3PagerLookup(pBt
->pPager
, pgno
);
2130 return btreePageFromDbPage(pDbPage
, pgno
, pBt
);
2136 ** Return the size of the database file in pages. If there is any kind of
2137 ** error, return ((unsigned int)-1).
2139 static Pgno
btreePagecount(BtShared
*pBt
){
2140 assert( (pBt
->nPage
& 0x80000000)==0 || CORRUPT_DB
);
2143 u32
sqlite3BtreeLastPage(Btree
*p
){
2144 assert( sqlite3BtreeHoldsMutex(p
) );
2145 return btreePagecount(p
->pBt
) & 0x7fffffff;
2149 ** Get a page from the pager and initialize it.
2151 ** If pCur!=0 then the page is being fetched as part of a moveToChild()
2152 ** call. Do additional sanity checking on the page in this case.
2153 ** And if the fetch fails, this routine must decrement pCur->iPage.
2155 ** The page is fetched as read-write unless pCur is not NULL and is
2156 ** a read-only cursor.
2158 ** If an error occurs, then *ppPage is undefined. It
2159 ** may remain unchanged, or it may be set to an invalid value.
2161 static int getAndInitPage(
2162 BtShared
*pBt
, /* The database file */
2163 Pgno pgno
, /* Number of the page to get */
2164 MemPage
**ppPage
, /* Write the page pointer here */
2165 BtCursor
*pCur
, /* Cursor to receive the page, or NULL */
2166 int bReadOnly
/* True for a read-only page */
2170 assert( sqlite3_mutex_held(pBt
->mutex
) );
2171 assert( pCur
==0 || ppPage
==&pCur
->pPage
);
2172 assert( pCur
==0 || bReadOnly
==pCur
->curPagerFlags
);
2173 assert( pCur
==0 || pCur
->iPage
>0 );
2175 if( pgno
>btreePagecount(pBt
) ){
2176 rc
= SQLITE_CORRUPT_BKPT
;
2177 goto getAndInitPage_error1
;
2179 rc
= sqlite3PagerGet(pBt
->pPager
, pgno
, (DbPage
**)&pDbPage
, bReadOnly
);
2181 goto getAndInitPage_error1
;
2183 *ppPage
= (MemPage
*)sqlite3PagerGetExtra(pDbPage
);
2184 if( (*ppPage
)->isInit
==0 ){
2185 btreePageFromDbPage(pDbPage
, pgno
, pBt
);
2186 rc
= btreeInitPage(*ppPage
);
2187 if( rc
!=SQLITE_OK
){
2188 goto getAndInitPage_error2
;
2191 assert( (*ppPage
)->pgno
==pgno
);
2192 assert( (*ppPage
)->aData
==sqlite3PagerGetData(pDbPage
) );
2194 /* If obtaining a child page for a cursor, we must verify that the page is
2195 ** compatible with the root page. */
2196 if( pCur
&& ((*ppPage
)->nCell
<1 || (*ppPage
)->intKey
!=pCur
->curIntKey
) ){
2197 rc
= SQLITE_CORRUPT_PGNO(pgno
);
2198 goto getAndInitPage_error2
;
2202 getAndInitPage_error2
:
2203 releasePage(*ppPage
);
2204 getAndInitPage_error1
:
2207 pCur
->pPage
= pCur
->apPage
[pCur
->iPage
];
2209 testcase( pgno
==0 );
2210 assert( pgno
!=0 || rc
==SQLITE_CORRUPT
);
2215 ** Release a MemPage. This should be called once for each prior
2216 ** call to btreeGetPage.
2218 ** Page1 is a special case and must be released using releasePageOne().
2220 static void releasePageNotNull(MemPage
*pPage
){
2221 assert( pPage
->aData
);
2222 assert( pPage
->pBt
);
2223 assert( pPage
->pDbPage
!=0 );
2224 assert( sqlite3PagerGetExtra(pPage
->pDbPage
) == (void*)pPage
);
2225 assert( sqlite3PagerGetData(pPage
->pDbPage
)==pPage
->aData
);
2226 assert( sqlite3_mutex_held(pPage
->pBt
->mutex
) );
2227 sqlite3PagerUnrefNotNull(pPage
->pDbPage
);
2229 static void releasePage(MemPage
*pPage
){
2230 if( pPage
) releasePageNotNull(pPage
);
2232 static void releasePageOne(MemPage
*pPage
){
2234 assert( pPage
->aData
);
2235 assert( pPage
->pBt
);
2236 assert( pPage
->pDbPage
!=0 );
2237 assert( sqlite3PagerGetExtra(pPage
->pDbPage
) == (void*)pPage
);
2238 assert( sqlite3PagerGetData(pPage
->pDbPage
)==pPage
->aData
);
2239 assert( sqlite3_mutex_held(pPage
->pBt
->mutex
) );
2240 sqlite3PagerUnrefPageOne(pPage
->pDbPage
);
2244 ** Get an unused page.
2246 ** This works just like btreeGetPage() with the addition:
2248 ** * If the page is already in use for some other purpose, immediately
2249 ** release it and return an SQLITE_CURRUPT error.
2250 ** * Make sure the isInit flag is clear
2252 static int btreeGetUnusedPage(
2253 BtShared
*pBt
, /* The btree */
2254 Pgno pgno
, /* Number of the page to fetch */
2255 MemPage
**ppPage
, /* Return the page in this parameter */
2256 int flags
/* PAGER_GET_NOCONTENT or PAGER_GET_READONLY */
2258 int rc
= btreeGetPage(pBt
, pgno
, ppPage
, flags
);
2259 if( rc
==SQLITE_OK
){
2260 if( sqlite3PagerPageRefcount((*ppPage
)->pDbPage
)>1 ){
2261 releasePage(*ppPage
);
2263 return SQLITE_CORRUPT_BKPT
;
2265 (*ppPage
)->isInit
= 0;
2274 ** During a rollback, when the pager reloads information into the cache
2275 ** so that the cache is restored to its original state at the start of
2276 ** the transaction, for each page restored this routine is called.
2278 ** This routine needs to reset the extra data section at the end of the
2279 ** page to agree with the restored data.
2281 static void pageReinit(DbPage
*pData
){
2283 pPage
= (MemPage
*)sqlite3PagerGetExtra(pData
);
2284 assert( sqlite3PagerPageRefcount(pData
)>0 );
2285 if( pPage
->isInit
){
2286 assert( sqlite3_mutex_held(pPage
->pBt
->mutex
) );
2288 if( sqlite3PagerPageRefcount(pData
)>1 ){
2289 /* pPage might not be a btree page; it might be an overflow page
2290 ** or ptrmap page or a free page. In those cases, the following
2291 ** call to btreeInitPage() will likely return SQLITE_CORRUPT.
2292 ** But no harm is done by this. And it is very important that
2293 ** btreeInitPage() be called on every btree page so we make
2294 ** the call for every page that comes in for re-initing. */
2295 btreeInitPage(pPage
);
2301 ** Invoke the busy handler for a btree.
2303 static int btreeInvokeBusyHandler(void *pArg
){
2304 BtShared
*pBt
= (BtShared
*)pArg
;
2306 assert( sqlite3_mutex_held(pBt
->db
->mutex
) );
2307 return sqlite3InvokeBusyHandler(&pBt
->db
->busyHandler
,
2308 sqlite3PagerFile(pBt
->pPager
));
2312 ** Open a database file.
2314 ** zFilename is the name of the database file. If zFilename is NULL
2315 ** then an ephemeral database is created. The ephemeral database might
2316 ** be exclusively in memory, or it might use a disk-based memory cache.
2317 ** Either way, the ephemeral database will be automatically deleted
2318 ** when sqlite3BtreeClose() is called.
2320 ** If zFilename is ":memory:" then an in-memory database is created
2321 ** that is automatically destroyed when it is closed.
2323 ** The "flags" parameter is a bitmask that might contain bits like
2324 ** BTREE_OMIT_JOURNAL and/or BTREE_MEMORY.
2326 ** If the database is already opened in the same database connection
2327 ** and we are in shared cache mode, then the open will fail with an
2328 ** SQLITE_CONSTRAINT error. We cannot allow two or more BtShared
2329 ** objects in the same database connection since doing so will lead
2330 ** to problems with locking.
2332 int sqlite3BtreeOpen(
2333 sqlite3_vfs
*pVfs
, /* VFS to use for this b-tree */
2334 const char *zFilename
, /* Name of the file containing the BTree database */
2335 sqlite3
*db
, /* Associated database handle */
2336 Btree
**ppBtree
, /* Pointer to new Btree object written here */
2337 int flags
, /* Options */
2338 int vfsFlags
/* Flags passed through to sqlite3_vfs.xOpen() */
2340 BtShared
*pBt
= 0; /* Shared part of btree structure */
2341 Btree
*p
; /* Handle to return */
2342 sqlite3_mutex
*mutexOpen
= 0; /* Prevents a race condition. Ticket #3537 */
2343 int rc
= SQLITE_OK
; /* Result code from this function */
2344 u8 nReserve
; /* Byte of unused space on each page */
2345 unsigned char zDbHeader
[100]; /* Database header content */
2347 /* True if opening an ephemeral, temporary database */
2348 const int isTempDb
= zFilename
==0 || zFilename
[0]==0;
2350 /* Set the variable isMemdb to true for an in-memory database, or
2351 ** false for a file-based database.
2353 #ifdef SQLITE_OMIT_MEMORYDB
2354 const int isMemdb
= 0;
2356 const int isMemdb
= (zFilename
&& strcmp(zFilename
, ":memory:")==0)
2357 || (isTempDb
&& sqlite3TempInMemory(db
))
2358 || (vfsFlags
& SQLITE_OPEN_MEMORY
)!=0;
2363 assert( sqlite3_mutex_held(db
->mutex
) );
2364 assert( (flags
&0xff)==flags
); /* flags fit in 8 bits */
2366 /* Only a BTREE_SINGLE database can be BTREE_UNORDERED */
2367 assert( (flags
& BTREE_UNORDERED
)==0 || (flags
& BTREE_SINGLE
)!=0 );
2369 /* A BTREE_SINGLE database is always a temporary and/or ephemeral */
2370 assert( (flags
& BTREE_SINGLE
)==0 || isTempDb
);
2373 flags
|= BTREE_MEMORY
;
2375 if( (vfsFlags
& SQLITE_OPEN_MAIN_DB
)!=0 && (isMemdb
|| isTempDb
) ){
2376 vfsFlags
= (vfsFlags
& ~SQLITE_OPEN_MAIN_DB
) | SQLITE_OPEN_TEMP_DB
;
2378 p
= sqlite3MallocZero(sizeof(Btree
));
2380 return SQLITE_NOMEM_BKPT
;
2382 p
->inTrans
= TRANS_NONE
;
2384 #ifndef SQLITE_OMIT_SHARED_CACHE
2389 #if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO)
2391 ** If this Btree is a candidate for shared cache, try to find an
2392 ** existing BtShared object that we can share with
2394 if( isTempDb
==0 && (isMemdb
==0 || (vfsFlags
&SQLITE_OPEN_URI
)!=0) ){
2395 if( vfsFlags
& SQLITE_OPEN_SHAREDCACHE
){
2396 int nFilename
= sqlite3Strlen30(zFilename
)+1;
2397 int nFullPathname
= pVfs
->mxPathname
+1;
2398 char *zFullPathname
= sqlite3Malloc(MAX(nFullPathname
,nFilename
));
2399 MUTEX_LOGIC( sqlite3_mutex
*mutexShared
; )
2402 if( !zFullPathname
){
2404 return SQLITE_NOMEM_BKPT
;
2407 memcpy(zFullPathname
, zFilename
, nFilename
);
2409 rc
= sqlite3OsFullPathname(pVfs
, zFilename
,
2410 nFullPathname
, zFullPathname
);
2412 if( rc
==SQLITE_OK_SYMLINK
){
2415 sqlite3_free(zFullPathname
);
2421 #if SQLITE_THREADSAFE
2422 mutexOpen
= sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_OPEN
);
2423 sqlite3_mutex_enter(mutexOpen
);
2424 mutexShared
= sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER
);
2425 sqlite3_mutex_enter(mutexShared
);
2427 for(pBt
=GLOBAL(BtShared
*,sqlite3SharedCacheList
); pBt
; pBt
=pBt
->pNext
){
2428 assert( pBt
->nRef
>0 );
2429 if( 0==strcmp(zFullPathname
, sqlite3PagerFilename(pBt
->pPager
, 0))
2430 && sqlite3PagerVfs(pBt
->pPager
)==pVfs
){
2432 for(iDb
=db
->nDb
-1; iDb
>=0; iDb
--){
2433 Btree
*pExisting
= db
->aDb
[iDb
].pBt
;
2434 if( pExisting
&& pExisting
->pBt
==pBt
){
2435 sqlite3_mutex_leave(mutexShared
);
2436 sqlite3_mutex_leave(mutexOpen
);
2437 sqlite3_free(zFullPathname
);
2439 return SQLITE_CONSTRAINT
;
2447 sqlite3_mutex_leave(mutexShared
);
2448 sqlite3_free(zFullPathname
);
2452 /* In debug mode, we mark all persistent databases as sharable
2453 ** even when they are not. This exercises the locking code and
2454 ** gives more opportunity for asserts(sqlite3_mutex_held())
2455 ** statements to find locking problems.
2464 ** The following asserts make sure that structures used by the btree are
2465 ** the right size. This is to guard against size changes that result
2466 ** when compiling on a different architecture.
2468 assert( sizeof(i64
)==8 );
2469 assert( sizeof(u64
)==8 );
2470 assert( sizeof(u32
)==4 );
2471 assert( sizeof(u16
)==2 );
2472 assert( sizeof(Pgno
)==4 );
2474 pBt
= sqlite3MallocZero( sizeof(*pBt
) );
2476 rc
= SQLITE_NOMEM_BKPT
;
2477 goto btree_open_out
;
2479 rc
= sqlite3PagerOpen(pVfs
, &pBt
->pPager
, zFilename
,
2480 sizeof(MemPage
), flags
, vfsFlags
, pageReinit
);
2481 if( rc
==SQLITE_OK
){
2482 sqlite3PagerSetMmapLimit(pBt
->pPager
, db
->szMmap
);
2483 rc
= sqlite3PagerReadFileheader(pBt
->pPager
,sizeof(zDbHeader
),zDbHeader
);
2485 if( rc
!=SQLITE_OK
){
2486 goto btree_open_out
;
2488 pBt
->openFlags
= (u8
)flags
;
2490 sqlite3PagerSetBusyHandler(pBt
->pPager
, btreeInvokeBusyHandler
, pBt
);
2495 if( sqlite3PagerIsreadonly(pBt
->pPager
) ) pBt
->btsFlags
|= BTS_READ_ONLY
;
2496 #if defined(SQLITE_SECURE_DELETE)
2497 pBt
->btsFlags
|= BTS_SECURE_DELETE
;
2498 #elif defined(SQLITE_FAST_SECURE_DELETE)
2499 pBt
->btsFlags
|= BTS_OVERWRITE
;
2501 /* EVIDENCE-OF: R-51873-39618 The page size for a database file is
2502 ** determined by the 2-byte integer located at an offset of 16 bytes from
2503 ** the beginning of the database file. */
2504 pBt
->pageSize
= (zDbHeader
[16]<<8) | (zDbHeader
[17]<<16);
2505 if( pBt
->pageSize
<512 || pBt
->pageSize
>SQLITE_MAX_PAGE_SIZE
2506 || ((pBt
->pageSize
-1)&pBt
->pageSize
)!=0 ){
2508 #ifndef SQLITE_OMIT_AUTOVACUUM
2509 /* If the magic name ":memory:" will create an in-memory database, then
2510 ** leave the autoVacuum mode at 0 (do not auto-vacuum), even if
2511 ** SQLITE_DEFAULT_AUTOVACUUM is true. On the other hand, if
2512 ** SQLITE_OMIT_MEMORYDB has been defined, then ":memory:" is just a
2513 ** regular file-name. In this case the auto-vacuum applies as per normal.
2515 if( zFilename
&& !isMemdb
){
2516 pBt
->autoVacuum
= (SQLITE_DEFAULT_AUTOVACUUM
? 1 : 0);
2517 pBt
->incrVacuum
= (SQLITE_DEFAULT_AUTOVACUUM
==2 ? 1 : 0);
2522 /* EVIDENCE-OF: R-37497-42412 The size of the reserved region is
2523 ** determined by the one-byte unsigned integer found at an offset of 20
2524 ** into the database file header. */
2525 nReserve
= zDbHeader
[20];
2526 pBt
->btsFlags
|= BTS_PAGESIZE_FIXED
;
2527 #ifndef SQLITE_OMIT_AUTOVACUUM
2528 pBt
->autoVacuum
= (get4byte(&zDbHeader
[36 + 4*4])?1:0);
2529 pBt
->incrVacuum
= (get4byte(&zDbHeader
[36 + 7*4])?1:0);
2532 rc
= sqlite3PagerSetPagesize(pBt
->pPager
, &pBt
->pageSize
, nReserve
);
2533 if( rc
) goto btree_open_out
;
2534 pBt
->usableSize
= pBt
->pageSize
- nReserve
;
2535 assert( (pBt
->pageSize
& 7)==0 ); /* 8-byte alignment of pageSize */
2537 #if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO)
2538 /* Add the new BtShared object to the linked list sharable BtShareds.
2542 MUTEX_LOGIC( sqlite3_mutex
*mutexShared
; )
2543 MUTEX_LOGIC( mutexShared
= sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER
);)
2544 if( SQLITE_THREADSAFE
&& sqlite3GlobalConfig
.bCoreMutex
){
2545 pBt
->mutex
= sqlite3MutexAlloc(SQLITE_MUTEX_FAST
);
2546 if( pBt
->mutex
==0 ){
2547 rc
= SQLITE_NOMEM_BKPT
;
2548 goto btree_open_out
;
2551 sqlite3_mutex_enter(mutexShared
);
2552 pBt
->pNext
= GLOBAL(BtShared
*,sqlite3SharedCacheList
);
2553 GLOBAL(BtShared
*,sqlite3SharedCacheList
) = pBt
;
2554 sqlite3_mutex_leave(mutexShared
);
2559 #if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO)
2560 /* If the new Btree uses a sharable pBtShared, then link the new
2561 ** Btree into the list of all sharable Btrees for the same connection.
2562 ** The list is kept in ascending order by pBt address.
2567 for(i
=0; i
<db
->nDb
; i
++){
2568 if( (pSib
= db
->aDb
[i
].pBt
)!=0 && pSib
->sharable
){
2569 while( pSib
->pPrev
){ pSib
= pSib
->pPrev
; }
2570 if( (uptr
)p
->pBt
<(uptr
)pSib
->pBt
){
2575 while( pSib
->pNext
&& (uptr
)pSib
->pNext
->pBt
<(uptr
)p
->pBt
){
2578 p
->pNext
= pSib
->pNext
;
2581 p
->pNext
->pPrev
= p
;
2593 if( rc
!=SQLITE_OK
){
2594 if( pBt
&& pBt
->pPager
){
2595 sqlite3PagerClose(pBt
->pPager
, 0);
2601 sqlite3_file
*pFile
;
2603 /* If the B-Tree was successfully opened, set the pager-cache size to the
2604 ** default value. Except, when opening on an existing shared pager-cache,
2605 ** do not change the pager-cache size.
2607 if( sqlite3BtreeSchema(p
, 0, 0)==0 ){
2608 sqlite3PagerSetCachesize(p
->pBt
->pPager
, SQLITE_DEFAULT_CACHE_SIZE
);
2611 pFile
= sqlite3PagerFile(pBt
->pPager
);
2612 if( pFile
->pMethods
){
2613 sqlite3OsFileControlHint(pFile
, SQLITE_FCNTL_PDB
, (void*)&pBt
->db
);
2617 assert( sqlite3_mutex_held(mutexOpen
) );
2618 sqlite3_mutex_leave(mutexOpen
);
2620 assert( rc
!=SQLITE_OK
|| sqlite3BtreeConnectionCount(*ppBtree
)>0 );
2625 ** Decrement the BtShared.nRef counter. When it reaches zero,
2626 ** remove the BtShared structure from the sharing list. Return
2627 ** true if the BtShared.nRef counter reaches zero and return
2628 ** false if it is still positive.
2630 static int removeFromSharingList(BtShared
*pBt
){
2631 #ifndef SQLITE_OMIT_SHARED_CACHE
2632 MUTEX_LOGIC( sqlite3_mutex
*pMaster
; )
2636 assert( sqlite3_mutex_notheld(pBt
->mutex
) );
2637 MUTEX_LOGIC( pMaster
= sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER
); )
2638 sqlite3_mutex_enter(pMaster
);
2641 if( GLOBAL(BtShared
*,sqlite3SharedCacheList
)==pBt
){
2642 GLOBAL(BtShared
*,sqlite3SharedCacheList
) = pBt
->pNext
;
2644 pList
= GLOBAL(BtShared
*,sqlite3SharedCacheList
);
2645 while( ALWAYS(pList
) && pList
->pNext
!=pBt
){
2648 if( ALWAYS(pList
) ){
2649 pList
->pNext
= pBt
->pNext
;
2652 if( SQLITE_THREADSAFE
){
2653 sqlite3_mutex_free(pBt
->mutex
);
2657 sqlite3_mutex_leave(pMaster
);
2665 ** Make sure pBt->pTmpSpace points to an allocation of
2666 ** MX_CELL_SIZE(pBt) bytes with a 4-byte prefix for a left-child
2669 static void allocateTempSpace(BtShared
*pBt
){
2670 if( !pBt
->pTmpSpace
){
2671 pBt
->pTmpSpace
= sqlite3PageMalloc( pBt
->pageSize
);
2673 /* One of the uses of pBt->pTmpSpace is to format cells before
2674 ** inserting them into a leaf page (function fillInCell()). If
2675 ** a cell is less than 4 bytes in size, it is rounded up to 4 bytes
2676 ** by the various routines that manipulate binary cells. Which
2677 ** can mean that fillInCell() only initializes the first 2 or 3
2678 ** bytes of pTmpSpace, but that the first 4 bytes are copied from
2679 ** it into a database page. This is not actually a problem, but it
2680 ** does cause a valgrind error when the 1 or 2 bytes of unitialized
2681 ** data is passed to system call write(). So to avoid this error,
2682 ** zero the first 4 bytes of temp space here.
2684 ** Also: Provide four bytes of initialized space before the
2685 ** beginning of pTmpSpace as an area available to prepend the
2686 ** left-child pointer to the beginning of a cell.
2688 if( pBt
->pTmpSpace
){
2689 memset(pBt
->pTmpSpace
, 0, 8);
2690 pBt
->pTmpSpace
+= 4;
2696 ** Free the pBt->pTmpSpace allocation
2698 static void freeTempSpace(BtShared
*pBt
){
2699 if( pBt
->pTmpSpace
){
2700 pBt
->pTmpSpace
-= 4;
2701 sqlite3PageFree(pBt
->pTmpSpace
);
2707 ** Close an open database and invalidate all cursors.
2709 int sqlite3BtreeClose(Btree
*p
){
2710 BtShared
*pBt
= p
->pBt
;
2713 /* Close all cursors opened via this handle. */
2714 assert( sqlite3_mutex_held(p
->db
->mutex
) );
2715 sqlite3BtreeEnter(p
);
2716 pCur
= pBt
->pCursor
;
2718 BtCursor
*pTmp
= pCur
;
2720 if( pTmp
->pBtree
==p
){
2721 sqlite3BtreeCloseCursor(pTmp
);
2725 /* Rollback any active transaction and free the handle structure.
2726 ** The call to sqlite3BtreeRollback() drops any table-locks held by
2729 sqlite3BtreeRollback(p
, SQLITE_OK
, 0);
2730 sqlite3BtreeLeave(p
);
2732 /* If there are still other outstanding references to the shared-btree
2733 ** structure, return now. The remainder of this procedure cleans
2734 ** up the shared-btree.
2736 assert( p
->wantToLock
==0 && p
->locked
==0 );
2737 if( !p
->sharable
|| removeFromSharingList(pBt
) ){
2738 /* The pBt is no longer on the sharing list, so we can access
2739 ** it without having to hold the mutex.
2741 ** Clean out and delete the BtShared object.
2743 assert( !pBt
->pCursor
);
2744 sqlite3PagerClose(pBt
->pPager
, p
->db
);
2745 if( pBt
->xFreeSchema
&& pBt
->pSchema
){
2746 pBt
->xFreeSchema(pBt
->pSchema
);
2748 sqlite3DbFree(0, pBt
->pSchema
);
2753 #ifndef SQLITE_OMIT_SHARED_CACHE
2754 assert( p
->wantToLock
==0 );
2755 assert( p
->locked
==0 );
2756 if( p
->pPrev
) p
->pPrev
->pNext
= p
->pNext
;
2757 if( p
->pNext
) p
->pNext
->pPrev
= p
->pPrev
;
2765 ** Change the "soft" limit on the number of pages in the cache.
2766 ** Unused and unmodified pages will be recycled when the number of
2767 ** pages in the cache exceeds this soft limit. But the size of the
2768 ** cache is allowed to grow larger than this limit if it contains
2769 ** dirty pages or pages still in active use.
2771 int sqlite3BtreeSetCacheSize(Btree
*p
, int mxPage
){
2772 BtShared
*pBt
= p
->pBt
;
2773 assert( sqlite3_mutex_held(p
->db
->mutex
) );
2774 sqlite3BtreeEnter(p
);
2775 sqlite3PagerSetCachesize(pBt
->pPager
, mxPage
);
2776 sqlite3BtreeLeave(p
);
2781 ** Change the "spill" limit on the number of pages in the cache.
2782 ** If the number of pages exceeds this limit during a write transaction,
2783 ** the pager might attempt to "spill" pages to the journal early in
2784 ** order to free up memory.
2786 ** The value returned is the current spill size. If zero is passed
2787 ** as an argument, no changes are made to the spill size setting, so
2788 ** using mxPage of 0 is a way to query the current spill size.
2790 int sqlite3BtreeSetSpillSize(Btree
*p
, int mxPage
){
2791 BtShared
*pBt
= p
->pBt
;
2793 assert( sqlite3_mutex_held(p
->db
->mutex
) );
2794 sqlite3BtreeEnter(p
);
2795 res
= sqlite3PagerSetSpillsize(pBt
->pPager
, mxPage
);
2796 sqlite3BtreeLeave(p
);
2800 #if SQLITE_MAX_MMAP_SIZE>0
2802 ** Change the limit on the amount of the database file that may be
2805 int sqlite3BtreeSetMmapLimit(Btree
*p
, sqlite3_int64 szMmap
){
2806 BtShared
*pBt
= p
->pBt
;
2807 assert( sqlite3_mutex_held(p
->db
->mutex
) );
2808 sqlite3BtreeEnter(p
);
2809 sqlite3PagerSetMmapLimit(pBt
->pPager
, szMmap
);
2810 sqlite3BtreeLeave(p
);
2813 #endif /* SQLITE_MAX_MMAP_SIZE>0 */
2816 ** Change the way data is synced to disk in order to increase or decrease
2817 ** how well the database resists damage due to OS crashes and power
2818 ** failures. Level 1 is the same as asynchronous (no syncs() occur and
2819 ** there is a high probability of damage) Level 2 is the default. There
2820 ** is a very low but non-zero probability of damage. Level 3 reduces the
2821 ** probability of damage to near zero but with a write performance reduction.
2823 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
2824 int sqlite3BtreeSetPagerFlags(
2825 Btree
*p
, /* The btree to set the safety level on */
2826 unsigned pgFlags
/* Various PAGER_* flags */
2828 BtShared
*pBt
= p
->pBt
;
2829 assert( sqlite3_mutex_held(p
->db
->mutex
) );
2830 sqlite3BtreeEnter(p
);
2831 sqlite3PagerSetFlags(pBt
->pPager
, pgFlags
);
2832 sqlite3BtreeLeave(p
);
2838 ** Change the default pages size and the number of reserved bytes per page.
2839 ** Or, if the page size has already been fixed, return SQLITE_READONLY
2840 ** without changing anything.
2842 ** The page size must be a power of 2 between 512 and 65536. If the page
2843 ** size supplied does not meet this constraint then the page size is not
2846 ** Page sizes are constrained to be a power of two so that the region
2847 ** of the database file used for locking (beginning at PENDING_BYTE,
2848 ** the first byte past the 1GB boundary, 0x40000000) needs to occur
2849 ** at the beginning of a page.
2851 ** If parameter nReserve is less than zero, then the number of reserved
2852 ** bytes per page is left unchanged.
2854 ** If the iFix!=0 then the BTS_PAGESIZE_FIXED flag is set so that the page size
2855 ** and autovacuum mode can no longer be changed.
2857 int sqlite3BtreeSetPageSize(Btree
*p
, int pageSize
, int nReserve
, int iFix
){
2859 BtShared
*pBt
= p
->pBt
;
2860 assert( nReserve
>=-1 && nReserve
<=255 );
2861 sqlite3BtreeEnter(p
);
2862 #if SQLITE_HAS_CODEC
2863 if( nReserve
>pBt
->optimalReserve
) pBt
->optimalReserve
= (u8
)nReserve
;
2865 if( pBt
->btsFlags
& BTS_PAGESIZE_FIXED
){
2866 sqlite3BtreeLeave(p
);
2867 return SQLITE_READONLY
;
2870 nReserve
= pBt
->pageSize
- pBt
->usableSize
;
2872 assert( nReserve
>=0 && nReserve
<=255 );
2873 if( pageSize
>=512 && pageSize
<=SQLITE_MAX_PAGE_SIZE
&&
2874 ((pageSize
-1)&pageSize
)==0 ){
2875 assert( (pageSize
& 7)==0 );
2876 assert( !pBt
->pCursor
);
2877 pBt
->pageSize
= (u32
)pageSize
;
2880 rc
= sqlite3PagerSetPagesize(pBt
->pPager
, &pBt
->pageSize
, nReserve
);
2881 pBt
->usableSize
= pBt
->pageSize
- (u16
)nReserve
;
2882 if( iFix
) pBt
->btsFlags
|= BTS_PAGESIZE_FIXED
;
2883 sqlite3BtreeLeave(p
);
2888 ** Return the currently defined page size
2890 int sqlite3BtreeGetPageSize(Btree
*p
){
2891 return p
->pBt
->pageSize
;
2895 ** This function is similar to sqlite3BtreeGetReserve(), except that it
2896 ** may only be called if it is guaranteed that the b-tree mutex is already
2899 ** This is useful in one special case in the backup API code where it is
2900 ** known that the shared b-tree mutex is held, but the mutex on the
2901 ** database handle that owns *p is not. In this case if sqlite3BtreeEnter()
2902 ** were to be called, it might collide with some other operation on the
2903 ** database handle that owns *p, causing undefined behavior.
2905 int sqlite3BtreeGetReserveNoMutex(Btree
*p
){
2907 assert( sqlite3_mutex_held(p
->pBt
->mutex
) );
2908 n
= p
->pBt
->pageSize
- p
->pBt
->usableSize
;
2913 ** Return the number of bytes of space at the end of every page that
2914 ** are intentually left unused. This is the "reserved" space that is
2915 ** sometimes used by extensions.
2917 ** If SQLITE_HAS_MUTEX is defined then the number returned is the
2918 ** greater of the current reserved space and the maximum requested
2921 int sqlite3BtreeGetOptimalReserve(Btree
*p
){
2923 sqlite3BtreeEnter(p
);
2924 n
= sqlite3BtreeGetReserveNoMutex(p
);
2925 #ifdef SQLITE_HAS_CODEC
2926 if( n
<p
->pBt
->optimalReserve
) n
= p
->pBt
->optimalReserve
;
2928 sqlite3BtreeLeave(p
);
2934 ** Set the maximum page count for a database if mxPage is positive.
2935 ** No changes are made if mxPage is 0 or negative.
2936 ** Regardless of the value of mxPage, return the maximum page count.
2938 int sqlite3BtreeMaxPageCount(Btree
*p
, int mxPage
){
2940 sqlite3BtreeEnter(p
);
2941 n
= sqlite3PagerMaxPageCount(p
->pBt
->pPager
, mxPage
);
2942 sqlite3BtreeLeave(p
);
2947 ** Change the values for the BTS_SECURE_DELETE and BTS_OVERWRITE flags:
2949 ** newFlag==0 Both BTS_SECURE_DELETE and BTS_OVERWRITE are cleared
2950 ** newFlag==1 BTS_SECURE_DELETE set and BTS_OVERWRITE is cleared
2951 ** newFlag==2 BTS_SECURE_DELETE cleared and BTS_OVERWRITE is set
2952 ** newFlag==(-1) No changes
2954 ** This routine acts as a query if newFlag is less than zero
2956 ** With BTS_OVERWRITE set, deleted content is overwritten by zeros, but
2957 ** freelist leaf pages are not written back to the database. Thus in-page
2958 ** deleted content is cleared, but freelist deleted content is not.
2960 ** With BTS_SECURE_DELETE, operation is like BTS_OVERWRITE with the addition
2961 ** that freelist leaf pages are written back into the database, increasing
2962 ** the amount of disk I/O.
2964 int sqlite3BtreeSecureDelete(Btree
*p
, int newFlag
){
2966 if( p
==0 ) return 0;
2967 sqlite3BtreeEnter(p
);
2968 assert( BTS_OVERWRITE
==BTS_SECURE_DELETE
*2 );
2969 assert( BTS_FAST_SECURE
==(BTS_OVERWRITE
|BTS_SECURE_DELETE
) );
2971 p
->pBt
->btsFlags
&= ~BTS_FAST_SECURE
;
2972 p
->pBt
->btsFlags
|= BTS_SECURE_DELETE
*newFlag
;
2974 b
= (p
->pBt
->btsFlags
& BTS_FAST_SECURE
)/BTS_SECURE_DELETE
;
2975 sqlite3BtreeLeave(p
);
2980 ** Change the 'auto-vacuum' property of the database. If the 'autoVacuum'
2981 ** parameter is non-zero, then auto-vacuum mode is enabled. If zero, it
2982 ** is disabled. The default value for the auto-vacuum property is
2983 ** determined by the SQLITE_DEFAULT_AUTOVACUUM macro.
2985 int sqlite3BtreeSetAutoVacuum(Btree
*p
, int autoVacuum
){
2986 #ifdef SQLITE_OMIT_AUTOVACUUM
2987 return SQLITE_READONLY
;
2989 BtShared
*pBt
= p
->pBt
;
2991 u8 av
= (u8
)autoVacuum
;
2993 sqlite3BtreeEnter(p
);
2994 if( (pBt
->btsFlags
& BTS_PAGESIZE_FIXED
)!=0 && (av
?1:0)!=pBt
->autoVacuum
){
2995 rc
= SQLITE_READONLY
;
2997 pBt
->autoVacuum
= av
?1:0;
2998 pBt
->incrVacuum
= av
==2 ?1:0;
3000 sqlite3BtreeLeave(p
);
3006 ** Return the value of the 'auto-vacuum' property. If auto-vacuum is
3007 ** enabled 1 is returned. Otherwise 0.
3009 int sqlite3BtreeGetAutoVacuum(Btree
*p
){
3010 #ifdef SQLITE_OMIT_AUTOVACUUM
3011 return BTREE_AUTOVACUUM_NONE
;
3014 sqlite3BtreeEnter(p
);
3016 (!p
->pBt
->autoVacuum
)?BTREE_AUTOVACUUM_NONE
:
3017 (!p
->pBt
->incrVacuum
)?BTREE_AUTOVACUUM_FULL
:
3018 BTREE_AUTOVACUUM_INCR
3020 sqlite3BtreeLeave(p
);
3026 ** If the user has not set the safety-level for this database connection
3027 ** using "PRAGMA synchronous", and if the safety-level is not already
3028 ** set to the value passed to this function as the second parameter,
3031 #if SQLITE_DEFAULT_SYNCHRONOUS!=SQLITE_DEFAULT_WAL_SYNCHRONOUS \
3032 && !defined(SQLITE_OMIT_WAL)
3033 static void setDefaultSyncFlag(BtShared
*pBt
, u8 safety_level
){
3036 if( (db
=pBt
->db
)!=0 && (pDb
=db
->aDb
)!=0 ){
3037 while( pDb
->pBt
==0 || pDb
->pBt
->pBt
!=pBt
){ pDb
++; }
3038 if( pDb
->bSyncSet
==0
3039 && pDb
->safety_level
!=safety_level
3042 pDb
->safety_level
= safety_level
;
3043 sqlite3PagerSetFlags(pBt
->pPager
,
3044 pDb
->safety_level
| (db
->flags
& PAGER_FLAGS_MASK
));
3049 # define setDefaultSyncFlag(pBt,safety_level)
3052 /* Forward declaration */
3053 static int newDatabase(BtShared
*);
3057 ** Get a reference to pPage1 of the database file. This will
3058 ** also acquire a readlock on that file.
3060 ** SQLITE_OK is returned on success. If the file is not a
3061 ** well-formed database file, then SQLITE_CORRUPT is returned.
3062 ** SQLITE_BUSY is returned if the database is locked. SQLITE_NOMEM
3063 ** is returned if we run out of memory.
3065 static int lockBtree(BtShared
*pBt
){
3066 int rc
; /* Result code from subfunctions */
3067 MemPage
*pPage1
; /* Page 1 of the database file */
3068 u32 nPage
; /* Number of pages in the database */
3069 u32 nPageFile
= 0; /* Number of pages in the database file */
3070 u32 nPageHeader
; /* Number of pages in the database according to hdr */
3072 assert( sqlite3_mutex_held(pBt
->mutex
) );
3073 assert( pBt
->pPage1
==0 );
3074 rc
= sqlite3PagerSharedLock(pBt
->pPager
);
3075 if( rc
!=SQLITE_OK
) return rc
;
3076 rc
= btreeGetPage(pBt
, 1, &pPage1
, 0);
3077 if( rc
!=SQLITE_OK
) return rc
;
3079 /* Do some checking to help insure the file we opened really is
3080 ** a valid database file.
3082 nPage
= nPageHeader
= get4byte(28+(u8
*)pPage1
->aData
);
3083 sqlite3PagerPagecount(pBt
->pPager
, (int*)&nPageFile
);
3084 if( nPage
==0 || memcmp(24+(u8
*)pPage1
->aData
, 92+(u8
*)pPage1
->aData
,4)!=0 ){
3087 if( (pBt
->db
->flags
& SQLITE_ResetDatabase
)!=0 ){
3093 u8
*page1
= pPage1
->aData
;
3095 /* EVIDENCE-OF: R-43737-39999 Every valid SQLite database file begins
3096 ** with the following 16 bytes (in hex): 53 51 4c 69 74 65 20 66 6f 72 6d
3097 ** 61 74 20 33 00. */
3098 if( memcmp(page1
, zMagicHeader
, 16)!=0 ){
3099 goto page1_init_failed
;
3102 #ifdef SQLITE_OMIT_WAL
3104 pBt
->btsFlags
|= BTS_READ_ONLY
;
3107 goto page1_init_failed
;
3111 pBt
->btsFlags
|= BTS_READ_ONLY
;
3114 goto page1_init_failed
;
3117 /* If the write version is set to 2, this database should be accessed
3118 ** in WAL mode. If the log is not already open, open it now. Then
3119 ** return SQLITE_OK and return without populating BtShared.pPage1.
3120 ** The caller detects this and calls this function again. This is
3121 ** required as the version of page 1 currently in the page1 buffer
3122 ** may not be the latest version - there may be a newer one in the log
3125 if( page1
[19]==2 && (pBt
->btsFlags
& BTS_NO_WAL
)==0 ){
3127 rc
= sqlite3PagerOpenWal(pBt
->pPager
, &isOpen
);
3128 if( rc
!=SQLITE_OK
){
3129 goto page1_init_failed
;
3131 setDefaultSyncFlag(pBt
, SQLITE_DEFAULT_WAL_SYNCHRONOUS
+1);
3133 releasePageOne(pPage1
);
3139 setDefaultSyncFlag(pBt
, SQLITE_DEFAULT_SYNCHRONOUS
+1);
3143 /* EVIDENCE-OF: R-15465-20813 The maximum and minimum embedded payload
3144 ** fractions and the leaf payload fraction values must be 64, 32, and 32.
3146 ** The original design allowed these amounts to vary, but as of
3147 ** version 3.6.0, we require them to be fixed.
3149 if( memcmp(&page1
[21], "\100\040\040",3)!=0 ){
3150 goto page1_init_failed
;
3152 /* EVIDENCE-OF: R-51873-39618 The page size for a database file is
3153 ** determined by the 2-byte integer located at an offset of 16 bytes from
3154 ** the beginning of the database file. */
3155 pageSize
= (page1
[16]<<8) | (page1
[17]<<16);
3156 /* EVIDENCE-OF: R-25008-21688 The size of a page is a power of two
3157 ** between 512 and 65536 inclusive. */
3158 if( ((pageSize
-1)&pageSize
)!=0
3159 || pageSize
>SQLITE_MAX_PAGE_SIZE
3162 goto page1_init_failed
;
3164 pBt
->btsFlags
|= BTS_PAGESIZE_FIXED
;
3165 assert( (pageSize
& 7)==0 );
3166 /* EVIDENCE-OF: R-59310-51205 The "reserved space" size in the 1-byte
3167 ** integer at offset 20 is the number of bytes of space at the end of
3168 ** each page to reserve for extensions.
3170 ** EVIDENCE-OF: R-37497-42412 The size of the reserved region is
3171 ** determined by the one-byte unsigned integer found at an offset of 20
3172 ** into the database file header. */
3173 usableSize
= pageSize
- page1
[20];
3174 if( (u32
)pageSize
!=pBt
->pageSize
){
3175 /* After reading the first page of the database assuming a page size
3176 ** of BtShared.pageSize, we have discovered that the page-size is
3177 ** actually pageSize. Unlock the database, leave pBt->pPage1 at
3178 ** zero and return SQLITE_OK. The caller will call this function
3179 ** again with the correct page-size.
3181 releasePageOne(pPage1
);
3182 pBt
->usableSize
= usableSize
;
3183 pBt
->pageSize
= pageSize
;
3185 rc
= sqlite3PagerSetPagesize(pBt
->pPager
, &pBt
->pageSize
,
3186 pageSize
-usableSize
);
3189 if( sqlite3WritableSchema(pBt
->db
)==0 && nPage
>nPageFile
){
3190 rc
= SQLITE_CORRUPT_BKPT
;
3191 goto page1_init_failed
;
3193 /* EVIDENCE-OF: R-28312-64704 However, the usable size is not allowed to
3194 ** be less than 480. In other words, if the page size is 512, then the
3195 ** reserved space size cannot exceed 32. */
3196 if( usableSize
<480 ){
3197 goto page1_init_failed
;
3199 pBt
->pageSize
= pageSize
;
3200 pBt
->usableSize
= usableSize
;
3201 #ifndef SQLITE_OMIT_AUTOVACUUM
3202 pBt
->autoVacuum
= (get4byte(&page1
[36 + 4*4])?1:0);
3203 pBt
->incrVacuum
= (get4byte(&page1
[36 + 7*4])?1:0);
3207 /* maxLocal is the maximum amount of payload to store locally for
3208 ** a cell. Make sure it is small enough so that at least minFanout
3209 ** cells can will fit on one page. We assume a 10-byte page header.
3210 ** Besides the payload, the cell must store:
3211 ** 2-byte pointer to the cell
3212 ** 4-byte child pointer
3213 ** 9-byte nKey value
3214 ** 4-byte nData value
3215 ** 4-byte overflow page pointer
3216 ** So a cell consists of a 2-byte pointer, a header which is as much as
3217 ** 17 bytes long, 0 to N bytes of payload, and an optional 4 byte overflow
3220 pBt
->maxLocal
= (u16
)((pBt
->usableSize
-12)*64/255 - 23);
3221 pBt
->minLocal
= (u16
)((pBt
->usableSize
-12)*32/255 - 23);
3222 pBt
->maxLeaf
= (u16
)(pBt
->usableSize
- 35);
3223 pBt
->minLeaf
= (u16
)((pBt
->usableSize
-12)*32/255 - 23);
3224 if( pBt
->maxLocal
>127 ){
3225 pBt
->max1bytePayload
= 127;
3227 pBt
->max1bytePayload
= (u8
)pBt
->maxLocal
;
3229 assert( pBt
->maxLeaf
+ 23 <= MX_CELL_SIZE(pBt
) );
3230 pBt
->pPage1
= pPage1
;
3235 releasePageOne(pPage1
);
3242 ** Return the number of cursors open on pBt. This is for use
3243 ** in assert() expressions, so it is only compiled if NDEBUG is not
3246 ** Only write cursors are counted if wrOnly is true. If wrOnly is
3247 ** false then all cursors are counted.
3249 ** For the purposes of this routine, a cursor is any cursor that
3250 ** is capable of reading or writing to the database. Cursors that
3251 ** have been tripped into the CURSOR_FAULT state are not counted.
3253 static int countValidCursors(BtShared
*pBt
, int wrOnly
){
3256 for(pCur
=pBt
->pCursor
; pCur
; pCur
=pCur
->pNext
){
3257 if( (wrOnly
==0 || (pCur
->curFlags
& BTCF_WriteFlag
)!=0)
3258 && pCur
->eState
!=CURSOR_FAULT
) r
++;
3265 ** If there are no outstanding cursors and we are not in the middle
3266 ** of a transaction but there is a read lock on the database, then
3267 ** this routine unrefs the first page of the database file which
3268 ** has the effect of releasing the read lock.
3270 ** If there is a transaction in progress, this routine is a no-op.
3272 static void unlockBtreeIfUnused(BtShared
*pBt
){
3273 assert( sqlite3_mutex_held(pBt
->mutex
) );
3274 assert( countValidCursors(pBt
,0)==0 || pBt
->inTransaction
>TRANS_NONE
);
3275 if( pBt
->inTransaction
==TRANS_NONE
&& pBt
->pPage1
!=0 ){
3276 MemPage
*pPage1
= pBt
->pPage1
;
3277 assert( pPage1
->aData
);
3278 assert( sqlite3PagerRefcount(pBt
->pPager
)==1 );
3280 releasePageOne(pPage1
);
3285 ** If pBt points to an empty file then convert that empty file
3286 ** into a new empty database by initializing the first page of
3289 static int newDatabase(BtShared
*pBt
){
3291 unsigned char *data
;
3294 assert( sqlite3_mutex_held(pBt
->mutex
) );
3301 rc
= sqlite3PagerWrite(pP1
->pDbPage
);
3303 memcpy(data
, zMagicHeader
, sizeof(zMagicHeader
));
3304 assert( sizeof(zMagicHeader
)==16 );
3305 data
[16] = (u8
)((pBt
->pageSize
>>8)&0xff);
3306 data
[17] = (u8
)((pBt
->pageSize
>>16)&0xff);
3309 assert( pBt
->usableSize
<=pBt
->pageSize
&& pBt
->usableSize
+255>=pBt
->pageSize
);
3310 data
[20] = (u8
)(pBt
->pageSize
- pBt
->usableSize
);
3314 memset(&data
[24], 0, 100-24);
3315 zeroPage(pP1
, PTF_INTKEY
|PTF_LEAF
|PTF_LEAFDATA
);
3316 pBt
->btsFlags
|= BTS_PAGESIZE_FIXED
;
3317 #ifndef SQLITE_OMIT_AUTOVACUUM
3318 assert( pBt
->autoVacuum
==1 || pBt
->autoVacuum
==0 );
3319 assert( pBt
->incrVacuum
==1 || pBt
->incrVacuum
==0 );
3320 put4byte(&data
[36 + 4*4], pBt
->autoVacuum
);
3321 put4byte(&data
[36 + 7*4], pBt
->incrVacuum
);
3329 ** Initialize the first page of the database file (creating a database
3330 ** consisting of a single page and no schema objects). Return SQLITE_OK
3331 ** if successful, or an SQLite error code otherwise.
3333 int sqlite3BtreeNewDb(Btree
*p
){
3335 sqlite3BtreeEnter(p
);
3337 rc
= newDatabase(p
->pBt
);
3338 sqlite3BtreeLeave(p
);
3343 ** Attempt to start a new transaction. A write-transaction
3344 ** is started if the second argument is nonzero, otherwise a read-
3345 ** transaction. If the second argument is 2 or more and exclusive
3346 ** transaction is started, meaning that no other process is allowed
3347 ** to access the database. A preexisting transaction may not be
3348 ** upgraded to exclusive by calling this routine a second time - the
3349 ** exclusivity flag only works for a new transaction.
3351 ** A write-transaction must be started before attempting any
3352 ** changes to the database. None of the following routines
3353 ** will work unless a transaction is started first:
3355 ** sqlite3BtreeCreateTable()
3356 ** sqlite3BtreeCreateIndex()
3357 ** sqlite3BtreeClearTable()
3358 ** sqlite3BtreeDropTable()
3359 ** sqlite3BtreeInsert()
3360 ** sqlite3BtreeDelete()
3361 ** sqlite3BtreeUpdateMeta()
3363 ** If an initial attempt to acquire the lock fails because of lock contention
3364 ** and the database was previously unlocked, then invoke the busy handler
3365 ** if there is one. But if there was previously a read-lock, do not
3366 ** invoke the busy handler - just return SQLITE_BUSY. SQLITE_BUSY is
3367 ** returned when there is already a read-lock in order to avoid a deadlock.
3369 ** Suppose there are two processes A and B. A has a read lock and B has
3370 ** a reserved lock. B tries to promote to exclusive but is blocked because
3371 ** of A's read lock. A tries to promote to reserved but is blocked by B.
3372 ** One or the other of the two processes must give way or there can be
3373 ** no progress. By returning SQLITE_BUSY and not invoking the busy callback
3374 ** when A already has a read lock, we encourage A to give up and let B
3377 int sqlite3BtreeBeginTrans(Btree
*p
, int wrflag
, int *pSchemaVersion
){
3378 BtShared
*pBt
= p
->pBt
;
3381 sqlite3BtreeEnter(p
);
3384 /* If the btree is already in a write-transaction, or it
3385 ** is already in a read-transaction and a read-transaction
3386 ** is requested, this is a no-op.
3388 if( p
->inTrans
==TRANS_WRITE
|| (p
->inTrans
==TRANS_READ
&& !wrflag
) ){
3391 assert( pBt
->inTransaction
==TRANS_WRITE
|| IfNotOmitAV(pBt
->bDoTruncate
)==0 );
3393 if( (p
->db
->flags
& SQLITE_ResetDatabase
)
3394 && sqlite3PagerIsreadonly(pBt
->pPager
)==0
3396 pBt
->btsFlags
&= ~BTS_READ_ONLY
;
3399 /* Write transactions are not possible on a read-only database */
3400 if( (pBt
->btsFlags
& BTS_READ_ONLY
)!=0 && wrflag
){
3401 rc
= SQLITE_READONLY
;
3405 #ifndef SQLITE_OMIT_SHARED_CACHE
3407 sqlite3
*pBlock
= 0;
3408 /* If another database handle has already opened a write transaction
3409 ** on this shared-btree structure and a second write transaction is
3410 ** requested, return SQLITE_LOCKED.
3412 if( (wrflag
&& pBt
->inTransaction
==TRANS_WRITE
)
3413 || (pBt
->btsFlags
& BTS_PENDING
)!=0
3415 pBlock
= pBt
->pWriter
->db
;
3416 }else if( wrflag
>1 ){
3418 for(pIter
=pBt
->pLock
; pIter
; pIter
=pIter
->pNext
){
3419 if( pIter
->pBtree
!=p
){
3420 pBlock
= pIter
->pBtree
->db
;
3426 sqlite3ConnectionBlocked(p
->db
, pBlock
);
3427 rc
= SQLITE_LOCKED_SHAREDCACHE
;
3433 /* Any read-only or read-write transaction implies a read-lock on
3434 ** page 1. So if some other shared-cache client already has a write-lock
3435 ** on page 1, the transaction cannot be opened. */
3436 rc
= querySharedCacheTableLock(p
, MASTER_ROOT
, READ_LOCK
);
3437 if( SQLITE_OK
!=rc
) goto trans_begun
;
3439 pBt
->btsFlags
&= ~BTS_INITIALLY_EMPTY
;
3440 if( pBt
->nPage
==0 ) pBt
->btsFlags
|= BTS_INITIALLY_EMPTY
;
3442 /* Call lockBtree() until either pBt->pPage1 is populated or
3443 ** lockBtree() returns something other than SQLITE_OK. lockBtree()
3444 ** may return SQLITE_OK but leave pBt->pPage1 set to 0 if after
3445 ** reading page 1 it discovers that the page-size of the database
3446 ** file is not pBt->pageSize. In this case lockBtree() will update
3447 ** pBt->pageSize to the page-size of the file on disk.
3449 while( pBt
->pPage1
==0 && SQLITE_OK
==(rc
= lockBtree(pBt
)) );
3451 if( rc
==SQLITE_OK
&& wrflag
){
3452 if( (pBt
->btsFlags
& BTS_READ_ONLY
)!=0 ){
3453 rc
= SQLITE_READONLY
;
3455 rc
= sqlite3PagerBegin(pBt
->pPager
,wrflag
>1,sqlite3TempInMemory(p
->db
));
3456 if( rc
==SQLITE_OK
){
3457 rc
= newDatabase(pBt
);
3458 }else if( rc
==SQLITE_BUSY_SNAPSHOT
&& pBt
->inTransaction
==TRANS_NONE
){
3459 /* if there was no transaction opened when this function was
3460 ** called and SQLITE_BUSY_SNAPSHOT is returned, change the error
3461 ** code to SQLITE_BUSY. */
3467 if( rc
!=SQLITE_OK
){
3468 unlockBtreeIfUnused(pBt
);
3470 }while( (rc
&0xFF)==SQLITE_BUSY
&& pBt
->inTransaction
==TRANS_NONE
&&
3471 btreeInvokeBusyHandler(pBt
) );
3472 sqlite3PagerResetLockTimeout(pBt
->pPager
);
3474 if( rc
==SQLITE_OK
){
3475 if( p
->inTrans
==TRANS_NONE
){
3476 pBt
->nTransaction
++;
3477 #ifndef SQLITE_OMIT_SHARED_CACHE
3479 assert( p
->lock
.pBtree
==p
&& p
->lock
.iTable
==1 );
3480 p
->lock
.eLock
= READ_LOCK
;
3481 p
->lock
.pNext
= pBt
->pLock
;
3482 pBt
->pLock
= &p
->lock
;
3486 p
->inTrans
= (wrflag
?TRANS_WRITE
:TRANS_READ
);
3487 if( p
->inTrans
>pBt
->inTransaction
){
3488 pBt
->inTransaction
= p
->inTrans
;
3491 MemPage
*pPage1
= pBt
->pPage1
;
3492 #ifndef SQLITE_OMIT_SHARED_CACHE
3493 assert( !pBt
->pWriter
);
3495 pBt
->btsFlags
&= ~BTS_EXCLUSIVE
;
3496 if( wrflag
>1 ) pBt
->btsFlags
|= BTS_EXCLUSIVE
;
3499 /* If the db-size header field is incorrect (as it may be if an old
3500 ** client has been writing the database file), update it now. Doing
3501 ** this sooner rather than later means the database size can safely
3502 ** re-read the database size from page 1 if a savepoint or transaction
3503 ** rollback occurs within the transaction.
3505 if( pBt
->nPage
!=get4byte(&pPage1
->aData
[28]) ){
3506 rc
= sqlite3PagerWrite(pPage1
->pDbPage
);
3507 if( rc
==SQLITE_OK
){
3508 put4byte(&pPage1
->aData
[28], pBt
->nPage
);
3515 if( rc
==SQLITE_OK
){
3516 if( pSchemaVersion
){
3517 *pSchemaVersion
= get4byte(&pBt
->pPage1
->aData
[40]);
3520 /* This call makes sure that the pager has the correct number of
3521 ** open savepoints. If the second parameter is greater than 0 and
3522 ** the sub-journal is not already open, then it will be opened here.
3524 rc
= sqlite3PagerOpenSavepoint(pBt
->pPager
, p
->db
->nSavepoint
);
3529 sqlite3BtreeLeave(p
);
3533 #ifndef SQLITE_OMIT_AUTOVACUUM
3536 ** Set the pointer-map entries for all children of page pPage. Also, if
3537 ** pPage contains cells that point to overflow pages, set the pointer
3538 ** map entries for the overflow pages as well.
3540 static int setChildPtrmaps(MemPage
*pPage
){
3541 int i
; /* Counter variable */
3542 int nCell
; /* Number of cells in page pPage */
3543 int rc
; /* Return code */
3544 BtShared
*pBt
= pPage
->pBt
;
3545 Pgno pgno
= pPage
->pgno
;
3547 assert( sqlite3_mutex_held(pPage
->pBt
->mutex
) );
3548 rc
= pPage
->isInit
? SQLITE_OK
: btreeInitPage(pPage
);
3549 if( rc
!=SQLITE_OK
) return rc
;
3550 nCell
= pPage
->nCell
;
3552 for(i
=0; i
<nCell
; i
++){
3553 u8
*pCell
= findCell(pPage
, i
);
3555 ptrmapPutOvflPtr(pPage
, pPage
, pCell
, &rc
);
3558 Pgno childPgno
= get4byte(pCell
);
3559 ptrmapPut(pBt
, childPgno
, PTRMAP_BTREE
, pgno
, &rc
);
3564 Pgno childPgno
= get4byte(&pPage
->aData
[pPage
->hdrOffset
+8]);
3565 ptrmapPut(pBt
, childPgno
, PTRMAP_BTREE
, pgno
, &rc
);
3572 ** Somewhere on pPage is a pointer to page iFrom. Modify this pointer so
3573 ** that it points to iTo. Parameter eType describes the type of pointer to
3574 ** be modified, as follows:
3576 ** PTRMAP_BTREE: pPage is a btree-page. The pointer points at a child
3579 ** PTRMAP_OVERFLOW1: pPage is a btree-page. The pointer points at an overflow
3580 ** page pointed to by one of the cells on pPage.
3582 ** PTRMAP_OVERFLOW2: pPage is an overflow-page. The pointer points at the next
3583 ** overflow page in the list.
3585 static int modifyPagePointer(MemPage
*pPage
, Pgno iFrom
, Pgno iTo
, u8 eType
){
3586 assert( sqlite3_mutex_held(pPage
->pBt
->mutex
) );
3587 assert( sqlite3PagerIswriteable(pPage
->pDbPage
) );
3588 if( eType
==PTRMAP_OVERFLOW2
){
3589 /* The pointer is always the first 4 bytes of the page in this case. */
3590 if( get4byte(pPage
->aData
)!=iFrom
){
3591 return SQLITE_CORRUPT_PAGE(pPage
);
3593 put4byte(pPage
->aData
, iTo
);
3599 rc
= pPage
->isInit
? SQLITE_OK
: btreeInitPage(pPage
);
3601 nCell
= pPage
->nCell
;
3603 for(i
=0; i
<nCell
; i
++){
3604 u8
*pCell
= findCell(pPage
, i
);
3605 if( eType
==PTRMAP_OVERFLOW1
){
3607 pPage
->xParseCell(pPage
, pCell
, &info
);
3608 if( info
.nLocal
<info
.nPayload
){
3609 if( pCell
+info
.nSize
> pPage
->aData
+pPage
->pBt
->usableSize
){
3610 return SQLITE_CORRUPT_PAGE(pPage
);
3612 if( iFrom
==get4byte(pCell
+info
.nSize
-4) ){
3613 put4byte(pCell
+info
.nSize
-4, iTo
);
3618 if( get4byte(pCell
)==iFrom
){
3619 put4byte(pCell
, iTo
);
3626 if( eType
!=PTRMAP_BTREE
||
3627 get4byte(&pPage
->aData
[pPage
->hdrOffset
+8])!=iFrom
){
3628 return SQLITE_CORRUPT_PAGE(pPage
);
3630 put4byte(&pPage
->aData
[pPage
->hdrOffset
+8], iTo
);
3638 ** Move the open database page pDbPage to location iFreePage in the
3639 ** database. The pDbPage reference remains valid.
3641 ** The isCommit flag indicates that there is no need to remember that
3642 ** the journal needs to be sync()ed before database page pDbPage->pgno
3643 ** can be written to. The caller has already promised not to write to that
3646 static int relocatePage(
3647 BtShared
*pBt
, /* Btree */
3648 MemPage
*pDbPage
, /* Open page to move */
3649 u8 eType
, /* Pointer map 'type' entry for pDbPage */
3650 Pgno iPtrPage
, /* Pointer map 'page-no' entry for pDbPage */
3651 Pgno iFreePage
, /* The location to move pDbPage to */
3652 int isCommit
/* isCommit flag passed to sqlite3PagerMovepage */
3654 MemPage
*pPtrPage
; /* The page that contains a pointer to pDbPage */
3655 Pgno iDbPage
= pDbPage
->pgno
;
3656 Pager
*pPager
= pBt
->pPager
;
3659 assert( eType
==PTRMAP_OVERFLOW2
|| eType
==PTRMAP_OVERFLOW1
||
3660 eType
==PTRMAP_BTREE
|| eType
==PTRMAP_ROOTPAGE
);
3661 assert( sqlite3_mutex_held(pBt
->mutex
) );
3662 assert( pDbPage
->pBt
==pBt
);
3663 if( iDbPage
<3 ) return SQLITE_CORRUPT_BKPT
;
3665 /* Move page iDbPage from its current location to page number iFreePage */
3666 TRACE(("AUTOVACUUM: Moving %d to free page %d (ptr page %d type %d)\n",
3667 iDbPage
, iFreePage
, iPtrPage
, eType
));
3668 rc
= sqlite3PagerMovepage(pPager
, pDbPage
->pDbPage
, iFreePage
, isCommit
);
3669 if( rc
!=SQLITE_OK
){
3672 pDbPage
->pgno
= iFreePage
;
3674 /* If pDbPage was a btree-page, then it may have child pages and/or cells
3675 ** that point to overflow pages. The pointer map entries for all these
3676 ** pages need to be changed.
3678 ** If pDbPage is an overflow page, then the first 4 bytes may store a
3679 ** pointer to a subsequent overflow page. If this is the case, then
3680 ** the pointer map needs to be updated for the subsequent overflow page.
3682 if( eType
==PTRMAP_BTREE
|| eType
==PTRMAP_ROOTPAGE
){
3683 rc
= setChildPtrmaps(pDbPage
);
3684 if( rc
!=SQLITE_OK
){
3688 Pgno nextOvfl
= get4byte(pDbPage
->aData
);
3690 ptrmapPut(pBt
, nextOvfl
, PTRMAP_OVERFLOW2
, iFreePage
, &rc
);
3691 if( rc
!=SQLITE_OK
){
3697 /* Fix the database pointer on page iPtrPage that pointed at iDbPage so
3698 ** that it points at iFreePage. Also fix the pointer map entry for
3701 if( eType
!=PTRMAP_ROOTPAGE
){
3702 rc
= btreeGetPage(pBt
, iPtrPage
, &pPtrPage
, 0);
3703 if( rc
!=SQLITE_OK
){
3706 rc
= sqlite3PagerWrite(pPtrPage
->pDbPage
);
3707 if( rc
!=SQLITE_OK
){
3708 releasePage(pPtrPage
);
3711 rc
= modifyPagePointer(pPtrPage
, iDbPage
, iFreePage
, eType
);
3712 releasePage(pPtrPage
);
3713 if( rc
==SQLITE_OK
){
3714 ptrmapPut(pBt
, iFreePage
, eType
, iPtrPage
, &rc
);
3720 /* Forward declaration required by incrVacuumStep(). */
3721 static int allocateBtreePage(BtShared
*, MemPage
**, Pgno
*, Pgno
, u8
);
3724 ** Perform a single step of an incremental-vacuum. If successful, return
3725 ** SQLITE_OK. If there is no work to do (and therefore no point in
3726 ** calling this function again), return SQLITE_DONE. Or, if an error
3727 ** occurs, return some other error code.
3729 ** More specifically, this function attempts to re-organize the database so
3730 ** that the last page of the file currently in use is no longer in use.
3732 ** Parameter nFin is the number of pages that this database would contain
3733 ** were this function called until it returns SQLITE_DONE.
3735 ** If the bCommit parameter is non-zero, this function assumes that the
3736 ** caller will keep calling incrVacuumStep() until it returns SQLITE_DONE
3737 ** or an error. bCommit is passed true for an auto-vacuum-on-commit
3738 ** operation, or false for an incremental vacuum.
3740 static int incrVacuumStep(BtShared
*pBt
, Pgno nFin
, Pgno iLastPg
, int bCommit
){
3741 Pgno nFreeList
; /* Number of pages still on the free-list */
3744 assert( sqlite3_mutex_held(pBt
->mutex
) );
3745 assert( iLastPg
>nFin
);
3747 if( !PTRMAP_ISPAGE(pBt
, iLastPg
) && iLastPg
!=PENDING_BYTE_PAGE(pBt
) ){
3751 nFreeList
= get4byte(&pBt
->pPage1
->aData
[36]);
3756 rc
= ptrmapGet(pBt
, iLastPg
, &eType
, &iPtrPage
);
3757 if( rc
!=SQLITE_OK
){
3760 if( eType
==PTRMAP_ROOTPAGE
){
3761 return SQLITE_CORRUPT_BKPT
;
3764 if( eType
==PTRMAP_FREEPAGE
){
3766 /* Remove the page from the files free-list. This is not required
3767 ** if bCommit is non-zero. In that case, the free-list will be
3768 ** truncated to zero after this function returns, so it doesn't
3769 ** matter if it still contains some garbage entries.
3773 rc
= allocateBtreePage(pBt
, &pFreePg
, &iFreePg
, iLastPg
, BTALLOC_EXACT
);
3774 if( rc
!=SQLITE_OK
){
3777 assert( iFreePg
==iLastPg
);
3778 releasePage(pFreePg
);
3781 Pgno iFreePg
; /* Index of free page to move pLastPg to */
3783 u8 eMode
= BTALLOC_ANY
; /* Mode parameter for allocateBtreePage() */
3784 Pgno iNear
= 0; /* nearby parameter for allocateBtreePage() */
3786 rc
= btreeGetPage(pBt
, iLastPg
, &pLastPg
, 0);
3787 if( rc
!=SQLITE_OK
){
3791 /* If bCommit is zero, this loop runs exactly once and page pLastPg
3792 ** is swapped with the first free page pulled off the free list.
3794 ** On the other hand, if bCommit is greater than zero, then keep
3795 ** looping until a free-page located within the first nFin pages
3796 ** of the file is found.
3804 rc
= allocateBtreePage(pBt
, &pFreePg
, &iFreePg
, iNear
, eMode
);
3805 if( rc
!=SQLITE_OK
){
3806 releasePage(pLastPg
);
3809 releasePage(pFreePg
);
3810 }while( bCommit
&& iFreePg
>nFin
);
3811 assert( iFreePg
<iLastPg
);
3813 rc
= relocatePage(pBt
, pLastPg
, eType
, iPtrPage
, iFreePg
, bCommit
);
3814 releasePage(pLastPg
);
3815 if( rc
!=SQLITE_OK
){
3824 }while( iLastPg
==PENDING_BYTE_PAGE(pBt
) || PTRMAP_ISPAGE(pBt
, iLastPg
) );
3825 pBt
->bDoTruncate
= 1;
3826 pBt
->nPage
= iLastPg
;
3832 ** The database opened by the first argument is an auto-vacuum database
3833 ** nOrig pages in size containing nFree free pages. Return the expected
3834 ** size of the database in pages following an auto-vacuum operation.
3836 static Pgno
finalDbSize(BtShared
*pBt
, Pgno nOrig
, Pgno nFree
){
3837 int nEntry
; /* Number of entries on one ptrmap page */
3838 Pgno nPtrmap
; /* Number of PtrMap pages to be freed */
3839 Pgno nFin
; /* Return value */
3841 nEntry
= pBt
->usableSize
/5;
3842 nPtrmap
= (nFree
-nOrig
+PTRMAP_PAGENO(pBt
, nOrig
)+nEntry
)/nEntry
;
3843 nFin
= nOrig
- nFree
- nPtrmap
;
3844 if( nOrig
>PENDING_BYTE_PAGE(pBt
) && nFin
<PENDING_BYTE_PAGE(pBt
) ){
3847 while( PTRMAP_ISPAGE(pBt
, nFin
) || nFin
==PENDING_BYTE_PAGE(pBt
) ){
3855 ** A write-transaction must be opened before calling this function.
3856 ** It performs a single unit of work towards an incremental vacuum.
3858 ** If the incremental vacuum is finished after this function has run,
3859 ** SQLITE_DONE is returned. If it is not finished, but no error occurred,
3860 ** SQLITE_OK is returned. Otherwise an SQLite error code.
3862 int sqlite3BtreeIncrVacuum(Btree
*p
){
3864 BtShared
*pBt
= p
->pBt
;
3866 sqlite3BtreeEnter(p
);
3867 assert( pBt
->inTransaction
==TRANS_WRITE
&& p
->inTrans
==TRANS_WRITE
);
3868 if( !pBt
->autoVacuum
){
3871 Pgno nOrig
= btreePagecount(pBt
);
3872 Pgno nFree
= get4byte(&pBt
->pPage1
->aData
[36]);
3873 Pgno nFin
= finalDbSize(pBt
, nOrig
, nFree
);
3876 rc
= SQLITE_CORRUPT_BKPT
;
3877 }else if( nFree
>0 ){
3878 rc
= saveAllCursors(pBt
, 0, 0);
3879 if( rc
==SQLITE_OK
){
3880 invalidateAllOverflowCache(pBt
);
3881 rc
= incrVacuumStep(pBt
, nFin
, nOrig
, 0);
3883 if( rc
==SQLITE_OK
){
3884 rc
= sqlite3PagerWrite(pBt
->pPage1
->pDbPage
);
3885 put4byte(&pBt
->pPage1
->aData
[28], pBt
->nPage
);
3891 sqlite3BtreeLeave(p
);
3896 ** This routine is called prior to sqlite3PagerCommit when a transaction
3897 ** is committed for an auto-vacuum database.
3899 ** If SQLITE_OK is returned, then *pnTrunc is set to the number of pages
3900 ** the database file should be truncated to during the commit process.
3901 ** i.e. the database has been reorganized so that only the first *pnTrunc
3902 ** pages are in use.
3904 static int autoVacuumCommit(BtShared
*pBt
){
3906 Pager
*pPager
= pBt
->pPager
;
3907 VVA_ONLY( int nRef
= sqlite3PagerRefcount(pPager
); )
3909 assert( sqlite3_mutex_held(pBt
->mutex
) );
3910 invalidateAllOverflowCache(pBt
);
3911 assert(pBt
->autoVacuum
);
3912 if( !pBt
->incrVacuum
){
3913 Pgno nFin
; /* Number of pages in database after autovacuuming */
3914 Pgno nFree
; /* Number of pages on the freelist initially */
3915 Pgno iFree
; /* The next page to be freed */
3916 Pgno nOrig
; /* Database size before freeing */
3918 nOrig
= btreePagecount(pBt
);
3919 if( PTRMAP_ISPAGE(pBt
, nOrig
) || nOrig
==PENDING_BYTE_PAGE(pBt
) ){
3920 /* It is not possible to create a database for which the final page
3921 ** is either a pointer-map page or the pending-byte page. If one
3922 ** is encountered, this indicates corruption.
3924 return SQLITE_CORRUPT_BKPT
;
3927 nFree
= get4byte(&pBt
->pPage1
->aData
[36]);
3928 nFin
= finalDbSize(pBt
, nOrig
, nFree
);
3929 if( nFin
>nOrig
) return SQLITE_CORRUPT_BKPT
;
3931 rc
= saveAllCursors(pBt
, 0, 0);
3933 for(iFree
=nOrig
; iFree
>nFin
&& rc
==SQLITE_OK
; iFree
--){
3934 rc
= incrVacuumStep(pBt
, nFin
, iFree
, 1);
3936 if( (rc
==SQLITE_DONE
|| rc
==SQLITE_OK
) && nFree
>0 ){
3937 rc
= sqlite3PagerWrite(pBt
->pPage1
->pDbPage
);
3938 put4byte(&pBt
->pPage1
->aData
[32], 0);
3939 put4byte(&pBt
->pPage1
->aData
[36], 0);
3940 put4byte(&pBt
->pPage1
->aData
[28], nFin
);
3941 pBt
->bDoTruncate
= 1;
3944 if( rc
!=SQLITE_OK
){
3945 sqlite3PagerRollback(pPager
);
3949 assert( nRef
>=sqlite3PagerRefcount(pPager
) );
3953 #else /* ifndef SQLITE_OMIT_AUTOVACUUM */
3954 # define setChildPtrmaps(x) SQLITE_OK
3958 ** This routine does the first phase of a two-phase commit. This routine
3959 ** causes a rollback journal to be created (if it does not already exist)
3960 ** and populated with enough information so that if a power loss occurs
3961 ** the database can be restored to its original state by playing back
3962 ** the journal. Then the contents of the journal are flushed out to
3963 ** the disk. After the journal is safely on oxide, the changes to the
3964 ** database are written into the database file and flushed to oxide.
3965 ** At the end of this call, the rollback journal still exists on the
3966 ** disk and we are still holding all locks, so the transaction has not
3967 ** committed. See sqlite3BtreeCommitPhaseTwo() for the second phase of the
3970 ** This call is a no-op if no write-transaction is currently active on pBt.
3972 ** Otherwise, sync the database file for the btree pBt. zMaster points to
3973 ** the name of a master journal file that should be written into the
3974 ** individual journal file, or is NULL, indicating no master journal file
3975 ** (single database transaction).
3977 ** When this is called, the master journal should already have been
3978 ** created, populated with this journal pointer and synced to disk.
3980 ** Once this is routine has returned, the only thing required to commit
3981 ** the write-transaction for this database file is to delete the journal.
3983 int sqlite3BtreeCommitPhaseOne(Btree
*p
, const char *zMaster
){
3985 if( p
->inTrans
==TRANS_WRITE
){
3986 BtShared
*pBt
= p
->pBt
;
3987 sqlite3BtreeEnter(p
);
3988 #ifndef SQLITE_OMIT_AUTOVACUUM
3989 if( pBt
->autoVacuum
){
3990 rc
= autoVacuumCommit(pBt
);
3991 if( rc
!=SQLITE_OK
){
3992 sqlite3BtreeLeave(p
);
3996 if( pBt
->bDoTruncate
){
3997 sqlite3PagerTruncateImage(pBt
->pPager
, pBt
->nPage
);
4000 rc
= sqlite3PagerCommitPhaseOne(pBt
->pPager
, zMaster
, 0);
4001 sqlite3BtreeLeave(p
);
4007 ** This function is called from both BtreeCommitPhaseTwo() and BtreeRollback()
4008 ** at the conclusion of a transaction.
4010 static void btreeEndTransaction(Btree
*p
){
4011 BtShared
*pBt
= p
->pBt
;
4012 sqlite3
*db
= p
->db
;
4013 assert( sqlite3BtreeHoldsMutex(p
) );
4015 #ifndef SQLITE_OMIT_AUTOVACUUM
4016 pBt
->bDoTruncate
= 0;
4018 if( p
->inTrans
>TRANS_NONE
&& db
->nVdbeRead
>1 ){
4019 /* If there are other active statements that belong to this database
4020 ** handle, downgrade to a read-only transaction. The other statements
4021 ** may still be reading from the database. */
4022 downgradeAllSharedCacheTableLocks(p
);
4023 p
->inTrans
= TRANS_READ
;
4025 /* If the handle had any kind of transaction open, decrement the
4026 ** transaction count of the shared btree. If the transaction count
4027 ** reaches 0, set the shared state to TRANS_NONE. The unlockBtreeIfUnused()
4028 ** call below will unlock the pager. */
4029 if( p
->inTrans
!=TRANS_NONE
){
4030 clearAllSharedCacheTableLocks(p
);
4031 pBt
->nTransaction
--;
4032 if( 0==pBt
->nTransaction
){
4033 pBt
->inTransaction
= TRANS_NONE
;
4037 /* Set the current transaction state to TRANS_NONE and unlock the
4038 ** pager if this call closed the only read or write transaction. */
4039 p
->inTrans
= TRANS_NONE
;
4040 unlockBtreeIfUnused(pBt
);
4047 ** Commit the transaction currently in progress.
4049 ** This routine implements the second phase of a 2-phase commit. The
4050 ** sqlite3BtreeCommitPhaseOne() routine does the first phase and should
4051 ** be invoked prior to calling this routine. The sqlite3BtreeCommitPhaseOne()
4052 ** routine did all the work of writing information out to disk and flushing the
4053 ** contents so that they are written onto the disk platter. All this
4054 ** routine has to do is delete or truncate or zero the header in the
4055 ** the rollback journal (which causes the transaction to commit) and
4058 ** Normally, if an error occurs while the pager layer is attempting to
4059 ** finalize the underlying journal file, this function returns an error and
4060 ** the upper layer will attempt a rollback. However, if the second argument
4061 ** is non-zero then this b-tree transaction is part of a multi-file
4062 ** transaction. In this case, the transaction has already been committed
4063 ** (by deleting a master journal file) and the caller will ignore this
4064 ** functions return code. So, even if an error occurs in the pager layer,
4065 ** reset the b-tree objects internal state to indicate that the write
4066 ** transaction has been closed. This is quite safe, as the pager will have
4067 ** transitioned to the error state.
4069 ** This will release the write lock on the database file. If there
4070 ** are no active cursors, it also releases the read lock.
4072 int sqlite3BtreeCommitPhaseTwo(Btree
*p
, int bCleanup
){
4074 if( p
->inTrans
==TRANS_NONE
) return SQLITE_OK
;
4075 sqlite3BtreeEnter(p
);
4078 /* If the handle has a write-transaction open, commit the shared-btrees
4079 ** transaction and set the shared state to TRANS_READ.
4081 if( p
->inTrans
==TRANS_WRITE
){
4083 BtShared
*pBt
= p
->pBt
;
4084 assert( pBt
->inTransaction
==TRANS_WRITE
);
4085 assert( pBt
->nTransaction
>0 );
4086 rc
= sqlite3PagerCommitPhaseTwo(pBt
->pPager
);
4087 if( rc
!=SQLITE_OK
&& bCleanup
==0 ){
4088 sqlite3BtreeLeave(p
);
4091 p
->iDataVersion
--; /* Compensate for pPager->iDataVersion++; */
4092 pBt
->inTransaction
= TRANS_READ
;
4093 btreeClearHasContent(pBt
);
4096 btreeEndTransaction(p
);
4097 sqlite3BtreeLeave(p
);
4102 ** Do both phases of a commit.
4104 int sqlite3BtreeCommit(Btree
*p
){
4106 sqlite3BtreeEnter(p
);
4107 rc
= sqlite3BtreeCommitPhaseOne(p
, 0);
4108 if( rc
==SQLITE_OK
){
4109 rc
= sqlite3BtreeCommitPhaseTwo(p
, 0);
4111 sqlite3BtreeLeave(p
);
4116 ** This routine sets the state to CURSOR_FAULT and the error
4117 ** code to errCode for every cursor on any BtShared that pBtree
4118 ** references. Or if the writeOnly flag is set to 1, then only
4119 ** trip write cursors and leave read cursors unchanged.
4121 ** Every cursor is a candidate to be tripped, including cursors
4122 ** that belong to other database connections that happen to be
4123 ** sharing the cache with pBtree.
4125 ** This routine gets called when a rollback occurs. If the writeOnly
4126 ** flag is true, then only write-cursors need be tripped - read-only
4127 ** cursors save their current positions so that they may continue
4128 ** following the rollback. Or, if writeOnly is false, all cursors are
4129 ** tripped. In general, writeOnly is false if the transaction being
4130 ** rolled back modified the database schema. In this case b-tree root
4131 ** pages may be moved or deleted from the database altogether, making
4132 ** it unsafe for read cursors to continue.
4134 ** If the writeOnly flag is true and an error is encountered while
4135 ** saving the current position of a read-only cursor, all cursors,
4136 ** including all read-cursors are tripped.
4138 ** SQLITE_OK is returned if successful, or if an error occurs while
4139 ** saving a cursor position, an SQLite error code.
4141 int sqlite3BtreeTripAllCursors(Btree
*pBtree
, int errCode
, int writeOnly
){
4145 assert( (writeOnly
==0 || writeOnly
==1) && BTCF_WriteFlag
==1 );
4147 sqlite3BtreeEnter(pBtree
);
4148 for(p
=pBtree
->pBt
->pCursor
; p
; p
=p
->pNext
){
4149 if( writeOnly
&& (p
->curFlags
& BTCF_WriteFlag
)==0 ){
4150 if( p
->eState
==CURSOR_VALID
|| p
->eState
==CURSOR_SKIPNEXT
){
4151 rc
= saveCursorPosition(p
);
4152 if( rc
!=SQLITE_OK
){
4153 (void)sqlite3BtreeTripAllCursors(pBtree
, rc
, 0);
4158 sqlite3BtreeClearCursor(p
);
4159 p
->eState
= CURSOR_FAULT
;
4160 p
->skipNext
= errCode
;
4162 btreeReleaseAllCursorPages(p
);
4164 sqlite3BtreeLeave(pBtree
);
4170 ** Set the pBt->nPage field correctly, according to the current
4171 ** state of the database. Assume pBt->pPage1 is valid.
4173 static void btreeSetNPage(BtShared
*pBt
, MemPage
*pPage1
){
4174 int nPage
= get4byte(&pPage1
->aData
[28]);
4175 testcase( nPage
==0 );
4176 if( nPage
==0 ) sqlite3PagerPagecount(pBt
->pPager
, &nPage
);
4177 testcase( pBt
->nPage
!=nPage
);
4182 ** Rollback the transaction in progress.
4184 ** If tripCode is not SQLITE_OK then cursors will be invalidated (tripped).
4185 ** Only write cursors are tripped if writeOnly is true but all cursors are
4186 ** tripped if writeOnly is false. Any attempt to use
4187 ** a tripped cursor will result in an error.
4189 ** This will release the write lock on the database file. If there
4190 ** are no active cursors, it also releases the read lock.
4192 int sqlite3BtreeRollback(Btree
*p
, int tripCode
, int writeOnly
){
4194 BtShared
*pBt
= p
->pBt
;
4197 assert( writeOnly
==1 || writeOnly
==0 );
4198 assert( tripCode
==SQLITE_ABORT_ROLLBACK
|| tripCode
==SQLITE_OK
);
4199 sqlite3BtreeEnter(p
);
4200 if( tripCode
==SQLITE_OK
){
4201 rc
= tripCode
= saveAllCursors(pBt
, 0, 0);
4202 if( rc
) writeOnly
= 0;
4207 int rc2
= sqlite3BtreeTripAllCursors(p
, tripCode
, writeOnly
);
4208 assert( rc
==SQLITE_OK
|| (writeOnly
==0 && rc2
==SQLITE_OK
) );
4209 if( rc2
!=SQLITE_OK
) rc
= rc2
;
4213 if( p
->inTrans
==TRANS_WRITE
){
4216 assert( TRANS_WRITE
==pBt
->inTransaction
);
4217 rc2
= sqlite3PagerRollback(pBt
->pPager
);
4218 if( rc2
!=SQLITE_OK
){
4222 /* The rollback may have destroyed the pPage1->aData value. So
4223 ** call btreeGetPage() on page 1 again to make
4224 ** sure pPage1->aData is set correctly. */
4225 if( btreeGetPage(pBt
, 1, &pPage1
, 0)==SQLITE_OK
){
4226 btreeSetNPage(pBt
, pPage1
);
4227 releasePageOne(pPage1
);
4229 assert( countValidCursors(pBt
, 1)==0 );
4230 pBt
->inTransaction
= TRANS_READ
;
4231 btreeClearHasContent(pBt
);
4234 btreeEndTransaction(p
);
4235 sqlite3BtreeLeave(p
);
4240 ** Start a statement subtransaction. The subtransaction can be rolled
4241 ** back independently of the main transaction. You must start a transaction
4242 ** before starting a subtransaction. The subtransaction is ended automatically
4243 ** if the main transaction commits or rolls back.
4245 ** Statement subtransactions are used around individual SQL statements
4246 ** that are contained within a BEGIN...COMMIT block. If a constraint
4247 ** error occurs within the statement, the effect of that one statement
4248 ** can be rolled back without having to rollback the entire transaction.
4250 ** A statement sub-transaction is implemented as an anonymous savepoint. The
4251 ** value passed as the second parameter is the total number of savepoints,
4252 ** including the new anonymous savepoint, open on the B-Tree. i.e. if there
4253 ** are no active savepoints and no other statement-transactions open,
4254 ** iStatement is 1. This anonymous savepoint can be released or rolled back
4255 ** using the sqlite3BtreeSavepoint() function.
4257 int sqlite3BtreeBeginStmt(Btree
*p
, int iStatement
){
4259 BtShared
*pBt
= p
->pBt
;
4260 sqlite3BtreeEnter(p
);
4261 assert( p
->inTrans
==TRANS_WRITE
);
4262 assert( (pBt
->btsFlags
& BTS_READ_ONLY
)==0 );
4263 assert( iStatement
>0 );
4264 assert( iStatement
>p
->db
->nSavepoint
);
4265 assert( pBt
->inTransaction
==TRANS_WRITE
);
4266 /* At the pager level, a statement transaction is a savepoint with
4267 ** an index greater than all savepoints created explicitly using
4268 ** SQL statements. It is illegal to open, release or rollback any
4269 ** such savepoints while the statement transaction savepoint is active.
4271 rc
= sqlite3PagerOpenSavepoint(pBt
->pPager
, iStatement
);
4272 sqlite3BtreeLeave(p
);
4277 ** The second argument to this function, op, is always SAVEPOINT_ROLLBACK
4278 ** or SAVEPOINT_RELEASE. This function either releases or rolls back the
4279 ** savepoint identified by parameter iSavepoint, depending on the value
4282 ** Normally, iSavepoint is greater than or equal to zero. However, if op is
4283 ** SAVEPOINT_ROLLBACK, then iSavepoint may also be -1. In this case the
4284 ** contents of the entire transaction are rolled back. This is different
4285 ** from a normal transaction rollback, as no locks are released and the
4286 ** transaction remains open.
4288 int sqlite3BtreeSavepoint(Btree
*p
, int op
, int iSavepoint
){
4290 if( p
&& p
->inTrans
==TRANS_WRITE
){
4291 BtShared
*pBt
= p
->pBt
;
4292 assert( op
==SAVEPOINT_RELEASE
|| op
==SAVEPOINT_ROLLBACK
);
4293 assert( iSavepoint
>=0 || (iSavepoint
==-1 && op
==SAVEPOINT_ROLLBACK
) );
4294 sqlite3BtreeEnter(p
);
4295 if( op
==SAVEPOINT_ROLLBACK
){
4296 rc
= saveAllCursors(pBt
, 0, 0);
4298 if( rc
==SQLITE_OK
){
4299 rc
= sqlite3PagerSavepoint(pBt
->pPager
, op
, iSavepoint
);
4301 if( rc
==SQLITE_OK
){
4302 if( iSavepoint
<0 && (pBt
->btsFlags
& BTS_INITIALLY_EMPTY
)!=0 ){
4305 rc
= newDatabase(pBt
);
4306 btreeSetNPage(pBt
, pBt
->pPage1
);
4308 /* pBt->nPage might be zero if the database was corrupt when
4309 ** the transaction was started. Otherwise, it must be at least 1. */
4310 assert( CORRUPT_DB
|| pBt
->nPage
>0 );
4312 sqlite3BtreeLeave(p
);
4318 ** Create a new cursor for the BTree whose root is on the page
4319 ** iTable. If a read-only cursor is requested, it is assumed that
4320 ** the caller already has at least a read-only transaction open
4321 ** on the database already. If a write-cursor is requested, then
4322 ** the caller is assumed to have an open write transaction.
4324 ** If the BTREE_WRCSR bit of wrFlag is clear, then the cursor can only
4325 ** be used for reading. If the BTREE_WRCSR bit is set, then the cursor
4326 ** can be used for reading or for writing if other conditions for writing
4327 ** are also met. These are the conditions that must be met in order
4328 ** for writing to be allowed:
4330 ** 1: The cursor must have been opened with wrFlag containing BTREE_WRCSR
4332 ** 2: Other database connections that share the same pager cache
4333 ** but which are not in the READ_UNCOMMITTED state may not have
4334 ** cursors open with wrFlag==0 on the same table. Otherwise
4335 ** the changes made by this write cursor would be visible to
4336 ** the read cursors in the other database connection.
4338 ** 3: The database must be writable (not on read-only media)
4340 ** 4: There must be an active transaction.
4342 ** The BTREE_FORDELETE bit of wrFlag may optionally be set if BTREE_WRCSR
4343 ** is set. If FORDELETE is set, that is a hint to the implementation that
4344 ** this cursor will only be used to seek to and delete entries of an index
4345 ** as part of a larger DELETE statement. The FORDELETE hint is not used by
4346 ** this implementation. But in a hypothetical alternative storage engine
4347 ** in which index entries are automatically deleted when corresponding table
4348 ** rows are deleted, the FORDELETE flag is a hint that all SEEK and DELETE
4349 ** operations on this cursor can be no-ops and all READ operations can
4350 ** return a null row (2-bytes: 0x01 0x00).
4352 ** No checking is done to make sure that page iTable really is the
4353 ** root page of a b-tree. If it is not, then the cursor acquired
4354 ** will not work correctly.
4356 ** It is assumed that the sqlite3BtreeCursorZero() has been called
4357 ** on pCur to initialize the memory space prior to invoking this routine.
4359 static int btreeCursor(
4360 Btree
*p
, /* The btree */
4361 int iTable
, /* Root page of table to open */
4362 int wrFlag
, /* 1 to write. 0 read-only */
4363 struct KeyInfo
*pKeyInfo
, /* First arg to comparison function */
4364 BtCursor
*pCur
/* Space for new cursor */
4366 BtShared
*pBt
= p
->pBt
; /* Shared b-tree handle */
4367 BtCursor
*pX
; /* Looping over other all cursors */
4369 assert( sqlite3BtreeHoldsMutex(p
) );
4371 || wrFlag
==BTREE_WRCSR
4372 || wrFlag
==(BTREE_WRCSR
|BTREE_FORDELETE
)
4375 /* The following assert statements verify that if this is a sharable
4376 ** b-tree database, the connection is holding the required table locks,
4377 ** and that no other connection has any open cursor that conflicts with
4378 ** this lock. The iTable<1 term disables the check for corrupt schemas. */
4379 assert( hasSharedCacheTableLock(p
, iTable
, pKeyInfo
!=0, (wrFlag
?2:1))
4381 assert( wrFlag
==0 || !hasReadConflicts(p
, iTable
) );
4383 /* Assert that the caller has opened the required transaction. */
4384 assert( p
->inTrans
>TRANS_NONE
);
4385 assert( wrFlag
==0 || p
->inTrans
==TRANS_WRITE
);
4386 assert( pBt
->pPage1
&& pBt
->pPage1
->aData
);
4387 assert( wrFlag
==0 || (pBt
->btsFlags
& BTS_READ_ONLY
)==0 );
4390 allocateTempSpace(pBt
);
4391 if( pBt
->pTmpSpace
==0 ) return SQLITE_NOMEM_BKPT
;
4395 return SQLITE_CORRUPT_BKPT
;
4396 }else if( btreePagecount(pBt
)==0 ){
4397 assert( wrFlag
==0 );
4402 /* Now that no other errors can occur, finish filling in the BtCursor
4403 ** variables and link the cursor into the BtShared list. */
4404 pCur
->pgnoRoot
= (Pgno
)iTable
;
4406 pCur
->pKeyInfo
= pKeyInfo
;
4409 pCur
->curFlags
= wrFlag
? BTCF_WriteFlag
: 0;
4410 pCur
->curPagerFlags
= wrFlag
? 0 : PAGER_GET_READONLY
;
4411 /* If there are two or more cursors on the same btree, then all such
4412 ** cursors *must* have the BTCF_Multiple flag set. */
4413 for(pX
=pBt
->pCursor
; pX
; pX
=pX
->pNext
){
4414 if( pX
->pgnoRoot
==(Pgno
)iTable
){
4415 pX
->curFlags
|= BTCF_Multiple
;
4416 pCur
->curFlags
|= BTCF_Multiple
;
4419 pCur
->pNext
= pBt
->pCursor
;
4420 pBt
->pCursor
= pCur
;
4421 pCur
->eState
= CURSOR_INVALID
;
4424 static int btreeCursorWithLock(
4425 Btree
*p
, /* The btree */
4426 int iTable
, /* Root page of table to open */
4427 int wrFlag
, /* 1 to write. 0 read-only */
4428 struct KeyInfo
*pKeyInfo
, /* First arg to comparison function */
4429 BtCursor
*pCur
/* Space for new cursor */
4432 sqlite3BtreeEnter(p
);
4433 rc
= btreeCursor(p
, iTable
, wrFlag
, pKeyInfo
, pCur
);
4434 sqlite3BtreeLeave(p
);
4437 int sqlite3BtreeCursor(
4438 Btree
*p
, /* The btree */
4439 int iTable
, /* Root page of table to open */
4440 int wrFlag
, /* 1 to write. 0 read-only */
4441 struct KeyInfo
*pKeyInfo
, /* First arg to xCompare() */
4442 BtCursor
*pCur
/* Write new cursor here */
4445 return btreeCursorWithLock(p
, iTable
, wrFlag
, pKeyInfo
, pCur
);
4447 return btreeCursor(p
, iTable
, wrFlag
, pKeyInfo
, pCur
);
4452 ** Return the size of a BtCursor object in bytes.
4454 ** This interfaces is needed so that users of cursors can preallocate
4455 ** sufficient storage to hold a cursor. The BtCursor object is opaque
4456 ** to users so they cannot do the sizeof() themselves - they must call
4459 int sqlite3BtreeCursorSize(void){
4460 return ROUND8(sizeof(BtCursor
));
4464 ** Initialize memory that will be converted into a BtCursor object.
4466 ** The simple approach here would be to memset() the entire object
4467 ** to zero. But it turns out that the apPage[] and aiIdx[] arrays
4468 ** do not need to be zeroed and they are large, so we can save a lot
4469 ** of run-time by skipping the initialization of those elements.
4471 void sqlite3BtreeCursorZero(BtCursor
*p
){
4472 memset(p
, 0, offsetof(BtCursor
, BTCURSOR_FIRST_UNINIT
));
4476 ** Close a cursor. The read lock on the database file is released
4477 ** when the last cursor is closed.
4479 int sqlite3BtreeCloseCursor(BtCursor
*pCur
){
4480 Btree
*pBtree
= pCur
->pBtree
;
4482 BtShared
*pBt
= pCur
->pBt
;
4483 sqlite3BtreeEnter(pBtree
);
4484 assert( pBt
->pCursor
!=0 );
4485 if( pBt
->pCursor
==pCur
){
4486 pBt
->pCursor
= pCur
->pNext
;
4488 BtCursor
*pPrev
= pBt
->pCursor
;
4490 if( pPrev
->pNext
==pCur
){
4491 pPrev
->pNext
= pCur
->pNext
;
4494 pPrev
= pPrev
->pNext
;
4495 }while( ALWAYS(pPrev
) );
4497 btreeReleaseAllCursorPages(pCur
);
4498 unlockBtreeIfUnused(pBt
);
4499 sqlite3_free(pCur
->aOverflow
);
4500 sqlite3_free(pCur
->pKey
);
4501 sqlite3BtreeLeave(pBtree
);
4508 ** Make sure the BtCursor* given in the argument has a valid
4509 ** BtCursor.info structure. If it is not already valid, call
4510 ** btreeParseCell() to fill it in.
4512 ** BtCursor.info is a cache of the information in the current cell.
4513 ** Using this cache reduces the number of calls to btreeParseCell().
4516 static int cellInfoEqual(CellInfo
*a
, CellInfo
*b
){
4517 if( a
->nKey
!=b
->nKey
) return 0;
4518 if( a
->pPayload
!=b
->pPayload
) return 0;
4519 if( a
->nPayload
!=b
->nPayload
) return 0;
4520 if( a
->nLocal
!=b
->nLocal
) return 0;
4521 if( a
->nSize
!=b
->nSize
) return 0;
4524 static void assertCellInfo(BtCursor
*pCur
){
4526 memset(&info
, 0, sizeof(info
));
4527 btreeParseCell(pCur
->pPage
, pCur
->ix
, &info
);
4528 assert( CORRUPT_DB
|| cellInfoEqual(&info
, &pCur
->info
) );
4531 #define assertCellInfo(x)
4533 static SQLITE_NOINLINE
void getCellInfo(BtCursor
*pCur
){
4534 if( pCur
->info
.nSize
==0 ){
4535 pCur
->curFlags
|= BTCF_ValidNKey
;
4536 btreeParseCell(pCur
->pPage
,pCur
->ix
,&pCur
->info
);
4538 assertCellInfo(pCur
);
4542 #ifndef NDEBUG /* The next routine used only within assert() statements */
4544 ** Return true if the given BtCursor is valid. A valid cursor is one
4545 ** that is currently pointing to a row in a (non-empty) table.
4546 ** This is a verification routine is used only within assert() statements.
4548 int sqlite3BtreeCursorIsValid(BtCursor
*pCur
){
4549 return pCur
&& pCur
->eState
==CURSOR_VALID
;
4552 int sqlite3BtreeCursorIsValidNN(BtCursor
*pCur
){
4554 return pCur
->eState
==CURSOR_VALID
;
4558 ** Return the value of the integer key or "rowid" for a table btree.
4559 ** This routine is only valid for a cursor that is pointing into a
4560 ** ordinary table btree. If the cursor points to an index btree or
4561 ** is invalid, the result of this routine is undefined.
4563 i64
sqlite3BtreeIntegerKey(BtCursor
*pCur
){
4564 assert( cursorHoldsMutex(pCur
) );
4565 assert( pCur
->eState
==CURSOR_VALID
);
4566 assert( pCur
->curIntKey
);
4568 return pCur
->info
.nKey
;
4572 ** Pin or unpin a cursor.
4574 void sqlite3BtreeCursorPin(BtCursor
*pCur
){
4575 assert( (pCur
->curFlags
& BTCF_Pinned
)==0 );
4576 pCur
->curFlags
|= BTCF_Pinned
;
4578 void sqlite3BtreeCursorUnpin(BtCursor
*pCur
){
4579 assert( (pCur
->curFlags
& BTCF_Pinned
)!=0 );
4580 pCur
->curFlags
&= ~BTCF_Pinned
;
4583 #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
4585 ** Return the offset into the database file for the start of the
4586 ** payload to which the cursor is pointing.
4588 i64
sqlite3BtreeOffset(BtCursor
*pCur
){
4589 assert( cursorHoldsMutex(pCur
) );
4590 assert( pCur
->eState
==CURSOR_VALID
);
4592 return (i64
)pCur
->pBt
->pageSize
*((i64
)pCur
->pPage
->pgno
- 1) +
4593 (i64
)(pCur
->info
.pPayload
- pCur
->pPage
->aData
);
4595 #endif /* SQLITE_ENABLE_OFFSET_SQL_FUNC */
4598 ** Return the number of bytes of payload for the entry that pCur is
4599 ** currently pointing to. For table btrees, this will be the amount
4600 ** of data. For index btrees, this will be the size of the key.
4602 ** The caller must guarantee that the cursor is pointing to a non-NULL
4603 ** valid entry. In other words, the calling procedure must guarantee
4604 ** that the cursor has Cursor.eState==CURSOR_VALID.
4606 u32
sqlite3BtreePayloadSize(BtCursor
*pCur
){
4607 assert( cursorHoldsMutex(pCur
) );
4608 assert( pCur
->eState
==CURSOR_VALID
);
4610 return pCur
->info
.nPayload
;
4614 ** Return an upper bound on the size of any record for the table
4615 ** that the cursor is pointing into.
4617 ** This is an optimization. Everything will still work if this
4618 ** routine always returns 2147483647 (which is the largest record
4619 ** that SQLite can handle) or more. But returning a smaller value might
4620 ** prevent large memory allocations when trying to interpret a
4621 ** corrupt datrabase.
4623 ** The current implementation merely returns the size of the underlying
4626 sqlite3_int64
sqlite3BtreeMaxRecordSize(BtCursor
*pCur
){
4627 assert( cursorHoldsMutex(pCur
) );
4628 assert( pCur
->eState
==CURSOR_VALID
);
4629 return pCur
->pBt
->pageSize
* (sqlite3_int64
)pCur
->pBt
->nPage
;
4633 ** Given the page number of an overflow page in the database (parameter
4634 ** ovfl), this function finds the page number of the next page in the
4635 ** linked list of overflow pages. If possible, it uses the auto-vacuum
4636 ** pointer-map data instead of reading the content of page ovfl to do so.
4638 ** If an error occurs an SQLite error code is returned. Otherwise:
4640 ** The page number of the next overflow page in the linked list is
4641 ** written to *pPgnoNext. If page ovfl is the last page in its linked
4642 ** list, *pPgnoNext is set to zero.
4644 ** If ppPage is not NULL, and a reference to the MemPage object corresponding
4645 ** to page number pOvfl was obtained, then *ppPage is set to point to that
4646 ** reference. It is the responsibility of the caller to call releasePage()
4647 ** on *ppPage to free the reference. In no reference was obtained (because
4648 ** the pointer-map was used to obtain the value for *pPgnoNext), then
4649 ** *ppPage is set to zero.
4651 static int getOverflowPage(
4652 BtShared
*pBt
, /* The database file */
4653 Pgno ovfl
, /* Current overflow page number */
4654 MemPage
**ppPage
, /* OUT: MemPage handle (may be NULL) */
4655 Pgno
*pPgnoNext
/* OUT: Next overflow page number */
4661 assert( sqlite3_mutex_held(pBt
->mutex
) );
4664 #ifndef SQLITE_OMIT_AUTOVACUUM
4665 /* Try to find the next page in the overflow list using the
4666 ** autovacuum pointer-map pages. Guess that the next page in
4667 ** the overflow list is page number (ovfl+1). If that guess turns
4668 ** out to be wrong, fall back to loading the data of page
4669 ** number ovfl to determine the next page number.
4671 if( pBt
->autoVacuum
){
4673 Pgno iGuess
= ovfl
+1;
4676 while( PTRMAP_ISPAGE(pBt
, iGuess
) || iGuess
==PENDING_BYTE_PAGE(pBt
) ){
4680 if( iGuess
<=btreePagecount(pBt
) ){
4681 rc
= ptrmapGet(pBt
, iGuess
, &eType
, &pgno
);
4682 if( rc
==SQLITE_OK
&& eType
==PTRMAP_OVERFLOW2
&& pgno
==ovfl
){
4690 assert( next
==0 || rc
==SQLITE_DONE
);
4691 if( rc
==SQLITE_OK
){
4692 rc
= btreeGetPage(pBt
, ovfl
, &pPage
, (ppPage
==0) ? PAGER_GET_READONLY
: 0);
4693 assert( rc
==SQLITE_OK
|| pPage
==0 );
4694 if( rc
==SQLITE_OK
){
4695 next
= get4byte(pPage
->aData
);
4705 return (rc
==SQLITE_DONE
? SQLITE_OK
: rc
);
4709 ** Copy data from a buffer to a page, or from a page to a buffer.
4711 ** pPayload is a pointer to data stored on database page pDbPage.
4712 ** If argument eOp is false, then nByte bytes of data are copied
4713 ** from pPayload to the buffer pointed at by pBuf. If eOp is true,
4714 ** then sqlite3PagerWrite() is called on pDbPage and nByte bytes
4715 ** of data are copied from the buffer pBuf to pPayload.
4717 ** SQLITE_OK is returned on success, otherwise an error code.
4719 static int copyPayload(
4720 void *pPayload
, /* Pointer to page data */
4721 void *pBuf
, /* Pointer to buffer */
4722 int nByte
, /* Number of bytes to copy */
4723 int eOp
, /* 0 -> copy from page, 1 -> copy to page */
4724 DbPage
*pDbPage
/* Page containing pPayload */
4727 /* Copy data from buffer to page (a write operation) */
4728 int rc
= sqlite3PagerWrite(pDbPage
);
4729 if( rc
!=SQLITE_OK
){
4732 memcpy(pPayload
, pBuf
, nByte
);
4734 /* Copy data from page to buffer (a read operation) */
4735 memcpy(pBuf
, pPayload
, nByte
);
4741 ** This function is used to read or overwrite payload information
4742 ** for the entry that the pCur cursor is pointing to. The eOp
4743 ** argument is interpreted as follows:
4745 ** 0: The operation is a read. Populate the overflow cache.
4746 ** 1: The operation is a write. Populate the overflow cache.
4748 ** A total of "amt" bytes are read or written beginning at "offset".
4749 ** Data is read to or from the buffer pBuf.
4751 ** The content being read or written might appear on the main page
4752 ** or be scattered out on multiple overflow pages.
4754 ** If the current cursor entry uses one or more overflow pages
4755 ** this function may allocate space for and lazily populate
4756 ** the overflow page-list cache array (BtCursor.aOverflow).
4757 ** Subsequent calls use this cache to make seeking to the supplied offset
4760 ** Once an overflow page-list cache has been allocated, it must be
4761 ** invalidated if some other cursor writes to the same table, or if
4762 ** the cursor is moved to a different row. Additionally, in auto-vacuum
4763 ** mode, the following events may invalidate an overflow page-list cache.
4765 ** * An incremental vacuum,
4766 ** * A commit in auto_vacuum="full" mode,
4767 ** * Creating a table (may require moving an overflow page).
4769 static int accessPayload(
4770 BtCursor
*pCur
, /* Cursor pointing to entry to read from */
4771 u32 offset
, /* Begin reading this far into payload */
4772 u32 amt
, /* Read this many bytes */
4773 unsigned char *pBuf
, /* Write the bytes into this buffer */
4774 int eOp
/* zero to read. non-zero to write. */
4776 unsigned char *aPayload
;
4779 MemPage
*pPage
= pCur
->pPage
; /* Btree page of current entry */
4780 BtShared
*pBt
= pCur
->pBt
; /* Btree this cursor belongs to */
4781 #ifdef SQLITE_DIRECT_OVERFLOW_READ
4782 unsigned char * const pBufStart
= pBuf
; /* Start of original out buffer */
4786 assert( eOp
==0 || eOp
==1 );
4787 assert( pCur
->eState
==CURSOR_VALID
);
4788 assert( pCur
->ix
<pPage
->nCell
);
4789 assert( cursorHoldsMutex(pCur
) );
4792 aPayload
= pCur
->info
.pPayload
;
4793 assert( offset
+amt
<= pCur
->info
.nPayload
);
4795 assert( aPayload
> pPage
->aData
);
4796 if( (uptr
)(aPayload
- pPage
->aData
) > (pBt
->usableSize
- pCur
->info
.nLocal
) ){
4797 /* Trying to read or write past the end of the data is an error. The
4798 ** conditional above is really:
4799 ** &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize]
4800 ** but is recast into its current form to avoid integer overflow problems
4802 return SQLITE_CORRUPT_PAGE(pPage
);
4805 /* Check if data must be read/written to/from the btree page itself. */
4806 if( offset
<pCur
->info
.nLocal
){
4808 if( a
+offset
>pCur
->info
.nLocal
){
4809 a
= pCur
->info
.nLocal
- offset
;
4811 rc
= copyPayload(&aPayload
[offset
], pBuf
, a
, eOp
, pPage
->pDbPage
);
4816 offset
-= pCur
->info
.nLocal
;
4820 if( rc
==SQLITE_OK
&& amt
>0 ){
4821 const u32 ovflSize
= pBt
->usableSize
- 4; /* Bytes content per ovfl page */
4824 nextPage
= get4byte(&aPayload
[pCur
->info
.nLocal
]);
4826 /* If the BtCursor.aOverflow[] has not been allocated, allocate it now.
4828 ** The aOverflow[] array is sized at one entry for each overflow page
4829 ** in the overflow chain. The page number of the first overflow page is
4830 ** stored in aOverflow[0], etc. A value of 0 in the aOverflow[] array
4831 ** means "not yet known" (the cache is lazily populated).
4833 if( (pCur
->curFlags
& BTCF_ValidOvfl
)==0 ){
4834 int nOvfl
= (pCur
->info
.nPayload
-pCur
->info
.nLocal
+ovflSize
-1)/ovflSize
;
4835 if( pCur
->aOverflow
==0
4836 || nOvfl
*(int)sizeof(Pgno
) > sqlite3MallocSize(pCur
->aOverflow
)
4838 Pgno
*aNew
= (Pgno
*)sqlite3Realloc(
4839 pCur
->aOverflow
, nOvfl
*2*sizeof(Pgno
)
4842 return SQLITE_NOMEM_BKPT
;
4844 pCur
->aOverflow
= aNew
;
4847 memset(pCur
->aOverflow
, 0, nOvfl
*sizeof(Pgno
));
4848 pCur
->curFlags
|= BTCF_ValidOvfl
;
4850 /* If the overflow page-list cache has been allocated and the
4851 ** entry for the first required overflow page is valid, skip
4854 if( pCur
->aOverflow
[offset
/ovflSize
] ){
4855 iIdx
= (offset
/ovflSize
);
4856 nextPage
= pCur
->aOverflow
[iIdx
];
4857 offset
= (offset
%ovflSize
);
4861 assert( rc
==SQLITE_OK
&& amt
>0 );
4863 /* If required, populate the overflow page-list cache. */
4864 assert( pCur
->aOverflow
[iIdx
]==0
4865 || pCur
->aOverflow
[iIdx
]==nextPage
4867 pCur
->aOverflow
[iIdx
] = nextPage
;
4869 if( offset
>=ovflSize
){
4870 /* The only reason to read this page is to obtain the page
4871 ** number for the next page in the overflow chain. The page
4872 ** data is not required. So first try to lookup the overflow
4873 ** page-list cache, if any, then fall back to the getOverflowPage()
4876 assert( pCur
->curFlags
& BTCF_ValidOvfl
);
4877 assert( pCur
->pBtree
->db
==pBt
->db
);
4878 if( pCur
->aOverflow
[iIdx
+1] ){
4879 nextPage
= pCur
->aOverflow
[iIdx
+1];
4881 rc
= getOverflowPage(pBt
, nextPage
, 0, &nextPage
);
4885 /* Need to read this page properly. It contains some of the
4886 ** range of data that is being read (eOp==0) or written (eOp!=0).
4889 if( a
+ offset
> ovflSize
){
4890 a
= ovflSize
- offset
;
4893 #ifdef SQLITE_DIRECT_OVERFLOW_READ
4894 /* If all the following are true:
4896 ** 1) this is a read operation, and
4897 ** 2) data is required from the start of this overflow page, and
4898 ** 3) there are no dirty pages in the page-cache
4899 ** 4) the database is file-backed, and
4900 ** 5) the page is not in the WAL file
4901 ** 6) at least 4 bytes have already been read into the output buffer
4903 ** then data can be read directly from the database file into the
4904 ** output buffer, bypassing the page-cache altogether. This speeds
4905 ** up loading large records that span many overflow pages.
4907 if( eOp
==0 /* (1) */
4908 && offset
==0 /* (2) */
4909 && sqlite3PagerDirectReadOk(pBt
->pPager
, nextPage
) /* (3,4,5) */
4910 && &pBuf
[-4]>=pBufStart
/* (6) */
4912 sqlite3_file
*fd
= sqlite3PagerFile(pBt
->pPager
);
4914 u8
*aWrite
= &pBuf
[-4];
4915 assert( aWrite
>=pBufStart
); /* due to (6) */
4916 memcpy(aSave
, aWrite
, 4);
4917 rc
= sqlite3OsRead(fd
, aWrite
, a
+4, (i64
)pBt
->pageSize
*(nextPage
-1));
4918 if( rc
&& nextPage
>pBt
->nPage
) rc
= SQLITE_CORRUPT_BKPT
;
4919 nextPage
= get4byte(aWrite
);
4920 memcpy(aWrite
, aSave
, 4);
4926 rc
= sqlite3PagerGet(pBt
->pPager
, nextPage
, &pDbPage
,
4927 (eOp
==0 ? PAGER_GET_READONLY
: 0)
4929 if( rc
==SQLITE_OK
){
4930 aPayload
= sqlite3PagerGetData(pDbPage
);
4931 nextPage
= get4byte(aPayload
);
4932 rc
= copyPayload(&aPayload
[offset
+4], pBuf
, a
, eOp
, pDbPage
);
4933 sqlite3PagerUnref(pDbPage
);
4938 if( amt
==0 ) return rc
;
4946 if( rc
==SQLITE_OK
&& amt
>0 ){
4947 /* Overflow chain ends prematurely */
4948 return SQLITE_CORRUPT_PAGE(pPage
);
4954 ** Read part of the payload for the row at which that cursor pCur is currently
4955 ** pointing. "amt" bytes will be transferred into pBuf[]. The transfer
4956 ** begins at "offset".
4958 ** pCur can be pointing to either a table or an index b-tree.
4959 ** If pointing to a table btree, then the content section is read. If
4960 ** pCur is pointing to an index b-tree then the key section is read.
4962 ** For sqlite3BtreePayload(), the caller must ensure that pCur is pointing
4963 ** to a valid row in the table. For sqlite3BtreePayloadChecked(), the
4964 ** cursor might be invalid or might need to be restored before being read.
4966 ** Return SQLITE_OK on success or an error code if anything goes
4967 ** wrong. An error is returned if "offset+amt" is larger than
4968 ** the available payload.
4970 int sqlite3BtreePayload(BtCursor
*pCur
, u32 offset
, u32 amt
, void *pBuf
){
4971 assert( cursorHoldsMutex(pCur
) );
4972 assert( pCur
->eState
==CURSOR_VALID
);
4973 assert( pCur
->iPage
>=0 && pCur
->pPage
);
4974 assert( pCur
->ix
<pCur
->pPage
->nCell
);
4975 return accessPayload(pCur
, offset
, amt
, (unsigned char*)pBuf
, 0);
4979 ** This variant of sqlite3BtreePayload() works even if the cursor has not
4980 ** in the CURSOR_VALID state. It is only used by the sqlite3_blob_read()
4983 #ifndef SQLITE_OMIT_INCRBLOB
4984 static SQLITE_NOINLINE
int accessPayloadChecked(
4991 if ( pCur
->eState
==CURSOR_INVALID
){
4992 return SQLITE_ABORT
;
4994 assert( cursorOwnsBtShared(pCur
) );
4995 rc
= btreeRestoreCursorPosition(pCur
);
4996 return rc
? rc
: accessPayload(pCur
, offset
, amt
, pBuf
, 0);
4998 int sqlite3BtreePayloadChecked(BtCursor
*pCur
, u32 offset
, u32 amt
, void *pBuf
){
4999 if( pCur
->eState
==CURSOR_VALID
){
5000 assert( cursorOwnsBtShared(pCur
) );
5001 return accessPayload(pCur
, offset
, amt
, pBuf
, 0);
5003 return accessPayloadChecked(pCur
, offset
, amt
, pBuf
);
5006 #endif /* SQLITE_OMIT_INCRBLOB */
5009 ** Return a pointer to payload information from the entry that the
5010 ** pCur cursor is pointing to. The pointer is to the beginning of
5011 ** the key if index btrees (pPage->intKey==0) and is the data for
5012 ** table btrees (pPage->intKey==1). The number of bytes of available
5013 ** key/data is written into *pAmt. If *pAmt==0, then the value
5014 ** returned will not be a valid pointer.
5016 ** This routine is an optimization. It is common for the entire key
5017 ** and data to fit on the local page and for there to be no overflow
5018 ** pages. When that is so, this routine can be used to access the
5019 ** key and data without making a copy. If the key and/or data spills
5020 ** onto overflow pages, then accessPayload() must be used to reassemble
5021 ** the key/data and copy it into a preallocated buffer.
5023 ** The pointer returned by this routine looks directly into the cached
5024 ** page of the database. The data might change or move the next time
5025 ** any btree routine is called.
5027 static const void *fetchPayload(
5028 BtCursor
*pCur
, /* Cursor pointing to entry to read from */
5029 u32
*pAmt
/* Write the number of available bytes here */
5032 assert( pCur
!=0 && pCur
->iPage
>=0 && pCur
->pPage
);
5033 assert( pCur
->eState
==CURSOR_VALID
);
5034 assert( sqlite3_mutex_held(pCur
->pBtree
->db
->mutex
) );
5035 assert( cursorOwnsBtShared(pCur
) );
5036 assert( pCur
->ix
<pCur
->pPage
->nCell
);
5037 assert( pCur
->info
.nSize
>0 );
5038 assert( pCur
->info
.pPayload
>pCur
->pPage
->aData
|| CORRUPT_DB
);
5039 assert( pCur
->info
.pPayload
<pCur
->pPage
->aDataEnd
||CORRUPT_DB
);
5040 amt
= pCur
->info
.nLocal
;
5041 if( amt
>(int)(pCur
->pPage
->aDataEnd
- pCur
->info
.pPayload
) ){
5042 /* There is too little space on the page for the expected amount
5043 ** of local content. Database must be corrupt. */
5044 assert( CORRUPT_DB
);
5045 amt
= MAX(0, (int)(pCur
->pPage
->aDataEnd
- pCur
->info
.pPayload
));
5048 return (void*)pCur
->info
.pPayload
;
5053 ** For the entry that cursor pCur is point to, return as
5054 ** many bytes of the key or data as are available on the local
5055 ** b-tree page. Write the number of available bytes into *pAmt.
5057 ** The pointer returned is ephemeral. The key/data may move
5058 ** or be destroyed on the next call to any Btree routine,
5059 ** including calls from other threads against the same cache.
5060 ** Hence, a mutex on the BtShared should be held prior to calling
5063 ** These routines is used to get quick access to key and data
5064 ** in the common case where no overflow pages are used.
5066 const void *sqlite3BtreePayloadFetch(BtCursor
*pCur
, u32
*pAmt
){
5067 return fetchPayload(pCur
, pAmt
);
5072 ** Move the cursor down to a new child page. The newPgno argument is the
5073 ** page number of the child page to move to.
5075 ** This function returns SQLITE_CORRUPT if the page-header flags field of
5076 ** the new child page does not match the flags field of the parent (i.e.
5077 ** if an intkey page appears to be the parent of a non-intkey page, or
5080 static int moveToChild(BtCursor
*pCur
, u32 newPgno
){
5081 BtShared
*pBt
= pCur
->pBt
;
5083 assert( cursorOwnsBtShared(pCur
) );
5084 assert( pCur
->eState
==CURSOR_VALID
);
5085 assert( pCur
->iPage
<BTCURSOR_MAX_DEPTH
);
5086 assert( pCur
->iPage
>=0 );
5087 if( pCur
->iPage
>=(BTCURSOR_MAX_DEPTH
-1) ){
5088 return SQLITE_CORRUPT_BKPT
;
5090 pCur
->info
.nSize
= 0;
5091 pCur
->curFlags
&= ~(BTCF_ValidNKey
|BTCF_ValidOvfl
);
5092 pCur
->aiIdx
[pCur
->iPage
] = pCur
->ix
;
5093 pCur
->apPage
[pCur
->iPage
] = pCur
->pPage
;
5096 return getAndInitPage(pBt
, newPgno
, &pCur
->pPage
, pCur
, pCur
->curPagerFlags
);
5101 ** Page pParent is an internal (non-leaf) tree page. This function
5102 ** asserts that page number iChild is the left-child if the iIdx'th
5103 ** cell in page pParent. Or, if iIdx is equal to the total number of
5104 ** cells in pParent, that page number iChild is the right-child of
5107 static void assertParentIndex(MemPage
*pParent
, int iIdx
, Pgno iChild
){
5108 if( CORRUPT_DB
) return; /* The conditions tested below might not be true
5109 ** in a corrupt database */
5110 assert( iIdx
<=pParent
->nCell
);
5111 if( iIdx
==pParent
->nCell
){
5112 assert( get4byte(&pParent
->aData
[pParent
->hdrOffset
+8])==iChild
);
5114 assert( get4byte(findCell(pParent
, iIdx
))==iChild
);
5118 # define assertParentIndex(x,y,z)
5122 ** Move the cursor up to the parent page.
5124 ** pCur->idx is set to the cell index that contains the pointer
5125 ** to the page we are coming from. If we are coming from the
5126 ** right-most child page then pCur->idx is set to one more than
5127 ** the largest cell index.
5129 static void moveToParent(BtCursor
*pCur
){
5131 assert( cursorOwnsBtShared(pCur
) );
5132 assert( pCur
->eState
==CURSOR_VALID
);
5133 assert( pCur
->iPage
>0 );
5134 assert( pCur
->pPage
);
5136 pCur
->apPage
[pCur
->iPage
-1],
5137 pCur
->aiIdx
[pCur
->iPage
-1],
5140 testcase( pCur
->aiIdx
[pCur
->iPage
-1] > pCur
->apPage
[pCur
->iPage
-1]->nCell
);
5141 pCur
->info
.nSize
= 0;
5142 pCur
->curFlags
&= ~(BTCF_ValidNKey
|BTCF_ValidOvfl
);
5143 pCur
->ix
= pCur
->aiIdx
[pCur
->iPage
-1];
5144 pLeaf
= pCur
->pPage
;
5145 pCur
->pPage
= pCur
->apPage
[--pCur
->iPage
];
5146 releasePageNotNull(pLeaf
);
5150 ** Move the cursor to point to the root page of its b-tree structure.
5152 ** If the table has a virtual root page, then the cursor is moved to point
5153 ** to the virtual root page instead of the actual root page. A table has a
5154 ** virtual root page when the actual root page contains no cells and a
5155 ** single child page. This can only happen with the table rooted at page 1.
5157 ** If the b-tree structure is empty, the cursor state is set to
5158 ** CURSOR_INVALID and this routine returns SQLITE_EMPTY. Otherwise,
5159 ** the cursor is set to point to the first cell located on the root
5160 ** (or virtual root) page and the cursor state is set to CURSOR_VALID.
5162 ** If this function returns successfully, it may be assumed that the
5163 ** page-header flags indicate that the [virtual] root-page is the expected
5164 ** kind of b-tree page (i.e. if when opening the cursor the caller did not
5165 ** specify a KeyInfo structure the flags byte is set to 0x05 or 0x0D,
5166 ** indicating a table b-tree, or if the caller did specify a KeyInfo
5167 ** structure the flags byte is set to 0x02 or 0x0A, indicating an index
5170 static int moveToRoot(BtCursor
*pCur
){
5174 assert( cursorOwnsBtShared(pCur
) );
5175 assert( CURSOR_INVALID
< CURSOR_REQUIRESEEK
);
5176 assert( CURSOR_VALID
< CURSOR_REQUIRESEEK
);
5177 assert( CURSOR_FAULT
> CURSOR_REQUIRESEEK
);
5178 assert( pCur
->eState
< CURSOR_REQUIRESEEK
|| pCur
->iPage
<0 );
5179 assert( pCur
->pgnoRoot
>0 || pCur
->iPage
<0 );
5181 if( pCur
->iPage
>=0 ){
5183 releasePageNotNull(pCur
->pPage
);
5184 while( --pCur
->iPage
){
5185 releasePageNotNull(pCur
->apPage
[pCur
->iPage
]);
5187 pCur
->pPage
= pCur
->apPage
[0];
5190 }else if( pCur
->pgnoRoot
==0 ){
5191 pCur
->eState
= CURSOR_INVALID
;
5192 return SQLITE_EMPTY
;
5194 assert( pCur
->iPage
==(-1) );
5195 if( pCur
->eState
>=CURSOR_REQUIRESEEK
){
5196 if( pCur
->eState
==CURSOR_FAULT
){
5197 assert( pCur
->skipNext
!=SQLITE_OK
);
5198 return pCur
->skipNext
;
5200 sqlite3BtreeClearCursor(pCur
);
5202 rc
= getAndInitPage(pCur
->pBtree
->pBt
, pCur
->pgnoRoot
, &pCur
->pPage
,
5203 0, pCur
->curPagerFlags
);
5204 if( rc
!=SQLITE_OK
){
5205 pCur
->eState
= CURSOR_INVALID
;
5209 pCur
->curIntKey
= pCur
->pPage
->intKey
;
5211 pRoot
= pCur
->pPage
;
5212 assert( pRoot
->pgno
==pCur
->pgnoRoot
);
5214 /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
5215 ** expected to open it on an index b-tree. Otherwise, if pKeyInfo is
5216 ** NULL, the caller expects a table b-tree. If this is not the case,
5217 ** return an SQLITE_CORRUPT error.
5219 ** Earlier versions of SQLite assumed that this test could not fail
5220 ** if the root page was already loaded when this function was called (i.e.
5221 ** if pCur->iPage>=0). But this is not so if the database is corrupted
5222 ** in such a way that page pRoot is linked into a second b-tree table
5223 ** (or the freelist). */
5224 assert( pRoot
->intKey
==1 || pRoot
->intKey
==0 );
5225 if( pRoot
->isInit
==0 || (pCur
->pKeyInfo
==0)!=pRoot
->intKey
){
5226 return SQLITE_CORRUPT_PAGE(pCur
->pPage
);
5231 pCur
->info
.nSize
= 0;
5232 pCur
->curFlags
&= ~(BTCF_AtLast
|BTCF_ValidNKey
|BTCF_ValidOvfl
);
5234 pRoot
= pCur
->pPage
;
5235 if( pRoot
->nCell
>0 ){
5236 pCur
->eState
= CURSOR_VALID
;
5237 }else if( !pRoot
->leaf
){
5239 if( pRoot
->pgno
!=1 ) return SQLITE_CORRUPT_BKPT
;
5240 subpage
= get4byte(&pRoot
->aData
[pRoot
->hdrOffset
+8]);
5241 pCur
->eState
= CURSOR_VALID
;
5242 rc
= moveToChild(pCur
, subpage
);
5244 pCur
->eState
= CURSOR_INVALID
;
5251 ** Move the cursor down to the left-most leaf entry beneath the
5252 ** entry to which it is currently pointing.
5254 ** The left-most leaf is the one with the smallest key - the first
5255 ** in ascending order.
5257 static int moveToLeftmost(BtCursor
*pCur
){
5262 assert( cursorOwnsBtShared(pCur
) );
5263 assert( pCur
->eState
==CURSOR_VALID
);
5264 while( rc
==SQLITE_OK
&& !(pPage
= pCur
->pPage
)->leaf
){
5265 assert( pCur
->ix
<pPage
->nCell
);
5266 pgno
= get4byte(findCell(pPage
, pCur
->ix
));
5267 rc
= moveToChild(pCur
, pgno
);
5273 ** Move the cursor down to the right-most leaf entry beneath the
5274 ** page to which it is currently pointing. Notice the difference
5275 ** between moveToLeftmost() and moveToRightmost(). moveToLeftmost()
5276 ** finds the left-most entry beneath the *entry* whereas moveToRightmost()
5277 ** finds the right-most entry beneath the *page*.
5279 ** The right-most entry is the one with the largest key - the last
5280 ** key in ascending order.
5282 static int moveToRightmost(BtCursor
*pCur
){
5287 assert( cursorOwnsBtShared(pCur
) );
5288 assert( pCur
->eState
==CURSOR_VALID
);
5289 while( !(pPage
= pCur
->pPage
)->leaf
){
5290 pgno
= get4byte(&pPage
->aData
[pPage
->hdrOffset
+8]);
5291 pCur
->ix
= pPage
->nCell
;
5292 rc
= moveToChild(pCur
, pgno
);
5295 pCur
->ix
= pPage
->nCell
-1;
5296 assert( pCur
->info
.nSize
==0 );
5297 assert( (pCur
->curFlags
& BTCF_ValidNKey
)==0 );
5301 /* Move the cursor to the first entry in the table. Return SQLITE_OK
5302 ** on success. Set *pRes to 0 if the cursor actually points to something
5303 ** or set *pRes to 1 if the table is empty.
5305 int sqlite3BtreeFirst(BtCursor
*pCur
, int *pRes
){
5308 assert( cursorOwnsBtShared(pCur
) );
5309 assert( sqlite3_mutex_held(pCur
->pBtree
->db
->mutex
) );
5310 rc
= moveToRoot(pCur
);
5311 if( rc
==SQLITE_OK
){
5312 assert( pCur
->pPage
->nCell
>0 );
5314 rc
= moveToLeftmost(pCur
);
5315 }else if( rc
==SQLITE_EMPTY
){
5316 assert( pCur
->pgnoRoot
==0 || pCur
->pPage
->nCell
==0 );
5323 /* Move the cursor to the last entry in the table. Return SQLITE_OK
5324 ** on success. Set *pRes to 0 if the cursor actually points to something
5325 ** or set *pRes to 1 if the table is empty.
5327 int sqlite3BtreeLast(BtCursor
*pCur
, int *pRes
){
5330 assert( cursorOwnsBtShared(pCur
) );
5331 assert( sqlite3_mutex_held(pCur
->pBtree
->db
->mutex
) );
5333 /* If the cursor already points to the last entry, this is a no-op. */
5334 if( CURSOR_VALID
==pCur
->eState
&& (pCur
->curFlags
& BTCF_AtLast
)!=0 ){
5336 /* This block serves to assert() that the cursor really does point
5337 ** to the last entry in the b-tree. */
5339 for(ii
=0; ii
<pCur
->iPage
; ii
++){
5340 assert( pCur
->aiIdx
[ii
]==pCur
->apPage
[ii
]->nCell
);
5342 assert( pCur
->ix
==pCur
->pPage
->nCell
-1 );
5343 assert( pCur
->pPage
->leaf
);
5349 rc
= moveToRoot(pCur
);
5350 if( rc
==SQLITE_OK
){
5351 assert( pCur
->eState
==CURSOR_VALID
);
5353 rc
= moveToRightmost(pCur
);
5354 if( rc
==SQLITE_OK
){
5355 pCur
->curFlags
|= BTCF_AtLast
;
5357 pCur
->curFlags
&= ~BTCF_AtLast
;
5359 }else if( rc
==SQLITE_EMPTY
){
5360 assert( pCur
->pgnoRoot
==0 || pCur
->pPage
->nCell
==0 );
5367 /* Move the cursor so that it points to an entry near the key
5368 ** specified by pIdxKey or intKey. Return a success code.
5370 ** For INTKEY tables, the intKey parameter is used. pIdxKey
5371 ** must be NULL. For index tables, pIdxKey is used and intKey
5374 ** If an exact match is not found, then the cursor is always
5375 ** left pointing at a leaf page which would hold the entry if it
5376 ** were present. The cursor might point to an entry that comes
5377 ** before or after the key.
5379 ** An integer is written into *pRes which is the result of
5380 ** comparing the key with the entry to which the cursor is
5381 ** pointing. The meaning of the integer written into
5382 ** *pRes is as follows:
5384 ** *pRes<0 The cursor is left pointing at an entry that
5385 ** is smaller than intKey/pIdxKey or if the table is empty
5386 ** and the cursor is therefore left point to nothing.
5388 ** *pRes==0 The cursor is left pointing at an entry that
5389 ** exactly matches intKey/pIdxKey.
5391 ** *pRes>0 The cursor is left pointing at an entry that
5392 ** is larger than intKey/pIdxKey.
5394 ** For index tables, the pIdxKey->eqSeen field is set to 1 if there
5395 ** exists an entry in the table that exactly matches pIdxKey.
5397 int sqlite3BtreeMovetoUnpacked(
5398 BtCursor
*pCur
, /* The cursor to be moved */
5399 UnpackedRecord
*pIdxKey
, /* Unpacked index key */
5400 i64 intKey
, /* The table key */
5401 int biasRight
, /* If true, bias the search to the high end */
5402 int *pRes
/* Write search results here */
5405 RecordCompare xRecordCompare
;
5407 assert( cursorOwnsBtShared(pCur
) );
5408 assert( sqlite3_mutex_held(pCur
->pBtree
->db
->mutex
) );
5410 assert( (pIdxKey
==0)==(pCur
->pKeyInfo
==0) );
5411 assert( pCur
->eState
!=CURSOR_VALID
|| (pIdxKey
==0)==(pCur
->curIntKey
!=0) );
5413 /* If the cursor is already positioned at the point we are trying
5414 ** to move to, then just return without doing any work */
5416 && pCur
->eState
==CURSOR_VALID
&& (pCur
->curFlags
& BTCF_ValidNKey
)!=0
5418 if( pCur
->info
.nKey
==intKey
){
5422 if( pCur
->info
.nKey
<intKey
){
5423 if( (pCur
->curFlags
& BTCF_AtLast
)!=0 ){
5427 /* If the requested key is one more than the previous key, then
5428 ** try to get there using sqlite3BtreeNext() rather than a full
5429 ** binary search. This is an optimization only. The correct answer
5430 ** is still obtained without this case, only a little more slowely */
5431 if( pCur
->info
.nKey
+1==intKey
){
5433 rc
= sqlite3BtreeNext(pCur
, 0);
5434 if( rc
==SQLITE_OK
){
5436 if( pCur
->info
.nKey
==intKey
){
5439 }else if( rc
==SQLITE_DONE
){
5449 xRecordCompare
= sqlite3VdbeFindCompare(pIdxKey
);
5450 pIdxKey
->errCode
= 0;
5451 assert( pIdxKey
->default_rc
==1
5452 || pIdxKey
->default_rc
==0
5453 || pIdxKey
->default_rc
==-1
5456 xRecordCompare
= 0; /* All keys are integers */
5459 rc
= moveToRoot(pCur
);
5461 if( rc
==SQLITE_EMPTY
){
5462 assert( pCur
->pgnoRoot
==0 || pCur
->pPage
->nCell
==0 );
5468 assert( pCur
->pPage
);
5469 assert( pCur
->pPage
->isInit
);
5470 assert( pCur
->eState
==CURSOR_VALID
);
5471 assert( pCur
->pPage
->nCell
> 0 );
5472 assert( pCur
->iPage
==0 || pCur
->apPage
[0]->intKey
==pCur
->curIntKey
);
5473 assert( pCur
->curIntKey
|| pIdxKey
);
5475 int lwr
, upr
, idx
, c
;
5477 MemPage
*pPage
= pCur
->pPage
;
5478 u8
*pCell
; /* Pointer to current cell in pPage */
5480 /* pPage->nCell must be greater than zero. If this is the root-page
5481 ** the cursor would have been INVALID above and this for(;;) loop
5482 ** not run. If this is not the root-page, then the moveToChild() routine
5483 ** would have already detected db corruption. Similarly, pPage must
5484 ** be the right kind (index or table) of b-tree page. Otherwise
5485 ** a moveToChild() or moveToRoot() call would have detected corruption. */
5486 assert( pPage
->nCell
>0 );
5487 assert( pPage
->intKey
==(pIdxKey
==0) );
5489 upr
= pPage
->nCell
-1;
5490 assert( biasRight
==0 || biasRight
==1 );
5491 idx
= upr
>>(1-biasRight
); /* idx = biasRight ? upr : (lwr+upr)/2; */
5492 pCur
->ix
= (u16
)idx
;
5493 if( xRecordCompare
==0 ){
5496 pCell
= findCellPastPtr(pPage
, idx
);
5497 if( pPage
->intKeyLeaf
){
5498 while( 0x80 <= *(pCell
++) ){
5499 if( pCell
>=pPage
->aDataEnd
){
5500 return SQLITE_CORRUPT_PAGE(pPage
);
5504 getVarint(pCell
, (u64
*)&nCellKey
);
5505 if( nCellKey
<intKey
){
5507 if( lwr
>upr
){ c
= -1; break; }
5508 }else if( nCellKey
>intKey
){
5510 if( lwr
>upr
){ c
= +1; break; }
5512 assert( nCellKey
==intKey
);
5513 pCur
->ix
= (u16
)idx
;
5516 goto moveto_next_layer
;
5518 pCur
->curFlags
|= BTCF_ValidNKey
;
5519 pCur
->info
.nKey
= nCellKey
;
5520 pCur
->info
.nSize
= 0;
5525 assert( lwr
+upr
>=0 );
5526 idx
= (lwr
+upr
)>>1; /* idx = (lwr+upr)/2; */
5530 int nCell
; /* Size of the pCell cell in bytes */
5531 pCell
= findCellPastPtr(pPage
, idx
);
5533 /* The maximum supported page-size is 65536 bytes. This means that
5534 ** the maximum number of record bytes stored on an index B-Tree
5535 ** page is less than 16384 bytes and may be stored as a 2-byte
5536 ** varint. This information is used to attempt to avoid parsing
5537 ** the entire cell by checking for the cases where the record is
5538 ** stored entirely within the b-tree page by inspecting the first
5539 ** 2 bytes of the cell.
5542 if( nCell
<=pPage
->max1bytePayload
){
5543 /* This branch runs if the record-size field of the cell is a
5544 ** single byte varint and the record fits entirely on the main
5546 testcase( pCell
+nCell
+1==pPage
->aDataEnd
);
5547 c
= xRecordCompare(nCell
, (void*)&pCell
[1], pIdxKey
);
5548 }else if( !(pCell
[1] & 0x80)
5549 && (nCell
= ((nCell
&0x7f)<<7) + pCell
[1])<=pPage
->maxLocal
5551 /* The record-size field is a 2 byte varint and the record
5552 ** fits entirely on the main b-tree page. */
5553 testcase( pCell
+nCell
+2==pPage
->aDataEnd
);
5554 c
= xRecordCompare(nCell
, (void*)&pCell
[2], pIdxKey
);
5556 /* The record flows over onto one or more overflow pages. In
5557 ** this case the whole cell needs to be parsed, a buffer allocated
5558 ** and accessPayload() used to retrieve the record into the
5559 ** buffer before VdbeRecordCompare() can be called.
5561 ** If the record is corrupt, the xRecordCompare routine may read
5562 ** up to two varints past the end of the buffer. An extra 18
5563 ** bytes of padding is allocated at the end of the buffer in
5564 ** case this happens. */
5566 u8
* const pCellBody
= pCell
- pPage
->childPtrSize
;
5567 const int nOverrun
= 18; /* Size of the overrun padding */
5568 pPage
->xParseCell(pPage
, pCellBody
, &pCur
->info
);
5569 nCell
= (int)pCur
->info
.nKey
;
5570 testcase( nCell
<0 ); /* True if key size is 2^32 or more */
5571 testcase( nCell
==0 ); /* Invalid key size: 0x80 0x80 0x00 */
5572 testcase( nCell
==1 ); /* Invalid key size: 0x80 0x80 0x01 */
5573 testcase( nCell
==2 ); /* Minimum legal index key size */
5574 if( nCell
<2 || nCell
/pCur
->pBt
->usableSize
>pCur
->pBt
->nPage
){
5575 rc
= SQLITE_CORRUPT_PAGE(pPage
);
5578 pCellKey
= sqlite3Malloc( nCell
+nOverrun
);
5580 rc
= SQLITE_NOMEM_BKPT
;
5583 pCur
->ix
= (u16
)idx
;
5584 rc
= accessPayload(pCur
, 0, nCell
, (unsigned char*)pCellKey
, 0);
5585 memset(((u8
*)pCellKey
)+nCell
,0,nOverrun
); /* Fix uninit warnings */
5586 pCur
->curFlags
&= ~BTCF_ValidOvfl
;
5588 sqlite3_free(pCellKey
);
5591 c
= sqlite3VdbeRecordCompare(nCell
, pCellKey
, pIdxKey
);
5592 sqlite3_free(pCellKey
);
5595 (pIdxKey
->errCode
!=SQLITE_CORRUPT
|| c
==0)
5596 && (pIdxKey
->errCode
!=SQLITE_NOMEM
|| pCur
->pBtree
->db
->mallocFailed
)
5606 pCur
->ix
= (u16
)idx
;
5607 if( pIdxKey
->errCode
) rc
= SQLITE_CORRUPT_BKPT
;
5610 if( lwr
>upr
) break;
5611 assert( lwr
+upr
>=0 );
5612 idx
= (lwr
+upr
)>>1; /* idx = (lwr+upr)/2 */
5615 assert( lwr
==upr
+1 || (pPage
->intKey
&& !pPage
->leaf
) );
5616 assert( pPage
->isInit
);
5618 assert( pCur
->ix
<pCur
->pPage
->nCell
);
5619 pCur
->ix
= (u16
)idx
;
5625 if( lwr
>=pPage
->nCell
){
5626 chldPg
= get4byte(&pPage
->aData
[pPage
->hdrOffset
+8]);
5628 chldPg
= get4byte(findCell(pPage
, lwr
));
5630 pCur
->ix
= (u16
)lwr
;
5631 rc
= moveToChild(pCur
, chldPg
);
5635 pCur
->info
.nSize
= 0;
5636 assert( (pCur
->curFlags
& BTCF_ValidOvfl
)==0 );
5642 ** Return TRUE if the cursor is not pointing at an entry of the table.
5644 ** TRUE will be returned after a call to sqlite3BtreeNext() moves
5645 ** past the last entry in the table or sqlite3BtreePrev() moves past
5646 ** the first entry. TRUE is also returned if the table is empty.
5648 int sqlite3BtreeEof(BtCursor
*pCur
){
5649 /* TODO: What if the cursor is in CURSOR_REQUIRESEEK but all table entries
5650 ** have been deleted? This API will need to change to return an error code
5651 ** as well as the boolean result value.
5653 return (CURSOR_VALID
!=pCur
->eState
);
5657 ** Return an estimate for the number of rows in the table that pCur is
5658 ** pointing to. Return a negative number if no estimate is currently
5661 i64
sqlite3BtreeRowCountEst(BtCursor
*pCur
){
5665 assert( cursorOwnsBtShared(pCur
) );
5666 assert( sqlite3_mutex_held(pCur
->pBtree
->db
->mutex
) );
5668 /* Currently this interface is only called by the OP_IfSmaller
5669 ** opcode, and it that case the cursor will always be valid and
5670 ** will always point to a leaf node. */
5671 if( NEVER(pCur
->eState
!=CURSOR_VALID
) ) return -1;
5672 if( NEVER(pCur
->pPage
->leaf
==0) ) return -1;
5674 n
= pCur
->pPage
->nCell
;
5675 for(i
=0; i
<pCur
->iPage
; i
++){
5676 n
*= pCur
->apPage
[i
]->nCell
;
5682 ** Advance the cursor to the next entry in the database.
5685 ** SQLITE_OK success
5686 ** SQLITE_DONE cursor is already pointing at the last element
5687 ** otherwise some kind of error occurred
5689 ** The main entry point is sqlite3BtreeNext(). That routine is optimized
5690 ** for the common case of merely incrementing the cell counter BtCursor.aiIdx
5691 ** to the next cell on the current page. The (slower) btreeNext() helper
5692 ** routine is called when it is necessary to move to a different page or
5693 ** to restore the cursor.
5695 ** If bit 0x01 of the F argument in sqlite3BtreeNext(C,F) is 1, then the
5696 ** cursor corresponds to an SQL index and this routine could have been
5697 ** skipped if the SQL index had been a unique index. The F argument
5698 ** is a hint to the implement. SQLite btree implementation does not use
5699 ** this hint, but COMDB2 does.
5701 static SQLITE_NOINLINE
int btreeNext(BtCursor
*pCur
){
5706 assert( cursorOwnsBtShared(pCur
) );
5707 if( pCur
->eState
!=CURSOR_VALID
){
5708 assert( (pCur
->curFlags
& BTCF_ValidOvfl
)==0 );
5709 rc
= restoreCursorPosition(pCur
);
5710 if( rc
!=SQLITE_OK
){
5713 if( CURSOR_INVALID
==pCur
->eState
){
5716 if( pCur
->eState
==CURSOR_SKIPNEXT
){
5717 pCur
->eState
= CURSOR_VALID
;
5718 if( pCur
->skipNext
>0 ) return SQLITE_OK
;
5722 pPage
= pCur
->pPage
;
5724 if( !pPage
->isInit
){
5725 /* The only known way for this to happen is for there to be a
5726 ** recursive SQL function that does a DELETE operation as part of a
5727 ** SELECT which deletes content out from under an active cursor
5728 ** in a corrupt database file where the table being DELETE-ed from
5729 ** has pages in common with the table being queried. See TH3
5730 ** module cov1/btree78.test testcase 220 (2018-06-08) for an
5732 return SQLITE_CORRUPT_BKPT
;
5735 /* If the database file is corrupt, it is possible for the value of idx
5736 ** to be invalid here. This can only occur if a second cursor modifies
5737 ** the page while cursor pCur is holding a reference to it. Which can
5738 ** only happen if the database is corrupt in such a way as to link the
5739 ** page into more than one b-tree structure.
5741 ** Update 2019-12-23: appears to long longer be possible after the
5742 ** addition of anotherValidCursor() condition on balance_deeper(). */
5743 harmless( idx
>pPage
->nCell
);
5745 if( idx
>=pPage
->nCell
){
5747 rc
= moveToChild(pCur
, get4byte(&pPage
->aData
[pPage
->hdrOffset
+8]));
5749 return moveToLeftmost(pCur
);
5752 if( pCur
->iPage
==0 ){
5753 pCur
->eState
= CURSOR_INVALID
;
5757 pPage
= pCur
->pPage
;
5758 }while( pCur
->ix
>=pPage
->nCell
);
5759 if( pPage
->intKey
){
5760 return sqlite3BtreeNext(pCur
, 0);
5768 return moveToLeftmost(pCur
);
5771 int sqlite3BtreeNext(BtCursor
*pCur
, int flags
){
5773 UNUSED_PARAMETER( flags
); /* Used in COMDB2 but not native SQLite */
5774 assert( cursorOwnsBtShared(pCur
) );
5775 assert( flags
==0 || flags
==1 );
5776 pCur
->info
.nSize
= 0;
5777 pCur
->curFlags
&= ~(BTCF_ValidNKey
|BTCF_ValidOvfl
);
5778 if( pCur
->eState
!=CURSOR_VALID
) return btreeNext(pCur
);
5779 pPage
= pCur
->pPage
;
5780 if( (++pCur
->ix
)>=pPage
->nCell
){
5782 return btreeNext(pCur
);
5787 return moveToLeftmost(pCur
);
5792 ** Step the cursor to the back to the previous entry in the database.
5795 ** SQLITE_OK success
5796 ** SQLITE_DONE the cursor is already on the first element of the table
5797 ** otherwise some kind of error occurred
5799 ** The main entry point is sqlite3BtreePrevious(). That routine is optimized
5800 ** for the common case of merely decrementing the cell counter BtCursor.aiIdx
5801 ** to the previous cell on the current page. The (slower) btreePrevious()
5802 ** helper routine is called when it is necessary to move to a different page
5803 ** or to restore the cursor.
5805 ** If bit 0x01 of the F argument to sqlite3BtreePrevious(C,F) is 1, then
5806 ** the cursor corresponds to an SQL index and this routine could have been
5807 ** skipped if the SQL index had been a unique index. The F argument is a
5808 ** hint to the implement. The native SQLite btree implementation does not
5809 ** use this hint, but COMDB2 does.
5811 static SQLITE_NOINLINE
int btreePrevious(BtCursor
*pCur
){
5815 assert( cursorOwnsBtShared(pCur
) );
5816 assert( (pCur
->curFlags
& (BTCF_AtLast
|BTCF_ValidOvfl
|BTCF_ValidNKey
))==0 );
5817 assert( pCur
->info
.nSize
==0 );
5818 if( pCur
->eState
!=CURSOR_VALID
){
5819 rc
= restoreCursorPosition(pCur
);
5820 if( rc
!=SQLITE_OK
){
5823 if( CURSOR_INVALID
==pCur
->eState
){
5826 if( CURSOR_SKIPNEXT
==pCur
->eState
){
5827 pCur
->eState
= CURSOR_VALID
;
5828 if( pCur
->skipNext
<0 ) return SQLITE_OK
;
5832 pPage
= pCur
->pPage
;
5833 assert( pPage
->isInit
);
5836 rc
= moveToChild(pCur
, get4byte(findCell(pPage
, idx
)));
5838 rc
= moveToRightmost(pCur
);
5840 while( pCur
->ix
==0 ){
5841 if( pCur
->iPage
==0 ){
5842 pCur
->eState
= CURSOR_INVALID
;
5847 assert( pCur
->info
.nSize
==0 );
5848 assert( (pCur
->curFlags
& (BTCF_ValidOvfl
))==0 );
5851 pPage
= pCur
->pPage
;
5852 if( pPage
->intKey
&& !pPage
->leaf
){
5853 rc
= sqlite3BtreePrevious(pCur
, 0);
5860 int sqlite3BtreePrevious(BtCursor
*pCur
, int flags
){
5861 assert( cursorOwnsBtShared(pCur
) );
5862 assert( flags
==0 || flags
==1 );
5863 UNUSED_PARAMETER( flags
); /* Used in COMDB2 but not native SQLite */
5864 pCur
->curFlags
&= ~(BTCF_AtLast
|BTCF_ValidOvfl
|BTCF_ValidNKey
);
5865 pCur
->info
.nSize
= 0;
5866 if( pCur
->eState
!=CURSOR_VALID
5868 || pCur
->pPage
->leaf
==0
5870 return btreePrevious(pCur
);
5877 ** Allocate a new page from the database file.
5879 ** The new page is marked as dirty. (In other words, sqlite3PagerWrite()
5880 ** has already been called on the new page.) The new page has also
5881 ** been referenced and the calling routine is responsible for calling
5882 ** sqlite3PagerUnref() on the new page when it is done.
5884 ** SQLITE_OK is returned on success. Any other return value indicates
5885 ** an error. *ppPage is set to NULL in the event of an error.
5887 ** If the "nearby" parameter is not 0, then an effort is made to
5888 ** locate a page close to the page number "nearby". This can be used in an
5889 ** attempt to keep related pages close to each other in the database file,
5890 ** which in turn can make database access faster.
5892 ** If the eMode parameter is BTALLOC_EXACT and the nearby page exists
5893 ** anywhere on the free-list, then it is guaranteed to be returned. If
5894 ** eMode is BTALLOC_LT then the page returned will be less than or equal
5895 ** to nearby if any such page exists. If eMode is BTALLOC_ANY then there
5896 ** are no restrictions on which page is returned.
5898 static int allocateBtreePage(
5899 BtShared
*pBt
, /* The btree */
5900 MemPage
**ppPage
, /* Store pointer to the allocated page here */
5901 Pgno
*pPgno
, /* Store the page number here */
5902 Pgno nearby
, /* Search for a page near this one */
5903 u8 eMode
/* BTALLOC_EXACT, BTALLOC_LT, or BTALLOC_ANY */
5907 u32 n
; /* Number of pages on the freelist */
5908 u32 k
; /* Number of leaves on the trunk of the freelist */
5909 MemPage
*pTrunk
= 0;
5910 MemPage
*pPrevTrunk
= 0;
5911 Pgno mxPage
; /* Total size of the database file */
5913 assert( sqlite3_mutex_held(pBt
->mutex
) );
5914 assert( eMode
==BTALLOC_ANY
|| (nearby
>0 && IfNotOmitAV(pBt
->autoVacuum
)) );
5915 pPage1
= pBt
->pPage1
;
5916 mxPage
= btreePagecount(pBt
);
5917 /* EVIDENCE-OF: R-05119-02637 The 4-byte big-endian integer at offset 36
5918 ** stores stores the total number of pages on the freelist. */
5919 n
= get4byte(&pPage1
->aData
[36]);
5920 testcase( n
==mxPage
-1 );
5922 return SQLITE_CORRUPT_BKPT
;
5925 /* There are pages on the freelist. Reuse one of those pages. */
5927 u8 searchList
= 0; /* If the free-list must be searched for 'nearby' */
5928 u32 nSearch
= 0; /* Count of the number of search attempts */
5930 /* If eMode==BTALLOC_EXACT and a query of the pointer-map
5931 ** shows that the page 'nearby' is somewhere on the free-list, then
5932 ** the entire-list will be searched for that page.
5934 #ifndef SQLITE_OMIT_AUTOVACUUM
5935 if( eMode
==BTALLOC_EXACT
){
5936 if( nearby
<=mxPage
){
5939 assert( pBt
->autoVacuum
);
5940 rc
= ptrmapGet(pBt
, nearby
, &eType
, 0);
5942 if( eType
==PTRMAP_FREEPAGE
){
5946 }else if( eMode
==BTALLOC_LE
){
5951 /* Decrement the free-list count by 1. Set iTrunk to the index of the
5952 ** first free-list trunk page. iPrevTrunk is initially 1.
5954 rc
= sqlite3PagerWrite(pPage1
->pDbPage
);
5956 put4byte(&pPage1
->aData
[36], n
-1);
5958 /* The code within this loop is run only once if the 'searchList' variable
5959 ** is not true. Otherwise, it runs once for each trunk-page on the
5960 ** free-list until the page 'nearby' is located (eMode==BTALLOC_EXACT)
5961 ** or until a page less than 'nearby' is located (eMode==BTALLOC_LT)
5964 pPrevTrunk
= pTrunk
;
5966 /* EVIDENCE-OF: R-01506-11053 The first integer on a freelist trunk page
5967 ** is the page number of the next freelist trunk page in the list or
5968 ** zero if this is the last freelist trunk page. */
5969 iTrunk
= get4byte(&pPrevTrunk
->aData
[0]);
5971 /* EVIDENCE-OF: R-59841-13798 The 4-byte big-endian integer at offset 32
5972 ** stores the page number of the first page of the freelist, or zero if
5973 ** the freelist is empty. */
5974 iTrunk
= get4byte(&pPage1
->aData
[32]);
5976 testcase( iTrunk
==mxPage
);
5977 if( iTrunk
>mxPage
|| nSearch
++ > n
){
5978 rc
= SQLITE_CORRUPT_PGNO(pPrevTrunk
? pPrevTrunk
->pgno
: 1);
5980 rc
= btreeGetUnusedPage(pBt
, iTrunk
, &pTrunk
, 0);
5984 goto end_allocate_page
;
5986 assert( pTrunk
!=0 );
5987 assert( pTrunk
->aData
!=0 );
5988 /* EVIDENCE-OF: R-13523-04394 The second integer on a freelist trunk page
5989 ** is the number of leaf page pointers to follow. */
5990 k
= get4byte(&pTrunk
->aData
[4]);
5991 if( k
==0 && !searchList
){
5992 /* The trunk has no leaves and the list is not being searched.
5993 ** So extract the trunk page itself and use it as the newly
5994 ** allocated page */
5995 assert( pPrevTrunk
==0 );
5996 rc
= sqlite3PagerWrite(pTrunk
->pDbPage
);
5998 goto end_allocate_page
;
6001 memcpy(&pPage1
->aData
[32], &pTrunk
->aData
[0], 4);
6004 TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno
, n
-1));
6005 }else if( k
>(u32
)(pBt
->usableSize
/4 - 2) ){
6006 /* Value of k is out of range. Database corruption */
6007 rc
= SQLITE_CORRUPT_PGNO(iTrunk
);
6008 goto end_allocate_page
;
6009 #ifndef SQLITE_OMIT_AUTOVACUUM
6010 }else if( searchList
6011 && (nearby
==iTrunk
|| (iTrunk
<nearby
&& eMode
==BTALLOC_LE
))
6013 /* The list is being searched and this trunk page is the page
6014 ** to allocate, regardless of whether it has leaves.
6019 rc
= sqlite3PagerWrite(pTrunk
->pDbPage
);
6021 goto end_allocate_page
;
6025 memcpy(&pPage1
->aData
[32], &pTrunk
->aData
[0], 4);
6027 rc
= sqlite3PagerWrite(pPrevTrunk
->pDbPage
);
6028 if( rc
!=SQLITE_OK
){
6029 goto end_allocate_page
;
6031 memcpy(&pPrevTrunk
->aData
[0], &pTrunk
->aData
[0], 4);
6034 /* The trunk page is required by the caller but it contains
6035 ** pointers to free-list leaves. The first leaf becomes a trunk
6036 ** page in this case.
6039 Pgno iNewTrunk
= get4byte(&pTrunk
->aData
[8]);
6040 if( iNewTrunk
>mxPage
){
6041 rc
= SQLITE_CORRUPT_PGNO(iTrunk
);
6042 goto end_allocate_page
;
6044 testcase( iNewTrunk
==mxPage
);
6045 rc
= btreeGetUnusedPage(pBt
, iNewTrunk
, &pNewTrunk
, 0);
6046 if( rc
!=SQLITE_OK
){
6047 goto end_allocate_page
;
6049 rc
= sqlite3PagerWrite(pNewTrunk
->pDbPage
);
6050 if( rc
!=SQLITE_OK
){
6051 releasePage(pNewTrunk
);
6052 goto end_allocate_page
;
6054 memcpy(&pNewTrunk
->aData
[0], &pTrunk
->aData
[0], 4);
6055 put4byte(&pNewTrunk
->aData
[4], k
-1);
6056 memcpy(&pNewTrunk
->aData
[8], &pTrunk
->aData
[12], (k
-1)*4);
6057 releasePage(pNewTrunk
);
6059 assert( sqlite3PagerIswriteable(pPage1
->pDbPage
) );
6060 put4byte(&pPage1
->aData
[32], iNewTrunk
);
6062 rc
= sqlite3PagerWrite(pPrevTrunk
->pDbPage
);
6064 goto end_allocate_page
;
6066 put4byte(&pPrevTrunk
->aData
[0], iNewTrunk
);
6070 TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno
, n
-1));
6073 /* Extract a leaf from the trunk */
6076 unsigned char *aData
= pTrunk
->aData
;
6080 if( eMode
==BTALLOC_LE
){
6082 iPage
= get4byte(&aData
[8+i
*4]);
6083 if( iPage
<=nearby
){
6090 dist
= sqlite3AbsInt32(get4byte(&aData
[8]) - nearby
);
6092 int d2
= sqlite3AbsInt32(get4byte(&aData
[8+i
*4]) - nearby
);
6103 iPage
= get4byte(&aData
[8+closest
*4]);
6104 testcase( iPage
==mxPage
);
6106 rc
= SQLITE_CORRUPT_PGNO(iTrunk
);
6107 goto end_allocate_page
;
6109 testcase( iPage
==mxPage
);
6111 || (iPage
==nearby
|| (iPage
<nearby
&& eMode
==BTALLOC_LE
))
6115 TRACE(("ALLOCATE: %d was leaf %d of %d on trunk %d"
6116 ": %d more free pages\n",
6117 *pPgno
, closest
+1, k
, pTrunk
->pgno
, n
-1));
6118 rc
= sqlite3PagerWrite(pTrunk
->pDbPage
);
6119 if( rc
) goto end_allocate_page
;
6121 memcpy(&aData
[8+closest
*4], &aData
[4+k
*4], 4);
6123 put4byte(&aData
[4], k
-1);
6124 noContent
= !btreeGetHasContent(pBt
, *pPgno
)? PAGER_GET_NOCONTENT
: 0;
6125 rc
= btreeGetUnusedPage(pBt
, *pPgno
, ppPage
, noContent
);
6126 if( rc
==SQLITE_OK
){
6127 rc
= sqlite3PagerWrite((*ppPage
)->pDbPage
);
6128 if( rc
!=SQLITE_OK
){
6129 releasePage(*ppPage
);
6136 releasePage(pPrevTrunk
);
6138 }while( searchList
);
6140 /* There are no pages on the freelist, so append a new page to the
6143 ** Normally, new pages allocated by this block can be requested from the
6144 ** pager layer with the 'no-content' flag set. This prevents the pager
6145 ** from trying to read the pages content from disk. However, if the
6146 ** current transaction has already run one or more incremental-vacuum
6147 ** steps, then the page we are about to allocate may contain content
6148 ** that is required in the event of a rollback. In this case, do
6149 ** not set the no-content flag. This causes the pager to load and journal
6150 ** the current page content before overwriting it.
6152 ** Note that the pager will not actually attempt to load or journal
6153 ** content for any page that really does lie past the end of the database
6154 ** file on disk. So the effects of disabling the no-content optimization
6155 ** here are confined to those pages that lie between the end of the
6156 ** database image and the end of the database file.
6158 int bNoContent
= (0==IfNotOmitAV(pBt
->bDoTruncate
))? PAGER_GET_NOCONTENT
:0;
6160 rc
= sqlite3PagerWrite(pBt
->pPage1
->pDbPage
);
6163 if( pBt
->nPage
==PENDING_BYTE_PAGE(pBt
) ) pBt
->nPage
++;
6165 #ifndef SQLITE_OMIT_AUTOVACUUM
6166 if( pBt
->autoVacuum
&& PTRMAP_ISPAGE(pBt
, pBt
->nPage
) ){
6167 /* If *pPgno refers to a pointer-map page, allocate two new pages
6168 ** at the end of the file instead of one. The first allocated page
6169 ** becomes a new pointer-map page, the second is used by the caller.
6172 TRACE(("ALLOCATE: %d from end of file (pointer-map page)\n", pBt
->nPage
));
6173 assert( pBt
->nPage
!=PENDING_BYTE_PAGE(pBt
) );
6174 rc
= btreeGetUnusedPage(pBt
, pBt
->nPage
, &pPg
, bNoContent
);
6175 if( rc
==SQLITE_OK
){
6176 rc
= sqlite3PagerWrite(pPg
->pDbPage
);
6181 if( pBt
->nPage
==PENDING_BYTE_PAGE(pBt
) ){ pBt
->nPage
++; }
6184 put4byte(28 + (u8
*)pBt
->pPage1
->aData
, pBt
->nPage
);
6185 *pPgno
= pBt
->nPage
;
6187 assert( *pPgno
!=PENDING_BYTE_PAGE(pBt
) );
6188 rc
= btreeGetUnusedPage(pBt
, *pPgno
, ppPage
, bNoContent
);
6190 rc
= sqlite3PagerWrite((*ppPage
)->pDbPage
);
6191 if( rc
!=SQLITE_OK
){
6192 releasePage(*ppPage
);
6195 TRACE(("ALLOCATE: %d from end of file\n", *pPgno
));
6198 assert( CORRUPT_DB
|| *pPgno
!=PENDING_BYTE_PAGE(pBt
) );
6201 releasePage(pTrunk
);
6202 releasePage(pPrevTrunk
);
6203 assert( rc
!=SQLITE_OK
|| sqlite3PagerPageRefcount((*ppPage
)->pDbPage
)<=1 );
6204 assert( rc
!=SQLITE_OK
|| (*ppPage
)->isInit
==0 );
6209 ** This function is used to add page iPage to the database file free-list.
6210 ** It is assumed that the page is not already a part of the free-list.
6212 ** The value passed as the second argument to this function is optional.
6213 ** If the caller happens to have a pointer to the MemPage object
6214 ** corresponding to page iPage handy, it may pass it as the second value.
6215 ** Otherwise, it may pass NULL.
6217 ** If a pointer to a MemPage object is passed as the second argument,
6218 ** its reference count is not altered by this function.
6220 static int freePage2(BtShared
*pBt
, MemPage
*pMemPage
, Pgno iPage
){
6221 MemPage
*pTrunk
= 0; /* Free-list trunk page */
6222 Pgno iTrunk
= 0; /* Page number of free-list trunk page */
6223 MemPage
*pPage1
= pBt
->pPage1
; /* Local reference to page 1 */
6224 MemPage
*pPage
; /* Page being freed. May be NULL. */
6225 int rc
; /* Return Code */
6226 u32 nFree
; /* Initial number of pages on free-list */
6228 assert( sqlite3_mutex_held(pBt
->mutex
) );
6229 assert( CORRUPT_DB
|| iPage
>1 );
6230 assert( !pMemPage
|| pMemPage
->pgno
==iPage
);
6232 if( iPage
<2 || iPage
>pBt
->nPage
){
6233 return SQLITE_CORRUPT_BKPT
;
6237 sqlite3PagerRef(pPage
->pDbPage
);
6239 pPage
= btreePageLookup(pBt
, iPage
);
6242 /* Increment the free page count on pPage1 */
6243 rc
= sqlite3PagerWrite(pPage1
->pDbPage
);
6244 if( rc
) goto freepage_out
;
6245 nFree
= get4byte(&pPage1
->aData
[36]);
6246 put4byte(&pPage1
->aData
[36], nFree
+1);
6248 if( pBt
->btsFlags
& BTS_SECURE_DELETE
){
6249 /* If the secure_delete option is enabled, then
6250 ** always fully overwrite deleted information with zeros.
6252 if( (!pPage
&& ((rc
= btreeGetPage(pBt
, iPage
, &pPage
, 0))!=0) )
6253 || ((rc
= sqlite3PagerWrite(pPage
->pDbPage
))!=0)
6257 memset(pPage
->aData
, 0, pPage
->pBt
->pageSize
);
6260 /* If the database supports auto-vacuum, write an entry in the pointer-map
6261 ** to indicate that the page is free.
6264 ptrmapPut(pBt
, iPage
, PTRMAP_FREEPAGE
, 0, &rc
);
6265 if( rc
) goto freepage_out
;
6268 /* Now manipulate the actual database free-list structure. There are two
6269 ** possibilities. If the free-list is currently empty, or if the first
6270 ** trunk page in the free-list is full, then this page will become a
6271 ** new free-list trunk page. Otherwise, it will become a leaf of the
6272 ** first trunk page in the current free-list. This block tests if it
6273 ** is possible to add the page as a new free-list leaf.
6276 u32 nLeaf
; /* Initial number of leaf cells on trunk page */
6278 iTrunk
= get4byte(&pPage1
->aData
[32]);
6279 rc
= btreeGetPage(pBt
, iTrunk
, &pTrunk
, 0);
6280 if( rc
!=SQLITE_OK
){
6284 nLeaf
= get4byte(&pTrunk
->aData
[4]);
6285 assert( pBt
->usableSize
>32 );
6286 if( nLeaf
> (u32
)pBt
->usableSize
/4 - 2 ){
6287 rc
= SQLITE_CORRUPT_BKPT
;
6290 if( nLeaf
< (u32
)pBt
->usableSize
/4 - 8 ){
6291 /* In this case there is room on the trunk page to insert the page
6292 ** being freed as a new leaf.
6294 ** Note that the trunk page is not really full until it contains
6295 ** usableSize/4 - 2 entries, not usableSize/4 - 8 entries as we have
6296 ** coded. But due to a coding error in versions of SQLite prior to
6297 ** 3.6.0, databases with freelist trunk pages holding more than
6298 ** usableSize/4 - 8 entries will be reported as corrupt. In order
6299 ** to maintain backwards compatibility with older versions of SQLite,
6300 ** we will continue to restrict the number of entries to usableSize/4 - 8
6301 ** for now. At some point in the future (once everyone has upgraded
6302 ** to 3.6.0 or later) we should consider fixing the conditional above
6303 ** to read "usableSize/4-2" instead of "usableSize/4-8".
6305 ** EVIDENCE-OF: R-19920-11576 However, newer versions of SQLite still
6306 ** avoid using the last six entries in the freelist trunk page array in
6307 ** order that database files created by newer versions of SQLite can be
6308 ** read by older versions of SQLite.
6310 rc
= sqlite3PagerWrite(pTrunk
->pDbPage
);
6311 if( rc
==SQLITE_OK
){
6312 put4byte(&pTrunk
->aData
[4], nLeaf
+1);
6313 put4byte(&pTrunk
->aData
[8+nLeaf
*4], iPage
);
6314 if( pPage
&& (pBt
->btsFlags
& BTS_SECURE_DELETE
)==0 ){
6315 sqlite3PagerDontWrite(pPage
->pDbPage
);
6317 rc
= btreeSetHasContent(pBt
, iPage
);
6319 TRACE(("FREE-PAGE: %d leaf on trunk page %d\n",pPage
->pgno
,pTrunk
->pgno
));
6324 /* If control flows to this point, then it was not possible to add the
6325 ** the page being freed as a leaf page of the first trunk in the free-list.
6326 ** Possibly because the free-list is empty, or possibly because the
6327 ** first trunk in the free-list is full. Either way, the page being freed
6328 ** will become the new first trunk page in the free-list.
6330 if( pPage
==0 && SQLITE_OK
!=(rc
= btreeGetPage(pBt
, iPage
, &pPage
, 0)) ){
6333 rc
= sqlite3PagerWrite(pPage
->pDbPage
);
6334 if( rc
!=SQLITE_OK
){
6337 put4byte(pPage
->aData
, iTrunk
);
6338 put4byte(&pPage
->aData
[4], 0);
6339 put4byte(&pPage1
->aData
[32], iPage
);
6340 TRACE(("FREE-PAGE: %d new trunk page replacing %d\n", pPage
->pgno
, iTrunk
));
6347 releasePage(pTrunk
);
6350 static void freePage(MemPage
*pPage
, int *pRC
){
6351 if( (*pRC
)==SQLITE_OK
){
6352 *pRC
= freePage2(pPage
->pBt
, pPage
, pPage
->pgno
);
6357 ** Free any overflow pages associated with the given Cell. Store
6358 ** size information about the cell in pInfo.
6360 static int clearCell(
6361 MemPage
*pPage
, /* The page that contains the Cell */
6362 unsigned char *pCell
, /* First byte of the Cell */
6363 CellInfo
*pInfo
/* Size information about the cell */
6371 assert( sqlite3_mutex_held(pPage
->pBt
->mutex
) );
6372 pPage
->xParseCell(pPage
, pCell
, pInfo
);
6373 if( pInfo
->nLocal
==pInfo
->nPayload
){
6374 return SQLITE_OK
; /* No overflow pages. Return without doing anything */
6376 testcase( pCell
+ pInfo
->nSize
== pPage
->aDataEnd
);
6377 testcase( pCell
+ (pInfo
->nSize
-1) == pPage
->aDataEnd
);
6378 if( pCell
+ pInfo
->nSize
> pPage
->aDataEnd
){
6379 /* Cell extends past end of page */
6380 return SQLITE_CORRUPT_PAGE(pPage
);
6382 ovflPgno
= get4byte(pCell
+ pInfo
->nSize
- 4);
6384 assert( pBt
->usableSize
> 4 );
6385 ovflPageSize
= pBt
->usableSize
- 4;
6386 nOvfl
= (pInfo
->nPayload
- pInfo
->nLocal
+ ovflPageSize
- 1)/ovflPageSize
;
6388 (CORRUPT_DB
&& (pInfo
->nPayload
+ ovflPageSize
)<ovflPageSize
)
6393 if( ovflPgno
<2 || ovflPgno
>btreePagecount(pBt
) ){
6394 /* 0 is not a legal page number and page 1 cannot be an
6395 ** overflow page. Therefore if ovflPgno<2 or past the end of the
6396 ** file the database must be corrupt. */
6397 return SQLITE_CORRUPT_BKPT
;
6400 rc
= getOverflowPage(pBt
, ovflPgno
, &pOvfl
, &iNext
);
6404 if( ( pOvfl
|| ((pOvfl
= btreePageLookup(pBt
, ovflPgno
))!=0) )
6405 && sqlite3PagerPageRefcount(pOvfl
->pDbPage
)!=1
6407 /* There is no reason any cursor should have an outstanding reference
6408 ** to an overflow page belonging to a cell that is being deleted/updated.
6409 ** So if there exists more than one reference to this page, then it
6410 ** must not really be an overflow page and the database must be corrupt.
6411 ** It is helpful to detect this before calling freePage2(), as
6412 ** freePage2() may zero the page contents if secure-delete mode is
6413 ** enabled. If this 'overflow' page happens to be a page that the
6414 ** caller is iterating through or using in some other way, this
6415 ** can be problematic.
6417 rc
= SQLITE_CORRUPT_BKPT
;
6419 rc
= freePage2(pBt
, pOvfl
, ovflPgno
);
6423 sqlite3PagerUnref(pOvfl
->pDbPage
);
6432 ** Create the byte sequence used to represent a cell on page pPage
6433 ** and write that byte sequence into pCell[]. Overflow pages are
6434 ** allocated and filled in as necessary. The calling procedure
6435 ** is responsible for making sure sufficient space has been allocated
6438 ** Note that pCell does not necessary need to point to the pPage->aData
6439 ** area. pCell might point to some temporary storage. The cell will
6440 ** be constructed in this temporary area then copied into pPage->aData
6443 static int fillInCell(
6444 MemPage
*pPage
, /* The page that contains the cell */
6445 unsigned char *pCell
, /* Complete text of the cell */
6446 const BtreePayload
*pX
, /* Payload with which to construct the cell */
6447 int *pnSize
/* Write cell size here */
6451 int nSrc
, n
, rc
, mn
;
6453 MemPage
*pToRelease
;
6454 unsigned char *pPrior
;
6455 unsigned char *pPayload
;
6460 assert( sqlite3_mutex_held(pPage
->pBt
->mutex
) );
6462 /* pPage is not necessarily writeable since pCell might be auxiliary
6463 ** buffer space that is separate from the pPage buffer area */
6464 assert( pCell
<pPage
->aData
|| pCell
>=&pPage
->aData
[pPage
->pBt
->pageSize
]
6465 || sqlite3PagerIswriteable(pPage
->pDbPage
) );
6467 /* Fill in the header. */
6468 nHeader
= pPage
->childPtrSize
;
6469 if( pPage
->intKey
){
6470 nPayload
= pX
->nData
+ pX
->nZero
;
6473 assert( pPage
->intKeyLeaf
); /* fillInCell() only called for leaves */
6474 nHeader
+= putVarint32(&pCell
[nHeader
], nPayload
);
6475 nHeader
+= putVarint(&pCell
[nHeader
], *(u64
*)&pX
->nKey
);
6477 assert( pX
->nKey
<=0x7fffffff && pX
->pKey
!=0 );
6478 nSrc
= nPayload
= (int)pX
->nKey
;
6480 nHeader
+= putVarint32(&pCell
[nHeader
], nPayload
);
6483 /* Fill in the payload */
6484 pPayload
= &pCell
[nHeader
];
6485 if( nPayload
<=pPage
->maxLocal
){
6486 /* This is the common case where everything fits on the btree page
6487 ** and no overflow pages are required. */
6488 n
= nHeader
+ nPayload
;
6493 assert( nSrc
<=nPayload
);
6494 testcase( nSrc
<nPayload
);
6495 memcpy(pPayload
, pSrc
, nSrc
);
6496 memset(pPayload
+nSrc
, 0, nPayload
-nSrc
);
6500 /* If we reach this point, it means that some of the content will need
6501 ** to spill onto overflow pages.
6503 mn
= pPage
->minLocal
;
6504 n
= mn
+ (nPayload
- mn
) % (pPage
->pBt
->usableSize
- 4);
6505 testcase( n
==pPage
->maxLocal
);
6506 testcase( n
==pPage
->maxLocal
+1 );
6507 if( n
> pPage
->maxLocal
) n
= mn
;
6509 *pnSize
= n
+ nHeader
+ 4;
6510 pPrior
= &pCell
[nHeader
+n
];
6515 /* At this point variables should be set as follows:
6517 ** nPayload Total payload size in bytes
6518 ** pPayload Begin writing payload here
6519 ** spaceLeft Space available at pPayload. If nPayload>spaceLeft,
6520 ** that means content must spill into overflow pages.
6521 ** *pnSize Size of the local cell (not counting overflow pages)
6522 ** pPrior Where to write the pgno of the first overflow page
6524 ** Use a call to btreeParseCellPtr() to verify that the values above
6525 ** were computed correctly.
6530 pPage
->xParseCell(pPage
, pCell
, &info
);
6531 assert( nHeader
==(int)(info
.pPayload
- pCell
) );
6532 assert( info
.nKey
==pX
->nKey
);
6533 assert( *pnSize
== info
.nSize
);
6534 assert( spaceLeft
== info
.nLocal
);
6538 /* Write the payload into the local Cell and any extra into overflow pages */
6541 if( n
>spaceLeft
) n
= spaceLeft
;
6543 /* If pToRelease is not zero than pPayload points into the data area
6544 ** of pToRelease. Make sure pToRelease is still writeable. */
6545 assert( pToRelease
==0 || sqlite3PagerIswriteable(pToRelease
->pDbPage
) );
6547 /* If pPayload is part of the data area of pPage, then make sure pPage
6548 ** is still writeable */
6549 assert( pPayload
<pPage
->aData
|| pPayload
>=&pPage
->aData
[pBt
->pageSize
]
6550 || sqlite3PagerIswriteable(pPage
->pDbPage
) );
6553 memcpy(pPayload
, pSrc
, n
);
6556 memcpy(pPayload
, pSrc
, n
);
6558 memset(pPayload
, 0, n
);
6561 if( nPayload
<=0 ) break;
6568 #ifndef SQLITE_OMIT_AUTOVACUUM
6569 Pgno pgnoPtrmap
= pgnoOvfl
; /* Overflow page pointer-map entry page */
6570 if( pBt
->autoVacuum
){
6574 PTRMAP_ISPAGE(pBt
, pgnoOvfl
) || pgnoOvfl
==PENDING_BYTE_PAGE(pBt
)
6578 rc
= allocateBtreePage(pBt
, &pOvfl
, &pgnoOvfl
, pgnoOvfl
, 0);
6579 #ifndef SQLITE_OMIT_AUTOVACUUM
6580 /* If the database supports auto-vacuum, and the second or subsequent
6581 ** overflow page is being allocated, add an entry to the pointer-map
6582 ** for that page now.
6584 ** If this is the first overflow page, then write a partial entry
6585 ** to the pointer-map. If we write nothing to this pointer-map slot,
6586 ** then the optimistic overflow chain processing in clearCell()
6587 ** may misinterpret the uninitialized values and delete the
6588 ** wrong pages from the database.
6590 if( pBt
->autoVacuum
&& rc
==SQLITE_OK
){
6591 u8 eType
= (pgnoPtrmap
?PTRMAP_OVERFLOW2
:PTRMAP_OVERFLOW1
);
6592 ptrmapPut(pBt
, pgnoOvfl
, eType
, pgnoPtrmap
, &rc
);
6599 releasePage(pToRelease
);
6603 /* If pToRelease is not zero than pPrior points into the data area
6604 ** of pToRelease. Make sure pToRelease is still writeable. */
6605 assert( pToRelease
==0 || sqlite3PagerIswriteable(pToRelease
->pDbPage
) );
6607 /* If pPrior is part of the data area of pPage, then make sure pPage
6608 ** is still writeable */
6609 assert( pPrior
<pPage
->aData
|| pPrior
>=&pPage
->aData
[pBt
->pageSize
]
6610 || sqlite3PagerIswriteable(pPage
->pDbPage
) );
6612 put4byte(pPrior
, pgnoOvfl
);
6613 releasePage(pToRelease
);
6615 pPrior
= pOvfl
->aData
;
6616 put4byte(pPrior
, 0);
6617 pPayload
= &pOvfl
->aData
[4];
6618 spaceLeft
= pBt
->usableSize
- 4;
6621 releasePage(pToRelease
);
6626 ** Remove the i-th cell from pPage. This routine effects pPage only.
6627 ** The cell content is not freed or deallocated. It is assumed that
6628 ** the cell content has been copied someplace else. This routine just
6629 ** removes the reference to the cell from pPage.
6631 ** "sz" must be the number of bytes in the cell.
6633 static void dropCell(MemPage
*pPage
, int idx
, int sz
, int *pRC
){
6634 u32 pc
; /* Offset to cell content of cell being deleted */
6635 u8
*data
; /* pPage->aData */
6636 u8
*ptr
; /* Used to move bytes around within data[] */
6637 int rc
; /* The return code */
6638 int hdr
; /* Beginning of the header. 0 most pages. 100 page 1 */
6641 assert( idx
>=0 && idx
<pPage
->nCell
);
6642 assert( CORRUPT_DB
|| sz
==cellSize(pPage
, idx
) );
6643 assert( sqlite3PagerIswriteable(pPage
->pDbPage
) );
6644 assert( sqlite3_mutex_held(pPage
->pBt
->mutex
) );
6645 assert( pPage
->nFree
>=0 );
6646 data
= pPage
->aData
;
6647 ptr
= &pPage
->aCellIdx
[2*idx
];
6649 hdr
= pPage
->hdrOffset
;
6650 testcase( pc
==get2byte(&data
[hdr
+5]) );
6651 testcase( pc
+sz
==pPage
->pBt
->usableSize
);
6652 if( pc
+sz
> pPage
->pBt
->usableSize
){
6653 *pRC
= SQLITE_CORRUPT_BKPT
;
6656 rc
= freeSpace(pPage
, pc
, sz
);
6662 if( pPage
->nCell
==0 ){
6663 memset(&data
[hdr
+1], 0, 4);
6665 put2byte(&data
[hdr
+5], pPage
->pBt
->usableSize
);
6666 pPage
->nFree
= pPage
->pBt
->usableSize
- pPage
->hdrOffset
6667 - pPage
->childPtrSize
- 8;
6669 memmove(ptr
, ptr
+2, 2*(pPage
->nCell
- idx
));
6670 put2byte(&data
[hdr
+3], pPage
->nCell
);
6676 ** Insert a new cell on pPage at cell index "i". pCell points to the
6677 ** content of the cell.
6679 ** If the cell content will fit on the page, then put it there. If it
6680 ** will not fit, then make a copy of the cell content into pTemp if
6681 ** pTemp is not null. Regardless of pTemp, allocate a new entry
6682 ** in pPage->apOvfl[] and make it point to the cell content (either
6683 ** in pTemp or the original pCell) and also record its index.
6684 ** Allocating a new entry in pPage->aCell[] implies that
6685 ** pPage->nOverflow is incremented.
6687 ** *pRC must be SQLITE_OK when this routine is called.
6689 static void insertCell(
6690 MemPage
*pPage
, /* Page into which we are copying */
6691 int i
, /* New cell becomes the i-th cell of the page */
6692 u8
*pCell
, /* Content of the new cell */
6693 int sz
, /* Bytes of content in pCell */
6694 u8
*pTemp
, /* Temp storage space for pCell, if needed */
6695 Pgno iChild
, /* If non-zero, replace first 4 bytes with this value */
6696 int *pRC
/* Read and write return code from here */
6698 int idx
= 0; /* Where to write new cell content in data[] */
6699 int j
; /* Loop counter */
6700 u8
*data
; /* The content of the whole page */
6701 u8
*pIns
; /* The point in pPage->aCellIdx[] where no cell inserted */
6703 assert( *pRC
==SQLITE_OK
);
6704 assert( i
>=0 && i
<=pPage
->nCell
+pPage
->nOverflow
);
6705 assert( MX_CELL(pPage
->pBt
)<=10921 );
6706 assert( pPage
->nCell
<=MX_CELL(pPage
->pBt
) || CORRUPT_DB
);
6707 assert( pPage
->nOverflow
<=ArraySize(pPage
->apOvfl
) );
6708 assert( ArraySize(pPage
->apOvfl
)==ArraySize(pPage
->aiOvfl
) );
6709 assert( sqlite3_mutex_held(pPage
->pBt
->mutex
) );
6710 assert( sz
==pPage
->xCellSize(pPage
, pCell
) || CORRUPT_DB
);
6711 assert( pPage
->nFree
>=0 );
6712 if( pPage
->nOverflow
|| sz
+2>pPage
->nFree
){
6714 memcpy(pTemp
, pCell
, sz
);
6718 put4byte(pCell
, iChild
);
6720 j
= pPage
->nOverflow
++;
6721 /* Comparison against ArraySize-1 since we hold back one extra slot
6722 ** as a contingency. In other words, never need more than 3 overflow
6723 ** slots but 4 are allocated, just to be safe. */
6724 assert( j
< ArraySize(pPage
->apOvfl
)-1 );
6725 pPage
->apOvfl
[j
] = pCell
;
6726 pPage
->aiOvfl
[j
] = (u16
)i
;
6728 /* When multiple overflows occur, they are always sequential and in
6729 ** sorted order. This invariants arise because multiple overflows can
6730 ** only occur when inserting divider cells into the parent page during
6731 ** balancing, and the dividers are adjacent and sorted.
6733 assert( j
==0 || pPage
->aiOvfl
[j
-1]<(u16
)i
); /* Overflows in sorted order */
6734 assert( j
==0 || i
==pPage
->aiOvfl
[j
-1]+1 ); /* Overflows are sequential */
6736 int rc
= sqlite3PagerWrite(pPage
->pDbPage
);
6737 if( rc
!=SQLITE_OK
){
6741 assert( sqlite3PagerIswriteable(pPage
->pDbPage
) );
6742 data
= pPage
->aData
;
6743 assert( &data
[pPage
->cellOffset
]==pPage
->aCellIdx
);
6744 rc
= allocateSpace(pPage
, sz
, &idx
);
6745 if( rc
){ *pRC
= rc
; return; }
6746 /* The allocateSpace() routine guarantees the following properties
6747 ** if it returns successfully */
6749 assert( idx
>= pPage
->cellOffset
+2*pPage
->nCell
+2 || CORRUPT_DB
);
6750 assert( idx
+sz
<= (int)pPage
->pBt
->usableSize
);
6751 pPage
->nFree
-= (u16
)(2 + sz
);
6753 /* In a corrupt database where an entry in the cell index section of
6754 ** a btree page has a value of 3 or less, the pCell value might point
6755 ** as many as 4 bytes in front of the start of the aData buffer for
6756 ** the source page. Make sure this does not cause problems by not
6757 ** reading the first 4 bytes */
6758 memcpy(&data
[idx
+4], pCell
+4, sz
-4);
6759 put4byte(&data
[idx
], iChild
);
6761 memcpy(&data
[idx
], pCell
, sz
);
6763 pIns
= pPage
->aCellIdx
+ i
*2;
6764 memmove(pIns
+2, pIns
, 2*(pPage
->nCell
- i
));
6765 put2byte(pIns
, idx
);
6767 /* increment the cell count */
6768 if( (++data
[pPage
->hdrOffset
+4])==0 ) data
[pPage
->hdrOffset
+3]++;
6769 assert( get2byte(&data
[pPage
->hdrOffset
+3])==pPage
->nCell
|| CORRUPT_DB
);
6770 #ifndef SQLITE_OMIT_AUTOVACUUM
6771 if( pPage
->pBt
->autoVacuum
){
6772 /* The cell may contain a pointer to an overflow page. If so, write
6773 ** the entry for the overflow page into the pointer map.
6775 ptrmapPutOvflPtr(pPage
, pPage
, pCell
, pRC
);
6782 ** The following parameters determine how many adjacent pages get involved
6783 ** in a balancing operation. NN is the number of neighbors on either side
6784 ** of the page that participate in the balancing operation. NB is the
6785 ** total number of pages that participate, including the target page and
6786 ** NN neighbors on either side.
6788 ** The minimum value of NN is 1 (of course). Increasing NN above 1
6789 ** (to 2 or 3) gives a modest improvement in SELECT and DELETE performance
6790 ** in exchange for a larger degradation in INSERT and UPDATE performance.
6791 ** The value of NN appears to give the best results overall.
6793 ** (Later:) The description above makes it seem as if these values are
6794 ** tunable - as if you could change them and recompile and it would all work.
6795 ** But that is unlikely. NB has been 3 since the inception of SQLite and
6796 ** we have never tested any other value.
6798 #define NN 1 /* Number of neighbors on either side of pPage */
6799 #define NB 3 /* (NN*2+1): Total pages involved in the balance */
6802 ** A CellArray object contains a cache of pointers and sizes for a
6803 ** consecutive sequence of cells that might be held on multiple pages.
6805 ** The cells in this array are the divider cell or cells from the pParent
6806 ** page plus up to three child pages. There are a total of nCell cells.
6808 ** pRef is a pointer to one of the pages that contributes cells. This is
6809 ** used to access information such as MemPage.intKey and MemPage.pBt->pageSize
6810 ** which should be common to all pages that contribute cells to this array.
6812 ** apCell[] and szCell[] hold, respectively, pointers to the start of each
6813 ** cell and the size of each cell. Some of the apCell[] pointers might refer
6814 ** to overflow cells. In other words, some apCel[] pointers might not point
6815 ** to content area of the pages.
6817 ** A szCell[] of zero means the size of that cell has not yet been computed.
6819 ** The cells come from as many as four different pages:
6826 ** --------- --------- ---------
6827 ** |Child-1| |Child-2| |Child-3|
6828 ** --------- --------- ---------
6830 ** The order of cells is in the array is for an index btree is:
6832 ** 1. All cells from Child-1 in order
6833 ** 2. The first divider cell from Parent
6834 ** 3. All cells from Child-2 in order
6835 ** 4. The second divider cell from Parent
6836 ** 5. All cells from Child-3 in order
6838 ** For a table-btree (with rowids) the items 2 and 4 are empty because
6839 ** content exists only in leaves and there are no divider cells.
6841 ** For an index btree, the apEnd[] array holds pointer to the end of page
6842 ** for Child-1, the Parent, Child-2, the Parent (again), and Child-3,
6843 ** respectively. The ixNx[] array holds the number of cells contained in
6844 ** each of these 5 stages, and all stages to the left. Hence:
6846 ** ixNx[0] = Number of cells in Child-1.
6847 ** ixNx[1] = Number of cells in Child-1 plus 1 for first divider.
6848 ** ixNx[2] = Number of cells in Child-1 and Child-2 + 1 for 1st divider.
6849 ** ixNx[3] = Number of cells in Child-1 and Child-2 + both divider cells
6850 ** ixNx[4] = Total number of cells.
6852 ** For a table-btree, the concept is similar, except only apEnd[0]..apEnd[2]
6853 ** are used and they point to the leaf pages only, and the ixNx value are:
6855 ** ixNx[0] = Number of cells in Child-1.
6856 ** ixNx[1] = Number of cells in Child-1 and Child-2.
6857 ** ixNx[2] = Total number of cells.
6859 ** Sometimes when deleting, a child page can have zero cells. In those
6860 ** cases, ixNx[] entries with higher indexes, and the corresponding apEnd[]
6861 ** entries, shift down. The end result is that each ixNx[] entry should
6862 ** be larger than the previous
6864 typedef struct CellArray CellArray
;
6866 int nCell
; /* Number of cells in apCell[] */
6867 MemPage
*pRef
; /* Reference page */
6868 u8
**apCell
; /* All cells begin balanced */
6869 u16
*szCell
; /* Local size of all cells in apCell[] */
6870 u8
*apEnd
[NB
*2]; /* MemPage.aDataEnd values */
6871 int ixNx
[NB
*2]; /* Index of at which we move to the next apEnd[] */
6875 ** Make sure the cell sizes at idx, idx+1, ..., idx+N-1 have been
6878 static void populateCellCache(CellArray
*p
, int idx
, int N
){
6879 assert( idx
>=0 && idx
+N
<=p
->nCell
);
6881 assert( p
->apCell
[idx
]!=0 );
6882 if( p
->szCell
[idx
]==0 ){
6883 p
->szCell
[idx
] = p
->pRef
->xCellSize(p
->pRef
, p
->apCell
[idx
]);
6885 assert( CORRUPT_DB
||
6886 p
->szCell
[idx
]==p
->pRef
->xCellSize(p
->pRef
, p
->apCell
[idx
]) );
6894 ** Return the size of the Nth element of the cell array
6896 static SQLITE_NOINLINE u16
computeCellSize(CellArray
*p
, int N
){
6897 assert( N
>=0 && N
<p
->nCell
);
6898 assert( p
->szCell
[N
]==0 );
6899 p
->szCell
[N
] = p
->pRef
->xCellSize(p
->pRef
, p
->apCell
[N
]);
6900 return p
->szCell
[N
];
6902 static u16
cachedCellSize(CellArray
*p
, int N
){
6903 assert( N
>=0 && N
<p
->nCell
);
6904 if( p
->szCell
[N
] ) return p
->szCell
[N
];
6905 return computeCellSize(p
, N
);
6909 ** Array apCell[] contains pointers to nCell b-tree page cells. The
6910 ** szCell[] array contains the size in bytes of each cell. This function
6911 ** replaces the current contents of page pPg with the contents of the cell
6914 ** Some of the cells in apCell[] may currently be stored in pPg. This
6915 ** function works around problems caused by this by making a copy of any
6916 ** such cells before overwriting the page data.
6918 ** The MemPage.nFree field is invalidated by this function. It is the
6919 ** responsibility of the caller to set it correctly.
6921 static int rebuildPage(
6922 CellArray
*pCArray
, /* Content to be added to page pPg */
6923 int iFirst
, /* First cell in pCArray to use */
6924 int nCell
, /* Final number of cells on page */
6925 MemPage
*pPg
/* The page to be reconstructed */
6927 const int hdr
= pPg
->hdrOffset
; /* Offset of header on pPg */
6928 u8
* const aData
= pPg
->aData
; /* Pointer to data for pPg */
6929 const int usableSize
= pPg
->pBt
->usableSize
;
6930 u8
* const pEnd
= &aData
[usableSize
];
6931 int i
= iFirst
; /* Which cell to copy from pCArray*/
6932 u32 j
; /* Start of cell content area */
6933 int iEnd
= i
+nCell
; /* Loop terminator */
6934 u8
*pCellptr
= pPg
->aCellIdx
;
6935 u8
*pTmp
= sqlite3PagerTempSpace(pPg
->pBt
->pPager
);
6937 int k
; /* Current slot in pCArray->apEnd[] */
6938 u8
*pSrcEnd
; /* Current pCArray->apEnd[k] value */
6941 j
= get2byte(&aData
[hdr
+5]);
6942 if( NEVER(j
>(u32
)usableSize
) ){ j
= 0; }
6943 memcpy(&pTmp
[j
], &aData
[j
], usableSize
- j
);
6945 for(k
=0; pCArray
->ixNx
[k
]<=i
&& ALWAYS(k
<NB
*2); k
++){}
6946 pSrcEnd
= pCArray
->apEnd
[k
];
6949 while( 1/*exit by break*/ ){
6950 u8
*pCell
= pCArray
->apCell
[i
];
6951 u16 sz
= pCArray
->szCell
[i
];
6953 if( SQLITE_WITHIN(pCell
,aData
,pEnd
) ){
6954 if( ((uptr
)(pCell
+sz
))>(uptr
)pEnd
) return SQLITE_CORRUPT_BKPT
;
6955 pCell
= &pTmp
[pCell
- aData
];
6956 }else if( (uptr
)(pCell
+sz
)>(uptr
)pSrcEnd
6957 && (uptr
)(pCell
)<(uptr
)pSrcEnd
6959 return SQLITE_CORRUPT_BKPT
;
6963 put2byte(pCellptr
, (pData
- aData
));
6965 if( pData
< pCellptr
) return SQLITE_CORRUPT_BKPT
;
6966 memcpy(pData
, pCell
, sz
);
6967 assert( sz
==pPg
->xCellSize(pPg
, pCell
) || CORRUPT_DB
);
6968 testcase( sz
!=pPg
->xCellSize(pPg
,pCell
) )
6970 if( i
>=iEnd
) break;
6971 if( pCArray
->ixNx
[k
]<=i
){
6973 pSrcEnd
= pCArray
->apEnd
[k
];
6977 /* The pPg->nFree field is now set incorrectly. The caller will fix it. */
6981 put2byte(&aData
[hdr
+1], 0);
6982 put2byte(&aData
[hdr
+3], pPg
->nCell
);
6983 put2byte(&aData
[hdr
+5], pData
- aData
);
6984 aData
[hdr
+7] = 0x00;
6989 ** The pCArray objects contains pointers to b-tree cells and the cell sizes.
6990 ** This function attempts to add the cells stored in the array to page pPg.
6991 ** If it cannot (because the page needs to be defragmented before the cells
6992 ** will fit), non-zero is returned. Otherwise, if the cells are added
6993 ** successfully, zero is returned.
6995 ** Argument pCellptr points to the first entry in the cell-pointer array
6996 ** (part of page pPg) to populate. After cell apCell[0] is written to the
6997 ** page body, a 16-bit offset is written to pCellptr. And so on, for each
6998 ** cell in the array. It is the responsibility of the caller to ensure
6999 ** that it is safe to overwrite this part of the cell-pointer array.
7001 ** When this function is called, *ppData points to the start of the
7002 ** content area on page pPg. If the size of the content area is extended,
7003 ** *ppData is updated to point to the new start of the content area
7004 ** before returning.
7006 ** Finally, argument pBegin points to the byte immediately following the
7007 ** end of the space required by this page for the cell-pointer area (for
7008 ** all cells - not just those inserted by the current call). If the content
7009 ** area must be extended to before this point in order to accomodate all
7010 ** cells in apCell[], then the cells do not fit and non-zero is returned.
7012 static int pageInsertArray(
7013 MemPage
*pPg
, /* Page to add cells to */
7014 u8
*pBegin
, /* End of cell-pointer array */
7015 u8
**ppData
, /* IN/OUT: Page content-area pointer */
7016 u8
*pCellptr
, /* Pointer to cell-pointer area */
7017 int iFirst
, /* Index of first cell to add */
7018 int nCell
, /* Number of cells to add to pPg */
7019 CellArray
*pCArray
/* Array of cells */
7021 int i
= iFirst
; /* Loop counter - cell index to insert */
7022 u8
*aData
= pPg
->aData
; /* Complete page */
7023 u8
*pData
= *ppData
; /* Content area. A subset of aData[] */
7024 int iEnd
= iFirst
+ nCell
; /* End of loop. One past last cell to ins */
7025 int k
; /* Current slot in pCArray->apEnd[] */
7026 u8
*pEnd
; /* Maximum extent of cell data */
7027 assert( CORRUPT_DB
|| pPg
->hdrOffset
==0 ); /* Never called on page 1 */
7028 if( iEnd
<=iFirst
) return 0;
7029 for(k
=0; pCArray
->ixNx
[k
]<=i
&& ALWAYS(k
<NB
*2); k
++){}
7030 pEnd
= pCArray
->apEnd
[k
];
7031 while( 1 /*Exit by break*/ ){
7034 assert( pCArray
->szCell
[i
]!=0 );
7035 sz
= pCArray
->szCell
[i
];
7036 if( (aData
[1]==0 && aData
[2]==0) || (pSlot
= pageFindSlot(pPg
,sz
,&rc
))==0 ){
7037 if( (pData
- pBegin
)<sz
) return 1;
7041 /* pSlot and pCArray->apCell[i] will never overlap on a well-formed
7042 ** database. But they might for a corrupt database. Hence use memmove()
7043 ** since memcpy() sends SIGABORT with overlapping buffers on OpenBSD */
7044 assert( (pSlot
+sz
)<=pCArray
->apCell
[i
]
7045 || pSlot
>=(pCArray
->apCell
[i
]+sz
)
7047 if( (uptr
)(pCArray
->apCell
[i
]+sz
)>(uptr
)pEnd
7048 && (uptr
)(pCArray
->apCell
[i
])<(uptr
)pEnd
7050 assert( CORRUPT_DB
);
7051 (void)SQLITE_CORRUPT_BKPT
;
7054 memmove(pSlot
, pCArray
->apCell
[i
], sz
);
7055 put2byte(pCellptr
, (pSlot
- aData
));
7058 if( i
>=iEnd
) break;
7059 if( pCArray
->ixNx
[k
]<=i
){
7061 pEnd
= pCArray
->apEnd
[k
];
7069 ** The pCArray object contains pointers to b-tree cells and their sizes.
7071 ** This function adds the space associated with each cell in the array
7072 ** that is currently stored within the body of pPg to the pPg free-list.
7073 ** The cell-pointers and other fields of the page are not updated.
7075 ** This function returns the total number of cells added to the free-list.
7077 static int pageFreeArray(
7078 MemPage
*pPg
, /* Page to edit */
7079 int iFirst
, /* First cell to delete */
7080 int nCell
, /* Cells to delete */
7081 CellArray
*pCArray
/* Array of cells */
7083 u8
* const aData
= pPg
->aData
;
7084 u8
* const pEnd
= &aData
[pPg
->pBt
->usableSize
];
7085 u8
* const pStart
= &aData
[pPg
->hdrOffset
+ 8 + pPg
->childPtrSize
];
7088 int iEnd
= iFirst
+ nCell
;
7092 for(i
=iFirst
; i
<iEnd
; i
++){
7093 u8
*pCell
= pCArray
->apCell
[i
];
7094 if( SQLITE_WITHIN(pCell
, pStart
, pEnd
) ){
7096 /* No need to use cachedCellSize() here. The sizes of all cells that
7097 ** are to be freed have already been computing while deciding which
7098 ** cells need freeing */
7099 sz
= pCArray
->szCell
[i
]; assert( sz
>0 );
7100 if( pFree
!=(pCell
+ sz
) ){
7102 assert( pFree
>aData
&& (pFree
- aData
)<65536 );
7103 freeSpace(pPg
, (u16
)(pFree
- aData
), szFree
);
7107 if( pFree
+sz
>pEnd
) return 0;
7116 assert( pFree
>aData
&& (pFree
- aData
)<65536 );
7117 freeSpace(pPg
, (u16
)(pFree
- aData
), szFree
);
7123 ** pCArray contains pointers to and sizes of all cells in the page being
7124 ** balanced. The current page, pPg, has pPg->nCell cells starting with
7125 ** pCArray->apCell[iOld]. After balancing, this page should hold nNew cells
7126 ** starting at apCell[iNew].
7128 ** This routine makes the necessary adjustments to pPg so that it contains
7129 ** the correct cells after being balanced.
7131 ** The pPg->nFree field is invalid when this function returns. It is the
7132 ** responsibility of the caller to set it correctly.
7134 static int editPage(
7135 MemPage
*pPg
, /* Edit this page */
7136 int iOld
, /* Index of first cell currently on page */
7137 int iNew
, /* Index of new first cell on page */
7138 int nNew
, /* Final number of cells on page */
7139 CellArray
*pCArray
/* Array of cells and sizes */
7141 u8
* const aData
= pPg
->aData
;
7142 const int hdr
= pPg
->hdrOffset
;
7143 u8
*pBegin
= &pPg
->aCellIdx
[nNew
* 2];
7144 int nCell
= pPg
->nCell
; /* Cells stored on pPg */
7148 int iOldEnd
= iOld
+ pPg
->nCell
+ pPg
->nOverflow
;
7149 int iNewEnd
= iNew
+ nNew
;
7152 u8
*pTmp
= sqlite3PagerTempSpace(pPg
->pBt
->pPager
);
7153 memcpy(pTmp
, aData
, pPg
->pBt
->usableSize
);
7156 /* Remove cells from the start and end of the page */
7159 int nShift
= pageFreeArray(pPg
, iOld
, iNew
-iOld
, pCArray
);
7160 if( nShift
>nCell
) return SQLITE_CORRUPT_BKPT
;
7161 memmove(pPg
->aCellIdx
, &pPg
->aCellIdx
[nShift
*2], nCell
*2);
7164 if( iNewEnd
< iOldEnd
){
7165 int nTail
= pageFreeArray(pPg
, iNewEnd
, iOldEnd
- iNewEnd
, pCArray
);
7166 assert( nCell
>=nTail
);
7170 pData
= &aData
[get2byteNotZero(&aData
[hdr
+5])];
7171 if( pData
<pBegin
) goto editpage_fail
;
7173 /* Add cells to the start of the page */
7175 int nAdd
= MIN(nNew
,iOld
-iNew
);
7176 assert( (iOld
-iNew
)<nNew
|| nCell
==0 || CORRUPT_DB
);
7178 pCellptr
= pPg
->aCellIdx
;
7179 memmove(&pCellptr
[nAdd
*2], pCellptr
, nCell
*2);
7180 if( pageInsertArray(
7181 pPg
, pBegin
, &pData
, pCellptr
,
7183 ) ) goto editpage_fail
;
7187 /* Add any overflow cells */
7188 for(i
=0; i
<pPg
->nOverflow
; i
++){
7189 int iCell
= (iOld
+ pPg
->aiOvfl
[i
]) - iNew
;
7190 if( iCell
>=0 && iCell
<nNew
){
7191 pCellptr
= &pPg
->aCellIdx
[iCell
* 2];
7193 memmove(&pCellptr
[2], pCellptr
, (nCell
- iCell
) * 2);
7196 cachedCellSize(pCArray
, iCell
+iNew
);
7197 if( pageInsertArray(
7198 pPg
, pBegin
, &pData
, pCellptr
,
7199 iCell
+iNew
, 1, pCArray
7200 ) ) goto editpage_fail
;
7204 /* Append cells to the end of the page */
7206 pCellptr
= &pPg
->aCellIdx
[nCell
*2];
7207 if( pageInsertArray(
7208 pPg
, pBegin
, &pData
, pCellptr
,
7209 iNew
+nCell
, nNew
-nCell
, pCArray
7210 ) ) goto editpage_fail
;
7215 put2byte(&aData
[hdr
+3], pPg
->nCell
);
7216 put2byte(&aData
[hdr
+5], pData
- aData
);
7219 for(i
=0; i
<nNew
&& !CORRUPT_DB
; i
++){
7220 u8
*pCell
= pCArray
->apCell
[i
+iNew
];
7221 int iOff
= get2byteAligned(&pPg
->aCellIdx
[i
*2]);
7222 if( SQLITE_WITHIN(pCell
, aData
, &aData
[pPg
->pBt
->usableSize
]) ){
7223 pCell
= &pTmp
[pCell
- aData
];
7225 assert( 0==memcmp(pCell
, &aData
[iOff
],
7226 pCArray
->pRef
->xCellSize(pCArray
->pRef
, pCArray
->apCell
[i
+iNew
])) );
7232 /* Unable to edit this page. Rebuild it from scratch instead. */
7233 populateCellCache(pCArray
, iNew
, nNew
);
7234 return rebuildPage(pCArray
, iNew
, nNew
, pPg
);
7238 #ifndef SQLITE_OMIT_QUICKBALANCE
7240 ** This version of balance() handles the common special case where
7241 ** a new entry is being inserted on the extreme right-end of the
7242 ** tree, in other words, when the new entry will become the largest
7243 ** entry in the tree.
7245 ** Instead of trying to balance the 3 right-most leaf pages, just add
7246 ** a new page to the right-hand side and put the one new entry in
7247 ** that page. This leaves the right side of the tree somewhat
7248 ** unbalanced. But odds are that we will be inserting new entries
7249 ** at the end soon afterwards so the nearly empty page will quickly
7250 ** fill up. On average.
7252 ** pPage is the leaf page which is the right-most page in the tree.
7253 ** pParent is its parent. pPage must have a single overflow entry
7254 ** which is also the right-most entry on the page.
7256 ** The pSpace buffer is used to store a temporary copy of the divider
7257 ** cell that will be inserted into pParent. Such a cell consists of a 4
7258 ** byte page number followed by a variable length integer. In other
7259 ** words, at most 13 bytes. Hence the pSpace buffer must be at
7260 ** least 13 bytes in size.
7262 static int balance_quick(MemPage
*pParent
, MemPage
*pPage
, u8
*pSpace
){
7263 BtShared
*const pBt
= pPage
->pBt
; /* B-Tree Database */
7264 MemPage
*pNew
; /* Newly allocated page */
7265 int rc
; /* Return Code */
7266 Pgno pgnoNew
; /* Page number of pNew */
7268 assert( sqlite3_mutex_held(pPage
->pBt
->mutex
) );
7269 assert( sqlite3PagerIswriteable(pParent
->pDbPage
) );
7270 assert( pPage
->nOverflow
==1 );
7272 if( pPage
->nCell
==0 ) return SQLITE_CORRUPT_BKPT
; /* dbfuzz001.test */
7273 assert( pPage
->nFree
>=0 );
7274 assert( pParent
->nFree
>=0 );
7276 /* Allocate a new page. This page will become the right-sibling of
7277 ** pPage. Make the parent page writable, so that the new divider cell
7278 ** may be inserted. If both these operations are successful, proceed.
7280 rc
= allocateBtreePage(pBt
, &pNew
, &pgnoNew
, 0, 0);
7282 if( rc
==SQLITE_OK
){
7284 u8
*pOut
= &pSpace
[4];
7285 u8
*pCell
= pPage
->apOvfl
[0];
7286 u16 szCell
= pPage
->xCellSize(pPage
, pCell
);
7290 assert( sqlite3PagerIswriteable(pNew
->pDbPage
) );
7291 assert( CORRUPT_DB
|| pPage
->aData
[0]==(PTF_INTKEY
|PTF_LEAFDATA
|PTF_LEAF
) );
7292 zeroPage(pNew
, PTF_INTKEY
|PTF_LEAFDATA
|PTF_LEAF
);
7297 b
.apEnd
[0] = pPage
->aDataEnd
;
7299 rc
= rebuildPage(&b
, 0, 1, pNew
);
7304 pNew
->nFree
= pBt
->usableSize
- pNew
->cellOffset
- 2 - szCell
;
7306 /* If this is an auto-vacuum database, update the pointer map
7307 ** with entries for the new page, and any pointer from the
7308 ** cell on the page to an overflow page. If either of these
7309 ** operations fails, the return code is set, but the contents
7310 ** of the parent page are still manipulated by thh code below.
7311 ** That is Ok, at this point the parent page is guaranteed to
7312 ** be marked as dirty. Returning an error code will cause a
7313 ** rollback, undoing any changes made to the parent page.
7316 ptrmapPut(pBt
, pgnoNew
, PTRMAP_BTREE
, pParent
->pgno
, &rc
);
7317 if( szCell
>pNew
->minLocal
){
7318 ptrmapPutOvflPtr(pNew
, pNew
, pCell
, &rc
);
7322 /* Create a divider cell to insert into pParent. The divider cell
7323 ** consists of a 4-byte page number (the page number of pPage) and
7324 ** a variable length key value (which must be the same value as the
7325 ** largest key on pPage).
7327 ** To find the largest key value on pPage, first find the right-most
7328 ** cell on pPage. The first two fields of this cell are the
7329 ** record-length (a variable length integer at most 32-bits in size)
7330 ** and the key value (a variable length integer, may have any value).
7331 ** The first of the while(...) loops below skips over the record-length
7332 ** field. The second while(...) loop copies the key value from the
7333 ** cell on pPage into the pSpace buffer.
7335 pCell
= findCell(pPage
, pPage
->nCell
-1);
7337 while( (*(pCell
++)&0x80) && pCell
<pStop
);
7339 while( ((*(pOut
++) = *(pCell
++))&0x80) && pCell
<pStop
);
7341 /* Insert the new divider cell into pParent. */
7342 if( rc
==SQLITE_OK
){
7343 insertCell(pParent
, pParent
->nCell
, pSpace
, (int)(pOut
-pSpace
),
7344 0, pPage
->pgno
, &rc
);
7347 /* Set the right-child pointer of pParent to point to the new page. */
7348 put4byte(&pParent
->aData
[pParent
->hdrOffset
+8], pgnoNew
);
7350 /* Release the reference to the new page. */
7356 #endif /* SQLITE_OMIT_QUICKBALANCE */
7360 ** This function does not contribute anything to the operation of SQLite.
7361 ** it is sometimes activated temporarily while debugging code responsible
7362 ** for setting pointer-map entries.
7364 static int ptrmapCheckPages(MemPage
**apPage
, int nPage
){
7366 for(i
=0; i
<nPage
; i
++){
7369 MemPage
*pPage
= apPage
[i
];
7370 BtShared
*pBt
= pPage
->pBt
;
7371 assert( pPage
->isInit
);
7373 for(j
=0; j
<pPage
->nCell
; j
++){
7377 z
= findCell(pPage
, j
);
7378 pPage
->xParseCell(pPage
, z
, &info
);
7379 if( info
.nLocal
<info
.nPayload
){
7380 Pgno ovfl
= get4byte(&z
[info
.nSize
-4]);
7381 ptrmapGet(pBt
, ovfl
, &e
, &n
);
7382 assert( n
==pPage
->pgno
&& e
==PTRMAP_OVERFLOW1
);
7385 Pgno child
= get4byte(z
);
7386 ptrmapGet(pBt
, child
, &e
, &n
);
7387 assert( n
==pPage
->pgno
&& e
==PTRMAP_BTREE
);
7391 Pgno child
= get4byte(&pPage
->aData
[pPage
->hdrOffset
+8]);
7392 ptrmapGet(pBt
, child
, &e
, &n
);
7393 assert( n
==pPage
->pgno
&& e
==PTRMAP_BTREE
);
7401 ** This function is used to copy the contents of the b-tree node stored
7402 ** on page pFrom to page pTo. If page pFrom was not a leaf page, then
7403 ** the pointer-map entries for each child page are updated so that the
7404 ** parent page stored in the pointer map is page pTo. If pFrom contained
7405 ** any cells with overflow page pointers, then the corresponding pointer
7406 ** map entries are also updated so that the parent page is page pTo.
7408 ** If pFrom is currently carrying any overflow cells (entries in the
7409 ** MemPage.apOvfl[] array), they are not copied to pTo.
7411 ** Before returning, page pTo is reinitialized using btreeInitPage().
7413 ** The performance of this function is not critical. It is only used by
7414 ** the balance_shallower() and balance_deeper() procedures, neither of
7415 ** which are called often under normal circumstances.
7417 static void copyNodeContent(MemPage
*pFrom
, MemPage
*pTo
, int *pRC
){
7418 if( (*pRC
)==SQLITE_OK
){
7419 BtShared
* const pBt
= pFrom
->pBt
;
7420 u8
* const aFrom
= pFrom
->aData
;
7421 u8
* const aTo
= pTo
->aData
;
7422 int const iFromHdr
= pFrom
->hdrOffset
;
7423 int const iToHdr
= ((pTo
->pgno
==1) ? 100 : 0);
7428 assert( pFrom
->isInit
);
7429 assert( pFrom
->nFree
>=iToHdr
);
7430 assert( get2byte(&aFrom
[iFromHdr
+5]) <= (int)pBt
->usableSize
);
7432 /* Copy the b-tree node content from page pFrom to page pTo. */
7433 iData
= get2byte(&aFrom
[iFromHdr
+5]);
7434 memcpy(&aTo
[iData
], &aFrom
[iData
], pBt
->usableSize
-iData
);
7435 memcpy(&aTo
[iToHdr
], &aFrom
[iFromHdr
], pFrom
->cellOffset
+ 2*pFrom
->nCell
);
7437 /* Reinitialize page pTo so that the contents of the MemPage structure
7438 ** match the new data. The initialization of pTo can actually fail under
7439 ** fairly obscure circumstances, even though it is a copy of initialized
7443 rc
= btreeInitPage(pTo
);
7444 if( rc
==SQLITE_OK
) rc
= btreeComputeFreeSpace(pTo
);
7445 if( rc
!=SQLITE_OK
){
7450 /* If this is an auto-vacuum database, update the pointer-map entries
7451 ** for any b-tree or overflow pages that pTo now contains the pointers to.
7454 *pRC
= setChildPtrmaps(pTo
);
7460 ** This routine redistributes cells on the iParentIdx'th child of pParent
7461 ** (hereafter "the page") and up to 2 siblings so that all pages have about the
7462 ** same amount of free space. Usually a single sibling on either side of the
7463 ** page are used in the balancing, though both siblings might come from one
7464 ** side if the page is the first or last child of its parent. If the page
7465 ** has fewer than 2 siblings (something which can only happen if the page
7466 ** is a root page or a child of a root page) then all available siblings
7467 ** participate in the balancing.
7469 ** The number of siblings of the page might be increased or decreased by
7470 ** one or two in an effort to keep pages nearly full but not over full.
7472 ** Note that when this routine is called, some of the cells on the page
7473 ** might not actually be stored in MemPage.aData[]. This can happen
7474 ** if the page is overfull. This routine ensures that all cells allocated
7475 ** to the page and its siblings fit into MemPage.aData[] before returning.
7477 ** In the course of balancing the page and its siblings, cells may be
7478 ** inserted into or removed from the parent page (pParent). Doing so
7479 ** may cause the parent page to become overfull or underfull. If this
7480 ** happens, it is the responsibility of the caller to invoke the correct
7481 ** balancing routine to fix this problem (see the balance() routine).
7483 ** If this routine fails for any reason, it might leave the database
7484 ** in a corrupted state. So if this routine fails, the database should
7487 ** The third argument to this function, aOvflSpace, is a pointer to a
7488 ** buffer big enough to hold one page. If while inserting cells into the parent
7489 ** page (pParent) the parent page becomes overfull, this buffer is
7490 ** used to store the parent's overflow cells. Because this function inserts
7491 ** a maximum of four divider cells into the parent page, and the maximum
7492 ** size of a cell stored within an internal node is always less than 1/4
7493 ** of the page-size, the aOvflSpace[] buffer is guaranteed to be large
7494 ** enough for all overflow cells.
7496 ** If aOvflSpace is set to a null pointer, this function returns
7499 static int balance_nonroot(
7500 MemPage
*pParent
, /* Parent page of siblings being balanced */
7501 int iParentIdx
, /* Index of "the page" in pParent */
7502 u8
*aOvflSpace
, /* page-size bytes of space for parent ovfl */
7503 int isRoot
, /* True if pParent is a root-page */
7504 int bBulk
/* True if this call is part of a bulk load */
7506 BtShared
*pBt
; /* The whole database */
7507 int nMaxCells
= 0; /* Allocated size of apCell, szCell, aFrom. */
7508 int nNew
= 0; /* Number of pages in apNew[] */
7509 int nOld
; /* Number of pages in apOld[] */
7510 int i
, j
, k
; /* Loop counters */
7511 int nxDiv
; /* Next divider slot in pParent->aCell[] */
7512 int rc
= SQLITE_OK
; /* The return code */
7513 u16 leafCorrection
; /* 4 if pPage is a leaf. 0 if not */
7514 int leafData
; /* True if pPage is a leaf of a LEAFDATA tree */
7515 int usableSpace
; /* Bytes in pPage beyond the header */
7516 int pageFlags
; /* Value of pPage->aData[0] */
7517 int iSpace1
= 0; /* First unused byte of aSpace1[] */
7518 int iOvflSpace
= 0; /* First unused byte of aOvflSpace[] */
7519 int szScratch
; /* Size of scratch memory requested */
7520 MemPage
*apOld
[NB
]; /* pPage and up to two siblings */
7521 MemPage
*apNew
[NB
+2]; /* pPage and up to NB siblings after balancing */
7522 u8
*pRight
; /* Location in parent of right-sibling pointer */
7523 u8
*apDiv
[NB
-1]; /* Divider cells in pParent */
7524 int cntNew
[NB
+2]; /* Index in b.paCell[] of cell after i-th page */
7525 int cntOld
[NB
+2]; /* Old index in b.apCell[] */
7526 int szNew
[NB
+2]; /* Combined size of cells placed on i-th page */
7527 u8
*aSpace1
; /* Space for copies of dividers cells */
7528 Pgno pgno
; /* Temp var to store a page number in */
7529 u8 abDone
[NB
+2]; /* True after i'th new page is populated */
7530 Pgno aPgno
[NB
+2]; /* Page numbers of new pages before shuffling */
7531 Pgno aPgOrder
[NB
+2]; /* Copy of aPgno[] used for sorting pages */
7532 u16 aPgFlags
[NB
+2]; /* flags field of new pages before shuffling */
7533 CellArray b
; /* Parsed information on cells being balanced */
7535 memset(abDone
, 0, sizeof(abDone
));
7539 assert( sqlite3_mutex_held(pBt
->mutex
) );
7540 assert( sqlite3PagerIswriteable(pParent
->pDbPage
) );
7542 /* At this point pParent may have at most one overflow cell. And if
7543 ** this overflow cell is present, it must be the cell with
7544 ** index iParentIdx. This scenario comes about when this function
7545 ** is called (indirectly) from sqlite3BtreeDelete().
7547 assert( pParent
->nOverflow
==0 || pParent
->nOverflow
==1 );
7548 assert( pParent
->nOverflow
==0 || pParent
->aiOvfl
[0]==iParentIdx
);
7551 return SQLITE_NOMEM_BKPT
;
7553 assert( pParent
->nFree
>=0 );
7555 /* Find the sibling pages to balance. Also locate the cells in pParent
7556 ** that divide the siblings. An attempt is made to find NN siblings on
7557 ** either side of pPage. More siblings are taken from one side, however,
7558 ** if there are fewer than NN siblings on the other side. If pParent
7559 ** has NB or fewer children then all children of pParent are taken.
7561 ** This loop also drops the divider cells from the parent page. This
7562 ** way, the remainder of the function does not have to deal with any
7563 ** overflow cells in the parent page, since if any existed they will
7564 ** have already been removed.
7566 i
= pParent
->nOverflow
+ pParent
->nCell
;
7570 assert( bBulk
==0 || bBulk
==1 );
7571 if( iParentIdx
==0 ){
7573 }else if( iParentIdx
==i
){
7576 nxDiv
= iParentIdx
-1;
7581 if( (i
+nxDiv
-pParent
->nOverflow
)==pParent
->nCell
){
7582 pRight
= &pParent
->aData
[pParent
->hdrOffset
+8];
7584 pRight
= findCell(pParent
, i
+nxDiv
-pParent
->nOverflow
);
7586 pgno
= get4byte(pRight
);
7588 rc
= getAndInitPage(pBt
, pgno
, &apOld
[i
], 0, 0);
7590 memset(apOld
, 0, (i
+1)*sizeof(MemPage
*));
7591 goto balance_cleanup
;
7593 if( apOld
[i
]->nFree
<0 ){
7594 rc
= btreeComputeFreeSpace(apOld
[i
]);
7596 memset(apOld
, 0, (i
)*sizeof(MemPage
*));
7597 goto balance_cleanup
;
7600 if( (i
--)==0 ) break;
7602 if( pParent
->nOverflow
&& i
+nxDiv
==pParent
->aiOvfl
[0] ){
7603 apDiv
[i
] = pParent
->apOvfl
[0];
7604 pgno
= get4byte(apDiv
[i
]);
7605 szNew
[i
] = pParent
->xCellSize(pParent
, apDiv
[i
]);
7606 pParent
->nOverflow
= 0;
7608 apDiv
[i
] = findCell(pParent
, i
+nxDiv
-pParent
->nOverflow
);
7609 pgno
= get4byte(apDiv
[i
]);
7610 szNew
[i
] = pParent
->xCellSize(pParent
, apDiv
[i
]);
7612 /* Drop the cell from the parent page. apDiv[i] still points to
7613 ** the cell within the parent, even though it has been dropped.
7614 ** This is safe because dropping a cell only overwrites the first
7615 ** four bytes of it, and this function does not need the first
7616 ** four bytes of the divider cell. So the pointer is safe to use
7619 ** But not if we are in secure-delete mode. In secure-delete mode,
7620 ** the dropCell() routine will overwrite the entire cell with zeroes.
7621 ** In this case, temporarily copy the cell into the aOvflSpace[]
7622 ** buffer. It will be copied out again as soon as the aSpace[] buffer
7624 if( pBt
->btsFlags
& BTS_FAST_SECURE
){
7627 iOff
= SQLITE_PTR_TO_INT(apDiv
[i
]) - SQLITE_PTR_TO_INT(pParent
->aData
);
7628 if( (iOff
+szNew
[i
])>(int)pBt
->usableSize
){
7629 rc
= SQLITE_CORRUPT_BKPT
;
7630 memset(apOld
, 0, (i
+1)*sizeof(MemPage
*));
7631 goto balance_cleanup
;
7633 memcpy(&aOvflSpace
[iOff
], apDiv
[i
], szNew
[i
]);
7634 apDiv
[i
] = &aOvflSpace
[apDiv
[i
]-pParent
->aData
];
7637 dropCell(pParent
, i
+nxDiv
-pParent
->nOverflow
, szNew
[i
], &rc
);
7641 /* Make nMaxCells a multiple of 4 in order to preserve 8-byte
7643 nMaxCells
= nOld
*(MX_CELL(pBt
) + ArraySize(pParent
->apOvfl
));
7644 nMaxCells
= (nMaxCells
+ 3)&~3;
7647 ** Allocate space for memory structures
7650 nMaxCells
*sizeof(u8
*) /* b.apCell */
7651 + nMaxCells
*sizeof(u16
) /* b.szCell */
7652 + pBt
->pageSize
; /* aSpace1 */
7654 assert( szScratch
<=7*(int)pBt
->pageSize
);
7655 b
.apCell
= sqlite3StackAllocRaw(0, szScratch
);
7657 rc
= SQLITE_NOMEM_BKPT
;
7658 goto balance_cleanup
;
7660 b
.szCell
= (u16
*)&b
.apCell
[nMaxCells
];
7661 aSpace1
= (u8
*)&b
.szCell
[nMaxCells
];
7662 assert( EIGHT_BYTE_ALIGNMENT(aSpace1
) );
7665 ** Load pointers to all cells on sibling pages and the divider cells
7666 ** into the local b.apCell[] array. Make copies of the divider cells
7667 ** into space obtained from aSpace1[]. The divider cells have already
7668 ** been removed from pParent.
7670 ** If the siblings are on leaf pages, then the child pointers of the
7671 ** divider cells are stripped from the cells before they are copied
7672 ** into aSpace1[]. In this way, all cells in b.apCell[] are without
7673 ** child pointers. If siblings are not leaves, then all cell in
7674 ** b.apCell[] include child pointers. Either way, all cells in b.apCell[]
7677 ** leafCorrection: 4 if pPage is a leaf. 0 if pPage is not a leaf.
7678 ** leafData: 1 if pPage holds key+data and pParent holds only keys.
7681 leafCorrection
= b
.pRef
->leaf
*4;
7682 leafData
= b
.pRef
->intKeyLeaf
;
7683 for(i
=0; i
<nOld
; i
++){
7684 MemPage
*pOld
= apOld
[i
];
7685 int limit
= pOld
->nCell
;
7686 u8
*aData
= pOld
->aData
;
7687 u16 maskPage
= pOld
->maskPage
;
7688 u8
*piCell
= aData
+ pOld
->cellOffset
;
7690 VVA_ONLY( int nCellAtStart
= b
.nCell
; )
7692 /* Verify that all sibling pages are of the same "type" (table-leaf,
7693 ** table-interior, index-leaf, or index-interior).
7695 if( pOld
->aData
[0]!=apOld
[0]->aData
[0] ){
7696 rc
= SQLITE_CORRUPT_BKPT
;
7697 goto balance_cleanup
;
7700 /* Load b.apCell[] with pointers to all cells in pOld. If pOld
7701 ** contains overflow cells, include them in the b.apCell[] array
7702 ** in the correct spot.
7704 ** Note that when there are multiple overflow cells, it is always the
7705 ** case that they are sequential and adjacent. This invariant arises
7706 ** because multiple overflows can only occurs when inserting divider
7707 ** cells into a parent on a prior balance, and divider cells are always
7708 ** adjacent and are inserted in order. There is an assert() tagged
7709 ** with "NOTE 1" in the overflow cell insertion loop to prove this
7712 ** This must be done in advance. Once the balance starts, the cell
7713 ** offset section of the btree page will be overwritten and we will no
7714 ** long be able to find the cells if a pointer to each cell is not saved
7717 memset(&b
.szCell
[b
.nCell
], 0, sizeof(b
.szCell
[0])*(limit
+pOld
->nOverflow
));
7718 if( pOld
->nOverflow
>0 ){
7719 if( NEVER(limit
<pOld
->aiOvfl
[0]) ){
7720 rc
= SQLITE_CORRUPT_BKPT
;
7721 goto balance_cleanup
;
7723 limit
= pOld
->aiOvfl
[0];
7724 for(j
=0; j
<limit
; j
++){
7725 b
.apCell
[b
.nCell
] = aData
+ (maskPage
& get2byteAligned(piCell
));
7729 for(k
=0; k
<pOld
->nOverflow
; k
++){
7730 assert( k
==0 || pOld
->aiOvfl
[k
-1]+1==pOld
->aiOvfl
[k
] );/* NOTE 1 */
7731 b
.apCell
[b
.nCell
] = pOld
->apOvfl
[k
];
7735 piEnd
= aData
+ pOld
->cellOffset
+ 2*pOld
->nCell
;
7736 while( piCell
<piEnd
){
7737 assert( b
.nCell
<nMaxCells
);
7738 b
.apCell
[b
.nCell
] = aData
+ (maskPage
& get2byteAligned(piCell
));
7742 assert( (b
.nCell
-nCellAtStart
)==(pOld
->nCell
+pOld
->nOverflow
) );
7744 cntOld
[i
] = b
.nCell
;
7745 if( i
<nOld
-1 && !leafData
){
7746 u16 sz
= (u16
)szNew
[i
];
7748 assert( b
.nCell
<nMaxCells
);
7749 b
.szCell
[b
.nCell
] = sz
;
7750 pTemp
= &aSpace1
[iSpace1
];
7752 assert( sz
<=pBt
->maxLocal
+23 );
7753 assert( iSpace1
<= (int)pBt
->pageSize
);
7754 memcpy(pTemp
, apDiv
[i
], sz
);
7755 b
.apCell
[b
.nCell
] = pTemp
+leafCorrection
;
7756 assert( leafCorrection
==0 || leafCorrection
==4 );
7757 b
.szCell
[b
.nCell
] = b
.szCell
[b
.nCell
] - leafCorrection
;
7759 assert( leafCorrection
==0 );
7760 assert( pOld
->hdrOffset
==0 );
7761 /* The right pointer of the child page pOld becomes the left
7762 ** pointer of the divider cell */
7763 memcpy(b
.apCell
[b
.nCell
], &pOld
->aData
[8], 4);
7765 assert( leafCorrection
==4 );
7766 while( b
.szCell
[b
.nCell
]<4 ){
7767 /* Do not allow any cells smaller than 4 bytes. If a smaller cell
7768 ** does exist, pad it with 0x00 bytes. */
7769 assert( b
.szCell
[b
.nCell
]==3 || CORRUPT_DB
);
7770 assert( b
.apCell
[b
.nCell
]==&aSpace1
[iSpace1
-3] || CORRUPT_DB
);
7771 aSpace1
[iSpace1
++] = 0x00;
7772 b
.szCell
[b
.nCell
]++;
7780 ** Figure out the number of pages needed to hold all b.nCell cells.
7781 ** Store this number in "k". Also compute szNew[] which is the total
7782 ** size of all cells on the i-th page and cntNew[] which is the index
7783 ** in b.apCell[] of the cell that divides page i from page i+1.
7784 ** cntNew[k] should equal b.nCell.
7786 ** Values computed by this block:
7788 ** k: The total number of sibling pages
7789 ** szNew[i]: Spaced used on the i-th sibling page.
7790 ** cntNew[i]: Index in b.apCell[] and b.szCell[] for the first cell to
7791 ** the right of the i-th sibling page.
7792 ** usableSpace: Number of bytes of space available on each sibling.
7795 usableSpace
= pBt
->usableSize
- 12 + leafCorrection
;
7796 for(i
=k
=0; i
<nOld
; i
++, k
++){
7797 MemPage
*p
= apOld
[i
];
7798 b
.apEnd
[k
] = p
->aDataEnd
;
7799 b
.ixNx
[k
] = cntOld
[i
];
7800 if( k
&& b
.ixNx
[k
]==b
.ixNx
[k
-1] ){
7801 k
--; /* Omit b.ixNx[] entry for child pages with no cells */
7805 b
.apEnd
[k
] = pParent
->aDataEnd
;
7806 b
.ixNx
[k
] = cntOld
[i
]+1;
7808 assert( p
->nFree
>=0 );
7809 szNew
[i
] = usableSpace
- p
->nFree
;
7810 for(j
=0; j
<p
->nOverflow
; j
++){
7811 szNew
[i
] += 2 + p
->xCellSize(p
, p
->apOvfl
[j
]);
7813 cntNew
[i
] = cntOld
[i
];
7818 while( szNew
[i
]>usableSpace
){
7821 if( k
>NB
+2 ){ rc
= SQLITE_CORRUPT_BKPT
; goto balance_cleanup
; }
7823 cntNew
[k
-1] = b
.nCell
;
7825 sz
= 2 + cachedCellSize(&b
, cntNew
[i
]-1);
7828 if( cntNew
[i
]<b
.nCell
){
7829 sz
= 2 + cachedCellSize(&b
, cntNew
[i
]);
7837 while( cntNew
[i
]<b
.nCell
){
7838 sz
= 2 + cachedCellSize(&b
, cntNew
[i
]);
7839 if( szNew
[i
]+sz
>usableSpace
) break;
7843 if( cntNew
[i
]<b
.nCell
){
7844 sz
= 2 + cachedCellSize(&b
, cntNew
[i
]);
7851 if( cntNew
[i
]>=b
.nCell
){
7853 }else if( cntNew
[i
] <= (i
>0 ? cntNew
[i
-1] : 0) ){
7854 rc
= SQLITE_CORRUPT_BKPT
;
7855 goto balance_cleanup
;
7860 ** The packing computed by the previous block is biased toward the siblings
7861 ** on the left side (siblings with smaller keys). The left siblings are
7862 ** always nearly full, while the right-most sibling might be nearly empty.
7863 ** The next block of code attempts to adjust the packing of siblings to
7864 ** get a better balance.
7866 ** This adjustment is more than an optimization. The packing above might
7867 ** be so out of balance as to be illegal. For example, the right-most
7868 ** sibling might be completely empty. This adjustment is not optional.
7870 for(i
=k
-1; i
>0; i
--){
7871 int szRight
= szNew
[i
]; /* Size of sibling on the right */
7872 int szLeft
= szNew
[i
-1]; /* Size of sibling on the left */
7873 int r
; /* Index of right-most cell in left sibling */
7874 int d
; /* Index of first cell to the left of right sibling */
7876 r
= cntNew
[i
-1] - 1;
7877 d
= r
+ 1 - leafData
;
7878 (void)cachedCellSize(&b
, d
);
7880 assert( d
<nMaxCells
);
7881 assert( r
<nMaxCells
);
7882 (void)cachedCellSize(&b
, r
);
7884 && (bBulk
|| szRight
+b
.szCell
[d
]+2 > szLeft
-(b
.szCell
[r
]+(i
==k
-1?0:2)))){
7887 szRight
+= b
.szCell
[d
] + 2;
7888 szLeft
-= b
.szCell
[r
] + 2;
7894 szNew
[i
-1] = szLeft
;
7895 if( cntNew
[i
-1] <= (i
>1 ? cntNew
[i
-2] : 0) ){
7896 rc
= SQLITE_CORRUPT_BKPT
;
7897 goto balance_cleanup
;
7901 /* Sanity check: For a non-corrupt database file one of the follwing
7903 ** (1) We found one or more cells (cntNew[0])>0), or
7904 ** (2) pPage is a virtual root page. A virtual root page is when
7905 ** the real root page is page 1 and we are the only child of
7908 assert( cntNew
[0]>0 || (pParent
->pgno
==1 && pParent
->nCell
==0) || CORRUPT_DB
);
7909 TRACE(("BALANCE: old: %d(nc=%d) %d(nc=%d) %d(nc=%d)\n",
7910 apOld
[0]->pgno
, apOld
[0]->nCell
,
7911 nOld
>=2 ? apOld
[1]->pgno
: 0, nOld
>=2 ? apOld
[1]->nCell
: 0,
7912 nOld
>=3 ? apOld
[2]->pgno
: 0, nOld
>=3 ? apOld
[2]->nCell
: 0
7916 ** Allocate k new pages. Reuse old pages where possible.
7918 pageFlags
= apOld
[0]->aData
[0];
7922 pNew
= apNew
[i
] = apOld
[i
];
7924 rc
= sqlite3PagerWrite(pNew
->pDbPage
);
7926 if( rc
) goto balance_cleanup
;
7929 rc
= allocateBtreePage(pBt
, &pNew
, &pgno
, (bBulk
? 1 : pgno
), 0);
7930 if( rc
) goto balance_cleanup
;
7931 zeroPage(pNew
, pageFlags
);
7934 cntOld
[i
] = b
.nCell
;
7936 /* Set the pointer-map entry for the new sibling page. */
7938 ptrmapPut(pBt
, pNew
->pgno
, PTRMAP_BTREE
, pParent
->pgno
, &rc
);
7939 if( rc
!=SQLITE_OK
){
7940 goto balance_cleanup
;
7947 ** Reassign page numbers so that the new pages are in ascending order.
7948 ** This helps to keep entries in the disk file in order so that a scan
7949 ** of the table is closer to a linear scan through the file. That in turn
7950 ** helps the operating system to deliver pages from the disk more rapidly.
7952 ** An O(n^2) insertion sort algorithm is used, but since n is never more
7953 ** than (NB+2) (a small constant), that should not be a problem.
7955 ** When NB==3, this one optimization makes the database about 25% faster
7956 ** for large insertions and deletions.
7958 for(i
=0; i
<nNew
; i
++){
7959 aPgOrder
[i
] = aPgno
[i
] = apNew
[i
]->pgno
;
7960 aPgFlags
[i
] = apNew
[i
]->pDbPage
->flags
;
7962 if( aPgno
[j
]==aPgno
[i
] ){
7963 /* This branch is taken if the set of sibling pages somehow contains
7964 ** duplicate entries. This can happen if the database is corrupt.
7965 ** It would be simpler to detect this as part of the loop below, but
7966 ** we do the detection here in order to avoid populating the pager
7967 ** cache with two separate objects associated with the same
7969 assert( CORRUPT_DB
);
7970 rc
= SQLITE_CORRUPT_BKPT
;
7971 goto balance_cleanup
;
7975 for(i
=0; i
<nNew
; i
++){
7976 int iBest
= 0; /* aPgno[] index of page number to use */
7977 for(j
=1; j
<nNew
; j
++){
7978 if( aPgOrder
[j
]<aPgOrder
[iBest
] ) iBest
= j
;
7980 pgno
= aPgOrder
[iBest
];
7981 aPgOrder
[iBest
] = 0xffffffff;
7984 sqlite3PagerRekey(apNew
[iBest
]->pDbPage
, pBt
->nPage
+iBest
+1, 0);
7986 sqlite3PagerRekey(apNew
[i
]->pDbPage
, pgno
, aPgFlags
[iBest
]);
7987 apNew
[i
]->pgno
= pgno
;
7991 TRACE(("BALANCE: new: %d(%d nc=%d) %d(%d nc=%d) %d(%d nc=%d) "
7992 "%d(%d nc=%d) %d(%d nc=%d)\n",
7993 apNew
[0]->pgno
, szNew
[0], cntNew
[0],
7994 nNew
>=2 ? apNew
[1]->pgno
: 0, nNew
>=2 ? szNew
[1] : 0,
7995 nNew
>=2 ? cntNew
[1] - cntNew
[0] - !leafData
: 0,
7996 nNew
>=3 ? apNew
[2]->pgno
: 0, nNew
>=3 ? szNew
[2] : 0,
7997 nNew
>=3 ? cntNew
[2] - cntNew
[1] - !leafData
: 0,
7998 nNew
>=4 ? apNew
[3]->pgno
: 0, nNew
>=4 ? szNew
[3] : 0,
7999 nNew
>=4 ? cntNew
[3] - cntNew
[2] - !leafData
: 0,
8000 nNew
>=5 ? apNew
[4]->pgno
: 0, nNew
>=5 ? szNew
[4] : 0,
8001 nNew
>=5 ? cntNew
[4] - cntNew
[3] - !leafData
: 0
8004 assert( sqlite3PagerIswriteable(pParent
->pDbPage
) );
8005 assert( nNew
>=1 && nNew
<=ArraySize(apNew
) );
8006 assert( apNew
[nNew
-1]!=0 );
8007 put4byte(pRight
, apNew
[nNew
-1]->pgno
);
8009 /* If the sibling pages are not leaves, ensure that the right-child pointer
8010 ** of the right-most new sibling page is set to the value that was
8011 ** originally in the same field of the right-most old sibling page. */
8012 if( (pageFlags
& PTF_LEAF
)==0 && nOld
!=nNew
){
8013 MemPage
*pOld
= (nNew
>nOld
? apNew
: apOld
)[nOld
-1];
8014 memcpy(&apNew
[nNew
-1]->aData
[8], &pOld
->aData
[8], 4);
8017 /* Make any required updates to pointer map entries associated with
8018 ** cells stored on sibling pages following the balance operation. Pointer
8019 ** map entries associated with divider cells are set by the insertCell()
8020 ** routine. The associated pointer map entries are:
8022 ** a) if the cell contains a reference to an overflow chain, the
8023 ** entry associated with the first page in the overflow chain, and
8025 ** b) if the sibling pages are not leaves, the child page associated
8028 ** If the sibling pages are not leaves, then the pointer map entry
8029 ** associated with the right-child of each sibling may also need to be
8030 ** updated. This happens below, after the sibling pages have been
8031 ** populated, not here.
8035 MemPage
*pNew
= pOld
= apNew
[0];
8036 int cntOldNext
= pNew
->nCell
+ pNew
->nOverflow
;
8040 for(i
=0; i
<b
.nCell
; i
++){
8041 u8
*pCell
= b
.apCell
[i
];
8042 while( i
==cntOldNext
){
8044 assert( iOld
<nNew
|| iOld
<nOld
);
8045 assert( iOld
>=0 && iOld
<NB
);
8046 pOld
= iOld
<nNew
? apNew
[iOld
] : apOld
[iOld
];
8047 cntOldNext
+= pOld
->nCell
+ pOld
->nOverflow
+ !leafData
;
8049 if( i
==cntNew
[iNew
] ){
8050 pNew
= apNew
[++iNew
];
8051 if( !leafData
) continue;
8054 /* Cell pCell is destined for new sibling page pNew. Originally, it
8055 ** was either part of sibling page iOld (possibly an overflow cell),
8056 ** or else the divider cell to the left of sibling page iOld. So,
8057 ** if sibling page iOld had the same page number as pNew, and if
8058 ** pCell really was a part of sibling page iOld (not a divider or
8059 ** overflow cell), we can skip updating the pointer map entries. */
8061 || pNew
->pgno
!=aPgno
[iOld
]
8062 || !SQLITE_WITHIN(pCell
,pOld
->aData
,pOld
->aDataEnd
)
8064 if( !leafCorrection
){
8065 ptrmapPut(pBt
, get4byte(pCell
), PTRMAP_BTREE
, pNew
->pgno
, &rc
);
8067 if( cachedCellSize(&b
,i
)>pNew
->minLocal
){
8068 ptrmapPutOvflPtr(pNew
, pOld
, pCell
, &rc
);
8070 if( rc
) goto balance_cleanup
;
8075 /* Insert new divider cells into pParent. */
8076 for(i
=0; i
<nNew
-1; i
++){
8080 MemPage
*pNew
= apNew
[i
];
8083 assert( j
<nMaxCells
);
8084 assert( b
.apCell
[j
]!=0 );
8085 pCell
= b
.apCell
[j
];
8086 sz
= b
.szCell
[j
] + leafCorrection
;
8087 pTemp
= &aOvflSpace
[iOvflSpace
];
8089 memcpy(&pNew
->aData
[8], pCell
, 4);
8090 }else if( leafData
){
8091 /* If the tree is a leaf-data tree, and the siblings are leaves,
8092 ** then there is no divider cell in b.apCell[]. Instead, the divider
8093 ** cell consists of the integer key for the right-most cell of
8094 ** the sibling-page assembled above only.
8098 pNew
->xParseCell(pNew
, b
.apCell
[j
], &info
);
8100 sz
= 4 + putVarint(&pCell
[4], info
.nKey
);
8104 /* Obscure case for non-leaf-data trees: If the cell at pCell was
8105 ** previously stored on a leaf node, and its reported size was 4
8106 ** bytes, then it may actually be smaller than this
8107 ** (see btreeParseCellPtr(), 4 bytes is the minimum size of
8108 ** any cell). But it is important to pass the correct size to
8109 ** insertCell(), so reparse the cell now.
8111 ** This can only happen for b-trees used to evaluate "IN (SELECT ...)"
8112 ** and WITHOUT ROWID tables with exactly one column which is the
8115 if( b
.szCell
[j
]==4 ){
8116 assert(leafCorrection
==4);
8117 sz
= pParent
->xCellSize(pParent
, pCell
);
8121 assert( sz
<=pBt
->maxLocal
+23 );
8122 assert( iOvflSpace
<= (int)pBt
->pageSize
);
8123 insertCell(pParent
, nxDiv
+i
, pCell
, sz
, pTemp
, pNew
->pgno
, &rc
);
8124 if( rc
!=SQLITE_OK
) goto balance_cleanup
;
8125 assert( sqlite3PagerIswriteable(pParent
->pDbPage
) );
8128 /* Now update the actual sibling pages. The order in which they are updated
8129 ** is important, as this code needs to avoid disrupting any page from which
8130 ** cells may still to be read. In practice, this means:
8132 ** (1) If cells are moving left (from apNew[iPg] to apNew[iPg-1])
8133 ** then it is not safe to update page apNew[iPg] until after
8134 ** the left-hand sibling apNew[iPg-1] has been updated.
8136 ** (2) If cells are moving right (from apNew[iPg] to apNew[iPg+1])
8137 ** then it is not safe to update page apNew[iPg] until after
8138 ** the right-hand sibling apNew[iPg+1] has been updated.
8140 ** If neither of the above apply, the page is safe to update.
8142 ** The iPg value in the following loop starts at nNew-1 goes down
8143 ** to 0, then back up to nNew-1 again, thus making two passes over
8144 ** the pages. On the initial downward pass, only condition (1) above
8145 ** needs to be tested because (2) will always be true from the previous
8146 ** step. On the upward pass, both conditions are always true, so the
8147 ** upwards pass simply processes pages that were missed on the downward
8150 for(i
=1-nNew
; i
<nNew
; i
++){
8151 int iPg
= i
<0 ? -i
: i
;
8152 assert( iPg
>=0 && iPg
<nNew
);
8153 if( abDone
[iPg
] ) continue; /* Skip pages already processed */
8154 if( i
>=0 /* On the upwards pass, or... */
8155 || cntOld
[iPg
-1]>=cntNew
[iPg
-1] /* Condition (1) is true */
8161 /* Verify condition (1): If cells are moving left, update iPg
8162 ** only after iPg-1 has already been updated. */
8163 assert( iPg
==0 || cntOld
[iPg
-1]>=cntNew
[iPg
-1] || abDone
[iPg
-1] );
8165 /* Verify condition (2): If cells are moving right, update iPg
8166 ** only after iPg+1 has already been updated. */
8167 assert( cntNew
[iPg
]>=cntOld
[iPg
] || abDone
[iPg
+1] );
8171 nNewCell
= cntNew
[0];
8173 iOld
= iPg
<nOld
? (cntOld
[iPg
-1] + !leafData
) : b
.nCell
;
8174 iNew
= cntNew
[iPg
-1] + !leafData
;
8175 nNewCell
= cntNew
[iPg
] - iNew
;
8178 rc
= editPage(apNew
[iPg
], iOld
, iNew
, nNewCell
, &b
);
8179 if( rc
) goto balance_cleanup
;
8181 apNew
[iPg
]->nFree
= usableSpace
-szNew
[iPg
];
8182 assert( apNew
[iPg
]->nOverflow
==0 );
8183 assert( apNew
[iPg
]->nCell
==nNewCell
);
8187 /* All pages have been processed exactly once */
8188 assert( memcmp(abDone
, "\01\01\01\01\01", nNew
)==0 );
8193 if( isRoot
&& pParent
->nCell
==0 && pParent
->hdrOffset
<=apNew
[0]->nFree
){
8194 /* The root page of the b-tree now contains no cells. The only sibling
8195 ** page is the right-child of the parent. Copy the contents of the
8196 ** child page into the parent, decreasing the overall height of the
8197 ** b-tree structure by one. This is described as the "balance-shallower"
8198 ** sub-algorithm in some documentation.
8200 ** If this is an auto-vacuum database, the call to copyNodeContent()
8201 ** sets all pointer-map entries corresponding to database image pages
8202 ** for which the pointer is stored within the content being copied.
8204 ** It is critical that the child page be defragmented before being
8205 ** copied into the parent, because if the parent is page 1 then it will
8206 ** by smaller than the child due to the database header, and so all the
8207 ** free space needs to be up front.
8209 assert( nNew
==1 || CORRUPT_DB
);
8210 rc
= defragmentPage(apNew
[0], -1);
8211 testcase( rc
!=SQLITE_OK
);
8212 assert( apNew
[0]->nFree
==
8213 (get2byteNotZero(&apNew
[0]->aData
[5]) - apNew
[0]->cellOffset
8214 - apNew
[0]->nCell
*2)
8217 copyNodeContent(apNew
[0], pParent
, &rc
);
8218 freePage(apNew
[0], &rc
);
8219 }else if( ISAUTOVACUUM
&& !leafCorrection
){
8220 /* Fix the pointer map entries associated with the right-child of each
8221 ** sibling page. All other pointer map entries have already been taken
8223 for(i
=0; i
<nNew
; i
++){
8224 u32 key
= get4byte(&apNew
[i
]->aData
[8]);
8225 ptrmapPut(pBt
, key
, PTRMAP_BTREE
, apNew
[i
]->pgno
, &rc
);
8229 assert( pParent
->isInit
);
8230 TRACE(("BALANCE: finished: old=%d new=%d cells=%d\n",
8231 nOld
, nNew
, b
.nCell
));
8233 /* Free any old pages that were not reused as new pages.
8235 for(i
=nNew
; i
<nOld
; i
++){
8236 freePage(apOld
[i
], &rc
);
8240 if( ISAUTOVACUUM
&& rc
==SQLITE_OK
&& apNew
[0]->isInit
){
8241 /* The ptrmapCheckPages() contains assert() statements that verify that
8242 ** all pointer map pages are set correctly. This is helpful while
8243 ** debugging. This is usually disabled because a corrupt database may
8244 ** cause an assert() statement to fail. */
8245 ptrmapCheckPages(apNew
, nNew
);
8246 ptrmapCheckPages(&pParent
, 1);
8251 ** Cleanup before returning.
8254 sqlite3StackFree(0, b
.apCell
);
8255 for(i
=0; i
<nOld
; i
++){
8256 releasePage(apOld
[i
]);
8258 for(i
=0; i
<nNew
; i
++){
8259 releasePage(apNew
[i
]);
8267 ** This function is called when the root page of a b-tree structure is
8268 ** overfull (has one or more overflow pages).
8270 ** A new child page is allocated and the contents of the current root
8271 ** page, including overflow cells, are copied into the child. The root
8272 ** page is then overwritten to make it an empty page with the right-child
8273 ** pointer pointing to the new page.
8275 ** Before returning, all pointer-map entries corresponding to pages
8276 ** that the new child-page now contains pointers to are updated. The
8277 ** entry corresponding to the new right-child pointer of the root
8278 ** page is also updated.
8280 ** If successful, *ppChild is set to contain a reference to the child
8281 ** page and SQLITE_OK is returned. In this case the caller is required
8282 ** to call releasePage() on *ppChild exactly once. If an error occurs,
8283 ** an error code is returned and *ppChild is set to 0.
8285 static int balance_deeper(MemPage
*pRoot
, MemPage
**ppChild
){
8286 int rc
; /* Return value from subprocedures */
8287 MemPage
*pChild
= 0; /* Pointer to a new child page */
8288 Pgno pgnoChild
= 0; /* Page number of the new child page */
8289 BtShared
*pBt
= pRoot
->pBt
; /* The BTree */
8291 assert( pRoot
->nOverflow
>0 );
8292 assert( sqlite3_mutex_held(pBt
->mutex
) );
8294 /* Make pRoot, the root page of the b-tree, writable. Allocate a new
8295 ** page that will become the new right-child of pPage. Copy the contents
8296 ** of the node stored on pRoot into the new child page.
8298 rc
= sqlite3PagerWrite(pRoot
->pDbPage
);
8299 if( rc
==SQLITE_OK
){
8300 rc
= allocateBtreePage(pBt
,&pChild
,&pgnoChild
,pRoot
->pgno
,0);
8301 copyNodeContent(pRoot
, pChild
, &rc
);
8303 ptrmapPut(pBt
, pgnoChild
, PTRMAP_BTREE
, pRoot
->pgno
, &rc
);
8308 releasePage(pChild
);
8311 assert( sqlite3PagerIswriteable(pChild
->pDbPage
) );
8312 assert( sqlite3PagerIswriteable(pRoot
->pDbPage
) );
8313 assert( pChild
->nCell
==pRoot
->nCell
|| CORRUPT_DB
);
8315 TRACE(("BALANCE: copy root %d into %d\n", pRoot
->pgno
, pChild
->pgno
));
8317 /* Copy the overflow cells from pRoot to pChild */
8318 memcpy(pChild
->aiOvfl
, pRoot
->aiOvfl
,
8319 pRoot
->nOverflow
*sizeof(pRoot
->aiOvfl
[0]));
8320 memcpy(pChild
->apOvfl
, pRoot
->apOvfl
,
8321 pRoot
->nOverflow
*sizeof(pRoot
->apOvfl
[0]));
8322 pChild
->nOverflow
= pRoot
->nOverflow
;
8324 /* Zero the contents of pRoot. Then install pChild as the right-child. */
8325 zeroPage(pRoot
, pChild
->aData
[0] & ~PTF_LEAF
);
8326 put4byte(&pRoot
->aData
[pRoot
->hdrOffset
+8], pgnoChild
);
8333 ** Return SQLITE_CORRUPT if any cursor other than pCur is currently valid
8334 ** on the same B-tree as pCur.
8336 ** This can if a database is corrupt with two or more SQL tables
8337 ** pointing to the same b-tree. If an insert occurs on one SQL table
8338 ** and causes a BEFORE TRIGGER to do a secondary insert on the other SQL
8339 ** table linked to the same b-tree. If the secondary insert causes a
8340 ** rebalance, that can change content out from under the cursor on the
8341 ** first SQL table, violating invariants on the first insert.
8343 static int anotherValidCursor(BtCursor
*pCur
){
8345 for(pOther
=pCur
->pBt
->pCursor
; pOther
; pOther
=pOther
->pNext
){
8347 && pOther
->eState
==CURSOR_VALID
8348 && pOther
->pPage
==pCur
->pPage
8350 return SQLITE_CORRUPT_BKPT
;
8357 ** The page that pCur currently points to has just been modified in
8358 ** some way. This function figures out if this modification means the
8359 ** tree needs to be balanced, and if so calls the appropriate balancing
8360 ** routine. Balancing routines are:
8364 ** balance_nonroot()
8366 static int balance(BtCursor
*pCur
){
8368 const int nMin
= pCur
->pBt
->usableSize
* 2 / 3;
8369 u8 aBalanceQuickSpace
[13];
8372 VVA_ONLY( int balance_quick_called
= 0 );
8373 VVA_ONLY( int balance_deeper_called
= 0 );
8377 MemPage
*pPage
= pCur
->pPage
;
8379 if( NEVER(pPage
->nFree
<0) && btreeComputeFreeSpace(pPage
) ) break;
8380 if( pPage
->nOverflow
==0 && pPage
->nFree
<=nMin
){
8382 }else if( (iPage
= pCur
->iPage
)==0 ){
8383 if( pPage
->nOverflow
&& (rc
= anotherValidCursor(pCur
))==SQLITE_OK
){
8384 /* The root page of the b-tree is overfull. In this case call the
8385 ** balance_deeper() function to create a new child for the root-page
8386 ** and copy the current contents of the root-page to it. The
8387 ** next iteration of the do-loop will balance the child page.
8389 assert( balance_deeper_called
==0 );
8390 VVA_ONLY( balance_deeper_called
++ );
8391 rc
= balance_deeper(pPage
, &pCur
->apPage
[1]);
8392 if( rc
==SQLITE_OK
){
8396 pCur
->apPage
[0] = pPage
;
8397 pCur
->pPage
= pCur
->apPage
[1];
8398 assert( pCur
->pPage
->nOverflow
);
8404 MemPage
* const pParent
= pCur
->apPage
[iPage
-1];
8405 int const iIdx
= pCur
->aiIdx
[iPage
-1];
8407 rc
= sqlite3PagerWrite(pParent
->pDbPage
);
8408 if( rc
==SQLITE_OK
&& pParent
->nFree
<0 ){
8409 rc
= btreeComputeFreeSpace(pParent
);
8411 if( rc
==SQLITE_OK
){
8412 #ifndef SQLITE_OMIT_QUICKBALANCE
8413 if( pPage
->intKeyLeaf
8414 && pPage
->nOverflow
==1
8415 && pPage
->aiOvfl
[0]==pPage
->nCell
8417 && pParent
->nCell
==iIdx
8419 /* Call balance_quick() to create a new sibling of pPage on which
8420 ** to store the overflow cell. balance_quick() inserts a new cell
8421 ** into pParent, which may cause pParent overflow. If this
8422 ** happens, the next iteration of the do-loop will balance pParent
8423 ** use either balance_nonroot() or balance_deeper(). Until this
8424 ** happens, the overflow cell is stored in the aBalanceQuickSpace[]
8427 ** The purpose of the following assert() is to check that only a
8428 ** single call to balance_quick() is made for each call to this
8429 ** function. If this were not verified, a subtle bug involving reuse
8430 ** of the aBalanceQuickSpace[] might sneak in.
8432 assert( balance_quick_called
==0 );
8433 VVA_ONLY( balance_quick_called
++ );
8434 rc
= balance_quick(pParent
, pPage
, aBalanceQuickSpace
);
8438 /* In this case, call balance_nonroot() to redistribute cells
8439 ** between pPage and up to 2 of its sibling pages. This involves
8440 ** modifying the contents of pParent, which may cause pParent to
8441 ** become overfull or underfull. The next iteration of the do-loop
8442 ** will balance the parent page to correct this.
8444 ** If the parent page becomes overfull, the overflow cell or cells
8445 ** are stored in the pSpace buffer allocated immediately below.
8446 ** A subsequent iteration of the do-loop will deal with this by
8447 ** calling balance_nonroot() (balance_deeper() may be called first,
8448 ** but it doesn't deal with overflow cells - just moves them to a
8449 ** different page). Once this subsequent call to balance_nonroot()
8450 ** has completed, it is safe to release the pSpace buffer used by
8451 ** the previous call, as the overflow cell data will have been
8452 ** copied either into the body of a database page or into the new
8453 ** pSpace buffer passed to the latter call to balance_nonroot().
8455 u8
*pSpace
= sqlite3PageMalloc(pCur
->pBt
->pageSize
);
8456 rc
= balance_nonroot(pParent
, iIdx
, pSpace
, iPage
==1,
8457 pCur
->hints
&BTREE_BULKLOAD
);
8459 /* If pFree is not NULL, it points to the pSpace buffer used
8460 ** by a previous call to balance_nonroot(). Its contents are
8461 ** now stored either on real database pages or within the
8462 ** new pSpace buffer, so it may be safely freed here. */
8463 sqlite3PageFree(pFree
);
8466 /* The pSpace buffer will be freed after the next call to
8467 ** balance_nonroot(), or just before this function returns, whichever
8473 pPage
->nOverflow
= 0;
8475 /* The next iteration of the do-loop balances the parent page. */
8478 assert( pCur
->iPage
>=0 );
8479 pCur
->pPage
= pCur
->apPage
[pCur
->iPage
];
8481 }while( rc
==SQLITE_OK
);
8484 sqlite3PageFree(pFree
);
8489 /* Overwrite content from pX into pDest. Only do the write if the
8490 ** content is different from what is already there.
8492 static int btreeOverwriteContent(
8493 MemPage
*pPage
, /* MemPage on which writing will occur */
8494 u8
*pDest
, /* Pointer to the place to start writing */
8495 const BtreePayload
*pX
, /* Source of data to write */
8496 int iOffset
, /* Offset of first byte to write */
8497 int iAmt
/* Number of bytes to be written */
8499 int nData
= pX
->nData
- iOffset
;
8501 /* Overwritting with zeros */
8503 for(i
=0; i
<iAmt
&& pDest
[i
]==0; i
++){}
8505 int rc
= sqlite3PagerWrite(pPage
->pDbPage
);
8507 memset(pDest
+ i
, 0, iAmt
- i
);
8511 /* Mixed read data and zeros at the end. Make a recursive call
8512 ** to write the zeros then fall through to write the real data */
8513 int rc
= btreeOverwriteContent(pPage
, pDest
+nData
, pX
, iOffset
+nData
,
8518 if( memcmp(pDest
, ((u8
*)pX
->pData
) + iOffset
, iAmt
)!=0 ){
8519 int rc
= sqlite3PagerWrite(pPage
->pDbPage
);
8521 /* In a corrupt database, it is possible for the source and destination
8522 ** buffers to overlap. This is harmless since the database is already
8523 ** corrupt but it does cause valgrind and ASAN warnings. So use
8525 memmove(pDest
, ((u8
*)pX
->pData
) + iOffset
, iAmt
);
8532 ** Overwrite the cell that cursor pCur is pointing to with fresh content
8535 static int btreeOverwriteCell(BtCursor
*pCur
, const BtreePayload
*pX
){
8536 int iOffset
; /* Next byte of pX->pData to write */
8537 int nTotal
= pX
->nData
+ pX
->nZero
; /* Total bytes of to write */
8538 int rc
; /* Return code */
8539 MemPage
*pPage
= pCur
->pPage
; /* Page being written */
8540 BtShared
*pBt
; /* Btree */
8541 Pgno ovflPgno
; /* Next overflow page to write */
8542 u32 ovflPageSize
; /* Size to write on overflow page */
8544 if( pCur
->info
.pPayload
+ pCur
->info
.nLocal
> pPage
->aDataEnd
8545 || pCur
->info
.pPayload
< pPage
->aData
+ pPage
->cellOffset
8547 return SQLITE_CORRUPT_BKPT
;
8549 /* Overwrite the local portion first */
8550 rc
= btreeOverwriteContent(pPage
, pCur
->info
.pPayload
, pX
,
8551 0, pCur
->info
.nLocal
);
8553 if( pCur
->info
.nLocal
==nTotal
) return SQLITE_OK
;
8555 /* Now overwrite the overflow pages */
8556 iOffset
= pCur
->info
.nLocal
;
8557 assert( nTotal
>=0 );
8558 assert( iOffset
>=0 );
8559 ovflPgno
= get4byte(pCur
->info
.pPayload
+ iOffset
);
8561 ovflPageSize
= pBt
->usableSize
- 4;
8563 rc
= btreeGetPage(pBt
, ovflPgno
, &pPage
, 0);
8565 if( sqlite3PagerPageRefcount(pPage
->pDbPage
)!=1 ){
8566 rc
= SQLITE_CORRUPT_BKPT
;
8568 if( iOffset
+ovflPageSize
<(u32
)nTotal
){
8569 ovflPgno
= get4byte(pPage
->aData
);
8571 ovflPageSize
= nTotal
- iOffset
;
8573 rc
= btreeOverwriteContent(pPage
, pPage
->aData
+4, pX
,
8574 iOffset
, ovflPageSize
);
8576 sqlite3PagerUnref(pPage
->pDbPage
);
8578 iOffset
+= ovflPageSize
;
8579 }while( iOffset
<nTotal
);
8585 ** Insert a new record into the BTree. The content of the new record
8586 ** is described by the pX object. The pCur cursor is used only to
8587 ** define what table the record should be inserted into, and is left
8588 ** pointing at a random location.
8590 ** For a table btree (used for rowid tables), only the pX.nKey value of
8591 ** the key is used. The pX.pKey value must be NULL. The pX.nKey is the
8592 ** rowid or INTEGER PRIMARY KEY of the row. The pX.nData,pData,nZero fields
8593 ** hold the content of the row.
8595 ** For an index btree (used for indexes and WITHOUT ROWID tables), the
8596 ** key is an arbitrary byte sequence stored in pX.pKey,nKey. The
8597 ** pX.pData,nData,nZero fields must be zero.
8599 ** If the seekResult parameter is non-zero, then a successful call to
8600 ** MovetoUnpacked() to seek cursor pCur to (pKey,nKey) has already
8601 ** been performed. In other words, if seekResult!=0 then the cursor
8602 ** is currently pointing to a cell that will be adjacent to the cell
8603 ** to be inserted. If seekResult<0 then pCur points to a cell that is
8604 ** smaller then (pKey,nKey). If seekResult>0 then pCur points to a cell
8605 ** that is larger than (pKey,nKey).
8607 ** If seekResult==0, that means pCur is pointing at some unknown location.
8608 ** In that case, this routine must seek the cursor to the correct insertion
8609 ** point for (pKey,nKey) before doing the insertion. For index btrees,
8610 ** if pX->nMem is non-zero, then pX->aMem contains pointers to the unpacked
8611 ** key values and pX->aMem can be used instead of pX->pKey to avoid having
8612 ** to decode the key.
8614 int sqlite3BtreeInsert(
8615 BtCursor
*pCur
, /* Insert data into the table of this cursor */
8616 const BtreePayload
*pX
, /* Content of the row to be inserted */
8617 int flags
, /* True if this is likely an append */
8618 int seekResult
/* Result of prior MovetoUnpacked() call */
8621 int loc
= seekResult
; /* -1: before desired location +1: after */
8625 Btree
*p
= pCur
->pBtree
;
8626 BtShared
*pBt
= p
->pBt
;
8627 unsigned char *oldCell
;
8628 unsigned char *newCell
= 0;
8630 assert( (flags
& (BTREE_SAVEPOSITION
|BTREE_APPEND
))==flags
);
8632 if( pCur
->eState
==CURSOR_FAULT
){
8633 assert( pCur
->skipNext
!=SQLITE_OK
);
8634 return pCur
->skipNext
;
8637 assert( cursorOwnsBtShared(pCur
) );
8638 assert( (pCur
->curFlags
& BTCF_WriteFlag
)!=0
8639 && pBt
->inTransaction
==TRANS_WRITE
8640 && (pBt
->btsFlags
& BTS_READ_ONLY
)==0 );
8641 assert( hasSharedCacheTableLock(p
, pCur
->pgnoRoot
, pCur
->pKeyInfo
!=0, 2) );
8643 /* Assert that the caller has been consistent. If this cursor was opened
8644 ** expecting an index b-tree, then the caller should be inserting blob
8645 ** keys with no associated data. If the cursor was opened expecting an
8646 ** intkey table, the caller should be inserting integer keys with a
8647 ** blob of associated data. */
8648 assert( (pX
->pKey
==0)==(pCur
->pKeyInfo
==0) );
8650 /* Save the positions of any other cursors open on this table.
8652 ** In some cases, the call to btreeMoveto() below is a no-op. For
8653 ** example, when inserting data into a table with auto-generated integer
8654 ** keys, the VDBE layer invokes sqlite3BtreeLast() to figure out the
8655 ** integer key to use. It then calls this function to actually insert the
8656 ** data into the intkey B-Tree. In this case btreeMoveto() recognizes
8657 ** that the cursor is already where it needs to be and returns without
8658 ** doing any work. To avoid thwarting these optimizations, it is important
8659 ** not to clear the cursor here.
8661 if( pCur
->curFlags
& BTCF_Multiple
){
8662 rc
= saveAllCursors(pBt
, pCur
->pgnoRoot
, pCur
);
8666 if( pCur
->pKeyInfo
==0 ){
8667 assert( pX
->pKey
==0 );
8668 /* If this is an insert into a table b-tree, invalidate any incrblob
8669 ** cursors open on the row being replaced */
8670 invalidateIncrblobCursors(p
, pCur
->pgnoRoot
, pX
->nKey
, 0);
8672 /* If BTREE_SAVEPOSITION is set, the cursor must already be pointing
8673 ** to a row with the same key as the new entry being inserted.
8676 if( flags
& BTREE_SAVEPOSITION
){
8677 assert( pCur
->curFlags
& BTCF_ValidNKey
);
8678 assert( pX
->nKey
==pCur
->info
.nKey
);
8683 /* On the other hand, BTREE_SAVEPOSITION==0 does not imply
8684 ** that the cursor is not pointing to a row to be overwritten.
8685 ** So do a complete check.
8687 if( (pCur
->curFlags
&BTCF_ValidNKey
)!=0 && pX
->nKey
==pCur
->info
.nKey
){
8688 /* The cursor is pointing to the entry that is to be
8690 assert( pX
->nData
>=0 && pX
->nZero
>=0 );
8691 if( pCur
->info
.nSize
!=0
8692 && pCur
->info
.nPayload
==(u32
)pX
->nData
+pX
->nZero
8694 /* New entry is the same size as the old. Do an overwrite */
8695 return btreeOverwriteCell(pCur
, pX
);
8699 /* The cursor is *not* pointing to the cell to be overwritten, nor
8700 ** to an adjacent cell. Move the cursor so that it is pointing either
8701 ** to the cell to be overwritten or an adjacent cell.
8703 rc
= sqlite3BtreeMovetoUnpacked(pCur
, 0, pX
->nKey
, flags
!=0, &loc
);
8707 /* This is an index or a WITHOUT ROWID table */
8709 /* If BTREE_SAVEPOSITION is set, the cursor must already be pointing
8710 ** to a row with the same key as the new entry being inserted.
8712 assert( (flags
& BTREE_SAVEPOSITION
)==0 || loc
==0 );
8714 /* If the cursor is not already pointing either to the cell to be
8715 ** overwritten, or if a new cell is being inserted, if the cursor is
8716 ** not pointing to an immediately adjacent cell, then move the cursor
8719 if( loc
==0 && (flags
& BTREE_SAVEPOSITION
)==0 ){
8722 r
.pKeyInfo
= pCur
->pKeyInfo
;
8724 r
.nField
= pX
->nMem
;
8730 rc
= sqlite3BtreeMovetoUnpacked(pCur
, &r
, 0, flags
!=0, &loc
);
8732 rc
= btreeMoveto(pCur
, pX
->pKey
, pX
->nKey
, flags
!=0, &loc
);
8737 /* If the cursor is currently pointing to an entry to be overwritten
8738 ** and the new content is the same as as the old, then use the
8739 ** overwrite optimization.
8743 if( pCur
->info
.nKey
==pX
->nKey
){
8745 x2
.pData
= pX
->pKey
;
8746 x2
.nData
= pX
->nKey
;
8748 return btreeOverwriteCell(pCur
, &x2
);
8753 assert( pCur
->eState
==CURSOR_VALID
8754 || (pCur
->eState
==CURSOR_INVALID
&& loc
)
8757 pPage
= pCur
->pPage
;
8758 assert( pPage
->intKey
|| pX
->nKey
>=0 );
8759 assert( pPage
->leaf
|| !pPage
->intKey
);
8760 if( pPage
->nFree
<0 ){
8761 rc
= btreeComputeFreeSpace(pPage
);
8765 TRACE(("INSERT: table=%d nkey=%lld ndata=%d page=%d %s\n",
8766 pCur
->pgnoRoot
, pX
->nKey
, pX
->nData
, pPage
->pgno
,
8767 loc
==0 ? "overwrite" : "new entry"));
8768 assert( pPage
->isInit
);
8769 newCell
= pBt
->pTmpSpace
;
8770 assert( newCell
!=0 );
8771 rc
= fillInCell(pPage
, newCell
, pX
, &szNew
);
8772 if( rc
) goto end_insert
;
8773 assert( szNew
==pPage
->xCellSize(pPage
, newCell
) );
8774 assert( szNew
<= MX_CELL_SIZE(pBt
) );
8778 assert( idx
<pPage
->nCell
);
8779 rc
= sqlite3PagerWrite(pPage
->pDbPage
);
8783 oldCell
= findCell(pPage
, idx
);
8785 memcpy(newCell
, oldCell
, 4);
8787 rc
= clearCell(pPage
, oldCell
, &info
);
8788 testcase( pCur
->curFlags
& BTCF_ValidOvfl
);
8789 invalidateOverflowCache(pCur
);
8790 if( info
.nSize
==szNew
&& info
.nLocal
==info
.nPayload
8791 && (!ISAUTOVACUUM
|| szNew
<pPage
->minLocal
)
8793 /* Overwrite the old cell with the new if they are the same size.
8794 ** We could also try to do this if the old cell is smaller, then add
8795 ** the leftover space to the free list. But experiments show that
8796 ** doing that is no faster then skipping this optimization and just
8797 ** calling dropCell() and insertCell().
8799 ** This optimization cannot be used on an autovacuum database if the
8800 ** new entry uses overflow pages, as the insertCell() call below is
8801 ** necessary to add the PTRMAP_OVERFLOW1 pointer-map entry. */
8802 assert( rc
==SQLITE_OK
); /* clearCell never fails when nLocal==nPayload */
8803 if( oldCell
< pPage
->aData
+pPage
->hdrOffset
+10 ){
8804 return SQLITE_CORRUPT_BKPT
;
8806 if( oldCell
+szNew
> pPage
->aDataEnd
){
8807 return SQLITE_CORRUPT_BKPT
;
8809 memcpy(oldCell
, newCell
, szNew
);
8812 dropCell(pPage
, idx
, info
.nSize
, &rc
);
8813 if( rc
) goto end_insert
;
8814 }else if( loc
<0 && pPage
->nCell
>0 ){
8815 assert( pPage
->leaf
);
8817 pCur
->curFlags
&= ~BTCF_ValidNKey
;
8819 assert( pPage
->leaf
);
8821 insertCell(pPage
, idx
, newCell
, szNew
, 0, 0, &rc
);
8822 assert( pPage
->nOverflow
==0 || rc
==SQLITE_OK
);
8823 assert( rc
!=SQLITE_OK
|| pPage
->nCell
>0 || pPage
->nOverflow
>0 );
8825 /* If no error has occurred and pPage has an overflow cell, call balance()
8826 ** to redistribute the cells within the tree. Since balance() may move
8827 ** the cursor, zero the BtCursor.info.nSize and BTCF_ValidNKey
8830 ** Previous versions of SQLite called moveToRoot() to move the cursor
8831 ** back to the root page as balance() used to invalidate the contents
8832 ** of BtCursor.apPage[] and BtCursor.aiIdx[]. Instead of doing that,
8833 ** set the cursor state to "invalid". This makes common insert operations
8836 ** There is a subtle but important optimization here too. When inserting
8837 ** multiple records into an intkey b-tree using a single cursor (as can
8838 ** happen while processing an "INSERT INTO ... SELECT" statement), it
8839 ** is advantageous to leave the cursor pointing to the last entry in
8840 ** the b-tree if possible. If the cursor is left pointing to the last
8841 ** entry in the table, and the next row inserted has an integer key
8842 ** larger than the largest existing key, it is possible to insert the
8843 ** row without seeking the cursor. This can be a big performance boost.
8845 pCur
->info
.nSize
= 0;
8846 if( pPage
->nOverflow
){
8847 assert( rc
==SQLITE_OK
);
8848 pCur
->curFlags
&= ~(BTCF_ValidNKey
);
8851 /* Must make sure nOverflow is reset to zero even if the balance()
8852 ** fails. Internal data structure corruption will result otherwise.
8853 ** Also, set the cursor state to invalid. This stops saveCursorPosition()
8854 ** from trying to save the current position of the cursor. */
8855 pCur
->pPage
->nOverflow
= 0;
8856 pCur
->eState
= CURSOR_INVALID
;
8857 if( (flags
& BTREE_SAVEPOSITION
) && rc
==SQLITE_OK
){
8858 btreeReleaseAllCursorPages(pCur
);
8859 if( pCur
->pKeyInfo
){
8860 assert( pCur
->pKey
==0 );
8861 pCur
->pKey
= sqlite3Malloc( pX
->nKey
);
8862 if( pCur
->pKey
==0 ){
8865 memcpy(pCur
->pKey
, pX
->pKey
, pX
->nKey
);
8868 pCur
->eState
= CURSOR_REQUIRESEEK
;
8869 pCur
->nKey
= pX
->nKey
;
8872 assert( pCur
->iPage
<0 || pCur
->pPage
->nOverflow
==0 );
8879 ** Delete the entry that the cursor is pointing to.
8881 ** If the BTREE_SAVEPOSITION bit of the flags parameter is zero, then
8882 ** the cursor is left pointing at an arbitrary location after the delete.
8883 ** But if that bit is set, then the cursor is left in a state such that
8884 ** the next call to BtreeNext() or BtreePrev() moves it to the same row
8885 ** as it would have been on if the call to BtreeDelete() had been omitted.
8887 ** The BTREE_AUXDELETE bit of flags indicates that is one of several deletes
8888 ** associated with a single table entry and its indexes. Only one of those
8889 ** deletes is considered the "primary" delete. The primary delete occurs
8890 ** on a cursor that is not a BTREE_FORDELETE cursor. All but one delete
8891 ** operation on non-FORDELETE cursors is tagged with the AUXDELETE flag.
8892 ** The BTREE_AUXDELETE bit is a hint that is not used by this implementation,
8893 ** but which might be used by alternative storage engines.
8895 int sqlite3BtreeDelete(BtCursor
*pCur
, u8 flags
){
8896 Btree
*p
= pCur
->pBtree
;
8897 BtShared
*pBt
= p
->pBt
;
8898 int rc
; /* Return code */
8899 MemPage
*pPage
; /* Page to delete cell from */
8900 unsigned char *pCell
; /* Pointer to cell to delete */
8901 int iCellIdx
; /* Index of cell to delete */
8902 int iCellDepth
; /* Depth of node containing pCell */
8903 CellInfo info
; /* Size of the cell being deleted */
8904 int bSkipnext
= 0; /* Leaf cursor in SKIPNEXT state */
8905 u8 bPreserve
= flags
& BTREE_SAVEPOSITION
; /* Keep cursor valid */
8907 assert( cursorOwnsBtShared(pCur
) );
8908 assert( pBt
->inTransaction
==TRANS_WRITE
);
8909 assert( (pBt
->btsFlags
& BTS_READ_ONLY
)==0 );
8910 assert( pCur
->curFlags
& BTCF_WriteFlag
);
8911 assert( hasSharedCacheTableLock(p
, pCur
->pgnoRoot
, pCur
->pKeyInfo
!=0, 2) );
8912 assert( !hasReadConflicts(p
, pCur
->pgnoRoot
) );
8913 assert( (flags
& ~(BTREE_SAVEPOSITION
| BTREE_AUXDELETE
))==0 );
8914 if( pCur
->eState
==CURSOR_REQUIRESEEK
){
8915 rc
= btreeRestoreCursorPosition(pCur
);
8918 assert( pCur
->eState
==CURSOR_VALID
);
8920 iCellDepth
= pCur
->iPage
;
8921 iCellIdx
= pCur
->ix
;
8922 pPage
= pCur
->pPage
;
8923 pCell
= findCell(pPage
, iCellIdx
);
8924 if( pPage
->nFree
<0 && btreeComputeFreeSpace(pPage
) ) return SQLITE_CORRUPT
;
8926 /* If the bPreserve flag is set to true, then the cursor position must
8927 ** be preserved following this delete operation. If the current delete
8928 ** will cause a b-tree rebalance, then this is done by saving the cursor
8929 ** key and leaving the cursor in CURSOR_REQUIRESEEK state before
8932 ** Or, if the current delete will not cause a rebalance, then the cursor
8933 ** will be left in CURSOR_SKIPNEXT state pointing to the entry immediately
8934 ** before or after the deleted entry. In this case set bSkipnext to true. */
8937 || (pPage
->nFree
+cellSizePtr(pPage
,pCell
)+2)>(int)(pBt
->usableSize
*2/3)
8938 || pPage
->nCell
==1 /* See dbfuzz001.test for a test case */
8940 /* A b-tree rebalance will be required after deleting this entry.
8941 ** Save the cursor key. */
8942 rc
= saveCursorKey(pCur
);
8949 /* If the page containing the entry to delete is not a leaf page, move
8950 ** the cursor to the largest entry in the tree that is smaller than
8951 ** the entry being deleted. This cell will replace the cell being deleted
8952 ** from the internal node. The 'previous' entry is used for this instead
8953 ** of the 'next' entry, as the previous entry is always a part of the
8954 ** sub-tree headed by the child page of the cell being deleted. This makes
8955 ** balancing the tree following the delete operation easier. */
8957 rc
= sqlite3BtreePrevious(pCur
, 0);
8958 assert( rc
!=SQLITE_DONE
);
8962 /* Save the positions of any other cursors open on this table before
8963 ** making any modifications. */
8964 if( pCur
->curFlags
& BTCF_Multiple
){
8965 rc
= saveAllCursors(pBt
, pCur
->pgnoRoot
, pCur
);
8969 /* If this is a delete operation to remove a row from a table b-tree,
8970 ** invalidate any incrblob cursors open on the row being deleted. */
8971 if( pCur
->pKeyInfo
==0 ){
8972 invalidateIncrblobCursors(p
, pCur
->pgnoRoot
, pCur
->info
.nKey
, 0);
8975 /* Make the page containing the entry to be deleted writable. Then free any
8976 ** overflow pages associated with the entry and finally remove the cell
8977 ** itself from within the page. */
8978 rc
= sqlite3PagerWrite(pPage
->pDbPage
);
8980 rc
= clearCell(pPage
, pCell
, &info
);
8981 dropCell(pPage
, iCellIdx
, info
.nSize
, &rc
);
8984 /* If the cell deleted was not located on a leaf page, then the cursor
8985 ** is currently pointing to the largest entry in the sub-tree headed
8986 ** by the child-page of the cell that was just deleted from an internal
8987 ** node. The cell from the leaf node needs to be moved to the internal
8988 ** node to replace the deleted cell. */
8990 MemPage
*pLeaf
= pCur
->pPage
;
8993 unsigned char *pTmp
;
8995 if( pLeaf
->nFree
<0 ){
8996 rc
= btreeComputeFreeSpace(pLeaf
);
8999 if( iCellDepth
<pCur
->iPage
-1 ){
9000 n
= pCur
->apPage
[iCellDepth
+1]->pgno
;
9002 n
= pCur
->pPage
->pgno
;
9004 pCell
= findCell(pLeaf
, pLeaf
->nCell
-1);
9005 if( pCell
<&pLeaf
->aData
[4] ) return SQLITE_CORRUPT_BKPT
;
9006 nCell
= pLeaf
->xCellSize(pLeaf
, pCell
);
9007 assert( MX_CELL_SIZE(pBt
) >= nCell
);
9008 pTmp
= pBt
->pTmpSpace
;
9010 rc
= sqlite3PagerWrite(pLeaf
->pDbPage
);
9011 if( rc
==SQLITE_OK
){
9012 insertCell(pPage
, iCellIdx
, pCell
-4, nCell
+4, pTmp
, n
, &rc
);
9014 dropCell(pLeaf
, pLeaf
->nCell
-1, nCell
, &rc
);
9018 /* Balance the tree. If the entry deleted was located on a leaf page,
9019 ** then the cursor still points to that page. In this case the first
9020 ** call to balance() repairs the tree, and the if(...) condition is
9023 ** Otherwise, if the entry deleted was on an internal node page, then
9024 ** pCur is pointing to the leaf page from which a cell was removed to
9025 ** replace the cell deleted from the internal node. This is slightly
9026 ** tricky as the leaf node may be underfull, and the internal node may
9027 ** be either under or overfull. In this case run the balancing algorithm
9028 ** on the leaf node first. If the balance proceeds far enough up the
9029 ** tree that we can be sure that any problem in the internal node has
9030 ** been corrected, so be it. Otherwise, after balancing the leaf node,
9031 ** walk the cursor up the tree to the internal node and balance it as
9034 if( rc
==SQLITE_OK
&& pCur
->iPage
>iCellDepth
){
9035 releasePageNotNull(pCur
->pPage
);
9037 while( pCur
->iPage
>iCellDepth
){
9038 releasePage(pCur
->apPage
[pCur
->iPage
--]);
9040 pCur
->pPage
= pCur
->apPage
[pCur
->iPage
];
9044 if( rc
==SQLITE_OK
){
9046 assert( bPreserve
&& (pCur
->iPage
==iCellDepth
|| CORRUPT_DB
) );
9047 assert( pPage
==pCur
->pPage
|| CORRUPT_DB
);
9048 assert( (pPage
->nCell
>0 || CORRUPT_DB
) && iCellIdx
<=pPage
->nCell
);
9049 pCur
->eState
= CURSOR_SKIPNEXT
;
9050 if( iCellIdx
>=pPage
->nCell
){
9051 pCur
->skipNext
= -1;
9052 pCur
->ix
= pPage
->nCell
-1;
9057 rc
= moveToRoot(pCur
);
9059 btreeReleaseAllCursorPages(pCur
);
9060 pCur
->eState
= CURSOR_REQUIRESEEK
;
9062 if( rc
==SQLITE_EMPTY
) rc
= SQLITE_OK
;
9069 ** Create a new BTree table. Write into *piTable the page
9070 ** number for the root page of the new table.
9072 ** The type of type is determined by the flags parameter. Only the
9073 ** following values of flags are currently in use. Other values for
9074 ** flags might not work:
9076 ** BTREE_INTKEY|BTREE_LEAFDATA Used for SQL tables with rowid keys
9077 ** BTREE_ZERODATA Used for SQL indices
9079 static int btreeCreateTable(Btree
*p
, int *piTable
, int createTabFlags
){
9080 BtShared
*pBt
= p
->pBt
;
9084 int ptfFlags
; /* Page-type flage for the root page of new table */
9086 assert( sqlite3BtreeHoldsMutex(p
) );
9087 assert( pBt
->inTransaction
==TRANS_WRITE
);
9088 assert( (pBt
->btsFlags
& BTS_READ_ONLY
)==0 );
9090 #ifdef SQLITE_OMIT_AUTOVACUUM
9091 rc
= allocateBtreePage(pBt
, &pRoot
, &pgnoRoot
, 1, 0);
9096 if( pBt
->autoVacuum
){
9097 Pgno pgnoMove
; /* Move a page here to make room for the root-page */
9098 MemPage
*pPageMove
; /* The page to move to. */
9100 /* Creating a new table may probably require moving an existing database
9101 ** to make room for the new tables root page. In case this page turns
9102 ** out to be an overflow page, delete all overflow page-map caches
9103 ** held by open cursors.
9105 invalidateAllOverflowCache(pBt
);
9107 /* Read the value of meta[3] from the database to determine where the
9108 ** root page of the new table should go. meta[3] is the largest root-page
9109 ** created so far, so the new root-page is (meta[3]+1).
9111 sqlite3BtreeGetMeta(p
, BTREE_LARGEST_ROOT_PAGE
, &pgnoRoot
);
9114 /* The new root-page may not be allocated on a pointer-map page, or the
9115 ** PENDING_BYTE page.
9117 while( pgnoRoot
==PTRMAP_PAGENO(pBt
, pgnoRoot
) ||
9118 pgnoRoot
==PENDING_BYTE_PAGE(pBt
) ){
9121 assert( pgnoRoot
>=3 || CORRUPT_DB
);
9122 testcase( pgnoRoot
<3 );
9124 /* Allocate a page. The page that currently resides at pgnoRoot will
9125 ** be moved to the allocated page (unless the allocated page happens
9126 ** to reside at pgnoRoot).
9128 rc
= allocateBtreePage(pBt
, &pPageMove
, &pgnoMove
, pgnoRoot
, BTALLOC_EXACT
);
9129 if( rc
!=SQLITE_OK
){
9133 if( pgnoMove
!=pgnoRoot
){
9134 /* pgnoRoot is the page that will be used for the root-page of
9135 ** the new table (assuming an error did not occur). But we were
9136 ** allocated pgnoMove. If required (i.e. if it was not allocated
9137 ** by extending the file), the current page at position pgnoMove
9138 ** is already journaled.
9143 /* Save the positions of any open cursors. This is required in
9144 ** case they are holding a reference to an xFetch reference
9145 ** corresponding to page pgnoRoot. */
9146 rc
= saveAllCursors(pBt
, 0, 0);
9147 releasePage(pPageMove
);
9148 if( rc
!=SQLITE_OK
){
9152 /* Move the page currently at pgnoRoot to pgnoMove. */
9153 rc
= btreeGetPage(pBt
, pgnoRoot
, &pRoot
, 0);
9154 if( rc
!=SQLITE_OK
){
9157 rc
= ptrmapGet(pBt
, pgnoRoot
, &eType
, &iPtrPage
);
9158 if( eType
==PTRMAP_ROOTPAGE
|| eType
==PTRMAP_FREEPAGE
){
9159 rc
= SQLITE_CORRUPT_BKPT
;
9161 if( rc
!=SQLITE_OK
){
9165 assert( eType
!=PTRMAP_ROOTPAGE
);
9166 assert( eType
!=PTRMAP_FREEPAGE
);
9167 rc
= relocatePage(pBt
, pRoot
, eType
, iPtrPage
, pgnoMove
, 0);
9170 /* Obtain the page at pgnoRoot */
9171 if( rc
!=SQLITE_OK
){
9174 rc
= btreeGetPage(pBt
, pgnoRoot
, &pRoot
, 0);
9175 if( rc
!=SQLITE_OK
){
9178 rc
= sqlite3PagerWrite(pRoot
->pDbPage
);
9179 if( rc
!=SQLITE_OK
){
9187 /* Update the pointer-map and meta-data with the new root-page number. */
9188 ptrmapPut(pBt
, pgnoRoot
, PTRMAP_ROOTPAGE
, 0, &rc
);
9194 /* When the new root page was allocated, page 1 was made writable in
9195 ** order either to increase the database filesize, or to decrement the
9196 ** freelist count. Hence, the sqlite3BtreeUpdateMeta() call cannot fail.
9198 assert( sqlite3PagerIswriteable(pBt
->pPage1
->pDbPage
) );
9199 rc
= sqlite3BtreeUpdateMeta(p
, 4, pgnoRoot
);
9206 rc
= allocateBtreePage(pBt
, &pRoot
, &pgnoRoot
, 1, 0);
9210 assert( sqlite3PagerIswriteable(pRoot
->pDbPage
) );
9211 if( createTabFlags
& BTREE_INTKEY
){
9212 ptfFlags
= PTF_INTKEY
| PTF_LEAFDATA
| PTF_LEAF
;
9214 ptfFlags
= PTF_ZERODATA
| PTF_LEAF
;
9216 zeroPage(pRoot
, ptfFlags
);
9217 sqlite3PagerUnref(pRoot
->pDbPage
);
9218 assert( (pBt
->openFlags
& BTREE_SINGLE
)==0 || pgnoRoot
==2 );
9219 *piTable
= (int)pgnoRoot
;
9222 int sqlite3BtreeCreateTable(Btree
*p
, int *piTable
, int flags
){
9224 sqlite3BtreeEnter(p
);
9225 rc
= btreeCreateTable(p
, piTable
, flags
);
9226 sqlite3BtreeLeave(p
);
9231 ** Erase the given database page and all its children. Return
9232 ** the page to the freelist.
9234 static int clearDatabasePage(
9235 BtShared
*pBt
, /* The BTree that contains the table */
9236 Pgno pgno
, /* Page number to clear */
9237 int freePageFlag
, /* Deallocate page if true */
9238 int *pnChange
/* Add number of Cells freed to this counter */
9242 unsigned char *pCell
;
9247 assert( sqlite3_mutex_held(pBt
->mutex
) );
9248 if( pgno
>btreePagecount(pBt
) ){
9249 return SQLITE_CORRUPT_BKPT
;
9251 rc
= getAndInitPage(pBt
, pgno
, &pPage
, 0, 0);
9254 rc
= SQLITE_CORRUPT_BKPT
;
9255 goto cleardatabasepage_out
;
9258 hdr
= pPage
->hdrOffset
;
9259 for(i
=0; i
<pPage
->nCell
; i
++){
9260 pCell
= findCell(pPage
, i
);
9262 rc
= clearDatabasePage(pBt
, get4byte(pCell
), 1, pnChange
);
9263 if( rc
) goto cleardatabasepage_out
;
9265 rc
= clearCell(pPage
, pCell
, &info
);
9266 if( rc
) goto cleardatabasepage_out
;
9269 rc
= clearDatabasePage(pBt
, get4byte(&pPage
->aData
[hdr
+8]), 1, pnChange
);
9270 if( rc
) goto cleardatabasepage_out
;
9271 }else if( pnChange
){
9272 assert( pPage
->intKey
|| CORRUPT_DB
);
9273 testcase( !pPage
->intKey
);
9274 *pnChange
+= pPage
->nCell
;
9277 freePage(pPage
, &rc
);
9278 }else if( (rc
= sqlite3PagerWrite(pPage
->pDbPage
))==0 ){
9279 zeroPage(pPage
, pPage
->aData
[hdr
] | PTF_LEAF
);
9282 cleardatabasepage_out
:
9289 ** Delete all information from a single table in the database. iTable is
9290 ** the page number of the root of the table. After this routine returns,
9291 ** the root page is empty, but still exists.
9293 ** This routine will fail with SQLITE_LOCKED if there are any open
9294 ** read cursors on the table. Open write cursors are moved to the
9295 ** root of the table.
9297 ** If pnChange is not NULL, then table iTable must be an intkey table. The
9298 ** integer value pointed to by pnChange is incremented by the number of
9299 ** entries in the table.
9301 int sqlite3BtreeClearTable(Btree
*p
, int iTable
, int *pnChange
){
9303 BtShared
*pBt
= p
->pBt
;
9304 sqlite3BtreeEnter(p
);
9305 assert( p
->inTrans
==TRANS_WRITE
);
9307 rc
= saveAllCursors(pBt
, (Pgno
)iTable
, 0);
9309 if( SQLITE_OK
==rc
){
9310 /* Invalidate all incrblob cursors open on table iTable (assuming iTable
9311 ** is the root of a table b-tree - if it is not, the following call is
9313 invalidateIncrblobCursors(p
, (Pgno
)iTable
, 0, 1);
9314 rc
= clearDatabasePage(pBt
, (Pgno
)iTable
, 0, pnChange
);
9316 sqlite3BtreeLeave(p
);
9321 ** Delete all information from the single table that pCur is open on.
9323 ** This routine only work for pCur on an ephemeral table.
9325 int sqlite3BtreeClearTableOfCursor(BtCursor
*pCur
){
9326 return sqlite3BtreeClearTable(pCur
->pBtree
, pCur
->pgnoRoot
, 0);
9330 ** Erase all information in a table and add the root of the table to
9331 ** the freelist. Except, the root of the principle table (the one on
9332 ** page 1) is never added to the freelist.
9334 ** This routine will fail with SQLITE_LOCKED if there are any open
9335 ** cursors on the table.
9337 ** If AUTOVACUUM is enabled and the page at iTable is not the last
9338 ** root page in the database file, then the last root page
9339 ** in the database file is moved into the slot formerly occupied by
9340 ** iTable and that last slot formerly occupied by the last root page
9341 ** is added to the freelist instead of iTable. In this say, all
9342 ** root pages are kept at the beginning of the database file, which
9343 ** is necessary for AUTOVACUUM to work right. *piMoved is set to the
9344 ** page number that used to be the last root page in the file before
9345 ** the move. If no page gets moved, *piMoved is set to 0.
9346 ** The last root page is recorded in meta[3] and the value of
9347 ** meta[3] is updated by this procedure.
9349 static int btreeDropTable(Btree
*p
, Pgno iTable
, int *piMoved
){
9352 BtShared
*pBt
= p
->pBt
;
9354 assert( sqlite3BtreeHoldsMutex(p
) );
9355 assert( p
->inTrans
==TRANS_WRITE
);
9356 assert( iTable
>=2 );
9357 if( iTable
>btreePagecount(pBt
) ){
9358 return SQLITE_CORRUPT_BKPT
;
9361 rc
= btreeGetPage(pBt
, (Pgno
)iTable
, &pPage
, 0);
9363 rc
= sqlite3BtreeClearTable(p
, iTable
, 0);
9371 #ifdef SQLITE_OMIT_AUTOVACUUM
9372 freePage(pPage
, &rc
);
9375 if( pBt
->autoVacuum
){
9377 sqlite3BtreeGetMeta(p
, BTREE_LARGEST_ROOT_PAGE
, &maxRootPgno
);
9379 if( iTable
==maxRootPgno
){
9380 /* If the table being dropped is the table with the largest root-page
9381 ** number in the database, put the root page on the free list.
9383 freePage(pPage
, &rc
);
9385 if( rc
!=SQLITE_OK
){
9389 /* The table being dropped does not have the largest root-page
9390 ** number in the database. So move the page that does into the
9391 ** gap left by the deleted root-page.
9395 rc
= btreeGetPage(pBt
, maxRootPgno
, &pMove
, 0);
9396 if( rc
!=SQLITE_OK
){
9399 rc
= relocatePage(pBt
, pMove
, PTRMAP_ROOTPAGE
, 0, iTable
, 0);
9401 if( rc
!=SQLITE_OK
){
9405 rc
= btreeGetPage(pBt
, maxRootPgno
, &pMove
, 0);
9406 freePage(pMove
, &rc
);
9408 if( rc
!=SQLITE_OK
){
9411 *piMoved
= maxRootPgno
;
9414 /* Set the new 'max-root-page' value in the database header. This
9415 ** is the old value less one, less one more if that happens to
9416 ** be a root-page number, less one again if that is the
9417 ** PENDING_BYTE_PAGE.
9420 while( maxRootPgno
==PENDING_BYTE_PAGE(pBt
)
9421 || PTRMAP_ISPAGE(pBt
, maxRootPgno
) ){
9424 assert( maxRootPgno
!=PENDING_BYTE_PAGE(pBt
) );
9426 rc
= sqlite3BtreeUpdateMeta(p
, 4, maxRootPgno
);
9428 freePage(pPage
, &rc
);
9434 int sqlite3BtreeDropTable(Btree
*p
, int iTable
, int *piMoved
){
9436 sqlite3BtreeEnter(p
);
9437 rc
= btreeDropTable(p
, iTable
, piMoved
);
9438 sqlite3BtreeLeave(p
);
9444 ** This function may only be called if the b-tree connection already
9445 ** has a read or write transaction open on the database.
9447 ** Read the meta-information out of a database file. Meta[0]
9448 ** is the number of free pages currently in the database. Meta[1]
9449 ** through meta[15] are available for use by higher layers. Meta[0]
9450 ** is read-only, the others are read/write.
9452 ** The schema layer numbers meta values differently. At the schema
9453 ** layer (and the SetCookie and ReadCookie opcodes) the number of
9454 ** free pages is not visible. So Cookie[0] is the same as Meta[1].
9456 ** This routine treats Meta[BTREE_DATA_VERSION] as a special case. Instead
9457 ** of reading the value out of the header, it instead loads the "DataVersion"
9458 ** from the pager. The BTREE_DATA_VERSION value is not actually stored in the
9459 ** database file. It is a number computed by the pager. But its access
9460 ** pattern is the same as header meta values, and so it is convenient to
9461 ** read it from this routine.
9463 void sqlite3BtreeGetMeta(Btree
*p
, int idx
, u32
*pMeta
){
9464 BtShared
*pBt
= p
->pBt
;
9466 sqlite3BtreeEnter(p
);
9467 assert( p
->inTrans
>TRANS_NONE
);
9468 assert( SQLITE_OK
==querySharedCacheTableLock(p
, MASTER_ROOT
, READ_LOCK
) );
9469 assert( pBt
->pPage1
);
9470 assert( idx
>=0 && idx
<=15 );
9472 if( idx
==BTREE_DATA_VERSION
){
9473 *pMeta
= sqlite3PagerDataVersion(pBt
->pPager
) + p
->iDataVersion
;
9475 *pMeta
= get4byte(&pBt
->pPage1
->aData
[36 + idx
*4]);
9478 /* If auto-vacuum is disabled in this build and this is an auto-vacuum
9479 ** database, mark the database as read-only. */
9480 #ifdef SQLITE_OMIT_AUTOVACUUM
9481 if( idx
==BTREE_LARGEST_ROOT_PAGE
&& *pMeta
>0 ){
9482 pBt
->btsFlags
|= BTS_READ_ONLY
;
9486 sqlite3BtreeLeave(p
);
9490 ** Write meta-information back into the database. Meta[0] is
9491 ** read-only and may not be written.
9493 int sqlite3BtreeUpdateMeta(Btree
*p
, int idx
, u32 iMeta
){
9494 BtShared
*pBt
= p
->pBt
;
9497 assert( idx
>=1 && idx
<=15 );
9498 sqlite3BtreeEnter(p
);
9499 assert( p
->inTrans
==TRANS_WRITE
);
9500 assert( pBt
->pPage1
!=0 );
9501 pP1
= pBt
->pPage1
->aData
;
9502 rc
= sqlite3PagerWrite(pBt
->pPage1
->pDbPage
);
9503 if( rc
==SQLITE_OK
){
9504 put4byte(&pP1
[36 + idx
*4], iMeta
);
9505 #ifndef SQLITE_OMIT_AUTOVACUUM
9506 if( idx
==BTREE_INCR_VACUUM
){
9507 assert( pBt
->autoVacuum
|| iMeta
==0 );
9508 assert( iMeta
==0 || iMeta
==1 );
9509 pBt
->incrVacuum
= (u8
)iMeta
;
9513 sqlite3BtreeLeave(p
);
9517 #ifndef SQLITE_OMIT_BTREECOUNT
9519 ** The first argument, pCur, is a cursor opened on some b-tree. Count the
9520 ** number of entries in the b-tree and write the result to *pnEntry.
9522 ** SQLITE_OK is returned if the operation is successfully executed.
9523 ** Otherwise, if an error is encountered (i.e. an IO error or database
9524 ** corruption) an SQLite error code is returned.
9526 int sqlite3BtreeCount(sqlite3
*db
, BtCursor
*pCur
, i64
*pnEntry
){
9527 i64 nEntry
= 0; /* Value to return in *pnEntry */
9528 int rc
; /* Return code */
9530 rc
= moveToRoot(pCur
);
9531 if( rc
==SQLITE_EMPTY
){
9536 /* Unless an error occurs, the following loop runs one iteration for each
9537 ** page in the B-Tree structure (not including overflow pages).
9539 while( rc
==SQLITE_OK
&& !db
->u1
.isInterrupted
){
9540 int iIdx
; /* Index of child node in parent */
9541 MemPage
*pPage
; /* Current page of the b-tree */
9543 /* If this is a leaf page or the tree is not an int-key tree, then
9544 ** this page contains countable entries. Increment the entry counter
9547 pPage
= pCur
->pPage
;
9548 if( pPage
->leaf
|| !pPage
->intKey
){
9549 nEntry
+= pPage
->nCell
;
9552 /* pPage is a leaf node. This loop navigates the cursor so that it
9553 ** points to the first interior cell that it points to the parent of
9554 ** the next page in the tree that has not yet been visited. The
9555 ** pCur->aiIdx[pCur->iPage] value is set to the index of the parent cell
9556 ** of the page, or to the number of cells in the page if the next page
9557 ** to visit is the right-child of its parent.
9559 ** If all pages in the tree have been visited, return SQLITE_OK to the
9564 if( pCur
->iPage
==0 ){
9565 /* All pages of the b-tree have been visited. Return successfully. */
9567 return moveToRoot(pCur
);
9570 }while ( pCur
->ix
>=pCur
->pPage
->nCell
);
9573 pPage
= pCur
->pPage
;
9576 /* Descend to the child node of the cell that the cursor currently
9577 ** points at. This is the right-child if (iIdx==pPage->nCell).
9580 if( iIdx
==pPage
->nCell
){
9581 rc
= moveToChild(pCur
, get4byte(&pPage
->aData
[pPage
->hdrOffset
+8]));
9583 rc
= moveToChild(pCur
, get4byte(findCell(pPage
, iIdx
)));
9587 /* An error has occurred. Return an error code. */
9593 ** Return the pager associated with a BTree. This routine is used for
9594 ** testing and debugging only.
9596 Pager
*sqlite3BtreePager(Btree
*p
){
9597 return p
->pBt
->pPager
;
9600 #ifndef SQLITE_OMIT_INTEGRITY_CHECK
9602 ** Append a message to the error message string.
9604 static void checkAppendMsg(
9605 IntegrityCk
*pCheck
,
9606 const char *zFormat
,
9610 if( !pCheck
->mxErr
) return;
9613 va_start(ap
, zFormat
);
9614 if( pCheck
->errMsg
.nChar
){
9615 sqlite3_str_append(&pCheck
->errMsg
, "\n", 1);
9618 sqlite3_str_appendf(&pCheck
->errMsg
, pCheck
->zPfx
, pCheck
->v1
, pCheck
->v2
);
9620 sqlite3_str_vappendf(&pCheck
->errMsg
, zFormat
, ap
);
9622 if( pCheck
->errMsg
.accError
==SQLITE_NOMEM
){
9623 pCheck
->mallocFailed
= 1;
9626 #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
9628 #ifndef SQLITE_OMIT_INTEGRITY_CHECK
9631 ** Return non-zero if the bit in the IntegrityCk.aPgRef[] array that
9632 ** corresponds to page iPg is already set.
9634 static int getPageReferenced(IntegrityCk
*pCheck
, Pgno iPg
){
9635 assert( iPg
<=pCheck
->nPage
&& sizeof(pCheck
->aPgRef
[0])==1 );
9636 return (pCheck
->aPgRef
[iPg
/8] & (1 << (iPg
& 0x07)));
9640 ** Set the bit in the IntegrityCk.aPgRef[] array that corresponds to page iPg.
9642 static void setPageReferenced(IntegrityCk
*pCheck
, Pgno iPg
){
9643 assert( iPg
<=pCheck
->nPage
&& sizeof(pCheck
->aPgRef
[0])==1 );
9644 pCheck
->aPgRef
[iPg
/8] |= (1 << (iPg
& 0x07));
9649 ** Add 1 to the reference count for page iPage. If this is the second
9650 ** reference to the page, add an error message to pCheck->zErrMsg.
9651 ** Return 1 if there are 2 or more references to the page and 0 if
9652 ** if this is the first reference to the page.
9654 ** Also check that the page number is in bounds.
9656 static int checkRef(IntegrityCk
*pCheck
, Pgno iPage
){
9657 if( iPage
>pCheck
->nPage
|| iPage
==0 ){
9658 checkAppendMsg(pCheck
, "invalid page number %d", iPage
);
9661 if( getPageReferenced(pCheck
, iPage
) ){
9662 checkAppendMsg(pCheck
, "2nd reference to page %d", iPage
);
9665 if( pCheck
->db
->u1
.isInterrupted
) return 1;
9666 setPageReferenced(pCheck
, iPage
);
9670 #ifndef SQLITE_OMIT_AUTOVACUUM
9672 ** Check that the entry in the pointer-map for page iChild maps to
9673 ** page iParent, pointer type ptrType. If not, append an error message
9676 static void checkPtrmap(
9677 IntegrityCk
*pCheck
, /* Integrity check context */
9678 Pgno iChild
, /* Child page number */
9679 u8 eType
, /* Expected pointer map type */
9680 Pgno iParent
/* Expected pointer map parent page number */
9686 rc
= ptrmapGet(pCheck
->pBt
, iChild
, &ePtrmapType
, &iPtrmapParent
);
9687 if( rc
!=SQLITE_OK
){
9688 if( rc
==SQLITE_NOMEM
|| rc
==SQLITE_IOERR_NOMEM
) pCheck
->mallocFailed
= 1;
9689 checkAppendMsg(pCheck
, "Failed to read ptrmap key=%d", iChild
);
9693 if( ePtrmapType
!=eType
|| iPtrmapParent
!=iParent
){
9694 checkAppendMsg(pCheck
,
9695 "Bad ptr map entry key=%d expected=(%d,%d) got=(%d,%d)",
9696 iChild
, eType
, iParent
, ePtrmapType
, iPtrmapParent
);
9702 ** Check the integrity of the freelist or of an overflow page list.
9703 ** Verify that the number of pages on the list is N.
9705 static void checkList(
9706 IntegrityCk
*pCheck
, /* Integrity checking context */
9707 int isFreeList
, /* True for a freelist. False for overflow page list */
9708 int iPage
, /* Page number for first page in the list */
9709 u32 N
/* Expected number of pages in the list */
9713 int nErrAtStart
= pCheck
->nErr
;
9714 while( iPage
!=0 && pCheck
->mxErr
){
9716 unsigned char *pOvflData
;
9717 if( checkRef(pCheck
, iPage
) ) break;
9719 if( sqlite3PagerGet(pCheck
->pPager
, (Pgno
)iPage
, &pOvflPage
, 0) ){
9720 checkAppendMsg(pCheck
, "failed to get page %d", iPage
);
9723 pOvflData
= (unsigned char *)sqlite3PagerGetData(pOvflPage
);
9725 u32 n
= (u32
)get4byte(&pOvflData
[4]);
9726 #ifndef SQLITE_OMIT_AUTOVACUUM
9727 if( pCheck
->pBt
->autoVacuum
){
9728 checkPtrmap(pCheck
, iPage
, PTRMAP_FREEPAGE
, 0);
9731 if( n
>pCheck
->pBt
->usableSize
/4-2 ){
9732 checkAppendMsg(pCheck
,
9733 "freelist leaf count too big on page %d", iPage
);
9736 for(i
=0; i
<(int)n
; i
++){
9737 Pgno iFreePage
= get4byte(&pOvflData
[8+i
*4]);
9738 #ifndef SQLITE_OMIT_AUTOVACUUM
9739 if( pCheck
->pBt
->autoVacuum
){
9740 checkPtrmap(pCheck
, iFreePage
, PTRMAP_FREEPAGE
, 0);
9743 checkRef(pCheck
, iFreePage
);
9748 #ifndef SQLITE_OMIT_AUTOVACUUM
9750 /* If this database supports auto-vacuum and iPage is not the last
9751 ** page in this overflow list, check that the pointer-map entry for
9752 ** the following page matches iPage.
9754 if( pCheck
->pBt
->autoVacuum
&& N
>0 ){
9755 i
= get4byte(pOvflData
);
9756 checkPtrmap(pCheck
, i
, PTRMAP_OVERFLOW2
, iPage
);
9760 iPage
= get4byte(pOvflData
);
9761 sqlite3PagerUnref(pOvflPage
);
9763 if( N
&& nErrAtStart
==pCheck
->nErr
){
9764 checkAppendMsg(pCheck
,
9765 "%s is %d but should be %d",
9766 isFreeList
? "size" : "overflow list length",
9767 expected
-N
, expected
);
9770 #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
9773 ** An implementation of a min-heap.
9775 ** aHeap[0] is the number of elements on the heap. aHeap[1] is the
9776 ** root element. The daughter nodes of aHeap[N] are aHeap[N*2]
9777 ** and aHeap[N*2+1].
9779 ** The heap property is this: Every node is less than or equal to both
9780 ** of its daughter nodes. A consequence of the heap property is that the
9781 ** root node aHeap[1] is always the minimum value currently in the heap.
9783 ** The btreeHeapInsert() routine inserts an unsigned 32-bit number onto
9784 ** the heap, preserving the heap property. The btreeHeapPull() routine
9785 ** removes the root element from the heap (the minimum value in the heap)
9786 ** and then moves other nodes around as necessary to preserve the heap
9789 ** This heap is used for cell overlap and coverage testing. Each u32
9790 ** entry represents the span of a cell or freeblock on a btree page.
9791 ** The upper 16 bits are the index of the first byte of a range and the
9792 ** lower 16 bits are the index of the last byte of that range.
9794 static void btreeHeapInsert(u32
*aHeap
, u32 x
){
9795 u32 j
, i
= ++aHeap
[0];
9797 while( (j
= i
/2)>0 && aHeap
[j
]>aHeap
[i
] ){
9799 aHeap
[j
] = aHeap
[i
];
9804 static int btreeHeapPull(u32
*aHeap
, u32
*pOut
){
9806 if( (x
= aHeap
[0])==0 ) return 0;
9808 aHeap
[1] = aHeap
[x
];
9809 aHeap
[x
] = 0xffffffff;
9812 while( (j
= i
*2)<=aHeap
[0] ){
9813 if( aHeap
[j
]>aHeap
[j
+1] ) j
++;
9814 if( aHeap
[i
]<aHeap
[j
] ) break;
9816 aHeap
[i
] = aHeap
[j
];
9823 #ifndef SQLITE_OMIT_INTEGRITY_CHECK
9825 ** Do various sanity checks on a single page of a tree. Return
9826 ** the tree depth. Root pages return 0. Parents of root pages
9827 ** return 1, and so forth.
9829 ** These checks are done:
9831 ** 1. Make sure that cells and freeblocks do not overlap
9832 ** but combine to completely cover the page.
9833 ** 2. Make sure integer cell keys are in order.
9834 ** 3. Check the integrity of overflow pages.
9835 ** 4. Recursively call checkTreePage on all children.
9836 ** 5. Verify that the depth of all children is the same.
9838 static int checkTreePage(
9839 IntegrityCk
*pCheck
, /* Context for the sanity check */
9840 int iPage
, /* Page number of the page to check */
9841 i64
*piMinKey
, /* Write minimum integer primary key here */
9842 i64 maxKey
/* Error if integer primary key greater than this */
9844 MemPage
*pPage
= 0; /* The page being analyzed */
9845 int i
; /* Loop counter */
9846 int rc
; /* Result code from subroutine call */
9847 int depth
= -1, d2
; /* Depth of a subtree */
9848 int pgno
; /* Page number */
9849 int nFrag
; /* Number of fragmented bytes on the page */
9850 int hdr
; /* Offset to the page header */
9851 int cellStart
; /* Offset to the start of the cell pointer array */
9852 int nCell
; /* Number of cells */
9853 int doCoverageCheck
= 1; /* True if cell coverage checking should be done */
9854 int keyCanBeEqual
= 1; /* True if IPK can be equal to maxKey
9855 ** False if IPK must be strictly less than maxKey */
9856 u8
*data
; /* Page content */
9857 u8
*pCell
; /* Cell content */
9858 u8
*pCellIdx
; /* Next element of the cell pointer array */
9859 BtShared
*pBt
; /* The BtShared object that owns pPage */
9860 u32 pc
; /* Address of a cell */
9861 u32 usableSize
; /* Usable size of the page */
9862 u32 contentOffset
; /* Offset to the start of the cell content area */
9863 u32
*heap
= 0; /* Min-heap used for checking cell coverage */
9864 u32 x
, prev
= 0; /* Next and previous entry on the min-heap */
9865 const char *saved_zPfx
= pCheck
->zPfx
;
9866 int saved_v1
= pCheck
->v1
;
9867 int saved_v2
= pCheck
->v2
;
9870 /* Check that the page exists
9873 usableSize
= pBt
->usableSize
;
9874 if( iPage
==0 ) return 0;
9875 if( checkRef(pCheck
, iPage
) ) return 0;
9876 pCheck
->zPfx
= "Page %d: ";
9878 if( (rc
= btreeGetPage(pBt
, (Pgno
)iPage
, &pPage
, 0))!=0 ){
9879 checkAppendMsg(pCheck
,
9880 "unable to get the page. error code=%d", rc
);
9884 /* Clear MemPage.isInit to make sure the corruption detection code in
9885 ** btreeInitPage() is executed. */
9886 savedIsInit
= pPage
->isInit
;
9888 if( (rc
= btreeInitPage(pPage
))!=0 ){
9889 assert( rc
==SQLITE_CORRUPT
); /* The only possible error from InitPage */
9890 checkAppendMsg(pCheck
,
9891 "btreeInitPage() returns error code %d", rc
);
9894 if( (rc
= btreeComputeFreeSpace(pPage
))!=0 ){
9895 assert( rc
==SQLITE_CORRUPT
);
9896 checkAppendMsg(pCheck
, "free space corruption", rc
);
9899 data
= pPage
->aData
;
9900 hdr
= pPage
->hdrOffset
;
9902 /* Set up for cell analysis */
9903 pCheck
->zPfx
= "On tree page %d cell %d: ";
9904 contentOffset
= get2byteNotZero(&data
[hdr
+5]);
9905 assert( contentOffset
<=usableSize
); /* Enforced by btreeInitPage() */
9907 /* EVIDENCE-OF: R-37002-32774 The two-byte integer at offset 3 gives the
9908 ** number of cells on the page. */
9909 nCell
= get2byte(&data
[hdr
+3]);
9910 assert( pPage
->nCell
==nCell
);
9912 /* EVIDENCE-OF: R-23882-45353 The cell pointer array of a b-tree page
9913 ** immediately follows the b-tree page header. */
9914 cellStart
= hdr
+ 12 - 4*pPage
->leaf
;
9915 assert( pPage
->aCellIdx
==&data
[cellStart
] );
9916 pCellIdx
= &data
[cellStart
+ 2*(nCell
-1)];
9919 /* Analyze the right-child page of internal pages */
9920 pgno
= get4byte(&data
[hdr
+8]);
9921 #ifndef SQLITE_OMIT_AUTOVACUUM
9922 if( pBt
->autoVacuum
){
9923 pCheck
->zPfx
= "On page %d at right child: ";
9924 checkPtrmap(pCheck
, pgno
, PTRMAP_BTREE
, iPage
);
9927 depth
= checkTreePage(pCheck
, pgno
, &maxKey
, maxKey
);
9930 /* For leaf pages, the coverage check will occur in the same loop
9931 ** as the other cell checks, so initialize the heap. */
9932 heap
= pCheck
->heap
;
9936 /* EVIDENCE-OF: R-02776-14802 The cell pointer array consists of K 2-byte
9937 ** integer offsets to the cell contents. */
9938 for(i
=nCell
-1; i
>=0 && pCheck
->mxErr
; i
--){
9941 /* Check cell size */
9943 assert( pCellIdx
==&data
[cellStart
+ i
*2] );
9944 pc
= get2byteAligned(pCellIdx
);
9946 if( pc
<contentOffset
|| pc
>usableSize
-4 ){
9947 checkAppendMsg(pCheck
, "Offset %d out of range %d..%d",
9948 pc
, contentOffset
, usableSize
-4);
9949 doCoverageCheck
= 0;
9953 pPage
->xParseCell(pPage
, pCell
, &info
);
9954 if( pc
+info
.nSize
>usableSize
){
9955 checkAppendMsg(pCheck
, "Extends off end of page");
9956 doCoverageCheck
= 0;
9960 /* Check for integer primary key out of range */
9961 if( pPage
->intKey
){
9962 if( keyCanBeEqual
? (info
.nKey
> maxKey
) : (info
.nKey
>= maxKey
) ){
9963 checkAppendMsg(pCheck
, "Rowid %lld out of order", info
.nKey
);
9966 keyCanBeEqual
= 0; /* Only the first key on the page may ==maxKey */
9969 /* Check the content overflow list */
9970 if( info
.nPayload
>info
.nLocal
){
9971 u32 nPage
; /* Number of pages on the overflow chain */
9972 Pgno pgnoOvfl
; /* First page of the overflow chain */
9973 assert( pc
+ info
.nSize
- 4 <= usableSize
);
9974 nPage
= (info
.nPayload
- info
.nLocal
+ usableSize
- 5)/(usableSize
- 4);
9975 pgnoOvfl
= get4byte(&pCell
[info
.nSize
- 4]);
9976 #ifndef SQLITE_OMIT_AUTOVACUUM
9977 if( pBt
->autoVacuum
){
9978 checkPtrmap(pCheck
, pgnoOvfl
, PTRMAP_OVERFLOW1
, iPage
);
9981 checkList(pCheck
, 0, pgnoOvfl
, nPage
);
9985 /* Check sanity of left child page for internal pages */
9986 pgno
= get4byte(pCell
);
9987 #ifndef SQLITE_OMIT_AUTOVACUUM
9988 if( pBt
->autoVacuum
){
9989 checkPtrmap(pCheck
, pgno
, PTRMAP_BTREE
, iPage
);
9992 d2
= checkTreePage(pCheck
, pgno
, &maxKey
, maxKey
);
9995 checkAppendMsg(pCheck
, "Child page depth differs");
9999 /* Populate the coverage-checking heap for leaf pages */
10000 btreeHeapInsert(heap
, (pc
<<16)|(pc
+info
.nSize
-1));
10003 *piMinKey
= maxKey
;
10005 /* Check for complete coverage of the page
10008 if( doCoverageCheck
&& pCheck
->mxErr
>0 ){
10009 /* For leaf pages, the min-heap has already been initialized and the
10010 ** cells have already been inserted. But for internal pages, that has
10011 ** not yet been done, so do it now */
10012 if( !pPage
->leaf
){
10013 heap
= pCheck
->heap
;
10015 for(i
=nCell
-1; i
>=0; i
--){
10017 pc
= get2byteAligned(&data
[cellStart
+i
*2]);
10018 size
= pPage
->xCellSize(pPage
, &data
[pc
]);
10019 btreeHeapInsert(heap
, (pc
<<16)|(pc
+size
-1));
10022 /* Add the freeblocks to the min-heap
10024 ** EVIDENCE-OF: R-20690-50594 The second field of the b-tree page header
10025 ** is the offset of the first freeblock, or zero if there are no
10026 ** freeblocks on the page.
10028 i
= get2byte(&data
[hdr
+1]);
10031 assert( (u32
)i
<=usableSize
-4 ); /* Enforced by btreeComputeFreeSpace() */
10032 size
= get2byte(&data
[i
+2]);
10033 assert( (u32
)(i
+size
)<=usableSize
); /* due to btreeComputeFreeSpace() */
10034 btreeHeapInsert(heap
, (((u32
)i
)<<16)|(i
+size
-1));
10035 /* EVIDENCE-OF: R-58208-19414 The first 2 bytes of a freeblock are a
10036 ** big-endian integer which is the offset in the b-tree page of the next
10037 ** freeblock in the chain, or zero if the freeblock is the last on the
10039 j
= get2byte(&data
[i
]);
10040 /* EVIDENCE-OF: R-06866-39125 Freeblocks are always connected in order of
10041 ** increasing offset. */
10042 assert( j
==0 || j
>i
+size
); /* Enforced by btreeComputeFreeSpace() */
10043 assert( (u32
)j
<=usableSize
-4 ); /* Enforced by btreeComputeFreeSpace() */
10046 /* Analyze the min-heap looking for overlap between cells and/or
10047 ** freeblocks, and counting the number of untracked bytes in nFrag.
10049 ** Each min-heap entry is of the form: (start_address<<16)|end_address.
10050 ** There is an implied first entry the covers the page header, the cell
10051 ** pointer index, and the gap between the cell pointer index and the start
10052 ** of cell content.
10054 ** The loop below pulls entries from the min-heap in order and compares
10055 ** the start_address against the previous end_address. If there is an
10056 ** overlap, that means bytes are used multiple times. If there is a gap,
10057 ** that gap is added to the fragmentation count.
10060 prev
= contentOffset
- 1; /* Implied first min-heap entry */
10061 while( btreeHeapPull(heap
,&x
) ){
10062 if( (prev
&0xffff)>=(x
>>16) ){
10063 checkAppendMsg(pCheck
,
10064 "Multiple uses for byte %u of page %d", x
>>16, iPage
);
10067 nFrag
+= (x
>>16) - (prev
&0xffff) - 1;
10071 nFrag
+= usableSize
- (prev
&0xffff) - 1;
10072 /* EVIDENCE-OF: R-43263-13491 The total number of bytes in all fragments
10073 ** is stored in the fifth field of the b-tree page header.
10074 ** EVIDENCE-OF: R-07161-27322 The one-byte integer at offset 7 gives the
10075 ** number of fragmented free bytes within the cell content area.
10077 if( heap
[0]==0 && nFrag
!=data
[hdr
+7] ){
10078 checkAppendMsg(pCheck
,
10079 "Fragmentation of %d bytes reported as %d on page %d",
10080 nFrag
, data
[hdr
+7], iPage
);
10085 if( !doCoverageCheck
) pPage
->isInit
= savedIsInit
;
10086 releasePage(pPage
);
10087 pCheck
->zPfx
= saved_zPfx
;
10088 pCheck
->v1
= saved_v1
;
10089 pCheck
->v2
= saved_v2
;
10092 #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
10094 #ifndef SQLITE_OMIT_INTEGRITY_CHECK
10096 ** This routine does a complete check of the given BTree file. aRoot[] is
10097 ** an array of pages numbers were each page number is the root page of
10098 ** a table. nRoot is the number of entries in aRoot.
10100 ** A read-only or read-write transaction must be opened before calling
10103 ** Write the number of error seen in *pnErr. Except for some memory
10104 ** allocation errors, an error message held in memory obtained from
10105 ** malloc is returned if *pnErr is non-zero. If *pnErr==0 then NULL is
10106 ** returned. If a memory allocation error occurs, NULL is returned.
10108 char *sqlite3BtreeIntegrityCheck(
10109 sqlite3
*db
, /* Database connection that is running the check */
10110 Btree
*p
, /* The btree to be checked */
10111 int *aRoot
, /* An array of root pages numbers for individual trees */
10112 int nRoot
, /* Number of entries in aRoot[] */
10113 int mxErr
, /* Stop reporting errors after this many */
10114 int *pnErr
/* Write number of errors seen to this variable */
10117 IntegrityCk sCheck
;
10118 BtShared
*pBt
= p
->pBt
;
10119 u64 savedDbFlags
= pBt
->db
->flags
;
10121 VVA_ONLY( int nRef
);
10123 sqlite3BtreeEnter(p
);
10124 assert( p
->inTrans
>TRANS_NONE
&& pBt
->inTransaction
>TRANS_NONE
);
10125 VVA_ONLY( nRef
= sqlite3PagerRefcount(pBt
->pPager
) );
10129 sCheck
.pPager
= pBt
->pPager
;
10130 sCheck
.nPage
= btreePagecount(sCheck
.pBt
);
10131 sCheck
.mxErr
= mxErr
;
10133 sCheck
.mallocFailed
= 0;
10139 sqlite3StrAccumInit(&sCheck
.errMsg
, 0, zErr
, sizeof(zErr
), SQLITE_MAX_LENGTH
);
10140 sCheck
.errMsg
.printfFlags
= SQLITE_PRINTF_INTERNAL
;
10141 if( sCheck
.nPage
==0 ){
10142 goto integrity_ck_cleanup
;
10145 sCheck
.aPgRef
= sqlite3MallocZero((sCheck
.nPage
/ 8)+ 1);
10146 if( !sCheck
.aPgRef
){
10147 sCheck
.mallocFailed
= 1;
10148 goto integrity_ck_cleanup
;
10150 sCheck
.heap
= (u32
*)sqlite3PageMalloc( pBt
->pageSize
);
10151 if( sCheck
.heap
==0 ){
10152 sCheck
.mallocFailed
= 1;
10153 goto integrity_ck_cleanup
;
10156 i
= PENDING_BYTE_PAGE(pBt
);
10157 if( i
<=sCheck
.nPage
) setPageReferenced(&sCheck
, i
);
10159 /* Check the integrity of the freelist
10161 sCheck
.zPfx
= "Main freelist: ";
10162 checkList(&sCheck
, 1, get4byte(&pBt
->pPage1
->aData
[32]),
10163 get4byte(&pBt
->pPage1
->aData
[36]));
10166 /* Check all the tables.
10168 #ifndef SQLITE_OMIT_AUTOVACUUM
10169 if( pBt
->autoVacuum
){
10172 for(i
=0; (int)i
<nRoot
; i
++) if( mx
<aRoot
[i
] ) mx
= aRoot
[i
];
10173 mxInHdr
= get4byte(&pBt
->pPage1
->aData
[52]);
10175 checkAppendMsg(&sCheck
,
10176 "max rootpage (%d) disagrees with header (%d)",
10180 }else if( get4byte(&pBt
->pPage1
->aData
[64])!=0 ){
10181 checkAppendMsg(&sCheck
,
10182 "incremental_vacuum enabled with a max rootpage of zero"
10186 testcase( pBt
->db
->flags
& SQLITE_CellSizeCk
);
10187 pBt
->db
->flags
&= ~(u64
)SQLITE_CellSizeCk
;
10188 for(i
=0; (int)i
<nRoot
&& sCheck
.mxErr
; i
++){
10190 if( aRoot
[i
]==0 ) continue;
10191 #ifndef SQLITE_OMIT_AUTOVACUUM
10192 if( pBt
->autoVacuum
&& aRoot
[i
]>1 ){
10193 checkPtrmap(&sCheck
, aRoot
[i
], PTRMAP_ROOTPAGE
, 0);
10196 checkTreePage(&sCheck
, aRoot
[i
], ¬Used
, LARGEST_INT64
);
10198 pBt
->db
->flags
= savedDbFlags
;
10200 /* Make sure every page in the file is referenced
10202 for(i
=1; i
<=sCheck
.nPage
&& sCheck
.mxErr
; i
++){
10203 #ifdef SQLITE_OMIT_AUTOVACUUM
10204 if( getPageReferenced(&sCheck
, i
)==0 ){
10205 checkAppendMsg(&sCheck
, "Page %d is never used", i
);
10208 /* If the database supports auto-vacuum, make sure no tables contain
10209 ** references to pointer-map pages.
10211 if( getPageReferenced(&sCheck
, i
)==0 &&
10212 (PTRMAP_PAGENO(pBt
, i
)!=i
|| !pBt
->autoVacuum
) ){
10213 checkAppendMsg(&sCheck
, "Page %d is never used", i
);
10215 if( getPageReferenced(&sCheck
, i
)!=0 &&
10216 (PTRMAP_PAGENO(pBt
, i
)==i
&& pBt
->autoVacuum
) ){
10217 checkAppendMsg(&sCheck
, "Pointer map page %d is referenced", i
);
10222 /* Clean up and report errors.
10224 integrity_ck_cleanup
:
10225 sqlite3PageFree(sCheck
.heap
);
10226 sqlite3_free(sCheck
.aPgRef
);
10227 if( sCheck
.mallocFailed
){
10228 sqlite3_str_reset(&sCheck
.errMsg
);
10231 *pnErr
= sCheck
.nErr
;
10232 if( sCheck
.nErr
==0 ) sqlite3_str_reset(&sCheck
.errMsg
);
10233 /* Make sure this analysis did not leave any unref() pages. */
10234 assert( nRef
==sqlite3PagerRefcount(pBt
->pPager
) );
10235 sqlite3BtreeLeave(p
);
10236 return sqlite3StrAccumFinish(&sCheck
.errMsg
);
10238 #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
10241 ** Return the full pathname of the underlying database file. Return
10242 ** an empty string if the database is in-memory or a TEMP database.
10244 ** The pager filename is invariant as long as the pager is
10245 ** open so it is safe to access without the BtShared mutex.
10247 const char *sqlite3BtreeGetFilename(Btree
*p
){
10248 assert( p
->pBt
->pPager
!=0 );
10249 return sqlite3PagerFilename(p
->pBt
->pPager
, 1);
10253 ** Return the pathname of the journal file for this database. The return
10254 ** value of this routine is the same regardless of whether the journal file
10255 ** has been created or not.
10257 ** The pager journal filename is invariant as long as the pager is
10258 ** open so it is safe to access without the BtShared mutex.
10260 const char *sqlite3BtreeGetJournalname(Btree
*p
){
10261 assert( p
->pBt
->pPager
!=0 );
10262 return sqlite3PagerJournalname(p
->pBt
->pPager
);
10266 ** Return non-zero if a transaction is active.
10268 int sqlite3BtreeIsInTrans(Btree
*p
){
10269 assert( p
==0 || sqlite3_mutex_held(p
->db
->mutex
) );
10270 return (p
&& (p
->inTrans
==TRANS_WRITE
));
10273 #ifndef SQLITE_OMIT_WAL
10275 ** Run a checkpoint on the Btree passed as the first argument.
10277 ** Return SQLITE_LOCKED if this or any other connection has an open
10278 ** transaction on the shared-cache the argument Btree is connected to.
10280 ** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART.
10282 int sqlite3BtreeCheckpoint(Btree
*p
, int eMode
, int *pnLog
, int *pnCkpt
){
10283 int rc
= SQLITE_OK
;
10285 BtShared
*pBt
= p
->pBt
;
10286 sqlite3BtreeEnter(p
);
10287 if( pBt
->inTransaction
!=TRANS_NONE
){
10288 rc
= SQLITE_LOCKED
;
10290 rc
= sqlite3PagerCheckpoint(pBt
->pPager
, p
->db
, eMode
, pnLog
, pnCkpt
);
10292 sqlite3BtreeLeave(p
);
10299 ** Return non-zero if a read (or write) transaction is active.
10301 int sqlite3BtreeIsInReadTrans(Btree
*p
){
10303 assert( sqlite3_mutex_held(p
->db
->mutex
) );
10304 return p
->inTrans
!=TRANS_NONE
;
10307 int sqlite3BtreeIsInBackup(Btree
*p
){
10309 assert( sqlite3_mutex_held(p
->db
->mutex
) );
10310 return p
->nBackup
!=0;
10314 ** This function returns a pointer to a blob of memory associated with
10315 ** a single shared-btree. The memory is used by client code for its own
10316 ** purposes (for example, to store a high-level schema associated with
10317 ** the shared-btree). The btree layer manages reference counting issues.
10319 ** The first time this is called on a shared-btree, nBytes bytes of memory
10320 ** are allocated, zeroed, and returned to the caller. For each subsequent
10321 ** call the nBytes parameter is ignored and a pointer to the same blob
10322 ** of memory returned.
10324 ** If the nBytes parameter is 0 and the blob of memory has not yet been
10325 ** allocated, a null pointer is returned. If the blob has already been
10326 ** allocated, it is returned as normal.
10328 ** Just before the shared-btree is closed, the function passed as the
10329 ** xFree argument when the memory allocation was made is invoked on the
10330 ** blob of allocated memory. The xFree function should not call sqlite3_free()
10331 ** on the memory, the btree layer does that.
10333 void *sqlite3BtreeSchema(Btree
*p
, int nBytes
, void(*xFree
)(void *)){
10334 BtShared
*pBt
= p
->pBt
;
10335 sqlite3BtreeEnter(p
);
10336 if( !pBt
->pSchema
&& nBytes
){
10337 pBt
->pSchema
= sqlite3DbMallocZero(0, nBytes
);
10338 pBt
->xFreeSchema
= xFree
;
10340 sqlite3BtreeLeave(p
);
10341 return pBt
->pSchema
;
10345 ** Return SQLITE_LOCKED_SHAREDCACHE if another user of the same shared
10346 ** btree as the argument handle holds an exclusive lock on the
10347 ** sqlite_master table. Otherwise SQLITE_OK.
10349 int sqlite3BtreeSchemaLocked(Btree
*p
){
10351 assert( sqlite3_mutex_held(p
->db
->mutex
) );
10352 sqlite3BtreeEnter(p
);
10353 rc
= querySharedCacheTableLock(p
, MASTER_ROOT
, READ_LOCK
);
10354 assert( rc
==SQLITE_OK
|| rc
==SQLITE_LOCKED_SHAREDCACHE
);
10355 sqlite3BtreeLeave(p
);
10360 #ifndef SQLITE_OMIT_SHARED_CACHE
10362 ** Obtain a lock on the table whose root page is iTab. The
10363 ** lock is a write lock if isWritelock is true or a read lock
10366 int sqlite3BtreeLockTable(Btree
*p
, int iTab
, u8 isWriteLock
){
10367 int rc
= SQLITE_OK
;
10368 assert( p
->inTrans
!=TRANS_NONE
);
10370 u8 lockType
= READ_LOCK
+ isWriteLock
;
10371 assert( READ_LOCK
+1==WRITE_LOCK
);
10372 assert( isWriteLock
==0 || isWriteLock
==1 );
10374 sqlite3BtreeEnter(p
);
10375 rc
= querySharedCacheTableLock(p
, iTab
, lockType
);
10376 if( rc
==SQLITE_OK
){
10377 rc
= setSharedCacheTableLock(p
, iTab
, lockType
);
10379 sqlite3BtreeLeave(p
);
10385 #ifndef SQLITE_OMIT_INCRBLOB
10387 ** Argument pCsr must be a cursor opened for writing on an
10388 ** INTKEY table currently pointing at a valid table entry.
10389 ** This function modifies the data stored as part of that entry.
10391 ** Only the data content may only be modified, it is not possible to
10392 ** change the length of the data stored. If this function is called with
10393 ** parameters that attempt to write past the end of the existing data,
10394 ** no modifications are made and SQLITE_CORRUPT is returned.
10396 int sqlite3BtreePutData(BtCursor
*pCsr
, u32 offset
, u32 amt
, void *z
){
10398 assert( cursorOwnsBtShared(pCsr
) );
10399 assert( sqlite3_mutex_held(pCsr
->pBtree
->db
->mutex
) );
10400 assert( pCsr
->curFlags
& BTCF_Incrblob
);
10402 rc
= restoreCursorPosition(pCsr
);
10403 if( rc
!=SQLITE_OK
){
10406 assert( pCsr
->eState
!=CURSOR_REQUIRESEEK
);
10407 if( pCsr
->eState
!=CURSOR_VALID
){
10408 return SQLITE_ABORT
;
10411 /* Save the positions of all other cursors open on this table. This is
10412 ** required in case any of them are holding references to an xFetch
10413 ** version of the b-tree page modified by the accessPayload call below.
10415 ** Note that pCsr must be open on a INTKEY table and saveCursorPosition()
10416 ** and hence saveAllCursors() cannot fail on a BTREE_INTKEY table, hence
10417 ** saveAllCursors can only return SQLITE_OK.
10419 VVA_ONLY(rc
=) saveAllCursors(pCsr
->pBt
, pCsr
->pgnoRoot
, pCsr
);
10420 assert( rc
==SQLITE_OK
);
10422 /* Check some assumptions:
10423 ** (a) the cursor is open for writing,
10424 ** (b) there is a read/write transaction open,
10425 ** (c) the connection holds a write-lock on the table (if required),
10426 ** (d) there are no conflicting read-locks, and
10427 ** (e) the cursor points at a valid row of an intKey table.
10429 if( (pCsr
->curFlags
& BTCF_WriteFlag
)==0 ){
10430 return SQLITE_READONLY
;
10432 assert( (pCsr
->pBt
->btsFlags
& BTS_READ_ONLY
)==0
10433 && pCsr
->pBt
->inTransaction
==TRANS_WRITE
);
10434 assert( hasSharedCacheTableLock(pCsr
->pBtree
, pCsr
->pgnoRoot
, 0, 2) );
10435 assert( !hasReadConflicts(pCsr
->pBtree
, pCsr
->pgnoRoot
) );
10436 assert( pCsr
->pPage
->intKey
);
10438 return accessPayload(pCsr
, offset
, amt
, (unsigned char *)z
, 1);
10442 ** Mark this cursor as an incremental blob cursor.
10444 void sqlite3BtreeIncrblobCursor(BtCursor
*pCur
){
10445 pCur
->curFlags
|= BTCF_Incrblob
;
10446 pCur
->pBtree
->hasIncrblobCur
= 1;
10451 ** Set both the "read version" (single byte at byte offset 18) and
10452 ** "write version" (single byte at byte offset 19) fields in the database
10453 ** header to iVersion.
10455 int sqlite3BtreeSetVersion(Btree
*pBtree
, int iVersion
){
10456 BtShared
*pBt
= pBtree
->pBt
;
10457 int rc
; /* Return code */
10459 assert( iVersion
==1 || iVersion
==2 );
10461 /* If setting the version fields to 1, do not automatically open the
10462 ** WAL connection, even if the version fields are currently set to 2.
10464 pBt
->btsFlags
&= ~BTS_NO_WAL
;
10465 if( iVersion
==1 ) pBt
->btsFlags
|= BTS_NO_WAL
;
10467 rc
= sqlite3BtreeBeginTrans(pBtree
, 0, 0);
10468 if( rc
==SQLITE_OK
){
10469 u8
*aData
= pBt
->pPage1
->aData
;
10470 if( aData
[18]!=(u8
)iVersion
|| aData
[19]!=(u8
)iVersion
){
10471 rc
= sqlite3BtreeBeginTrans(pBtree
, 2, 0);
10472 if( rc
==SQLITE_OK
){
10473 rc
= sqlite3PagerWrite(pBt
->pPage1
->pDbPage
);
10474 if( rc
==SQLITE_OK
){
10475 aData
[18] = (u8
)iVersion
;
10476 aData
[19] = (u8
)iVersion
;
10482 pBt
->btsFlags
&= ~BTS_NO_WAL
;
10487 ** Return true if the cursor has a hint specified. This routine is
10488 ** only used from within assert() statements
10490 int sqlite3BtreeCursorHasHint(BtCursor
*pCsr
, unsigned int mask
){
10491 return (pCsr
->hints
& mask
)!=0;
10495 ** Return true if the given Btree is read-only.
10497 int sqlite3BtreeIsReadonly(Btree
*p
){
10498 return (p
->pBt
->btsFlags
& BTS_READ_ONLY
)!=0;
10502 ** Return the size of the header added to each page by this module.
10504 int sqlite3HeaderSizeBtree(void){ return ROUND8(sizeof(MemPage
)); }
10506 #if !defined(SQLITE_OMIT_SHARED_CACHE)
10508 ** Return true if the Btree passed as the only argument is sharable.
10510 int sqlite3BtreeSharable(Btree
*p
){
10511 return p
->sharable
;
10515 ** Return the number of connections to the BtShared object accessed by
10516 ** the Btree handle passed as the only argument. For private caches
10517 ** this is always 1. For shared caches it may be 1 or greater.
10519 int sqlite3BtreeConnectionCount(Btree
*p
){
10520 testcase( p
->sharable
);
10521 return p
->pBt
->nRef
;