Annotation of embedaddon/sqlite3/src/btree.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2004 April 6
! 3: **
! 4: ** The author disclaims copyright to this source code. In place of
! 5: ** a legal notice, here is a blessing:
! 6: **
! 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.
! 10: **
! 11: *************************************************************************
! 12: ** This file implements a 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.
! 15: */
! 16: #include "btreeInt.h"
! 17:
! 18: /*
! 19: ** The header string that appears at the beginning of every
! 20: ** SQLite database.
! 21: */
! 22: static const char zMagicHeader[] = SQLITE_FILE_HEADER;
! 23:
! 24: /*
! 25: ** Set this global variable to 1 to enable tracing using the TRACE
! 26: ** macro.
! 27: */
! 28: #if 0
! 29: int sqlite3BtreeTrace=1; /* True to enable tracing */
! 30: # define TRACE(X) if(sqlite3BtreeTrace){printf X;fflush(stdout);}
! 31: #else
! 32: # define TRACE(X)
! 33: #endif
! 34:
! 35: /*
! 36: ** Extract a 2-byte big-endian integer from an array of unsigned bytes.
! 37: ** But if the value is zero, make it 65536.
! 38: **
! 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.
! 43: */
! 44: #define get2byteNotZero(X) (((((int)get2byte(X))-1)&0xffff)+1)
! 45:
! 46: #ifndef SQLITE_OMIT_SHARED_CACHE
! 47: /*
! 48: ** A list of BtShared objects that are eligible for participation
! 49: ** in shared cache. This variable has file scope during normal builds,
! 50: ** but the test harness needs to access it so we make it global for
! 51: ** test builds.
! 52: **
! 53: ** Access to this variable is protected by SQLITE_MUTEX_STATIC_MASTER.
! 54: */
! 55: #ifdef SQLITE_TEST
! 56: BtShared *SQLITE_WSD sqlite3SharedCacheList = 0;
! 57: #else
! 58: static BtShared *SQLITE_WSD sqlite3SharedCacheList = 0;
! 59: #endif
! 60: #endif /* SQLITE_OMIT_SHARED_CACHE */
! 61:
! 62: #ifndef SQLITE_OMIT_SHARED_CACHE
! 63: /*
! 64: ** Enable or disable the shared pager and schema features.
! 65: **
! 66: ** This routine has no effect on existing database connections.
! 67: ** The shared cache setting effects only future calls to
! 68: ** sqlite3_open(), sqlite3_open16(), or sqlite3_open_v2().
! 69: */
! 70: int sqlite3_enable_shared_cache(int enable){
! 71: sqlite3GlobalConfig.sharedCacheEnabled = enable;
! 72: return SQLITE_OK;
! 73: }
! 74: #endif
! 75:
! 76:
! 77:
! 78: #ifdef SQLITE_OMIT_SHARED_CACHE
! 79: /*
! 80: ** The functions querySharedCacheTableLock(), setSharedCacheTableLock(),
! 81: ** and clearAllSharedCacheTableLocks()
! 82: ** manipulate entries in the BtShared.pLock linked list used to store
! 83: ** shared-cache table level locks. If the library is compiled with the
! 84: ** shared-cache feature disabled, then there is only ever one user
! 85: ** of each BtShared structure and so this locking is not necessary.
! 86: ** So define the lock related functions as no-ops.
! 87: */
! 88: #define querySharedCacheTableLock(a,b,c) SQLITE_OK
! 89: #define setSharedCacheTableLock(a,b,c) SQLITE_OK
! 90: #define clearAllSharedCacheTableLocks(a)
! 91: #define downgradeAllSharedCacheTableLocks(a)
! 92: #define hasSharedCacheTableLock(a,b,c,d) 1
! 93: #define hasReadConflicts(a, b) 0
! 94: #endif
! 95:
! 96: #ifndef SQLITE_OMIT_SHARED_CACHE
! 97:
! 98: #ifdef SQLITE_DEBUG
! 99: /*
! 100: **** This function is only used as part of an assert() statement. ***
! 101: **
! 102: ** Check to see if pBtree holds the required locks to read or write to the
! 103: ** table with root page iRoot. Return 1 if it does and 0 if not.
! 104: **
! 105: ** For example, when writing to a table with root-page iRoot via
! 106: ** Btree connection pBtree:
! 107: **
! 108: ** assert( hasSharedCacheTableLock(pBtree, iRoot, 0, WRITE_LOCK) );
! 109: **
! 110: ** When writing to an index that resides in a sharable database, the
! 111: ** caller should have first obtained a lock specifying the root page of
! 112: ** the corresponding table. This makes things a bit more complicated,
! 113: ** as this module treats each table as a separate structure. To determine
! 114: ** the table corresponding to the index being written, this
! 115: ** function has to search through the database schema.
! 116: **
! 117: ** Instead of a lock on the table/index rooted at page iRoot, the caller may
! 118: ** hold a write-lock on the schema table (root page 1). This is also
! 119: ** acceptable.
! 120: */
! 121: static int hasSharedCacheTableLock(
! 122: Btree *pBtree, /* Handle that must hold lock */
! 123: Pgno iRoot, /* Root page of b-tree */
! 124: int isIndex, /* True if iRoot is the root of an index b-tree */
! 125: int eLockType /* Required lock type (READ_LOCK or WRITE_LOCK) */
! 126: ){
! 127: Schema *pSchema = (Schema *)pBtree->pBt->pSchema;
! 128: Pgno iTab = 0;
! 129: BtLock *pLock;
! 130:
! 131: /* If this database is not shareable, or if the client is reading
! 132: ** and has the read-uncommitted flag set, then no lock is required.
! 133: ** Return true immediately.
! 134: */
! 135: if( (pBtree->sharable==0)
! 136: || (eLockType==READ_LOCK && (pBtree->db->flags & SQLITE_ReadUncommitted))
! 137: ){
! 138: return 1;
! 139: }
! 140:
! 141: /* If the client is reading or writing an index and the schema is
! 142: ** not loaded, then it is too difficult to actually check to see if
! 143: ** the correct locks are held. So do not bother - just return true.
! 144: ** This case does not come up very often anyhow.
! 145: */
! 146: if( isIndex && (!pSchema || (pSchema->flags&DB_SchemaLoaded)==0) ){
! 147: return 1;
! 148: }
! 149:
! 150: /* Figure out the root-page that the lock should be held on. For table
! 151: ** b-trees, this is just the root page of the b-tree being read or
! 152: ** written. For index b-trees, it is the root page of the associated
! 153: ** table. */
! 154: if( isIndex ){
! 155: HashElem *p;
! 156: for(p=sqliteHashFirst(&pSchema->idxHash); p; p=sqliteHashNext(p)){
! 157: Index *pIdx = (Index *)sqliteHashData(p);
! 158: if( pIdx->tnum==(int)iRoot ){
! 159: iTab = pIdx->pTable->tnum;
! 160: }
! 161: }
! 162: }else{
! 163: iTab = iRoot;
! 164: }
! 165:
! 166: /* Search for the required lock. Either a write-lock on root-page iTab, a
! 167: ** write-lock on the schema table, or (if the client is reading) a
! 168: ** read-lock on iTab will suffice. Return 1 if any of these are found. */
! 169: for(pLock=pBtree->pBt->pLock; pLock; pLock=pLock->pNext){
! 170: if( pLock->pBtree==pBtree
! 171: && (pLock->iTable==iTab || (pLock->eLock==WRITE_LOCK && pLock->iTable==1))
! 172: && pLock->eLock>=eLockType
! 173: ){
! 174: return 1;
! 175: }
! 176: }
! 177:
! 178: /* Failed to find the required lock. */
! 179: return 0;
! 180: }
! 181: #endif /* SQLITE_DEBUG */
! 182:
! 183: #ifdef SQLITE_DEBUG
! 184: /*
! 185: **** This function may be used as part of assert() statements only. ****
! 186: **
! 187: ** Return true if it would be illegal for pBtree to write into the
! 188: ** table or index rooted at iRoot because other shared connections are
! 189: ** simultaneously reading that same table or index.
! 190: **
! 191: ** It is illegal for pBtree to write if some other Btree object that
! 192: ** shares the same BtShared object is currently reading or writing
! 193: ** the iRoot table. Except, if the other Btree object has the
! 194: ** read-uncommitted flag set, then it is OK for the other object to
! 195: ** have a read cursor.
! 196: **
! 197: ** For example, before writing to any part of the table or index
! 198: ** rooted at page iRoot, one should call:
! 199: **
! 200: ** assert( !hasReadConflicts(pBtree, iRoot) );
! 201: */
! 202: static int hasReadConflicts(Btree *pBtree, Pgno iRoot){
! 203: BtCursor *p;
! 204: for(p=pBtree->pBt->pCursor; p; p=p->pNext){
! 205: if( p->pgnoRoot==iRoot
! 206: && p->pBtree!=pBtree
! 207: && 0==(p->pBtree->db->flags & SQLITE_ReadUncommitted)
! 208: ){
! 209: return 1;
! 210: }
! 211: }
! 212: return 0;
! 213: }
! 214: #endif /* #ifdef SQLITE_DEBUG */
! 215:
! 216: /*
! 217: ** Query to see if Btree handle p may obtain a lock of type eLock
! 218: ** (READ_LOCK or WRITE_LOCK) on the table with root-page iTab. Return
! 219: ** SQLITE_OK if the lock may be obtained (by calling
! 220: ** setSharedCacheTableLock()), or SQLITE_LOCKED if not.
! 221: */
! 222: static int querySharedCacheTableLock(Btree *p, Pgno iTab, u8 eLock){
! 223: BtShared *pBt = p->pBt;
! 224: BtLock *pIter;
! 225:
! 226: assert( sqlite3BtreeHoldsMutex(p) );
! 227: assert( eLock==READ_LOCK || eLock==WRITE_LOCK );
! 228: assert( p->db!=0 );
! 229: assert( !(p->db->flags&SQLITE_ReadUncommitted)||eLock==WRITE_LOCK||iTab==1 );
! 230:
! 231: /* If requesting a write-lock, then the Btree must have an open write
! 232: ** transaction on this file. And, obviously, for this to be so there
! 233: ** must be an open write transaction on the file itself.
! 234: */
! 235: assert( eLock==READ_LOCK || (p==pBt->pWriter && p->inTrans==TRANS_WRITE) );
! 236: assert( eLock==READ_LOCK || pBt->inTransaction==TRANS_WRITE );
! 237:
! 238: /* This routine is a no-op if the shared-cache is not enabled */
! 239: if( !p->sharable ){
! 240: return SQLITE_OK;
! 241: }
! 242:
! 243: /* If some other connection is holding an exclusive lock, the
! 244: ** requested lock may not be obtained.
! 245: */
! 246: if( pBt->pWriter!=p && (pBt->btsFlags & BTS_EXCLUSIVE)!=0 ){
! 247: sqlite3ConnectionBlocked(p->db, pBt->pWriter->db);
! 248: return SQLITE_LOCKED_SHAREDCACHE;
! 249: }
! 250:
! 251: for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
! 252: /* The condition (pIter->eLock!=eLock) in the following if(...)
! 253: ** statement is a simplification of:
! 254: **
! 255: ** (eLock==WRITE_LOCK || pIter->eLock==WRITE_LOCK)
! 256: **
! 257: ** since we know that if eLock==WRITE_LOCK, then no other connection
! 258: ** may hold a WRITE_LOCK on any table in this file (since there can
! 259: ** only be a single writer).
! 260: */
! 261: assert( pIter->eLock==READ_LOCK || pIter->eLock==WRITE_LOCK );
! 262: assert( eLock==READ_LOCK || pIter->pBtree==p || pIter->eLock==READ_LOCK);
! 263: if( pIter->pBtree!=p && pIter->iTable==iTab && pIter->eLock!=eLock ){
! 264: sqlite3ConnectionBlocked(p->db, pIter->pBtree->db);
! 265: if( eLock==WRITE_LOCK ){
! 266: assert( p==pBt->pWriter );
! 267: pBt->btsFlags |= BTS_PENDING;
! 268: }
! 269: return SQLITE_LOCKED_SHAREDCACHE;
! 270: }
! 271: }
! 272: return SQLITE_OK;
! 273: }
! 274: #endif /* !SQLITE_OMIT_SHARED_CACHE */
! 275:
! 276: #ifndef SQLITE_OMIT_SHARED_CACHE
! 277: /*
! 278: ** Add a lock on the table with root-page iTable to the shared-btree used
! 279: ** by Btree handle p. Parameter eLock must be either READ_LOCK or
! 280: ** WRITE_LOCK.
! 281: **
! 282: ** This function assumes the following:
! 283: **
! 284: ** (a) The specified Btree object p is connected to a sharable
! 285: ** database (one with the BtShared.sharable flag set), and
! 286: **
! 287: ** (b) No other Btree objects hold a lock that conflicts
! 288: ** with the requested lock (i.e. querySharedCacheTableLock() has
! 289: ** already been called and returned SQLITE_OK).
! 290: **
! 291: ** SQLITE_OK is returned if the lock is added successfully. SQLITE_NOMEM
! 292: ** is returned if a malloc attempt fails.
! 293: */
! 294: static int setSharedCacheTableLock(Btree *p, Pgno iTable, u8 eLock){
! 295: BtShared *pBt = p->pBt;
! 296: BtLock *pLock = 0;
! 297: BtLock *pIter;
! 298:
! 299: assert( sqlite3BtreeHoldsMutex(p) );
! 300: assert( eLock==READ_LOCK || eLock==WRITE_LOCK );
! 301: assert( p->db!=0 );
! 302:
! 303: /* A connection with the read-uncommitted flag set will never try to
! 304: ** obtain a read-lock using this function. The only read-lock obtained
! 305: ** by a connection in read-uncommitted mode is on the sqlite_master
! 306: ** table, and that lock is obtained in BtreeBeginTrans(). */
! 307: assert( 0==(p->db->flags&SQLITE_ReadUncommitted) || eLock==WRITE_LOCK );
! 308:
! 309: /* This function should only be called on a sharable b-tree after it
! 310: ** has been determined that no other b-tree holds a conflicting lock. */
! 311: assert( p->sharable );
! 312: assert( SQLITE_OK==querySharedCacheTableLock(p, iTable, eLock) );
! 313:
! 314: /* First search the list for an existing lock on this table. */
! 315: for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
! 316: if( pIter->iTable==iTable && pIter->pBtree==p ){
! 317: pLock = pIter;
! 318: break;
! 319: }
! 320: }
! 321:
! 322: /* If the above search did not find a BtLock struct associating Btree p
! 323: ** with table iTable, allocate one and link it into the list.
! 324: */
! 325: if( !pLock ){
! 326: pLock = (BtLock *)sqlite3MallocZero(sizeof(BtLock));
! 327: if( !pLock ){
! 328: return SQLITE_NOMEM;
! 329: }
! 330: pLock->iTable = iTable;
! 331: pLock->pBtree = p;
! 332: pLock->pNext = pBt->pLock;
! 333: pBt->pLock = pLock;
! 334: }
! 335:
! 336: /* Set the BtLock.eLock variable to the maximum of the current lock
! 337: ** and the requested lock. This means if a write-lock was already held
! 338: ** and a read-lock requested, we don't incorrectly downgrade the lock.
! 339: */
! 340: assert( WRITE_LOCK>READ_LOCK );
! 341: if( eLock>pLock->eLock ){
! 342: pLock->eLock = eLock;
! 343: }
! 344:
! 345: return SQLITE_OK;
! 346: }
! 347: #endif /* !SQLITE_OMIT_SHARED_CACHE */
! 348:
! 349: #ifndef SQLITE_OMIT_SHARED_CACHE
! 350: /*
! 351: ** Release all the table locks (locks obtained via calls to
! 352: ** the setSharedCacheTableLock() procedure) held by Btree object p.
! 353: **
! 354: ** This function assumes that Btree p has an open read or write
! 355: ** transaction. If it does not, then the BTS_PENDING flag
! 356: ** may be incorrectly cleared.
! 357: */
! 358: static void clearAllSharedCacheTableLocks(Btree *p){
! 359: BtShared *pBt = p->pBt;
! 360: BtLock **ppIter = &pBt->pLock;
! 361:
! 362: assert( sqlite3BtreeHoldsMutex(p) );
! 363: assert( p->sharable || 0==*ppIter );
! 364: assert( p->inTrans>0 );
! 365:
! 366: while( *ppIter ){
! 367: BtLock *pLock = *ppIter;
! 368: assert( (pBt->btsFlags & BTS_EXCLUSIVE)==0 || pBt->pWriter==pLock->pBtree );
! 369: assert( pLock->pBtree->inTrans>=pLock->eLock );
! 370: if( pLock->pBtree==p ){
! 371: *ppIter = pLock->pNext;
! 372: assert( pLock->iTable!=1 || pLock==&p->lock );
! 373: if( pLock->iTable!=1 ){
! 374: sqlite3_free(pLock);
! 375: }
! 376: }else{
! 377: ppIter = &pLock->pNext;
! 378: }
! 379: }
! 380:
! 381: assert( (pBt->btsFlags & BTS_PENDING)==0 || pBt->pWriter );
! 382: if( pBt->pWriter==p ){
! 383: pBt->pWriter = 0;
! 384: pBt->btsFlags &= ~(BTS_EXCLUSIVE|BTS_PENDING);
! 385: }else if( pBt->nTransaction==2 ){
! 386: /* This function is called when Btree p is concluding its
! 387: ** transaction. If there currently exists a writer, and p is not
! 388: ** that writer, then the number of locks held by connections other
! 389: ** than the writer must be about to drop to zero. In this case
! 390: ** set the BTS_PENDING flag to 0.
! 391: **
! 392: ** If there is not currently a writer, then BTS_PENDING must
! 393: ** be zero already. So this next line is harmless in that case.
! 394: */
! 395: pBt->btsFlags &= ~BTS_PENDING;
! 396: }
! 397: }
! 398:
! 399: /*
! 400: ** This function changes all write-locks held by Btree p into read-locks.
! 401: */
! 402: static void downgradeAllSharedCacheTableLocks(Btree *p){
! 403: BtShared *pBt = p->pBt;
! 404: if( pBt->pWriter==p ){
! 405: BtLock *pLock;
! 406: pBt->pWriter = 0;
! 407: pBt->btsFlags &= ~(BTS_EXCLUSIVE|BTS_PENDING);
! 408: for(pLock=pBt->pLock; pLock; pLock=pLock->pNext){
! 409: assert( pLock->eLock==READ_LOCK || pLock->pBtree==p );
! 410: pLock->eLock = READ_LOCK;
! 411: }
! 412: }
! 413: }
! 414:
! 415: #endif /* SQLITE_OMIT_SHARED_CACHE */
! 416:
! 417: static void releasePage(MemPage *pPage); /* Forward reference */
! 418:
! 419: /*
! 420: ***** This routine is used inside of assert() only ****
! 421: **
! 422: ** Verify that the cursor holds the mutex on its BtShared
! 423: */
! 424: #ifdef SQLITE_DEBUG
! 425: static int cursorHoldsMutex(BtCursor *p){
! 426: return sqlite3_mutex_held(p->pBt->mutex);
! 427: }
! 428: #endif
! 429:
! 430:
! 431: #ifndef SQLITE_OMIT_INCRBLOB
! 432: /*
! 433: ** Invalidate the overflow page-list cache for cursor pCur, if any.
! 434: */
! 435: static void invalidateOverflowCache(BtCursor *pCur){
! 436: assert( cursorHoldsMutex(pCur) );
! 437: sqlite3_free(pCur->aOverflow);
! 438: pCur->aOverflow = 0;
! 439: }
! 440:
! 441: /*
! 442: ** Invalidate the overflow page-list cache for all cursors opened
! 443: ** on the shared btree structure pBt.
! 444: */
! 445: static void invalidateAllOverflowCache(BtShared *pBt){
! 446: BtCursor *p;
! 447: assert( sqlite3_mutex_held(pBt->mutex) );
! 448: for(p=pBt->pCursor; p; p=p->pNext){
! 449: invalidateOverflowCache(p);
! 450: }
! 451: }
! 452:
! 453: /*
! 454: ** This function is called before modifying the contents of a table
! 455: ** to invalidate any incrblob cursors that are open on the
! 456: ** row or one of the rows being modified.
! 457: **
! 458: ** If argument isClearTable is true, then the entire contents of the
! 459: ** table is about to be deleted. In this case invalidate all incrblob
! 460: ** cursors open on any row within the table with root-page pgnoRoot.
! 461: **
! 462: ** Otherwise, if argument isClearTable is false, then the row with
! 463: ** rowid iRow is being replaced or deleted. In this case invalidate
! 464: ** only those incrblob cursors open on that specific row.
! 465: */
! 466: static void invalidateIncrblobCursors(
! 467: Btree *pBtree, /* The database file to check */
! 468: i64 iRow, /* The rowid that might be changing */
! 469: int isClearTable /* True if all rows are being deleted */
! 470: ){
! 471: BtCursor *p;
! 472: BtShared *pBt = pBtree->pBt;
! 473: assert( sqlite3BtreeHoldsMutex(pBtree) );
! 474: for(p=pBt->pCursor; p; p=p->pNext){
! 475: if( p->isIncrblobHandle && (isClearTable || p->info.nKey==iRow) ){
! 476: p->eState = CURSOR_INVALID;
! 477: }
! 478: }
! 479: }
! 480:
! 481: #else
! 482: /* Stub functions when INCRBLOB is omitted */
! 483: #define invalidateOverflowCache(x)
! 484: #define invalidateAllOverflowCache(x)
! 485: #define invalidateIncrblobCursors(x,y,z)
! 486: #endif /* SQLITE_OMIT_INCRBLOB */
! 487:
! 488: /*
! 489: ** Set bit pgno of the BtShared.pHasContent bitvec. This is called
! 490: ** when a page that previously contained data becomes a free-list leaf
! 491: ** page.
! 492: **
! 493: ** The BtShared.pHasContent bitvec exists to work around an obscure
! 494: ** bug caused by the interaction of two useful IO optimizations surrounding
! 495: ** free-list leaf pages:
! 496: **
! 497: ** 1) When all data is deleted from a page and the page becomes
! 498: ** a free-list leaf page, the page is not written to the database
! 499: ** (as free-list leaf pages contain no meaningful data). Sometimes
! 500: ** such a page is not even journalled (as it will not be modified,
! 501: ** why bother journalling it?).
! 502: **
! 503: ** 2) When a free-list leaf page is reused, its content is not read
! 504: ** from the database or written to the journal file (why should it
! 505: ** be, if it is not at all meaningful?).
! 506: **
! 507: ** By themselves, these optimizations work fine and provide a handy
! 508: ** performance boost to bulk delete or insert operations. However, if
! 509: ** a page is moved to the free-list and then reused within the same
! 510: ** transaction, a problem comes up. If the page is not journalled when
! 511: ** it is moved to the free-list and it is also not journalled when it
! 512: ** is extracted from the free-list and reused, then the original data
! 513: ** may be lost. In the event of a rollback, it may not be possible
! 514: ** to restore the database to its original configuration.
! 515: **
! 516: ** The solution is the BtShared.pHasContent bitvec. Whenever a page is
! 517: ** moved to become a free-list leaf page, the corresponding bit is
! 518: ** set in the bitvec. Whenever a leaf page is extracted from the free-list,
! 519: ** optimization 2 above is omitted if the corresponding bit is already
! 520: ** set in BtShared.pHasContent. The contents of the bitvec are cleared
! 521: ** at the end of every transaction.
! 522: */
! 523: static int btreeSetHasContent(BtShared *pBt, Pgno pgno){
! 524: int rc = SQLITE_OK;
! 525: if( !pBt->pHasContent ){
! 526: assert( pgno<=pBt->nPage );
! 527: pBt->pHasContent = sqlite3BitvecCreate(pBt->nPage);
! 528: if( !pBt->pHasContent ){
! 529: rc = SQLITE_NOMEM;
! 530: }
! 531: }
! 532: if( rc==SQLITE_OK && pgno<=sqlite3BitvecSize(pBt->pHasContent) ){
! 533: rc = sqlite3BitvecSet(pBt->pHasContent, pgno);
! 534: }
! 535: return rc;
! 536: }
! 537:
! 538: /*
! 539: ** Query the BtShared.pHasContent vector.
! 540: **
! 541: ** This function is called when a free-list leaf page is removed from the
! 542: ** free-list for reuse. It returns false if it is safe to retrieve the
! 543: ** page from the pager layer with the 'no-content' flag set. True otherwise.
! 544: */
! 545: static int btreeGetHasContent(BtShared *pBt, Pgno pgno){
! 546: Bitvec *p = pBt->pHasContent;
! 547: return (p && (pgno>sqlite3BitvecSize(p) || sqlite3BitvecTest(p, pgno)));
! 548: }
! 549:
! 550: /*
! 551: ** Clear (destroy) the BtShared.pHasContent bitvec. This should be
! 552: ** invoked at the conclusion of each write-transaction.
! 553: */
! 554: static void btreeClearHasContent(BtShared *pBt){
! 555: sqlite3BitvecDestroy(pBt->pHasContent);
! 556: pBt->pHasContent = 0;
! 557: }
! 558:
! 559: /*
! 560: ** Save the current cursor position in the variables BtCursor.nKey
! 561: ** and BtCursor.pKey. The cursor's state is set to CURSOR_REQUIRESEEK.
! 562: **
! 563: ** The caller must ensure that the cursor is valid (has eState==CURSOR_VALID)
! 564: ** prior to calling this routine.
! 565: */
! 566: static int saveCursorPosition(BtCursor *pCur){
! 567: int rc;
! 568:
! 569: assert( CURSOR_VALID==pCur->eState );
! 570: assert( 0==pCur->pKey );
! 571: assert( cursorHoldsMutex(pCur) );
! 572:
! 573: rc = sqlite3BtreeKeySize(pCur, &pCur->nKey);
! 574: assert( rc==SQLITE_OK ); /* KeySize() cannot fail */
! 575:
! 576: /* If this is an intKey table, then the above call to BtreeKeySize()
! 577: ** stores the integer key in pCur->nKey. In this case this value is
! 578: ** all that is required. Otherwise, if pCur is not open on an intKey
! 579: ** table, then malloc space for and store the pCur->nKey bytes of key
! 580: ** data.
! 581: */
! 582: if( 0==pCur->apPage[0]->intKey ){
! 583: void *pKey = sqlite3Malloc( (int)pCur->nKey );
! 584: if( pKey ){
! 585: rc = sqlite3BtreeKey(pCur, 0, (int)pCur->nKey, pKey);
! 586: if( rc==SQLITE_OK ){
! 587: pCur->pKey = pKey;
! 588: }else{
! 589: sqlite3_free(pKey);
! 590: }
! 591: }else{
! 592: rc = SQLITE_NOMEM;
! 593: }
! 594: }
! 595: assert( !pCur->apPage[0]->intKey || !pCur->pKey );
! 596:
! 597: if( rc==SQLITE_OK ){
! 598: int i;
! 599: for(i=0; i<=pCur->iPage; i++){
! 600: releasePage(pCur->apPage[i]);
! 601: pCur->apPage[i] = 0;
! 602: }
! 603: pCur->iPage = -1;
! 604: pCur->eState = CURSOR_REQUIRESEEK;
! 605: }
! 606:
! 607: invalidateOverflowCache(pCur);
! 608: return rc;
! 609: }
! 610:
! 611: /*
! 612: ** Save the positions of all cursors (except pExcept) that are open on
! 613: ** the table with root-page iRoot. Usually, this is called just before cursor
! 614: ** pExcept is used to modify the table (BtreeDelete() or BtreeInsert()).
! 615: */
! 616: static int saveAllCursors(BtShared *pBt, Pgno iRoot, BtCursor *pExcept){
! 617: BtCursor *p;
! 618: assert( sqlite3_mutex_held(pBt->mutex) );
! 619: assert( pExcept==0 || pExcept->pBt==pBt );
! 620: for(p=pBt->pCursor; p; p=p->pNext){
! 621: if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) &&
! 622: p->eState==CURSOR_VALID ){
! 623: int rc = saveCursorPosition(p);
! 624: if( SQLITE_OK!=rc ){
! 625: return rc;
! 626: }
! 627: }
! 628: }
! 629: return SQLITE_OK;
! 630: }
! 631:
! 632: /*
! 633: ** Clear the current cursor position.
! 634: */
! 635: void sqlite3BtreeClearCursor(BtCursor *pCur){
! 636: assert( cursorHoldsMutex(pCur) );
! 637: sqlite3_free(pCur->pKey);
! 638: pCur->pKey = 0;
! 639: pCur->eState = CURSOR_INVALID;
! 640: }
! 641:
! 642: /*
! 643: ** In this version of BtreeMoveto, pKey is a packed index record
! 644: ** such as is generated by the OP_MakeRecord opcode. Unpack the
! 645: ** record and then call BtreeMovetoUnpacked() to do the work.
! 646: */
! 647: static int btreeMoveto(
! 648: BtCursor *pCur, /* Cursor open on the btree to be searched */
! 649: const void *pKey, /* Packed key if the btree is an index */
! 650: i64 nKey, /* Integer key for tables. Size of pKey for indices */
! 651: int bias, /* Bias search to the high end */
! 652: int *pRes /* Write search results here */
! 653: ){
! 654: int rc; /* Status code */
! 655: UnpackedRecord *pIdxKey; /* Unpacked index key */
! 656: char aSpace[150]; /* Temp space for pIdxKey - to avoid a malloc */
! 657: char *pFree = 0;
! 658:
! 659: if( pKey ){
! 660: assert( nKey==(i64)(int)nKey );
! 661: pIdxKey = sqlite3VdbeAllocUnpackedRecord(
! 662: pCur->pKeyInfo, aSpace, sizeof(aSpace), &pFree
! 663: );
! 664: if( pIdxKey==0 ) return SQLITE_NOMEM;
! 665: sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey, pIdxKey);
! 666: }else{
! 667: pIdxKey = 0;
! 668: }
! 669: rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
! 670: if( pFree ){
! 671: sqlite3DbFree(pCur->pKeyInfo->db, pFree);
! 672: }
! 673: return rc;
! 674: }
! 675:
! 676: /*
! 677: ** Restore the cursor to the position it was in (or as close to as possible)
! 678: ** when saveCursorPosition() was called. Note that this call deletes the
! 679: ** saved position info stored by saveCursorPosition(), so there can be
! 680: ** at most one effective restoreCursorPosition() call after each
! 681: ** saveCursorPosition().
! 682: */
! 683: static int btreeRestoreCursorPosition(BtCursor *pCur){
! 684: int rc;
! 685: assert( cursorHoldsMutex(pCur) );
! 686: assert( pCur->eState>=CURSOR_REQUIRESEEK );
! 687: if( pCur->eState==CURSOR_FAULT ){
! 688: return pCur->skipNext;
! 689: }
! 690: pCur->eState = CURSOR_INVALID;
! 691: rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &pCur->skipNext);
! 692: if( rc==SQLITE_OK ){
! 693: sqlite3_free(pCur->pKey);
! 694: pCur->pKey = 0;
! 695: assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
! 696: }
! 697: return rc;
! 698: }
! 699:
! 700: #define restoreCursorPosition(p) \
! 701: (p->eState>=CURSOR_REQUIRESEEK ? \
! 702: btreeRestoreCursorPosition(p) : \
! 703: SQLITE_OK)
! 704:
! 705: /*
! 706: ** Determine whether or not a cursor has moved from the position it
! 707: ** was last placed at. Cursors can move when the row they are pointing
! 708: ** at is deleted out from under them.
! 709: **
! 710: ** This routine returns an error code if something goes wrong. The
! 711: ** integer *pHasMoved is set to one if the cursor has moved and 0 if not.
! 712: */
! 713: int sqlite3BtreeCursorHasMoved(BtCursor *pCur, int *pHasMoved){
! 714: int rc;
! 715:
! 716: rc = restoreCursorPosition(pCur);
! 717: if( rc ){
! 718: *pHasMoved = 1;
! 719: return rc;
! 720: }
! 721: if( pCur->eState!=CURSOR_VALID || pCur->skipNext!=0 ){
! 722: *pHasMoved = 1;
! 723: }else{
! 724: *pHasMoved = 0;
! 725: }
! 726: return SQLITE_OK;
! 727: }
! 728:
! 729: #ifndef SQLITE_OMIT_AUTOVACUUM
! 730: /*
! 731: ** Given a page number of a regular database page, return the page
! 732: ** number for the pointer-map page that contains the entry for the
! 733: ** input page number.
! 734: **
! 735: ** Return 0 (not a valid page) for pgno==1 since there is
! 736: ** no pointer map associated with page 1. The integrity_check logic
! 737: ** requires that ptrmapPageno(*,1)!=1.
! 738: */
! 739: static Pgno ptrmapPageno(BtShared *pBt, Pgno pgno){
! 740: int nPagesPerMapPage;
! 741: Pgno iPtrMap, ret;
! 742: assert( sqlite3_mutex_held(pBt->mutex) );
! 743: if( pgno<2 ) return 0;
! 744: nPagesPerMapPage = (pBt->usableSize/5)+1;
! 745: iPtrMap = (pgno-2)/nPagesPerMapPage;
! 746: ret = (iPtrMap*nPagesPerMapPage) + 2;
! 747: if( ret==PENDING_BYTE_PAGE(pBt) ){
! 748: ret++;
! 749: }
! 750: return ret;
! 751: }
! 752:
! 753: /*
! 754: ** Write an entry into the pointer map.
! 755: **
! 756: ** This routine updates the pointer map entry for page number 'key'
! 757: ** so that it maps to type 'eType' and parent page number 'pgno'.
! 758: **
! 759: ** If *pRC is initially non-zero (non-SQLITE_OK) then this routine is
! 760: ** a no-op. If an error occurs, the appropriate error code is written
! 761: ** into *pRC.
! 762: */
! 763: static void ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent, int *pRC){
! 764: DbPage *pDbPage; /* The pointer map page */
! 765: u8 *pPtrmap; /* The pointer map data */
! 766: Pgno iPtrmap; /* The pointer map page number */
! 767: int offset; /* Offset in pointer map page */
! 768: int rc; /* Return code from subfunctions */
! 769:
! 770: if( *pRC ) return;
! 771:
! 772: assert( sqlite3_mutex_held(pBt->mutex) );
! 773: /* The master-journal page number must never be used as a pointer map page */
! 774: assert( 0==PTRMAP_ISPAGE(pBt, PENDING_BYTE_PAGE(pBt)) );
! 775:
! 776: assert( pBt->autoVacuum );
! 777: if( key==0 ){
! 778: *pRC = SQLITE_CORRUPT_BKPT;
! 779: return;
! 780: }
! 781: iPtrmap = PTRMAP_PAGENO(pBt, key);
! 782: rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage);
! 783: if( rc!=SQLITE_OK ){
! 784: *pRC = rc;
! 785: return;
! 786: }
! 787: offset = PTRMAP_PTROFFSET(iPtrmap, key);
! 788: if( offset<0 ){
! 789: *pRC = SQLITE_CORRUPT_BKPT;
! 790: goto ptrmap_exit;
! 791: }
! 792: assert( offset <= (int)pBt->usableSize-5 );
! 793: pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage);
! 794:
! 795: if( eType!=pPtrmap[offset] || get4byte(&pPtrmap[offset+1])!=parent ){
! 796: TRACE(("PTRMAP_UPDATE: %d->(%d,%d)\n", key, eType, parent));
! 797: *pRC= rc = sqlite3PagerWrite(pDbPage);
! 798: if( rc==SQLITE_OK ){
! 799: pPtrmap[offset] = eType;
! 800: put4byte(&pPtrmap[offset+1], parent);
! 801: }
! 802: }
! 803:
! 804: ptrmap_exit:
! 805: sqlite3PagerUnref(pDbPage);
! 806: }
! 807:
! 808: /*
! 809: ** Read an entry from the pointer map.
! 810: **
! 811: ** This routine retrieves the pointer map entry for page 'key', writing
! 812: ** the type and parent page number to *pEType and *pPgno respectively.
! 813: ** An error code is returned if something goes wrong, otherwise SQLITE_OK.
! 814: */
! 815: static int ptrmapGet(BtShared *pBt, Pgno key, u8 *pEType, Pgno *pPgno){
! 816: DbPage *pDbPage; /* The pointer map page */
! 817: int iPtrmap; /* Pointer map page index */
! 818: u8 *pPtrmap; /* Pointer map page data */
! 819: int offset; /* Offset of entry in pointer map */
! 820: int rc;
! 821:
! 822: assert( sqlite3_mutex_held(pBt->mutex) );
! 823:
! 824: iPtrmap = PTRMAP_PAGENO(pBt, key);
! 825: rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage);
! 826: if( rc!=0 ){
! 827: return rc;
! 828: }
! 829: pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage);
! 830:
! 831: offset = PTRMAP_PTROFFSET(iPtrmap, key);
! 832: if( offset<0 ){
! 833: sqlite3PagerUnref(pDbPage);
! 834: return SQLITE_CORRUPT_BKPT;
! 835: }
! 836: assert( offset <= (int)pBt->usableSize-5 );
! 837: assert( pEType!=0 );
! 838: *pEType = pPtrmap[offset];
! 839: if( pPgno ) *pPgno = get4byte(&pPtrmap[offset+1]);
! 840:
! 841: sqlite3PagerUnref(pDbPage);
! 842: if( *pEType<1 || *pEType>5 ) return SQLITE_CORRUPT_BKPT;
! 843: return SQLITE_OK;
! 844: }
! 845:
! 846: #else /* if defined SQLITE_OMIT_AUTOVACUUM */
! 847: #define ptrmapPut(w,x,y,z,rc)
! 848: #define ptrmapGet(w,x,y,z) SQLITE_OK
! 849: #define ptrmapPutOvflPtr(x, y, rc)
! 850: #endif
! 851:
! 852: /*
! 853: ** Given a btree page and a cell index (0 means the first cell on
! 854: ** the page, 1 means the second cell, and so forth) return a pointer
! 855: ** to the cell content.
! 856: **
! 857: ** This routine works only for pages that do not contain overflow cells.
! 858: */
! 859: #define findCell(P,I) \
! 860: ((P)->aData + ((P)->maskPage & get2byte(&(P)->aCellIdx[2*(I)])))
! 861: #define findCellv2(D,M,O,I) (D+(M&get2byte(D+(O+2*(I)))))
! 862:
! 863:
! 864: /*
! 865: ** This a more complex version of findCell() that works for
! 866: ** pages that do contain overflow cells.
! 867: */
! 868: static u8 *findOverflowCell(MemPage *pPage, int iCell){
! 869: int i;
! 870: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
! 871: for(i=pPage->nOverflow-1; i>=0; i--){
! 872: int k;
! 873: struct _OvflCell *pOvfl;
! 874: pOvfl = &pPage->aOvfl[i];
! 875: k = pOvfl->idx;
! 876: if( k<=iCell ){
! 877: if( k==iCell ){
! 878: return pOvfl->pCell;
! 879: }
! 880: iCell--;
! 881: }
! 882: }
! 883: return findCell(pPage, iCell);
! 884: }
! 885:
! 886: /*
! 887: ** Parse a cell content block and fill in the CellInfo structure. There
! 888: ** are two versions of this function. btreeParseCell() takes a
! 889: ** cell index as the second argument and btreeParseCellPtr()
! 890: ** takes a pointer to the body of the cell as its second argument.
! 891: **
! 892: ** Within this file, the parseCell() macro can be called instead of
! 893: ** btreeParseCellPtr(). Using some compilers, this will be faster.
! 894: */
! 895: static void btreeParseCellPtr(
! 896: MemPage *pPage, /* Page containing the cell */
! 897: u8 *pCell, /* Pointer to the cell text. */
! 898: CellInfo *pInfo /* Fill in this structure */
! 899: ){
! 900: u16 n; /* Number bytes in cell content header */
! 901: u32 nPayload; /* Number of bytes of cell payload */
! 902:
! 903: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
! 904:
! 905: pInfo->pCell = pCell;
! 906: assert( pPage->leaf==0 || pPage->leaf==1 );
! 907: n = pPage->childPtrSize;
! 908: assert( n==4-4*pPage->leaf );
! 909: if( pPage->intKey ){
! 910: if( pPage->hasData ){
! 911: n += getVarint32(&pCell[n], nPayload);
! 912: }else{
! 913: nPayload = 0;
! 914: }
! 915: n += getVarint(&pCell[n], (u64*)&pInfo->nKey);
! 916: pInfo->nData = nPayload;
! 917: }else{
! 918: pInfo->nData = 0;
! 919: n += getVarint32(&pCell[n], nPayload);
! 920: pInfo->nKey = nPayload;
! 921: }
! 922: pInfo->nPayload = nPayload;
! 923: pInfo->nHeader = n;
! 924: testcase( nPayload==pPage->maxLocal );
! 925: testcase( nPayload==pPage->maxLocal+1 );
! 926: if( likely(nPayload<=pPage->maxLocal) ){
! 927: /* This is the (easy) common case where the entire payload fits
! 928: ** on the local page. No overflow is required.
! 929: */
! 930: if( (pInfo->nSize = (u16)(n+nPayload))<4 ) pInfo->nSize = 4;
! 931: pInfo->nLocal = (u16)nPayload;
! 932: pInfo->iOverflow = 0;
! 933: }else{
! 934: /* If the payload will not fit completely on the local page, we have
! 935: ** to decide how much to store locally and how much to spill onto
! 936: ** overflow pages. The strategy is to minimize the amount of unused
! 937: ** space on overflow pages while keeping the amount of local storage
! 938: ** in between minLocal and maxLocal.
! 939: **
! 940: ** Warning: changing the way overflow payload is distributed in any
! 941: ** way will result in an incompatible file format.
! 942: */
! 943: int minLocal; /* Minimum amount of payload held locally */
! 944: int maxLocal; /* Maximum amount of payload held locally */
! 945: int surplus; /* Overflow payload available for local storage */
! 946:
! 947: minLocal = pPage->minLocal;
! 948: maxLocal = pPage->maxLocal;
! 949: surplus = minLocal + (nPayload - minLocal)%(pPage->pBt->usableSize - 4);
! 950: testcase( surplus==maxLocal );
! 951: testcase( surplus==maxLocal+1 );
! 952: if( surplus <= maxLocal ){
! 953: pInfo->nLocal = (u16)surplus;
! 954: }else{
! 955: pInfo->nLocal = (u16)minLocal;
! 956: }
! 957: pInfo->iOverflow = (u16)(pInfo->nLocal + n);
! 958: pInfo->nSize = pInfo->iOverflow + 4;
! 959: }
! 960: }
! 961: #define parseCell(pPage, iCell, pInfo) \
! 962: btreeParseCellPtr((pPage), findCell((pPage), (iCell)), (pInfo))
! 963: static void btreeParseCell(
! 964: MemPage *pPage, /* Page containing the cell */
! 965: int iCell, /* The cell index. First cell is 0 */
! 966: CellInfo *pInfo /* Fill in this structure */
! 967: ){
! 968: parseCell(pPage, iCell, pInfo);
! 969: }
! 970:
! 971: /*
! 972: ** Compute the total number of bytes that a Cell needs in the cell
! 973: ** data area of the btree-page. The return number includes the cell
! 974: ** data header and the local payload, but not any overflow page or
! 975: ** the space used by the cell pointer.
! 976: */
! 977: static u16 cellSizePtr(MemPage *pPage, u8 *pCell){
! 978: u8 *pIter = &pCell[pPage->childPtrSize];
! 979: u32 nSize;
! 980:
! 981: #ifdef SQLITE_DEBUG
! 982: /* The value returned by this function should always be the same as
! 983: ** the (CellInfo.nSize) value found by doing a full parse of the
! 984: ** cell. If SQLITE_DEBUG is defined, an assert() at the bottom of
! 985: ** this function verifies that this invariant is not violated. */
! 986: CellInfo debuginfo;
! 987: btreeParseCellPtr(pPage, pCell, &debuginfo);
! 988: #endif
! 989:
! 990: if( pPage->intKey ){
! 991: u8 *pEnd;
! 992: if( pPage->hasData ){
! 993: pIter += getVarint32(pIter, nSize);
! 994: }else{
! 995: nSize = 0;
! 996: }
! 997:
! 998: /* pIter now points at the 64-bit integer key value, a variable length
! 999: ** integer. The following block moves pIter to point at the first byte
! 1000: ** past the end of the key value. */
! 1001: pEnd = &pIter[9];
! 1002: while( (*pIter++)&0x80 && pIter<pEnd );
! 1003: }else{
! 1004: pIter += getVarint32(pIter, nSize);
! 1005: }
! 1006:
! 1007: testcase( nSize==pPage->maxLocal );
! 1008: testcase( nSize==pPage->maxLocal+1 );
! 1009: if( nSize>pPage->maxLocal ){
! 1010: int minLocal = pPage->minLocal;
! 1011: nSize = minLocal + (nSize - minLocal) % (pPage->pBt->usableSize - 4);
! 1012: testcase( nSize==pPage->maxLocal );
! 1013: testcase( nSize==pPage->maxLocal+1 );
! 1014: if( nSize>pPage->maxLocal ){
! 1015: nSize = minLocal;
! 1016: }
! 1017: nSize += 4;
! 1018: }
! 1019: nSize += (u32)(pIter - pCell);
! 1020:
! 1021: /* The minimum size of any cell is 4 bytes. */
! 1022: if( nSize<4 ){
! 1023: nSize = 4;
! 1024: }
! 1025:
! 1026: assert( nSize==debuginfo.nSize );
! 1027: return (u16)nSize;
! 1028: }
! 1029:
! 1030: #ifdef SQLITE_DEBUG
! 1031: /* This variation on cellSizePtr() is used inside of assert() statements
! 1032: ** only. */
! 1033: static u16 cellSize(MemPage *pPage, int iCell){
! 1034: return cellSizePtr(pPage, findCell(pPage, iCell));
! 1035: }
! 1036: #endif
! 1037:
! 1038: #ifndef SQLITE_OMIT_AUTOVACUUM
! 1039: /*
! 1040: ** If the cell pCell, part of page pPage contains a pointer
! 1041: ** to an overflow page, insert an entry into the pointer-map
! 1042: ** for the overflow page.
! 1043: */
! 1044: static void ptrmapPutOvflPtr(MemPage *pPage, u8 *pCell, int *pRC){
! 1045: CellInfo info;
! 1046: if( *pRC ) return;
! 1047: assert( pCell!=0 );
! 1048: btreeParseCellPtr(pPage, pCell, &info);
! 1049: assert( (info.nData+(pPage->intKey?0:info.nKey))==info.nPayload );
! 1050: if( info.iOverflow ){
! 1051: Pgno ovfl = get4byte(&pCell[info.iOverflow]);
! 1052: ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, pRC);
! 1053: }
! 1054: }
! 1055: #endif
! 1056:
! 1057:
! 1058: /*
! 1059: ** Defragment the page given. All Cells are moved to the
! 1060: ** end of the page and all free space is collected into one
! 1061: ** big FreeBlk that occurs in between the header and cell
! 1062: ** pointer array and the cell content area.
! 1063: */
! 1064: static int defragmentPage(MemPage *pPage){
! 1065: int i; /* Loop counter */
! 1066: int pc; /* Address of a i-th cell */
! 1067: int hdr; /* Offset to the page header */
! 1068: int size; /* Size of a cell */
! 1069: int usableSize; /* Number of usable bytes on a page */
! 1070: int cellOffset; /* Offset to the cell pointer array */
! 1071: int cbrk; /* Offset to the cell content area */
! 1072: int nCell; /* Number of cells on the page */
! 1073: unsigned char *data; /* The page data */
! 1074: unsigned char *temp; /* Temp area for cell content */
! 1075: int iCellFirst; /* First allowable cell index */
! 1076: int iCellLast; /* Last possible cell index */
! 1077:
! 1078:
! 1079: assert( sqlite3PagerIswriteable(pPage->pDbPage) );
! 1080: assert( pPage->pBt!=0 );
! 1081: assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE );
! 1082: assert( pPage->nOverflow==0 );
! 1083: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
! 1084: temp = sqlite3PagerTempSpace(pPage->pBt->pPager);
! 1085: data = pPage->aData;
! 1086: hdr = pPage->hdrOffset;
! 1087: cellOffset = pPage->cellOffset;
! 1088: nCell = pPage->nCell;
! 1089: assert( nCell==get2byte(&data[hdr+3]) );
! 1090: usableSize = pPage->pBt->usableSize;
! 1091: cbrk = get2byte(&data[hdr+5]);
! 1092: memcpy(&temp[cbrk], &data[cbrk], usableSize - cbrk);
! 1093: cbrk = usableSize;
! 1094: iCellFirst = cellOffset + 2*nCell;
! 1095: iCellLast = usableSize - 4;
! 1096: for(i=0; i<nCell; i++){
! 1097: u8 *pAddr; /* The i-th cell pointer */
! 1098: pAddr = &data[cellOffset + i*2];
! 1099: pc = get2byte(pAddr);
! 1100: testcase( pc==iCellFirst );
! 1101: testcase( pc==iCellLast );
! 1102: #if !defined(SQLITE_ENABLE_OVERSIZE_CELL_CHECK)
! 1103: /* These conditions have already been verified in btreeInitPage()
! 1104: ** if SQLITE_ENABLE_OVERSIZE_CELL_CHECK is defined
! 1105: */
! 1106: if( pc<iCellFirst || pc>iCellLast ){
! 1107: return SQLITE_CORRUPT_BKPT;
! 1108: }
! 1109: #endif
! 1110: assert( pc>=iCellFirst && pc<=iCellLast );
! 1111: size = cellSizePtr(pPage, &temp[pc]);
! 1112: cbrk -= size;
! 1113: #if defined(SQLITE_ENABLE_OVERSIZE_CELL_CHECK)
! 1114: if( cbrk<iCellFirst ){
! 1115: return SQLITE_CORRUPT_BKPT;
! 1116: }
! 1117: #else
! 1118: if( cbrk<iCellFirst || pc+size>usableSize ){
! 1119: return SQLITE_CORRUPT_BKPT;
! 1120: }
! 1121: #endif
! 1122: assert( cbrk+size<=usableSize && cbrk>=iCellFirst );
! 1123: testcase( cbrk+size==usableSize );
! 1124: testcase( pc+size==usableSize );
! 1125: memcpy(&data[cbrk], &temp[pc], size);
! 1126: put2byte(pAddr, cbrk);
! 1127: }
! 1128: assert( cbrk>=iCellFirst );
! 1129: put2byte(&data[hdr+5], cbrk);
! 1130: data[hdr+1] = 0;
! 1131: data[hdr+2] = 0;
! 1132: data[hdr+7] = 0;
! 1133: memset(&data[iCellFirst], 0, cbrk-iCellFirst);
! 1134: assert( sqlite3PagerIswriteable(pPage->pDbPage) );
! 1135: if( cbrk-iCellFirst!=pPage->nFree ){
! 1136: return SQLITE_CORRUPT_BKPT;
! 1137: }
! 1138: return SQLITE_OK;
! 1139: }
! 1140:
! 1141: /*
! 1142: ** Allocate nByte bytes of space from within the B-Tree page passed
! 1143: ** as the first argument. Write into *pIdx the index into pPage->aData[]
! 1144: ** of the first byte of allocated space. Return either SQLITE_OK or
! 1145: ** an error code (usually SQLITE_CORRUPT).
! 1146: **
! 1147: ** The caller guarantees that there is sufficient space to make the
! 1148: ** allocation. This routine might need to defragment in order to bring
! 1149: ** all the space together, however. This routine will avoid using
! 1150: ** the first two bytes past the cell pointer area since presumably this
! 1151: ** allocation is being made in order to insert a new cell, so we will
! 1152: ** also end up needing a new cell pointer.
! 1153: */
! 1154: static int allocateSpace(MemPage *pPage, int nByte, int *pIdx){
! 1155: const int hdr = pPage->hdrOffset; /* Local cache of pPage->hdrOffset */
! 1156: u8 * const data = pPage->aData; /* Local cache of pPage->aData */
! 1157: int nFrag; /* Number of fragmented bytes on pPage */
! 1158: int top; /* First byte of cell content area */
! 1159: int gap; /* First byte of gap between cell pointers and cell content */
! 1160: int rc; /* Integer return code */
! 1161: int usableSize; /* Usable size of the page */
! 1162:
! 1163: assert( sqlite3PagerIswriteable(pPage->pDbPage) );
! 1164: assert( pPage->pBt );
! 1165: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
! 1166: assert( nByte>=0 ); /* Minimum cell size is 4 */
! 1167: assert( pPage->nFree>=nByte );
! 1168: assert( pPage->nOverflow==0 );
! 1169: usableSize = pPage->pBt->usableSize;
! 1170: assert( nByte < usableSize-8 );
! 1171:
! 1172: nFrag = data[hdr+7];
! 1173: assert( pPage->cellOffset == hdr + 12 - 4*pPage->leaf );
! 1174: gap = pPage->cellOffset + 2*pPage->nCell;
! 1175: top = get2byteNotZero(&data[hdr+5]);
! 1176: if( gap>top ) return SQLITE_CORRUPT_BKPT;
! 1177: testcase( gap+2==top );
! 1178: testcase( gap+1==top );
! 1179: testcase( gap==top );
! 1180:
! 1181: if( nFrag>=60 ){
! 1182: /* Always defragment highly fragmented pages */
! 1183: rc = defragmentPage(pPage);
! 1184: if( rc ) return rc;
! 1185: top = get2byteNotZero(&data[hdr+5]);
! 1186: }else if( gap+2<=top ){
! 1187: /* Search the freelist looking for a free slot big enough to satisfy
! 1188: ** the request. The allocation is made from the first free slot in
! 1189: ** the list that is large enough to accomadate it.
! 1190: */
! 1191: int pc, addr;
! 1192: for(addr=hdr+1; (pc = get2byte(&data[addr]))>0; addr=pc){
! 1193: int size; /* Size of the free slot */
! 1194: if( pc>usableSize-4 || pc<addr+4 ){
! 1195: return SQLITE_CORRUPT_BKPT;
! 1196: }
! 1197: size = get2byte(&data[pc+2]);
! 1198: if( size>=nByte ){
! 1199: int x = size - nByte;
! 1200: testcase( x==4 );
! 1201: testcase( x==3 );
! 1202: if( x<4 ){
! 1203: /* Remove the slot from the free-list. Update the number of
! 1204: ** fragmented bytes within the page. */
! 1205: memcpy(&data[addr], &data[pc], 2);
! 1206: data[hdr+7] = (u8)(nFrag + x);
! 1207: }else if( size+pc > usableSize ){
! 1208: return SQLITE_CORRUPT_BKPT;
! 1209: }else{
! 1210: /* The slot remains on the free-list. Reduce its size to account
! 1211: ** for the portion used by the new allocation. */
! 1212: put2byte(&data[pc+2], x);
! 1213: }
! 1214: *pIdx = pc + x;
! 1215: return SQLITE_OK;
! 1216: }
! 1217: }
! 1218: }
! 1219:
! 1220: /* Check to make sure there is enough space in the gap to satisfy
! 1221: ** the allocation. If not, defragment.
! 1222: */
! 1223: testcase( gap+2+nByte==top );
! 1224: if( gap+2+nByte>top ){
! 1225: rc = defragmentPage(pPage);
! 1226: if( rc ) return rc;
! 1227: top = get2byteNotZero(&data[hdr+5]);
! 1228: assert( gap+nByte<=top );
! 1229: }
! 1230:
! 1231:
! 1232: /* Allocate memory from the gap in between the cell pointer array
! 1233: ** and the cell content area. The btreeInitPage() call has already
! 1234: ** validated the freelist. Given that the freelist is valid, there
! 1235: ** is no way that the allocation can extend off the end of the page.
! 1236: ** The assert() below verifies the previous sentence.
! 1237: */
! 1238: top -= nByte;
! 1239: put2byte(&data[hdr+5], top);
! 1240: assert( top+nByte <= (int)pPage->pBt->usableSize );
! 1241: *pIdx = top;
! 1242: return SQLITE_OK;
! 1243: }
! 1244:
! 1245: /*
! 1246: ** Return a section of the pPage->aData to the freelist.
! 1247: ** The first byte of the new free block is pPage->aDisk[start]
! 1248: ** and the size of the block is "size" bytes.
! 1249: **
! 1250: ** Most of the effort here is involved in coalesing adjacent
! 1251: ** free blocks into a single big free block.
! 1252: */
! 1253: static int freeSpace(MemPage *pPage, int start, int size){
! 1254: int addr, pbegin, hdr;
! 1255: int iLast; /* Largest possible freeblock offset */
! 1256: unsigned char *data = pPage->aData;
! 1257:
! 1258: assert( pPage->pBt!=0 );
! 1259: assert( sqlite3PagerIswriteable(pPage->pDbPage) );
! 1260: assert( start>=pPage->hdrOffset+6+pPage->childPtrSize );
! 1261: assert( (start + size) <= (int)pPage->pBt->usableSize );
! 1262: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
! 1263: assert( size>=0 ); /* Minimum cell size is 4 */
! 1264:
! 1265: if( pPage->pBt->btsFlags & BTS_SECURE_DELETE ){
! 1266: /* Overwrite deleted information with zeros when the secure_delete
! 1267: ** option is enabled */
! 1268: memset(&data[start], 0, size);
! 1269: }
! 1270:
! 1271: /* Add the space back into the linked list of freeblocks. Note that
! 1272: ** even though the freeblock list was checked by btreeInitPage(),
! 1273: ** btreeInitPage() did not detect overlapping cells or
! 1274: ** freeblocks that overlapped cells. Nor does it detect when the
! 1275: ** cell content area exceeds the value in the page header. If these
! 1276: ** situations arise, then subsequent insert operations might corrupt
! 1277: ** the freelist. So we do need to check for corruption while scanning
! 1278: ** the freelist.
! 1279: */
! 1280: hdr = pPage->hdrOffset;
! 1281: addr = hdr + 1;
! 1282: iLast = pPage->pBt->usableSize - 4;
! 1283: assert( start<=iLast );
! 1284: while( (pbegin = get2byte(&data[addr]))<start && pbegin>0 ){
! 1285: if( pbegin<addr+4 ){
! 1286: return SQLITE_CORRUPT_BKPT;
! 1287: }
! 1288: addr = pbegin;
! 1289: }
! 1290: if( pbegin>iLast ){
! 1291: return SQLITE_CORRUPT_BKPT;
! 1292: }
! 1293: assert( pbegin>addr || pbegin==0 );
! 1294: put2byte(&data[addr], start);
! 1295: put2byte(&data[start], pbegin);
! 1296: put2byte(&data[start+2], size);
! 1297: pPage->nFree = pPage->nFree + (u16)size;
! 1298:
! 1299: /* Coalesce adjacent free blocks */
! 1300: addr = hdr + 1;
! 1301: while( (pbegin = get2byte(&data[addr]))>0 ){
! 1302: int pnext, psize, x;
! 1303: assert( pbegin>addr );
! 1304: assert( pbegin <= (int)pPage->pBt->usableSize-4 );
! 1305: pnext = get2byte(&data[pbegin]);
! 1306: psize = get2byte(&data[pbegin+2]);
! 1307: if( pbegin + psize + 3 >= pnext && pnext>0 ){
! 1308: int frag = pnext - (pbegin+psize);
! 1309: if( (frag<0) || (frag>(int)data[hdr+7]) ){
! 1310: return SQLITE_CORRUPT_BKPT;
! 1311: }
! 1312: data[hdr+7] -= (u8)frag;
! 1313: x = get2byte(&data[pnext]);
! 1314: put2byte(&data[pbegin], x);
! 1315: x = pnext + get2byte(&data[pnext+2]) - pbegin;
! 1316: put2byte(&data[pbegin+2], x);
! 1317: }else{
! 1318: addr = pbegin;
! 1319: }
! 1320: }
! 1321:
! 1322: /* If the cell content area begins with a freeblock, remove it. */
! 1323: if( data[hdr+1]==data[hdr+5] && data[hdr+2]==data[hdr+6] ){
! 1324: int top;
! 1325: pbegin = get2byte(&data[hdr+1]);
! 1326: memcpy(&data[hdr+1], &data[pbegin], 2);
! 1327: top = get2byte(&data[hdr+5]) + get2byte(&data[pbegin+2]);
! 1328: put2byte(&data[hdr+5], top);
! 1329: }
! 1330: assert( sqlite3PagerIswriteable(pPage->pDbPage) );
! 1331: return SQLITE_OK;
! 1332: }
! 1333:
! 1334: /*
! 1335: ** Decode the flags byte (the first byte of the header) for a page
! 1336: ** and initialize fields of the MemPage structure accordingly.
! 1337: **
! 1338: ** Only the following combinations are supported. Anything different
! 1339: ** indicates a corrupt database files:
! 1340: **
! 1341: ** PTF_ZERODATA
! 1342: ** PTF_ZERODATA | PTF_LEAF
! 1343: ** PTF_LEAFDATA | PTF_INTKEY
! 1344: ** PTF_LEAFDATA | PTF_INTKEY | PTF_LEAF
! 1345: */
! 1346: static int decodeFlags(MemPage *pPage, int flagByte){
! 1347: BtShared *pBt; /* A copy of pPage->pBt */
! 1348:
! 1349: assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) );
! 1350: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
! 1351: pPage->leaf = (u8)(flagByte>>3); assert( PTF_LEAF == 1<<3 );
! 1352: flagByte &= ~PTF_LEAF;
! 1353: pPage->childPtrSize = 4-4*pPage->leaf;
! 1354: pBt = pPage->pBt;
! 1355: if( flagByte==(PTF_LEAFDATA | PTF_INTKEY) ){
! 1356: pPage->intKey = 1;
! 1357: pPage->hasData = pPage->leaf;
! 1358: pPage->maxLocal = pBt->maxLeaf;
! 1359: pPage->minLocal = pBt->minLeaf;
! 1360: }else if( flagByte==PTF_ZERODATA ){
! 1361: pPage->intKey = 0;
! 1362: pPage->hasData = 0;
! 1363: pPage->maxLocal = pBt->maxLocal;
! 1364: pPage->minLocal = pBt->minLocal;
! 1365: }else{
! 1366: return SQLITE_CORRUPT_BKPT;
! 1367: }
! 1368: pPage->max1bytePayload = pBt->max1bytePayload;
! 1369: return SQLITE_OK;
! 1370: }
! 1371:
! 1372: /*
! 1373: ** Initialize the auxiliary information for a disk block.
! 1374: **
! 1375: ** Return SQLITE_OK on success. If we see that the page does
! 1376: ** not contain a well-formed database page, then return
! 1377: ** SQLITE_CORRUPT. Note that a return of SQLITE_OK does not
! 1378: ** guarantee that the page is well-formed. It only shows that
! 1379: ** we failed to detect any corruption.
! 1380: */
! 1381: static int btreeInitPage(MemPage *pPage){
! 1382:
! 1383: assert( pPage->pBt!=0 );
! 1384: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
! 1385: assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
! 1386: assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) );
! 1387: assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) );
! 1388:
! 1389: if( !pPage->isInit ){
! 1390: u16 pc; /* Address of a freeblock within pPage->aData[] */
! 1391: u8 hdr; /* Offset to beginning of page header */
! 1392: u8 *data; /* Equal to pPage->aData */
! 1393: BtShared *pBt; /* The main btree structure */
! 1394: int usableSize; /* Amount of usable space on each page */
! 1395: u16 cellOffset; /* Offset from start of page to first cell pointer */
! 1396: int nFree; /* Number of unused bytes on the page */
! 1397: int top; /* First byte of the cell content area */
! 1398: int iCellFirst; /* First allowable cell or freeblock offset */
! 1399: int iCellLast; /* Last possible cell or freeblock offset */
! 1400:
! 1401: pBt = pPage->pBt;
! 1402:
! 1403: hdr = pPage->hdrOffset;
! 1404: data = pPage->aData;
! 1405: if( decodeFlags(pPage, data[hdr]) ) return SQLITE_CORRUPT_BKPT;
! 1406: assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
! 1407: pPage->maskPage = (u16)(pBt->pageSize - 1);
! 1408: pPage->nOverflow = 0;
! 1409: usableSize = pBt->usableSize;
! 1410: pPage->cellOffset = cellOffset = hdr + 12 - 4*pPage->leaf;
! 1411: pPage->aDataEnd = &data[usableSize];
! 1412: pPage->aCellIdx = &data[cellOffset];
! 1413: top = get2byteNotZero(&data[hdr+5]);
! 1414: pPage->nCell = get2byte(&data[hdr+3]);
! 1415: if( pPage->nCell>MX_CELL(pBt) ){
! 1416: /* To many cells for a single page. The page must be corrupt */
! 1417: return SQLITE_CORRUPT_BKPT;
! 1418: }
! 1419: testcase( pPage->nCell==MX_CELL(pBt) );
! 1420:
! 1421: /* A malformed database page might cause us to read past the end
! 1422: ** of page when parsing a cell.
! 1423: **
! 1424: ** The following block of code checks early to see if a cell extends
! 1425: ** past the end of a page boundary and causes SQLITE_CORRUPT to be
! 1426: ** returned if it does.
! 1427: */
! 1428: iCellFirst = cellOffset + 2*pPage->nCell;
! 1429: iCellLast = usableSize - 4;
! 1430: #if defined(SQLITE_ENABLE_OVERSIZE_CELL_CHECK)
! 1431: {
! 1432: int i; /* Index into the cell pointer array */
! 1433: int sz; /* Size of a cell */
! 1434:
! 1435: if( !pPage->leaf ) iCellLast--;
! 1436: for(i=0; i<pPage->nCell; i++){
! 1437: pc = get2byte(&data[cellOffset+i*2]);
! 1438: testcase( pc==iCellFirst );
! 1439: testcase( pc==iCellLast );
! 1440: if( pc<iCellFirst || pc>iCellLast ){
! 1441: return SQLITE_CORRUPT_BKPT;
! 1442: }
! 1443: sz = cellSizePtr(pPage, &data[pc]);
! 1444: testcase( pc+sz==usableSize );
! 1445: if( pc+sz>usableSize ){
! 1446: return SQLITE_CORRUPT_BKPT;
! 1447: }
! 1448: }
! 1449: if( !pPage->leaf ) iCellLast++;
! 1450: }
! 1451: #endif
! 1452:
! 1453: /* Compute the total free space on the page */
! 1454: pc = get2byte(&data[hdr+1]);
! 1455: nFree = data[hdr+7] + top;
! 1456: while( pc>0 ){
! 1457: u16 next, size;
! 1458: if( pc<iCellFirst || pc>iCellLast ){
! 1459: /* Start of free block is off the page */
! 1460: return SQLITE_CORRUPT_BKPT;
! 1461: }
! 1462: next = get2byte(&data[pc]);
! 1463: size = get2byte(&data[pc+2]);
! 1464: if( (next>0 && next<=pc+size+3) || pc+size>usableSize ){
! 1465: /* Free blocks must be in ascending order. And the last byte of
! 1466: ** the free-block must lie on the database page. */
! 1467: return SQLITE_CORRUPT_BKPT;
! 1468: }
! 1469: nFree = nFree + size;
! 1470: pc = next;
! 1471: }
! 1472:
! 1473: /* At this point, nFree contains the sum of the offset to the start
! 1474: ** of the cell-content area plus the number of free bytes within
! 1475: ** the cell-content area. If this is greater than the usable-size
! 1476: ** of the page, then the page must be corrupted. This check also
! 1477: ** serves to verify that the offset to the start of the cell-content
! 1478: ** area, according to the page header, lies within the page.
! 1479: */
! 1480: if( nFree>usableSize ){
! 1481: return SQLITE_CORRUPT_BKPT;
! 1482: }
! 1483: pPage->nFree = (u16)(nFree - iCellFirst);
! 1484: pPage->isInit = 1;
! 1485: }
! 1486: return SQLITE_OK;
! 1487: }
! 1488:
! 1489: /*
! 1490: ** Set up a raw page so that it looks like a database page holding
! 1491: ** no entries.
! 1492: */
! 1493: static void zeroPage(MemPage *pPage, int flags){
! 1494: unsigned char *data = pPage->aData;
! 1495: BtShared *pBt = pPage->pBt;
! 1496: u8 hdr = pPage->hdrOffset;
! 1497: u16 first;
! 1498:
! 1499: assert( sqlite3PagerPagenumber(pPage->pDbPage)==pPage->pgno );
! 1500: assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
! 1501: assert( sqlite3PagerGetData(pPage->pDbPage) == data );
! 1502: assert( sqlite3PagerIswriteable(pPage->pDbPage) );
! 1503: assert( sqlite3_mutex_held(pBt->mutex) );
! 1504: if( pBt->btsFlags & BTS_SECURE_DELETE ){
! 1505: memset(&data[hdr], 0, pBt->usableSize - hdr);
! 1506: }
! 1507: data[hdr] = (char)flags;
! 1508: first = hdr + 8 + 4*((flags&PTF_LEAF)==0 ?1:0);
! 1509: memset(&data[hdr+1], 0, 4);
! 1510: data[hdr+7] = 0;
! 1511: put2byte(&data[hdr+5], pBt->usableSize);
! 1512: pPage->nFree = (u16)(pBt->usableSize - first);
! 1513: decodeFlags(pPage, flags);
! 1514: pPage->hdrOffset = hdr;
! 1515: pPage->cellOffset = first;
! 1516: pPage->aDataEnd = &data[pBt->usableSize];
! 1517: pPage->aCellIdx = &data[first];
! 1518: pPage->nOverflow = 0;
! 1519: assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
! 1520: pPage->maskPage = (u16)(pBt->pageSize - 1);
! 1521: pPage->nCell = 0;
! 1522: pPage->isInit = 1;
! 1523: }
! 1524:
! 1525:
! 1526: /*
! 1527: ** Convert a DbPage obtained from the pager into a MemPage used by
! 1528: ** the btree layer.
! 1529: */
! 1530: static MemPage *btreePageFromDbPage(DbPage *pDbPage, Pgno pgno, BtShared *pBt){
! 1531: MemPage *pPage = (MemPage*)sqlite3PagerGetExtra(pDbPage);
! 1532: pPage->aData = sqlite3PagerGetData(pDbPage);
! 1533: pPage->pDbPage = pDbPage;
! 1534: pPage->pBt = pBt;
! 1535: pPage->pgno = pgno;
! 1536: pPage->hdrOffset = pPage->pgno==1 ? 100 : 0;
! 1537: return pPage;
! 1538: }
! 1539:
! 1540: /*
! 1541: ** Get a page from the pager. Initialize the MemPage.pBt and
! 1542: ** MemPage.aData elements if needed.
! 1543: **
! 1544: ** If the noContent flag is set, it means that we do not care about
! 1545: ** the content of the page at this time. So do not go to the disk
! 1546: ** to fetch the content. Just fill in the content with zeros for now.
! 1547: ** If in the future we call sqlite3PagerWrite() on this page, that
! 1548: ** means we have started to be concerned about content and the disk
! 1549: ** read should occur at that point.
! 1550: */
! 1551: static int btreeGetPage(
! 1552: BtShared *pBt, /* The btree */
! 1553: Pgno pgno, /* Number of the page to fetch */
! 1554: MemPage **ppPage, /* Return the page in this parameter */
! 1555: int noContent /* Do not load page content if true */
! 1556: ){
! 1557: int rc;
! 1558: DbPage *pDbPage;
! 1559:
! 1560: assert( sqlite3_mutex_held(pBt->mutex) );
! 1561: rc = sqlite3PagerAcquire(pBt->pPager, pgno, (DbPage**)&pDbPage, noContent);
! 1562: if( rc ) return rc;
! 1563: *ppPage = btreePageFromDbPage(pDbPage, pgno, pBt);
! 1564: return SQLITE_OK;
! 1565: }
! 1566:
! 1567: /*
! 1568: ** Retrieve a page from the pager cache. If the requested page is not
! 1569: ** already in the pager cache return NULL. Initialize the MemPage.pBt and
! 1570: ** MemPage.aData elements if needed.
! 1571: */
! 1572: static MemPage *btreePageLookup(BtShared *pBt, Pgno pgno){
! 1573: DbPage *pDbPage;
! 1574: assert( sqlite3_mutex_held(pBt->mutex) );
! 1575: pDbPage = sqlite3PagerLookup(pBt->pPager, pgno);
! 1576: if( pDbPage ){
! 1577: return btreePageFromDbPage(pDbPage, pgno, pBt);
! 1578: }
! 1579: return 0;
! 1580: }
! 1581:
! 1582: /*
! 1583: ** Return the size of the database file in pages. If there is any kind of
! 1584: ** error, return ((unsigned int)-1).
! 1585: */
! 1586: static Pgno btreePagecount(BtShared *pBt){
! 1587: return pBt->nPage;
! 1588: }
! 1589: u32 sqlite3BtreeLastPage(Btree *p){
! 1590: assert( sqlite3BtreeHoldsMutex(p) );
! 1591: assert( ((p->pBt->nPage)&0x8000000)==0 );
! 1592: return (int)btreePagecount(p->pBt);
! 1593: }
! 1594:
! 1595: /*
! 1596: ** Get a page from the pager and initialize it. This routine is just a
! 1597: ** convenience wrapper around separate calls to btreeGetPage() and
! 1598: ** btreeInitPage().
! 1599: **
! 1600: ** If an error occurs, then the value *ppPage is set to is undefined. It
! 1601: ** may remain unchanged, or it may be set to an invalid value.
! 1602: */
! 1603: static int getAndInitPage(
! 1604: BtShared *pBt, /* The database file */
! 1605: Pgno pgno, /* Number of the page to get */
! 1606: MemPage **ppPage /* Write the page pointer here */
! 1607: ){
! 1608: int rc;
! 1609: assert( sqlite3_mutex_held(pBt->mutex) );
! 1610:
! 1611: if( pgno>btreePagecount(pBt) ){
! 1612: rc = SQLITE_CORRUPT_BKPT;
! 1613: }else{
! 1614: rc = btreeGetPage(pBt, pgno, ppPage, 0);
! 1615: if( rc==SQLITE_OK ){
! 1616: rc = btreeInitPage(*ppPage);
! 1617: if( rc!=SQLITE_OK ){
! 1618: releasePage(*ppPage);
! 1619: }
! 1620: }
! 1621: }
! 1622:
! 1623: testcase( pgno==0 );
! 1624: assert( pgno!=0 || rc==SQLITE_CORRUPT );
! 1625: return rc;
! 1626: }
! 1627:
! 1628: /*
! 1629: ** Release a MemPage. This should be called once for each prior
! 1630: ** call to btreeGetPage.
! 1631: */
! 1632: static void releasePage(MemPage *pPage){
! 1633: if( pPage ){
! 1634: assert( pPage->aData );
! 1635: assert( pPage->pBt );
! 1636: assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
! 1637: assert( sqlite3PagerGetData(pPage->pDbPage)==pPage->aData );
! 1638: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
! 1639: sqlite3PagerUnref(pPage->pDbPage);
! 1640: }
! 1641: }
! 1642:
! 1643: /*
! 1644: ** During a rollback, when the pager reloads information into the cache
! 1645: ** so that the cache is restored to its original state at the start of
! 1646: ** the transaction, for each page restored this routine is called.
! 1647: **
! 1648: ** This routine needs to reset the extra data section at the end of the
! 1649: ** page to agree with the restored data.
! 1650: */
! 1651: static void pageReinit(DbPage *pData){
! 1652: MemPage *pPage;
! 1653: pPage = (MemPage *)sqlite3PagerGetExtra(pData);
! 1654: assert( sqlite3PagerPageRefcount(pData)>0 );
! 1655: if( pPage->isInit ){
! 1656: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
! 1657: pPage->isInit = 0;
! 1658: if( sqlite3PagerPageRefcount(pData)>1 ){
! 1659: /* pPage might not be a btree page; it might be an overflow page
! 1660: ** or ptrmap page or a free page. In those cases, the following
! 1661: ** call to btreeInitPage() will likely return SQLITE_CORRUPT.
! 1662: ** But no harm is done by this. And it is very important that
! 1663: ** btreeInitPage() be called on every btree page so we make
! 1664: ** the call for every page that comes in for re-initing. */
! 1665: btreeInitPage(pPage);
! 1666: }
! 1667: }
! 1668: }
! 1669:
! 1670: /*
! 1671: ** Invoke the busy handler for a btree.
! 1672: */
! 1673: static int btreeInvokeBusyHandler(void *pArg){
! 1674: BtShared *pBt = (BtShared*)pArg;
! 1675: assert( pBt->db );
! 1676: assert( sqlite3_mutex_held(pBt->db->mutex) );
! 1677: return sqlite3InvokeBusyHandler(&pBt->db->busyHandler);
! 1678: }
! 1679:
! 1680: /*
! 1681: ** Open a database file.
! 1682: **
! 1683: ** zFilename is the name of the database file. If zFilename is NULL
! 1684: ** then an ephemeral database is created. The ephemeral database might
! 1685: ** be exclusively in memory, or it might use a disk-based memory cache.
! 1686: ** Either way, the ephemeral database will be automatically deleted
! 1687: ** when sqlite3BtreeClose() is called.
! 1688: **
! 1689: ** If zFilename is ":memory:" then an in-memory database is created
! 1690: ** that is automatically destroyed when it is closed.
! 1691: **
! 1692: ** The "flags" parameter is a bitmask that might contain bits
! 1693: ** BTREE_OMIT_JOURNAL and/or BTREE_NO_READLOCK. The BTREE_NO_READLOCK
! 1694: ** bit is also set if the SQLITE_NoReadlock flags is set in db->flags.
! 1695: ** These flags are passed through into sqlite3PagerOpen() and must
! 1696: ** be the same values as PAGER_OMIT_JOURNAL and PAGER_NO_READLOCK.
! 1697: **
! 1698: ** If the database is already opened in the same database connection
! 1699: ** and we are in shared cache mode, then the open will fail with an
! 1700: ** SQLITE_CONSTRAINT error. We cannot allow two or more BtShared
! 1701: ** objects in the same database connection since doing so will lead
! 1702: ** to problems with locking.
! 1703: */
! 1704: int sqlite3BtreeOpen(
! 1705: sqlite3_vfs *pVfs, /* VFS to use for this b-tree */
! 1706: const char *zFilename, /* Name of the file containing the BTree database */
! 1707: sqlite3 *db, /* Associated database handle */
! 1708: Btree **ppBtree, /* Pointer to new Btree object written here */
! 1709: int flags, /* Options */
! 1710: int vfsFlags /* Flags passed through to sqlite3_vfs.xOpen() */
! 1711: ){
! 1712: BtShared *pBt = 0; /* Shared part of btree structure */
! 1713: Btree *p; /* Handle to return */
! 1714: sqlite3_mutex *mutexOpen = 0; /* Prevents a race condition. Ticket #3537 */
! 1715: int rc = SQLITE_OK; /* Result code from this function */
! 1716: u8 nReserve; /* Byte of unused space on each page */
! 1717: unsigned char zDbHeader[100]; /* Database header content */
! 1718:
! 1719: /* True if opening an ephemeral, temporary database */
! 1720: const int isTempDb = zFilename==0 || zFilename[0]==0;
! 1721:
! 1722: /* Set the variable isMemdb to true for an in-memory database, or
! 1723: ** false for a file-based database.
! 1724: */
! 1725: #ifdef SQLITE_OMIT_MEMORYDB
! 1726: const int isMemdb = 0;
! 1727: #else
! 1728: const int isMemdb = (zFilename && strcmp(zFilename, ":memory:")==0)
! 1729: || (isTempDb && sqlite3TempInMemory(db));
! 1730: #endif
! 1731:
! 1732: assert( db!=0 );
! 1733: assert( pVfs!=0 );
! 1734: assert( sqlite3_mutex_held(db->mutex) );
! 1735: assert( (flags&0xff)==flags ); /* flags fit in 8 bits */
! 1736:
! 1737: /* Only a BTREE_SINGLE database can be BTREE_UNORDERED */
! 1738: assert( (flags & BTREE_UNORDERED)==0 || (flags & BTREE_SINGLE)!=0 );
! 1739:
! 1740: /* A BTREE_SINGLE database is always a temporary and/or ephemeral */
! 1741: assert( (flags & BTREE_SINGLE)==0 || isTempDb );
! 1742:
! 1743: if( db->flags & SQLITE_NoReadlock ){
! 1744: flags |= BTREE_NO_READLOCK;
! 1745: }
! 1746: if( isMemdb ){
! 1747: flags |= BTREE_MEMORY;
! 1748: }
! 1749: if( (vfsFlags & SQLITE_OPEN_MAIN_DB)!=0 && (isMemdb || isTempDb) ){
! 1750: vfsFlags = (vfsFlags & ~SQLITE_OPEN_MAIN_DB) | SQLITE_OPEN_TEMP_DB;
! 1751: }
! 1752: p = sqlite3MallocZero(sizeof(Btree));
! 1753: if( !p ){
! 1754: return SQLITE_NOMEM;
! 1755: }
! 1756: p->inTrans = TRANS_NONE;
! 1757: p->db = db;
! 1758: #ifndef SQLITE_OMIT_SHARED_CACHE
! 1759: p->lock.pBtree = p;
! 1760: p->lock.iTable = 1;
! 1761: #endif
! 1762:
! 1763: #if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO)
! 1764: /*
! 1765: ** If this Btree is a candidate for shared cache, try to find an
! 1766: ** existing BtShared object that we can share with
! 1767: */
! 1768: if( isMemdb==0 && isTempDb==0 ){
! 1769: if( vfsFlags & SQLITE_OPEN_SHAREDCACHE ){
! 1770: int nFullPathname = pVfs->mxPathname+1;
! 1771: char *zFullPathname = sqlite3Malloc(nFullPathname);
! 1772: MUTEX_LOGIC( sqlite3_mutex *mutexShared; )
! 1773: p->sharable = 1;
! 1774: if( !zFullPathname ){
! 1775: sqlite3_free(p);
! 1776: return SQLITE_NOMEM;
! 1777: }
! 1778: rc = sqlite3OsFullPathname(pVfs, zFilename, nFullPathname, zFullPathname);
! 1779: if( rc ){
! 1780: sqlite3_free(zFullPathname);
! 1781: sqlite3_free(p);
! 1782: return rc;
! 1783: }
! 1784: #if SQLITE_THREADSAFE
! 1785: mutexOpen = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_OPEN);
! 1786: sqlite3_mutex_enter(mutexOpen);
! 1787: mutexShared = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
! 1788: sqlite3_mutex_enter(mutexShared);
! 1789: #endif
! 1790: for(pBt=GLOBAL(BtShared*,sqlite3SharedCacheList); pBt; pBt=pBt->pNext){
! 1791: assert( pBt->nRef>0 );
! 1792: if( 0==strcmp(zFullPathname, sqlite3PagerFilename(pBt->pPager))
! 1793: && sqlite3PagerVfs(pBt->pPager)==pVfs ){
! 1794: int iDb;
! 1795: for(iDb=db->nDb-1; iDb>=0; iDb--){
! 1796: Btree *pExisting = db->aDb[iDb].pBt;
! 1797: if( pExisting && pExisting->pBt==pBt ){
! 1798: sqlite3_mutex_leave(mutexShared);
! 1799: sqlite3_mutex_leave(mutexOpen);
! 1800: sqlite3_free(zFullPathname);
! 1801: sqlite3_free(p);
! 1802: return SQLITE_CONSTRAINT;
! 1803: }
! 1804: }
! 1805: p->pBt = pBt;
! 1806: pBt->nRef++;
! 1807: break;
! 1808: }
! 1809: }
! 1810: sqlite3_mutex_leave(mutexShared);
! 1811: sqlite3_free(zFullPathname);
! 1812: }
! 1813: #ifdef SQLITE_DEBUG
! 1814: else{
! 1815: /* In debug mode, we mark all persistent databases as sharable
! 1816: ** even when they are not. This exercises the locking code and
! 1817: ** gives more opportunity for asserts(sqlite3_mutex_held())
! 1818: ** statements to find locking problems.
! 1819: */
! 1820: p->sharable = 1;
! 1821: }
! 1822: #endif
! 1823: }
! 1824: #endif
! 1825: if( pBt==0 ){
! 1826: /*
! 1827: ** The following asserts make sure that structures used by the btree are
! 1828: ** the right size. This is to guard against size changes that result
! 1829: ** when compiling on a different architecture.
! 1830: */
! 1831: assert( sizeof(i64)==8 || sizeof(i64)==4 );
! 1832: assert( sizeof(u64)==8 || sizeof(u64)==4 );
! 1833: assert( sizeof(u32)==4 );
! 1834: assert( sizeof(u16)==2 );
! 1835: assert( sizeof(Pgno)==4 );
! 1836:
! 1837: pBt = sqlite3MallocZero( sizeof(*pBt) );
! 1838: if( pBt==0 ){
! 1839: rc = SQLITE_NOMEM;
! 1840: goto btree_open_out;
! 1841: }
! 1842: rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename,
! 1843: EXTRA_SIZE, flags, vfsFlags, pageReinit);
! 1844: if( rc==SQLITE_OK ){
! 1845: rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader);
! 1846: }
! 1847: if( rc!=SQLITE_OK ){
! 1848: goto btree_open_out;
! 1849: }
! 1850: pBt->openFlags = (u8)flags;
! 1851: pBt->db = db;
! 1852: sqlite3PagerSetBusyhandler(pBt->pPager, btreeInvokeBusyHandler, pBt);
! 1853: p->pBt = pBt;
! 1854:
! 1855: pBt->pCursor = 0;
! 1856: pBt->pPage1 = 0;
! 1857: if( sqlite3PagerIsreadonly(pBt->pPager) ) pBt->btsFlags |= BTS_READ_ONLY;
! 1858: #ifdef SQLITE_SECURE_DELETE
! 1859: pBt->btsFlags |= BTS_SECURE_DELETE;
! 1860: #endif
! 1861: pBt->pageSize = (zDbHeader[16]<<8) | (zDbHeader[17]<<16);
! 1862: if( pBt->pageSize<512 || pBt->pageSize>SQLITE_MAX_PAGE_SIZE
! 1863: || ((pBt->pageSize-1)&pBt->pageSize)!=0 ){
! 1864: pBt->pageSize = 0;
! 1865: #ifndef SQLITE_OMIT_AUTOVACUUM
! 1866: /* If the magic name ":memory:" will create an in-memory database, then
! 1867: ** leave the autoVacuum mode at 0 (do not auto-vacuum), even if
! 1868: ** SQLITE_DEFAULT_AUTOVACUUM is true. On the other hand, if
! 1869: ** SQLITE_OMIT_MEMORYDB has been defined, then ":memory:" is just a
! 1870: ** regular file-name. In this case the auto-vacuum applies as per normal.
! 1871: */
! 1872: if( zFilename && !isMemdb ){
! 1873: pBt->autoVacuum = (SQLITE_DEFAULT_AUTOVACUUM ? 1 : 0);
! 1874: pBt->incrVacuum = (SQLITE_DEFAULT_AUTOVACUUM==2 ? 1 : 0);
! 1875: }
! 1876: #endif
! 1877: nReserve = 0;
! 1878: }else{
! 1879: nReserve = zDbHeader[20];
! 1880: pBt->btsFlags |= BTS_PAGESIZE_FIXED;
! 1881: #ifndef SQLITE_OMIT_AUTOVACUUM
! 1882: pBt->autoVacuum = (get4byte(&zDbHeader[36 + 4*4])?1:0);
! 1883: pBt->incrVacuum = (get4byte(&zDbHeader[36 + 7*4])?1:0);
! 1884: #endif
! 1885: }
! 1886: rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
! 1887: if( rc ) goto btree_open_out;
! 1888: pBt->usableSize = pBt->pageSize - nReserve;
! 1889: assert( (pBt->pageSize & 7)==0 ); /* 8-byte alignment of pageSize */
! 1890:
! 1891: #if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO)
! 1892: /* Add the new BtShared object to the linked list sharable BtShareds.
! 1893: */
! 1894: if( p->sharable ){
! 1895: MUTEX_LOGIC( sqlite3_mutex *mutexShared; )
! 1896: pBt->nRef = 1;
! 1897: MUTEX_LOGIC( mutexShared = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);)
! 1898: if( SQLITE_THREADSAFE && sqlite3GlobalConfig.bCoreMutex ){
! 1899: pBt->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_FAST);
! 1900: if( pBt->mutex==0 ){
! 1901: rc = SQLITE_NOMEM;
! 1902: db->mallocFailed = 0;
! 1903: goto btree_open_out;
! 1904: }
! 1905: }
! 1906: sqlite3_mutex_enter(mutexShared);
! 1907: pBt->pNext = GLOBAL(BtShared*,sqlite3SharedCacheList);
! 1908: GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt;
! 1909: sqlite3_mutex_leave(mutexShared);
! 1910: }
! 1911: #endif
! 1912: }
! 1913:
! 1914: #if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO)
! 1915: /* If the new Btree uses a sharable pBtShared, then link the new
! 1916: ** Btree into the list of all sharable Btrees for the same connection.
! 1917: ** The list is kept in ascending order by pBt address.
! 1918: */
! 1919: if( p->sharable ){
! 1920: int i;
! 1921: Btree *pSib;
! 1922: for(i=0; i<db->nDb; i++){
! 1923: if( (pSib = db->aDb[i].pBt)!=0 && pSib->sharable ){
! 1924: while( pSib->pPrev ){ pSib = pSib->pPrev; }
! 1925: if( p->pBt<pSib->pBt ){
! 1926: p->pNext = pSib;
! 1927: p->pPrev = 0;
! 1928: pSib->pPrev = p;
! 1929: }else{
! 1930: while( pSib->pNext && pSib->pNext->pBt<p->pBt ){
! 1931: pSib = pSib->pNext;
! 1932: }
! 1933: p->pNext = pSib->pNext;
! 1934: p->pPrev = pSib;
! 1935: if( p->pNext ){
! 1936: p->pNext->pPrev = p;
! 1937: }
! 1938: pSib->pNext = p;
! 1939: }
! 1940: break;
! 1941: }
! 1942: }
! 1943: }
! 1944: #endif
! 1945: *ppBtree = p;
! 1946:
! 1947: btree_open_out:
! 1948: if( rc!=SQLITE_OK ){
! 1949: if( pBt && pBt->pPager ){
! 1950: sqlite3PagerClose(pBt->pPager);
! 1951: }
! 1952: sqlite3_free(pBt);
! 1953: sqlite3_free(p);
! 1954: *ppBtree = 0;
! 1955: }else{
! 1956: /* If the B-Tree was successfully opened, set the pager-cache size to the
! 1957: ** default value. Except, when opening on an existing shared pager-cache,
! 1958: ** do not change the pager-cache size.
! 1959: */
! 1960: if( sqlite3BtreeSchema(p, 0, 0)==0 ){
! 1961: sqlite3PagerSetCachesize(p->pBt->pPager, SQLITE_DEFAULT_CACHE_SIZE);
! 1962: }
! 1963: }
! 1964: if( mutexOpen ){
! 1965: assert( sqlite3_mutex_held(mutexOpen) );
! 1966: sqlite3_mutex_leave(mutexOpen);
! 1967: }
! 1968: return rc;
! 1969: }
! 1970:
! 1971: /*
! 1972: ** Decrement the BtShared.nRef counter. When it reaches zero,
! 1973: ** remove the BtShared structure from the sharing list. Return
! 1974: ** true if the BtShared.nRef counter reaches zero and return
! 1975: ** false if it is still positive.
! 1976: */
! 1977: static int removeFromSharingList(BtShared *pBt){
! 1978: #ifndef SQLITE_OMIT_SHARED_CACHE
! 1979: MUTEX_LOGIC( sqlite3_mutex *pMaster; )
! 1980: BtShared *pList;
! 1981: int removed = 0;
! 1982:
! 1983: assert( sqlite3_mutex_notheld(pBt->mutex) );
! 1984: MUTEX_LOGIC( pMaster = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); )
! 1985: sqlite3_mutex_enter(pMaster);
! 1986: pBt->nRef--;
! 1987: if( pBt->nRef<=0 ){
! 1988: if( GLOBAL(BtShared*,sqlite3SharedCacheList)==pBt ){
! 1989: GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt->pNext;
! 1990: }else{
! 1991: pList = GLOBAL(BtShared*,sqlite3SharedCacheList);
! 1992: while( ALWAYS(pList) && pList->pNext!=pBt ){
! 1993: pList=pList->pNext;
! 1994: }
! 1995: if( ALWAYS(pList) ){
! 1996: pList->pNext = pBt->pNext;
! 1997: }
! 1998: }
! 1999: if( SQLITE_THREADSAFE ){
! 2000: sqlite3_mutex_free(pBt->mutex);
! 2001: }
! 2002: removed = 1;
! 2003: }
! 2004: sqlite3_mutex_leave(pMaster);
! 2005: return removed;
! 2006: #else
! 2007: return 1;
! 2008: #endif
! 2009: }
! 2010:
! 2011: /*
! 2012: ** Make sure pBt->pTmpSpace points to an allocation of
! 2013: ** MX_CELL_SIZE(pBt) bytes.
! 2014: */
! 2015: static void allocateTempSpace(BtShared *pBt){
! 2016: if( !pBt->pTmpSpace ){
! 2017: pBt->pTmpSpace = sqlite3PageMalloc( pBt->pageSize );
! 2018: }
! 2019: }
! 2020:
! 2021: /*
! 2022: ** Free the pBt->pTmpSpace allocation
! 2023: */
! 2024: static void freeTempSpace(BtShared *pBt){
! 2025: sqlite3PageFree( pBt->pTmpSpace);
! 2026: pBt->pTmpSpace = 0;
! 2027: }
! 2028:
! 2029: /*
! 2030: ** Close an open database and invalidate all cursors.
! 2031: */
! 2032: int sqlite3BtreeClose(Btree *p){
! 2033: BtShared *pBt = p->pBt;
! 2034: BtCursor *pCur;
! 2035:
! 2036: /* Close all cursors opened via this handle. */
! 2037: assert( sqlite3_mutex_held(p->db->mutex) );
! 2038: sqlite3BtreeEnter(p);
! 2039: pCur = pBt->pCursor;
! 2040: while( pCur ){
! 2041: BtCursor *pTmp = pCur;
! 2042: pCur = pCur->pNext;
! 2043: if( pTmp->pBtree==p ){
! 2044: sqlite3BtreeCloseCursor(pTmp);
! 2045: }
! 2046: }
! 2047:
! 2048: /* Rollback any active transaction and free the handle structure.
! 2049: ** The call to sqlite3BtreeRollback() drops any table-locks held by
! 2050: ** this handle.
! 2051: */
! 2052: sqlite3BtreeRollback(p);
! 2053: sqlite3BtreeLeave(p);
! 2054:
! 2055: /* If there are still other outstanding references to the shared-btree
! 2056: ** structure, return now. The remainder of this procedure cleans
! 2057: ** up the shared-btree.
! 2058: */
! 2059: assert( p->wantToLock==0 && p->locked==0 );
! 2060: if( !p->sharable || removeFromSharingList(pBt) ){
! 2061: /* The pBt is no longer on the sharing list, so we can access
! 2062: ** it without having to hold the mutex.
! 2063: **
! 2064: ** Clean out and delete the BtShared object.
! 2065: */
! 2066: assert( !pBt->pCursor );
! 2067: sqlite3PagerClose(pBt->pPager);
! 2068: if( pBt->xFreeSchema && pBt->pSchema ){
! 2069: pBt->xFreeSchema(pBt->pSchema);
! 2070: }
! 2071: sqlite3DbFree(0, pBt->pSchema);
! 2072: freeTempSpace(pBt);
! 2073: sqlite3_free(pBt);
! 2074: }
! 2075:
! 2076: #ifndef SQLITE_OMIT_SHARED_CACHE
! 2077: assert( p->wantToLock==0 );
! 2078: assert( p->locked==0 );
! 2079: if( p->pPrev ) p->pPrev->pNext = p->pNext;
! 2080: if( p->pNext ) p->pNext->pPrev = p->pPrev;
! 2081: #endif
! 2082:
! 2083: sqlite3_free(p);
! 2084: return SQLITE_OK;
! 2085: }
! 2086:
! 2087: /*
! 2088: ** Change the limit on the number of pages allowed in the cache.
! 2089: **
! 2090: ** The maximum number of cache pages is set to the absolute
! 2091: ** value of mxPage. If mxPage is negative, the pager will
! 2092: ** operate asynchronously - it will not stop to do fsync()s
! 2093: ** to insure data is written to the disk surface before
! 2094: ** continuing. Transactions still work if synchronous is off,
! 2095: ** and the database cannot be corrupted if this program
! 2096: ** crashes. But if the operating system crashes or there is
! 2097: ** an abrupt power failure when synchronous is off, the database
! 2098: ** could be left in an inconsistent and unrecoverable state.
! 2099: ** Synchronous is on by default so database corruption is not
! 2100: ** normally a worry.
! 2101: */
! 2102: int sqlite3BtreeSetCacheSize(Btree *p, int mxPage){
! 2103: BtShared *pBt = p->pBt;
! 2104: assert( sqlite3_mutex_held(p->db->mutex) );
! 2105: sqlite3BtreeEnter(p);
! 2106: sqlite3PagerSetCachesize(pBt->pPager, mxPage);
! 2107: sqlite3BtreeLeave(p);
! 2108: return SQLITE_OK;
! 2109: }
! 2110:
! 2111: /*
! 2112: ** Change the way data is synced to disk in order to increase or decrease
! 2113: ** how well the database resists damage due to OS crashes and power
! 2114: ** failures. Level 1 is the same as asynchronous (no syncs() occur and
! 2115: ** there is a high probability of damage) Level 2 is the default. There
! 2116: ** is a very low but non-zero probability of damage. Level 3 reduces the
! 2117: ** probability of damage to near zero but with a write performance reduction.
! 2118: */
! 2119: #ifndef SQLITE_OMIT_PAGER_PRAGMAS
! 2120: int sqlite3BtreeSetSafetyLevel(
! 2121: Btree *p, /* The btree to set the safety level on */
! 2122: int level, /* PRAGMA synchronous. 1=OFF, 2=NORMAL, 3=FULL */
! 2123: int fullSync, /* PRAGMA fullfsync. */
! 2124: int ckptFullSync /* PRAGMA checkpoint_fullfync */
! 2125: ){
! 2126: BtShared *pBt = p->pBt;
! 2127: assert( sqlite3_mutex_held(p->db->mutex) );
! 2128: assert( level>=1 && level<=3 );
! 2129: sqlite3BtreeEnter(p);
! 2130: sqlite3PagerSetSafetyLevel(pBt->pPager, level, fullSync, ckptFullSync);
! 2131: sqlite3BtreeLeave(p);
! 2132: return SQLITE_OK;
! 2133: }
! 2134: #endif
! 2135:
! 2136: /*
! 2137: ** Return TRUE if the given btree is set to safety level 1. In other
! 2138: ** words, return TRUE if no sync() occurs on the disk files.
! 2139: */
! 2140: int sqlite3BtreeSyncDisabled(Btree *p){
! 2141: BtShared *pBt = p->pBt;
! 2142: int rc;
! 2143: assert( sqlite3_mutex_held(p->db->mutex) );
! 2144: sqlite3BtreeEnter(p);
! 2145: assert( pBt && pBt->pPager );
! 2146: rc = sqlite3PagerNosync(pBt->pPager);
! 2147: sqlite3BtreeLeave(p);
! 2148: return rc;
! 2149: }
! 2150:
! 2151: /*
! 2152: ** Change the default pages size and the number of reserved bytes per page.
! 2153: ** Or, if the page size has already been fixed, return SQLITE_READONLY
! 2154: ** without changing anything.
! 2155: **
! 2156: ** The page size must be a power of 2 between 512 and 65536. If the page
! 2157: ** size supplied does not meet this constraint then the page size is not
! 2158: ** changed.
! 2159: **
! 2160: ** Page sizes are constrained to be a power of two so that the region
! 2161: ** of the database file used for locking (beginning at PENDING_BYTE,
! 2162: ** the first byte past the 1GB boundary, 0x40000000) needs to occur
! 2163: ** at the beginning of a page.
! 2164: **
! 2165: ** If parameter nReserve is less than zero, then the number of reserved
! 2166: ** bytes per page is left unchanged.
! 2167: **
! 2168: ** If the iFix!=0 then the BTS_PAGESIZE_FIXED flag is set so that the page size
! 2169: ** and autovacuum mode can no longer be changed.
! 2170: */
! 2171: int sqlite3BtreeSetPageSize(Btree *p, int pageSize, int nReserve, int iFix){
! 2172: int rc = SQLITE_OK;
! 2173: BtShared *pBt = p->pBt;
! 2174: assert( nReserve>=-1 && nReserve<=255 );
! 2175: sqlite3BtreeEnter(p);
! 2176: if( pBt->btsFlags & BTS_PAGESIZE_FIXED ){
! 2177: sqlite3BtreeLeave(p);
! 2178: return SQLITE_READONLY;
! 2179: }
! 2180: if( nReserve<0 ){
! 2181: nReserve = pBt->pageSize - pBt->usableSize;
! 2182: }
! 2183: assert( nReserve>=0 && nReserve<=255 );
! 2184: if( pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE &&
! 2185: ((pageSize-1)&pageSize)==0 ){
! 2186: assert( (pageSize & 7)==0 );
! 2187: assert( !pBt->pPage1 && !pBt->pCursor );
! 2188: pBt->pageSize = (u32)pageSize;
! 2189: freeTempSpace(pBt);
! 2190: }
! 2191: rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
! 2192: pBt->usableSize = pBt->pageSize - (u16)nReserve;
! 2193: if( iFix ) pBt->btsFlags |= BTS_PAGESIZE_FIXED;
! 2194: sqlite3BtreeLeave(p);
! 2195: return rc;
! 2196: }
! 2197:
! 2198: /*
! 2199: ** Return the currently defined page size
! 2200: */
! 2201: int sqlite3BtreeGetPageSize(Btree *p){
! 2202: return p->pBt->pageSize;
! 2203: }
! 2204:
! 2205: #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) || !defined(SQLITE_OMIT_VACUUM)
! 2206: /*
! 2207: ** Return the number of bytes of space at the end of every page that
! 2208: ** are intentually left unused. This is the "reserved" space that is
! 2209: ** sometimes used by extensions.
! 2210: */
! 2211: int sqlite3BtreeGetReserve(Btree *p){
! 2212: int n;
! 2213: sqlite3BtreeEnter(p);
! 2214: n = p->pBt->pageSize - p->pBt->usableSize;
! 2215: sqlite3BtreeLeave(p);
! 2216: return n;
! 2217: }
! 2218:
! 2219: /*
! 2220: ** Set the maximum page count for a database if mxPage is positive.
! 2221: ** No changes are made if mxPage is 0 or negative.
! 2222: ** Regardless of the value of mxPage, return the maximum page count.
! 2223: */
! 2224: int sqlite3BtreeMaxPageCount(Btree *p, int mxPage){
! 2225: int n;
! 2226: sqlite3BtreeEnter(p);
! 2227: n = sqlite3PagerMaxPageCount(p->pBt->pPager, mxPage);
! 2228: sqlite3BtreeLeave(p);
! 2229: return n;
! 2230: }
! 2231:
! 2232: /*
! 2233: ** Set the BTS_SECURE_DELETE flag if newFlag is 0 or 1. If newFlag is -1,
! 2234: ** then make no changes. Always return the value of the BTS_SECURE_DELETE
! 2235: ** setting after the change.
! 2236: */
! 2237: int sqlite3BtreeSecureDelete(Btree *p, int newFlag){
! 2238: int b;
! 2239: if( p==0 ) return 0;
! 2240: sqlite3BtreeEnter(p);
! 2241: if( newFlag>=0 ){
! 2242: p->pBt->btsFlags &= ~BTS_SECURE_DELETE;
! 2243: if( newFlag ) p->pBt->btsFlags |= BTS_SECURE_DELETE;
! 2244: }
! 2245: b = (p->pBt->btsFlags & BTS_SECURE_DELETE)!=0;
! 2246: sqlite3BtreeLeave(p);
! 2247: return b;
! 2248: }
! 2249: #endif /* !defined(SQLITE_OMIT_PAGER_PRAGMAS) || !defined(SQLITE_OMIT_VACUUM) */
! 2250:
! 2251: /*
! 2252: ** Change the 'auto-vacuum' property of the database. If the 'autoVacuum'
! 2253: ** parameter is non-zero, then auto-vacuum mode is enabled. If zero, it
! 2254: ** is disabled. The default value for the auto-vacuum property is
! 2255: ** determined by the SQLITE_DEFAULT_AUTOVACUUM macro.
! 2256: */
! 2257: int sqlite3BtreeSetAutoVacuum(Btree *p, int autoVacuum){
! 2258: #ifdef SQLITE_OMIT_AUTOVACUUM
! 2259: return SQLITE_READONLY;
! 2260: #else
! 2261: BtShared *pBt = p->pBt;
! 2262: int rc = SQLITE_OK;
! 2263: u8 av = (u8)autoVacuum;
! 2264:
! 2265: sqlite3BtreeEnter(p);
! 2266: if( (pBt->btsFlags & BTS_PAGESIZE_FIXED)!=0 && (av ?1:0)!=pBt->autoVacuum ){
! 2267: rc = SQLITE_READONLY;
! 2268: }else{
! 2269: pBt->autoVacuum = av ?1:0;
! 2270: pBt->incrVacuum = av==2 ?1:0;
! 2271: }
! 2272: sqlite3BtreeLeave(p);
! 2273: return rc;
! 2274: #endif
! 2275: }
! 2276:
! 2277: /*
! 2278: ** Return the value of the 'auto-vacuum' property. If auto-vacuum is
! 2279: ** enabled 1 is returned. Otherwise 0.
! 2280: */
! 2281: int sqlite3BtreeGetAutoVacuum(Btree *p){
! 2282: #ifdef SQLITE_OMIT_AUTOVACUUM
! 2283: return BTREE_AUTOVACUUM_NONE;
! 2284: #else
! 2285: int rc;
! 2286: sqlite3BtreeEnter(p);
! 2287: rc = (
! 2288: (!p->pBt->autoVacuum)?BTREE_AUTOVACUUM_NONE:
! 2289: (!p->pBt->incrVacuum)?BTREE_AUTOVACUUM_FULL:
! 2290: BTREE_AUTOVACUUM_INCR
! 2291: );
! 2292: sqlite3BtreeLeave(p);
! 2293: return rc;
! 2294: #endif
! 2295: }
! 2296:
! 2297:
! 2298: /*
! 2299: ** Get a reference to pPage1 of the database file. This will
! 2300: ** also acquire a readlock on that file.
! 2301: **
! 2302: ** SQLITE_OK is returned on success. If the file is not a
! 2303: ** well-formed database file, then SQLITE_CORRUPT is returned.
! 2304: ** SQLITE_BUSY is returned if the database is locked. SQLITE_NOMEM
! 2305: ** is returned if we run out of memory.
! 2306: */
! 2307: static int lockBtree(BtShared *pBt){
! 2308: int rc; /* Result code from subfunctions */
! 2309: MemPage *pPage1; /* Page 1 of the database file */
! 2310: int nPage; /* Number of pages in the database */
! 2311: int nPageFile = 0; /* Number of pages in the database file */
! 2312: int nPageHeader; /* Number of pages in the database according to hdr */
! 2313:
! 2314: assert( sqlite3_mutex_held(pBt->mutex) );
! 2315: assert( pBt->pPage1==0 );
! 2316: rc = sqlite3PagerSharedLock(pBt->pPager);
! 2317: if( rc!=SQLITE_OK ) return rc;
! 2318: rc = btreeGetPage(pBt, 1, &pPage1, 0);
! 2319: if( rc!=SQLITE_OK ) return rc;
! 2320:
! 2321: /* Do some checking to help insure the file we opened really is
! 2322: ** a valid database file.
! 2323: */
! 2324: nPage = nPageHeader = get4byte(28+(u8*)pPage1->aData);
! 2325: sqlite3PagerPagecount(pBt->pPager, &nPageFile);
! 2326: if( nPage==0 || memcmp(24+(u8*)pPage1->aData, 92+(u8*)pPage1->aData,4)!=0 ){
! 2327: nPage = nPageFile;
! 2328: }
! 2329: if( nPage>0 ){
! 2330: u32 pageSize;
! 2331: u32 usableSize;
! 2332: u8 *page1 = pPage1->aData;
! 2333: rc = SQLITE_NOTADB;
! 2334: if( memcmp(page1, zMagicHeader, 16)!=0 ){
! 2335: goto page1_init_failed;
! 2336: }
! 2337:
! 2338: #ifdef SQLITE_OMIT_WAL
! 2339: if( page1[18]>1 ){
! 2340: pBt->btsFlags |= BTS_READ_ONLY;
! 2341: }
! 2342: if( page1[19]>1 ){
! 2343: goto page1_init_failed;
! 2344: }
! 2345: #else
! 2346: if( page1[18]>2 ){
! 2347: pBt->btsFlags |= BTS_READ_ONLY;
! 2348: }
! 2349: if( page1[19]>2 ){
! 2350: goto page1_init_failed;
! 2351: }
! 2352:
! 2353: /* If the write version is set to 2, this database should be accessed
! 2354: ** in WAL mode. If the log is not already open, open it now. Then
! 2355: ** return SQLITE_OK and return without populating BtShared.pPage1.
! 2356: ** The caller detects this and calls this function again. This is
! 2357: ** required as the version of page 1 currently in the page1 buffer
! 2358: ** may not be the latest version - there may be a newer one in the log
! 2359: ** file.
! 2360: */
! 2361: if( page1[19]==2 && (pBt->btsFlags & BTS_NO_WAL)==0 ){
! 2362: int isOpen = 0;
! 2363: rc = sqlite3PagerOpenWal(pBt->pPager, &isOpen);
! 2364: if( rc!=SQLITE_OK ){
! 2365: goto page1_init_failed;
! 2366: }else if( isOpen==0 ){
! 2367: releasePage(pPage1);
! 2368: return SQLITE_OK;
! 2369: }
! 2370: rc = SQLITE_NOTADB;
! 2371: }
! 2372: #endif
! 2373:
! 2374: /* The maximum embedded fraction must be exactly 25%. And the minimum
! 2375: ** embedded fraction must be 12.5% for both leaf-data and non-leaf-data.
! 2376: ** The original design allowed these amounts to vary, but as of
! 2377: ** version 3.6.0, we require them to be fixed.
! 2378: */
! 2379: if( memcmp(&page1[21], "\100\040\040",3)!=0 ){
! 2380: goto page1_init_failed;
! 2381: }
! 2382: pageSize = (page1[16]<<8) | (page1[17]<<16);
! 2383: if( ((pageSize-1)&pageSize)!=0
! 2384: || pageSize>SQLITE_MAX_PAGE_SIZE
! 2385: || pageSize<=256
! 2386: ){
! 2387: goto page1_init_failed;
! 2388: }
! 2389: assert( (pageSize & 7)==0 );
! 2390: usableSize = pageSize - page1[20];
! 2391: if( (u32)pageSize!=pBt->pageSize ){
! 2392: /* After reading the first page of the database assuming a page size
! 2393: ** of BtShared.pageSize, we have discovered that the page-size is
! 2394: ** actually pageSize. Unlock the database, leave pBt->pPage1 at
! 2395: ** zero and return SQLITE_OK. The caller will call this function
! 2396: ** again with the correct page-size.
! 2397: */
! 2398: releasePage(pPage1);
! 2399: pBt->usableSize = usableSize;
! 2400: pBt->pageSize = pageSize;
! 2401: freeTempSpace(pBt);
! 2402: rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize,
! 2403: pageSize-usableSize);
! 2404: return rc;
! 2405: }
! 2406: if( (pBt->db->flags & SQLITE_RecoveryMode)==0 && nPage>nPageFile ){
! 2407: rc = SQLITE_CORRUPT_BKPT;
! 2408: goto page1_init_failed;
! 2409: }
! 2410: if( usableSize<480 ){
! 2411: goto page1_init_failed;
! 2412: }
! 2413: pBt->pageSize = pageSize;
! 2414: pBt->usableSize = usableSize;
! 2415: #ifndef SQLITE_OMIT_AUTOVACUUM
! 2416: pBt->autoVacuum = (get4byte(&page1[36 + 4*4])?1:0);
! 2417: pBt->incrVacuum = (get4byte(&page1[36 + 7*4])?1:0);
! 2418: #endif
! 2419: }
! 2420:
! 2421: /* maxLocal is the maximum amount of payload to store locally for
! 2422: ** a cell. Make sure it is small enough so that at least minFanout
! 2423: ** cells can will fit on one page. We assume a 10-byte page header.
! 2424: ** Besides the payload, the cell must store:
! 2425: ** 2-byte pointer to the cell
! 2426: ** 4-byte child pointer
! 2427: ** 9-byte nKey value
! 2428: ** 4-byte nData value
! 2429: ** 4-byte overflow page pointer
! 2430: ** So a cell consists of a 2-byte pointer, a header which is as much as
! 2431: ** 17 bytes long, 0 to N bytes of payload, and an optional 4 byte overflow
! 2432: ** page pointer.
! 2433: */
! 2434: pBt->maxLocal = (u16)((pBt->usableSize-12)*64/255 - 23);
! 2435: pBt->minLocal = (u16)((pBt->usableSize-12)*32/255 - 23);
! 2436: pBt->maxLeaf = (u16)(pBt->usableSize - 35);
! 2437: pBt->minLeaf = (u16)((pBt->usableSize-12)*32/255 - 23);
! 2438: if( pBt->maxLocal>127 ){
! 2439: pBt->max1bytePayload = 127;
! 2440: }else{
! 2441: pBt->max1bytePayload = (u8)pBt->maxLocal;
! 2442: }
! 2443: assert( pBt->maxLeaf + 23 <= MX_CELL_SIZE(pBt) );
! 2444: pBt->pPage1 = pPage1;
! 2445: pBt->nPage = nPage;
! 2446: return SQLITE_OK;
! 2447:
! 2448: page1_init_failed:
! 2449: releasePage(pPage1);
! 2450: pBt->pPage1 = 0;
! 2451: return rc;
! 2452: }
! 2453:
! 2454: /*
! 2455: ** If there are no outstanding cursors and we are not in the middle
! 2456: ** of a transaction but there is a read lock on the database, then
! 2457: ** this routine unrefs the first page of the database file which
! 2458: ** has the effect of releasing the read lock.
! 2459: **
! 2460: ** If there is a transaction in progress, this routine is a no-op.
! 2461: */
! 2462: static void unlockBtreeIfUnused(BtShared *pBt){
! 2463: assert( sqlite3_mutex_held(pBt->mutex) );
! 2464: assert( pBt->pCursor==0 || pBt->inTransaction>TRANS_NONE );
! 2465: if( pBt->inTransaction==TRANS_NONE && pBt->pPage1!=0 ){
! 2466: assert( pBt->pPage1->aData );
! 2467: assert( sqlite3PagerRefcount(pBt->pPager)==1 );
! 2468: assert( pBt->pPage1->aData );
! 2469: releasePage(pBt->pPage1);
! 2470: pBt->pPage1 = 0;
! 2471: }
! 2472: }
! 2473:
! 2474: /*
! 2475: ** If pBt points to an empty file then convert that empty file
! 2476: ** into a new empty database by initializing the first page of
! 2477: ** the database.
! 2478: */
! 2479: static int newDatabase(BtShared *pBt){
! 2480: MemPage *pP1;
! 2481: unsigned char *data;
! 2482: int rc;
! 2483:
! 2484: assert( sqlite3_mutex_held(pBt->mutex) );
! 2485: if( pBt->nPage>0 ){
! 2486: return SQLITE_OK;
! 2487: }
! 2488: pP1 = pBt->pPage1;
! 2489: assert( pP1!=0 );
! 2490: data = pP1->aData;
! 2491: rc = sqlite3PagerWrite(pP1->pDbPage);
! 2492: if( rc ) return rc;
! 2493: memcpy(data, zMagicHeader, sizeof(zMagicHeader));
! 2494: assert( sizeof(zMagicHeader)==16 );
! 2495: data[16] = (u8)((pBt->pageSize>>8)&0xff);
! 2496: data[17] = (u8)((pBt->pageSize>>16)&0xff);
! 2497: data[18] = 1;
! 2498: data[19] = 1;
! 2499: assert( pBt->usableSize<=pBt->pageSize && pBt->usableSize+255>=pBt->pageSize);
! 2500: data[20] = (u8)(pBt->pageSize - pBt->usableSize);
! 2501: data[21] = 64;
! 2502: data[22] = 32;
! 2503: data[23] = 32;
! 2504: memset(&data[24], 0, 100-24);
! 2505: zeroPage(pP1, PTF_INTKEY|PTF_LEAF|PTF_LEAFDATA );
! 2506: pBt->btsFlags |= BTS_PAGESIZE_FIXED;
! 2507: #ifndef SQLITE_OMIT_AUTOVACUUM
! 2508: assert( pBt->autoVacuum==1 || pBt->autoVacuum==0 );
! 2509: assert( pBt->incrVacuum==1 || pBt->incrVacuum==0 );
! 2510: put4byte(&data[36 + 4*4], pBt->autoVacuum);
! 2511: put4byte(&data[36 + 7*4], pBt->incrVacuum);
! 2512: #endif
! 2513: pBt->nPage = 1;
! 2514: data[31] = 1;
! 2515: return SQLITE_OK;
! 2516: }
! 2517:
! 2518: /*
! 2519: ** Attempt to start a new transaction. A write-transaction
! 2520: ** is started if the second argument is nonzero, otherwise a read-
! 2521: ** transaction. If the second argument is 2 or more and exclusive
! 2522: ** transaction is started, meaning that no other process is allowed
! 2523: ** to access the database. A preexisting transaction may not be
! 2524: ** upgraded to exclusive by calling this routine a second time - the
! 2525: ** exclusivity flag only works for a new transaction.
! 2526: **
! 2527: ** A write-transaction must be started before attempting any
! 2528: ** changes to the database. None of the following routines
! 2529: ** will work unless a transaction is started first:
! 2530: **
! 2531: ** sqlite3BtreeCreateTable()
! 2532: ** sqlite3BtreeCreateIndex()
! 2533: ** sqlite3BtreeClearTable()
! 2534: ** sqlite3BtreeDropTable()
! 2535: ** sqlite3BtreeInsert()
! 2536: ** sqlite3BtreeDelete()
! 2537: ** sqlite3BtreeUpdateMeta()
! 2538: **
! 2539: ** If an initial attempt to acquire the lock fails because of lock contention
! 2540: ** and the database was previously unlocked, then invoke the busy handler
! 2541: ** if there is one. But if there was previously a read-lock, do not
! 2542: ** invoke the busy handler - just return SQLITE_BUSY. SQLITE_BUSY is
! 2543: ** returned when there is already a read-lock in order to avoid a deadlock.
! 2544: **
! 2545: ** Suppose there are two processes A and B. A has a read lock and B has
! 2546: ** a reserved lock. B tries to promote to exclusive but is blocked because
! 2547: ** of A's read lock. A tries to promote to reserved but is blocked by B.
! 2548: ** One or the other of the two processes must give way or there can be
! 2549: ** no progress. By returning SQLITE_BUSY and not invoking the busy callback
! 2550: ** when A already has a read lock, we encourage A to give up and let B
! 2551: ** proceed.
! 2552: */
! 2553: int sqlite3BtreeBeginTrans(Btree *p, int wrflag){
! 2554: sqlite3 *pBlock = 0;
! 2555: BtShared *pBt = p->pBt;
! 2556: int rc = SQLITE_OK;
! 2557:
! 2558: sqlite3BtreeEnter(p);
! 2559: btreeIntegrity(p);
! 2560:
! 2561: /* If the btree is already in a write-transaction, or it
! 2562: ** is already in a read-transaction and a read-transaction
! 2563: ** is requested, this is a no-op.
! 2564: */
! 2565: if( p->inTrans==TRANS_WRITE || (p->inTrans==TRANS_READ && !wrflag) ){
! 2566: goto trans_begun;
! 2567: }
! 2568:
! 2569: /* Write transactions are not possible on a read-only database */
! 2570: if( (pBt->btsFlags & BTS_READ_ONLY)!=0 && wrflag ){
! 2571: rc = SQLITE_READONLY;
! 2572: goto trans_begun;
! 2573: }
! 2574:
! 2575: #ifndef SQLITE_OMIT_SHARED_CACHE
! 2576: /* If another database handle has already opened a write transaction
! 2577: ** on this shared-btree structure and a second write transaction is
! 2578: ** requested, return SQLITE_LOCKED.
! 2579: */
! 2580: if( (wrflag && pBt->inTransaction==TRANS_WRITE)
! 2581: || (pBt->btsFlags & BTS_PENDING)!=0
! 2582: ){
! 2583: pBlock = pBt->pWriter->db;
! 2584: }else if( wrflag>1 ){
! 2585: BtLock *pIter;
! 2586: for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
! 2587: if( pIter->pBtree!=p ){
! 2588: pBlock = pIter->pBtree->db;
! 2589: break;
! 2590: }
! 2591: }
! 2592: }
! 2593: if( pBlock ){
! 2594: sqlite3ConnectionBlocked(p->db, pBlock);
! 2595: rc = SQLITE_LOCKED_SHAREDCACHE;
! 2596: goto trans_begun;
! 2597: }
! 2598: #endif
! 2599:
! 2600: /* Any read-only or read-write transaction implies a read-lock on
! 2601: ** page 1. So if some other shared-cache client already has a write-lock
! 2602: ** on page 1, the transaction cannot be opened. */
! 2603: rc = querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK);
! 2604: if( SQLITE_OK!=rc ) goto trans_begun;
! 2605:
! 2606: pBt->btsFlags &= ~BTS_INITIALLY_EMPTY;
! 2607: if( pBt->nPage==0 ) pBt->btsFlags |= BTS_INITIALLY_EMPTY;
! 2608: do {
! 2609: /* Call lockBtree() until either pBt->pPage1 is populated or
! 2610: ** lockBtree() returns something other than SQLITE_OK. lockBtree()
! 2611: ** may return SQLITE_OK but leave pBt->pPage1 set to 0 if after
! 2612: ** reading page 1 it discovers that the page-size of the database
! 2613: ** file is not pBt->pageSize. In this case lockBtree() will update
! 2614: ** pBt->pageSize to the page-size of the file on disk.
! 2615: */
! 2616: while( pBt->pPage1==0 && SQLITE_OK==(rc = lockBtree(pBt)) );
! 2617:
! 2618: if( rc==SQLITE_OK && wrflag ){
! 2619: if( (pBt->btsFlags & BTS_READ_ONLY)!=0 ){
! 2620: rc = SQLITE_READONLY;
! 2621: }else{
! 2622: rc = sqlite3PagerBegin(pBt->pPager,wrflag>1,sqlite3TempInMemory(p->db));
! 2623: if( rc==SQLITE_OK ){
! 2624: rc = newDatabase(pBt);
! 2625: }
! 2626: }
! 2627: }
! 2628:
! 2629: if( rc!=SQLITE_OK ){
! 2630: unlockBtreeIfUnused(pBt);
! 2631: }
! 2632: }while( (rc&0xFF)==SQLITE_BUSY && pBt->inTransaction==TRANS_NONE &&
! 2633: btreeInvokeBusyHandler(pBt) );
! 2634:
! 2635: if( rc==SQLITE_OK ){
! 2636: if( p->inTrans==TRANS_NONE ){
! 2637: pBt->nTransaction++;
! 2638: #ifndef SQLITE_OMIT_SHARED_CACHE
! 2639: if( p->sharable ){
! 2640: assert( p->lock.pBtree==p && p->lock.iTable==1 );
! 2641: p->lock.eLock = READ_LOCK;
! 2642: p->lock.pNext = pBt->pLock;
! 2643: pBt->pLock = &p->lock;
! 2644: }
! 2645: #endif
! 2646: }
! 2647: p->inTrans = (wrflag?TRANS_WRITE:TRANS_READ);
! 2648: if( p->inTrans>pBt->inTransaction ){
! 2649: pBt->inTransaction = p->inTrans;
! 2650: }
! 2651: if( wrflag ){
! 2652: MemPage *pPage1 = pBt->pPage1;
! 2653: #ifndef SQLITE_OMIT_SHARED_CACHE
! 2654: assert( !pBt->pWriter );
! 2655: pBt->pWriter = p;
! 2656: pBt->btsFlags &= ~BTS_EXCLUSIVE;
! 2657: if( wrflag>1 ) pBt->btsFlags |= BTS_EXCLUSIVE;
! 2658: #endif
! 2659:
! 2660: /* If the db-size header field is incorrect (as it may be if an old
! 2661: ** client has been writing the database file), update it now. Doing
! 2662: ** this sooner rather than later means the database size can safely
! 2663: ** re-read the database size from page 1 if a savepoint or transaction
! 2664: ** rollback occurs within the transaction.
! 2665: */
! 2666: if( pBt->nPage!=get4byte(&pPage1->aData[28]) ){
! 2667: rc = sqlite3PagerWrite(pPage1->pDbPage);
! 2668: if( rc==SQLITE_OK ){
! 2669: put4byte(&pPage1->aData[28], pBt->nPage);
! 2670: }
! 2671: }
! 2672: }
! 2673: }
! 2674:
! 2675:
! 2676: trans_begun:
! 2677: if( rc==SQLITE_OK && wrflag ){
! 2678: /* This call makes sure that the pager has the correct number of
! 2679: ** open savepoints. If the second parameter is greater than 0 and
! 2680: ** the sub-journal is not already open, then it will be opened here.
! 2681: */
! 2682: rc = sqlite3PagerOpenSavepoint(pBt->pPager, p->db->nSavepoint);
! 2683: }
! 2684:
! 2685: btreeIntegrity(p);
! 2686: sqlite3BtreeLeave(p);
! 2687: return rc;
! 2688: }
! 2689:
! 2690: #ifndef SQLITE_OMIT_AUTOVACUUM
! 2691:
! 2692: /*
! 2693: ** Set the pointer-map entries for all children of page pPage. Also, if
! 2694: ** pPage contains cells that point to overflow pages, set the pointer
! 2695: ** map entries for the overflow pages as well.
! 2696: */
! 2697: static int setChildPtrmaps(MemPage *pPage){
! 2698: int i; /* Counter variable */
! 2699: int nCell; /* Number of cells in page pPage */
! 2700: int rc; /* Return code */
! 2701: BtShared *pBt = pPage->pBt;
! 2702: u8 isInitOrig = pPage->isInit;
! 2703: Pgno pgno = pPage->pgno;
! 2704:
! 2705: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
! 2706: rc = btreeInitPage(pPage);
! 2707: if( rc!=SQLITE_OK ){
! 2708: goto set_child_ptrmaps_out;
! 2709: }
! 2710: nCell = pPage->nCell;
! 2711:
! 2712: for(i=0; i<nCell; i++){
! 2713: u8 *pCell = findCell(pPage, i);
! 2714:
! 2715: ptrmapPutOvflPtr(pPage, pCell, &rc);
! 2716:
! 2717: if( !pPage->leaf ){
! 2718: Pgno childPgno = get4byte(pCell);
! 2719: ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
! 2720: }
! 2721: }
! 2722:
! 2723: if( !pPage->leaf ){
! 2724: Pgno childPgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
! 2725: ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
! 2726: }
! 2727:
! 2728: set_child_ptrmaps_out:
! 2729: pPage->isInit = isInitOrig;
! 2730: return rc;
! 2731: }
! 2732:
! 2733: /*
! 2734: ** Somewhere on pPage is a pointer to page iFrom. Modify this pointer so
! 2735: ** that it points to iTo. Parameter eType describes the type of pointer to
! 2736: ** be modified, as follows:
! 2737: **
! 2738: ** PTRMAP_BTREE: pPage is a btree-page. The pointer points at a child
! 2739: ** page of pPage.
! 2740: **
! 2741: ** PTRMAP_OVERFLOW1: pPage is a btree-page. The pointer points at an overflow
! 2742: ** page pointed to by one of the cells on pPage.
! 2743: **
! 2744: ** PTRMAP_OVERFLOW2: pPage is an overflow-page. The pointer points at the next
! 2745: ** overflow page in the list.
! 2746: */
! 2747: static int modifyPagePointer(MemPage *pPage, Pgno iFrom, Pgno iTo, u8 eType){
! 2748: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
! 2749: assert( sqlite3PagerIswriteable(pPage->pDbPage) );
! 2750: if( eType==PTRMAP_OVERFLOW2 ){
! 2751: /* The pointer is always the first 4 bytes of the page in this case. */
! 2752: if( get4byte(pPage->aData)!=iFrom ){
! 2753: return SQLITE_CORRUPT_BKPT;
! 2754: }
! 2755: put4byte(pPage->aData, iTo);
! 2756: }else{
! 2757: u8 isInitOrig = pPage->isInit;
! 2758: int i;
! 2759: int nCell;
! 2760:
! 2761: btreeInitPage(pPage);
! 2762: nCell = pPage->nCell;
! 2763:
! 2764: for(i=0; i<nCell; i++){
! 2765: u8 *pCell = findCell(pPage, i);
! 2766: if( eType==PTRMAP_OVERFLOW1 ){
! 2767: CellInfo info;
! 2768: btreeParseCellPtr(pPage, pCell, &info);
! 2769: if( info.iOverflow
! 2770: && pCell+info.iOverflow+3<=pPage->aData+pPage->maskPage
! 2771: && iFrom==get4byte(&pCell[info.iOverflow])
! 2772: ){
! 2773: put4byte(&pCell[info.iOverflow], iTo);
! 2774: break;
! 2775: }
! 2776: }else{
! 2777: if( get4byte(pCell)==iFrom ){
! 2778: put4byte(pCell, iTo);
! 2779: break;
! 2780: }
! 2781: }
! 2782: }
! 2783:
! 2784: if( i==nCell ){
! 2785: if( eType!=PTRMAP_BTREE ||
! 2786: get4byte(&pPage->aData[pPage->hdrOffset+8])!=iFrom ){
! 2787: return SQLITE_CORRUPT_BKPT;
! 2788: }
! 2789: put4byte(&pPage->aData[pPage->hdrOffset+8], iTo);
! 2790: }
! 2791:
! 2792: pPage->isInit = isInitOrig;
! 2793: }
! 2794: return SQLITE_OK;
! 2795: }
! 2796:
! 2797:
! 2798: /*
! 2799: ** Move the open database page pDbPage to location iFreePage in the
! 2800: ** database. The pDbPage reference remains valid.
! 2801: **
! 2802: ** The isCommit flag indicates that there is no need to remember that
! 2803: ** the journal needs to be sync()ed before database page pDbPage->pgno
! 2804: ** can be written to. The caller has already promised not to write to that
! 2805: ** page.
! 2806: */
! 2807: static int relocatePage(
! 2808: BtShared *pBt, /* Btree */
! 2809: MemPage *pDbPage, /* Open page to move */
! 2810: u8 eType, /* Pointer map 'type' entry for pDbPage */
! 2811: Pgno iPtrPage, /* Pointer map 'page-no' entry for pDbPage */
! 2812: Pgno iFreePage, /* The location to move pDbPage to */
! 2813: int isCommit /* isCommit flag passed to sqlite3PagerMovepage */
! 2814: ){
! 2815: MemPage *pPtrPage; /* The page that contains a pointer to pDbPage */
! 2816: Pgno iDbPage = pDbPage->pgno;
! 2817: Pager *pPager = pBt->pPager;
! 2818: int rc;
! 2819:
! 2820: assert( eType==PTRMAP_OVERFLOW2 || eType==PTRMAP_OVERFLOW1 ||
! 2821: eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE );
! 2822: assert( sqlite3_mutex_held(pBt->mutex) );
! 2823: assert( pDbPage->pBt==pBt );
! 2824:
! 2825: /* Move page iDbPage from its current location to page number iFreePage */
! 2826: TRACE(("AUTOVACUUM: Moving %d to free page %d (ptr page %d type %d)\n",
! 2827: iDbPage, iFreePage, iPtrPage, eType));
! 2828: rc = sqlite3PagerMovepage(pPager, pDbPage->pDbPage, iFreePage, isCommit);
! 2829: if( rc!=SQLITE_OK ){
! 2830: return rc;
! 2831: }
! 2832: pDbPage->pgno = iFreePage;
! 2833:
! 2834: /* If pDbPage was a btree-page, then it may have child pages and/or cells
! 2835: ** that point to overflow pages. The pointer map entries for all these
! 2836: ** pages need to be changed.
! 2837: **
! 2838: ** If pDbPage is an overflow page, then the first 4 bytes may store a
! 2839: ** pointer to a subsequent overflow page. If this is the case, then
! 2840: ** the pointer map needs to be updated for the subsequent overflow page.
! 2841: */
! 2842: if( eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE ){
! 2843: rc = setChildPtrmaps(pDbPage);
! 2844: if( rc!=SQLITE_OK ){
! 2845: return rc;
! 2846: }
! 2847: }else{
! 2848: Pgno nextOvfl = get4byte(pDbPage->aData);
! 2849: if( nextOvfl!=0 ){
! 2850: ptrmapPut(pBt, nextOvfl, PTRMAP_OVERFLOW2, iFreePage, &rc);
! 2851: if( rc!=SQLITE_OK ){
! 2852: return rc;
! 2853: }
! 2854: }
! 2855: }
! 2856:
! 2857: /* Fix the database pointer on page iPtrPage that pointed at iDbPage so
! 2858: ** that it points at iFreePage. Also fix the pointer map entry for
! 2859: ** iPtrPage.
! 2860: */
! 2861: if( eType!=PTRMAP_ROOTPAGE ){
! 2862: rc = btreeGetPage(pBt, iPtrPage, &pPtrPage, 0);
! 2863: if( rc!=SQLITE_OK ){
! 2864: return rc;
! 2865: }
! 2866: rc = sqlite3PagerWrite(pPtrPage->pDbPage);
! 2867: if( rc!=SQLITE_OK ){
! 2868: releasePage(pPtrPage);
! 2869: return rc;
! 2870: }
! 2871: rc = modifyPagePointer(pPtrPage, iDbPage, iFreePage, eType);
! 2872: releasePage(pPtrPage);
! 2873: if( rc==SQLITE_OK ){
! 2874: ptrmapPut(pBt, iFreePage, eType, iPtrPage, &rc);
! 2875: }
! 2876: }
! 2877: return rc;
! 2878: }
! 2879:
! 2880: /* Forward declaration required by incrVacuumStep(). */
! 2881: static int allocateBtreePage(BtShared *, MemPage **, Pgno *, Pgno, u8);
! 2882:
! 2883: /*
! 2884: ** Perform a single step of an incremental-vacuum. If successful,
! 2885: ** return SQLITE_OK. If there is no work to do (and therefore no
! 2886: ** point in calling this function again), return SQLITE_DONE.
! 2887: **
! 2888: ** More specificly, this function attempts to re-organize the
! 2889: ** database so that the last page of the file currently in use
! 2890: ** is no longer in use.
! 2891: **
! 2892: ** If the nFin parameter is non-zero, this function assumes
! 2893: ** that the caller will keep calling incrVacuumStep() until
! 2894: ** it returns SQLITE_DONE or an error, and that nFin is the
! 2895: ** number of pages the database file will contain after this
! 2896: ** process is complete. If nFin is zero, it is assumed that
! 2897: ** incrVacuumStep() will be called a finite amount of times
! 2898: ** which may or may not empty the freelist. A full autovacuum
! 2899: ** has nFin>0. A "PRAGMA incremental_vacuum" has nFin==0.
! 2900: */
! 2901: static int incrVacuumStep(BtShared *pBt, Pgno nFin, Pgno iLastPg){
! 2902: Pgno nFreeList; /* Number of pages still on the free-list */
! 2903: int rc;
! 2904:
! 2905: assert( sqlite3_mutex_held(pBt->mutex) );
! 2906: assert( iLastPg>nFin );
! 2907:
! 2908: if( !PTRMAP_ISPAGE(pBt, iLastPg) && iLastPg!=PENDING_BYTE_PAGE(pBt) ){
! 2909: u8 eType;
! 2910: Pgno iPtrPage;
! 2911:
! 2912: nFreeList = get4byte(&pBt->pPage1->aData[36]);
! 2913: if( nFreeList==0 ){
! 2914: return SQLITE_DONE;
! 2915: }
! 2916:
! 2917: rc = ptrmapGet(pBt, iLastPg, &eType, &iPtrPage);
! 2918: if( rc!=SQLITE_OK ){
! 2919: return rc;
! 2920: }
! 2921: if( eType==PTRMAP_ROOTPAGE ){
! 2922: return SQLITE_CORRUPT_BKPT;
! 2923: }
! 2924:
! 2925: if( eType==PTRMAP_FREEPAGE ){
! 2926: if( nFin==0 ){
! 2927: /* Remove the page from the files free-list. This is not required
! 2928: ** if nFin is non-zero. In that case, the free-list will be
! 2929: ** truncated to zero after this function returns, so it doesn't
! 2930: ** matter if it still contains some garbage entries.
! 2931: */
! 2932: Pgno iFreePg;
! 2933: MemPage *pFreePg;
! 2934: rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, iLastPg, 1);
! 2935: if( rc!=SQLITE_OK ){
! 2936: return rc;
! 2937: }
! 2938: assert( iFreePg==iLastPg );
! 2939: releasePage(pFreePg);
! 2940: }
! 2941: } else {
! 2942: Pgno iFreePg; /* Index of free page to move pLastPg to */
! 2943: MemPage *pLastPg;
! 2944:
! 2945: rc = btreeGetPage(pBt, iLastPg, &pLastPg, 0);
! 2946: if( rc!=SQLITE_OK ){
! 2947: return rc;
! 2948: }
! 2949:
! 2950: /* If nFin is zero, this loop runs exactly once and page pLastPg
! 2951: ** is swapped with the first free page pulled off the free list.
! 2952: **
! 2953: ** On the other hand, if nFin is greater than zero, then keep
! 2954: ** looping until a free-page located within the first nFin pages
! 2955: ** of the file is found.
! 2956: */
! 2957: do {
! 2958: MemPage *pFreePg;
! 2959: rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, 0, 0);
! 2960: if( rc!=SQLITE_OK ){
! 2961: releasePage(pLastPg);
! 2962: return rc;
! 2963: }
! 2964: releasePage(pFreePg);
! 2965: }while( nFin!=0 && iFreePg>nFin );
! 2966: assert( iFreePg<iLastPg );
! 2967:
! 2968: rc = sqlite3PagerWrite(pLastPg->pDbPage);
! 2969: if( rc==SQLITE_OK ){
! 2970: rc = relocatePage(pBt, pLastPg, eType, iPtrPage, iFreePg, nFin!=0);
! 2971: }
! 2972: releasePage(pLastPg);
! 2973: if( rc!=SQLITE_OK ){
! 2974: return rc;
! 2975: }
! 2976: }
! 2977: }
! 2978:
! 2979: if( nFin==0 ){
! 2980: iLastPg--;
! 2981: while( iLastPg==PENDING_BYTE_PAGE(pBt)||PTRMAP_ISPAGE(pBt, iLastPg) ){
! 2982: if( PTRMAP_ISPAGE(pBt, iLastPg) ){
! 2983: MemPage *pPg;
! 2984: rc = btreeGetPage(pBt, iLastPg, &pPg, 0);
! 2985: if( rc!=SQLITE_OK ){
! 2986: return rc;
! 2987: }
! 2988: rc = sqlite3PagerWrite(pPg->pDbPage);
! 2989: releasePage(pPg);
! 2990: if( rc!=SQLITE_OK ){
! 2991: return rc;
! 2992: }
! 2993: }
! 2994: iLastPg--;
! 2995: }
! 2996: sqlite3PagerTruncateImage(pBt->pPager, iLastPg);
! 2997: pBt->nPage = iLastPg;
! 2998: }
! 2999: return SQLITE_OK;
! 3000: }
! 3001:
! 3002: /*
! 3003: ** A write-transaction must be opened before calling this function.
! 3004: ** It performs a single unit of work towards an incremental vacuum.
! 3005: **
! 3006: ** If the incremental vacuum is finished after this function has run,
! 3007: ** SQLITE_DONE is returned. If it is not finished, but no error occurred,
! 3008: ** SQLITE_OK is returned. Otherwise an SQLite error code.
! 3009: */
! 3010: int sqlite3BtreeIncrVacuum(Btree *p){
! 3011: int rc;
! 3012: BtShared *pBt = p->pBt;
! 3013:
! 3014: sqlite3BtreeEnter(p);
! 3015: assert( pBt->inTransaction==TRANS_WRITE && p->inTrans==TRANS_WRITE );
! 3016: if( !pBt->autoVacuum ){
! 3017: rc = SQLITE_DONE;
! 3018: }else{
! 3019: invalidateAllOverflowCache(pBt);
! 3020: rc = incrVacuumStep(pBt, 0, btreePagecount(pBt));
! 3021: if( rc==SQLITE_OK ){
! 3022: rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
! 3023: put4byte(&pBt->pPage1->aData[28], pBt->nPage);
! 3024: }
! 3025: }
! 3026: sqlite3BtreeLeave(p);
! 3027: return rc;
! 3028: }
! 3029:
! 3030: /*
! 3031: ** This routine is called prior to sqlite3PagerCommit when a transaction
! 3032: ** is commited for an auto-vacuum database.
! 3033: **
! 3034: ** If SQLITE_OK is returned, then *pnTrunc is set to the number of pages
! 3035: ** the database file should be truncated to during the commit process.
! 3036: ** i.e. the database has been reorganized so that only the first *pnTrunc
! 3037: ** pages are in use.
! 3038: */
! 3039: static int autoVacuumCommit(BtShared *pBt){
! 3040: int rc = SQLITE_OK;
! 3041: Pager *pPager = pBt->pPager;
! 3042: VVA_ONLY( int nRef = sqlite3PagerRefcount(pPager) );
! 3043:
! 3044: assert( sqlite3_mutex_held(pBt->mutex) );
! 3045: invalidateAllOverflowCache(pBt);
! 3046: assert(pBt->autoVacuum);
! 3047: if( !pBt->incrVacuum ){
! 3048: Pgno nFin; /* Number of pages in database after autovacuuming */
! 3049: Pgno nFree; /* Number of pages on the freelist initially */
! 3050: Pgno nPtrmap; /* Number of PtrMap pages to be freed */
! 3051: Pgno iFree; /* The next page to be freed */
! 3052: int nEntry; /* Number of entries on one ptrmap page */
! 3053: Pgno nOrig; /* Database size before freeing */
! 3054:
! 3055: nOrig = btreePagecount(pBt);
! 3056: if( PTRMAP_ISPAGE(pBt, nOrig) || nOrig==PENDING_BYTE_PAGE(pBt) ){
! 3057: /* It is not possible to create a database for which the final page
! 3058: ** is either a pointer-map page or the pending-byte page. If one
! 3059: ** is encountered, this indicates corruption.
! 3060: */
! 3061: return SQLITE_CORRUPT_BKPT;
! 3062: }
! 3063:
! 3064: nFree = get4byte(&pBt->pPage1->aData[36]);
! 3065: nEntry = pBt->usableSize/5;
! 3066: nPtrmap = (nFree-nOrig+PTRMAP_PAGENO(pBt, nOrig)+nEntry)/nEntry;
! 3067: nFin = nOrig - nFree - nPtrmap;
! 3068: if( nOrig>PENDING_BYTE_PAGE(pBt) && nFin<PENDING_BYTE_PAGE(pBt) ){
! 3069: nFin--;
! 3070: }
! 3071: while( PTRMAP_ISPAGE(pBt, nFin) || nFin==PENDING_BYTE_PAGE(pBt) ){
! 3072: nFin--;
! 3073: }
! 3074: if( nFin>nOrig ) return SQLITE_CORRUPT_BKPT;
! 3075:
! 3076: for(iFree=nOrig; iFree>nFin && rc==SQLITE_OK; iFree--){
! 3077: rc = incrVacuumStep(pBt, nFin, iFree);
! 3078: }
! 3079: if( (rc==SQLITE_DONE || rc==SQLITE_OK) && nFree>0 ){
! 3080: rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
! 3081: put4byte(&pBt->pPage1->aData[32], 0);
! 3082: put4byte(&pBt->pPage1->aData[36], 0);
! 3083: put4byte(&pBt->pPage1->aData[28], nFin);
! 3084: sqlite3PagerTruncateImage(pBt->pPager, nFin);
! 3085: pBt->nPage = nFin;
! 3086: }
! 3087: if( rc!=SQLITE_OK ){
! 3088: sqlite3PagerRollback(pPager);
! 3089: }
! 3090: }
! 3091:
! 3092: assert( nRef==sqlite3PagerRefcount(pPager) );
! 3093: return rc;
! 3094: }
! 3095:
! 3096: #else /* ifndef SQLITE_OMIT_AUTOVACUUM */
! 3097: # define setChildPtrmaps(x) SQLITE_OK
! 3098: #endif
! 3099:
! 3100: /*
! 3101: ** This routine does the first phase of a two-phase commit. This routine
! 3102: ** causes a rollback journal to be created (if it does not already exist)
! 3103: ** and populated with enough information so that if a power loss occurs
! 3104: ** the database can be restored to its original state by playing back
! 3105: ** the journal. Then the contents of the journal are flushed out to
! 3106: ** the disk. After the journal is safely on oxide, the changes to the
! 3107: ** database are written into the database file and flushed to oxide.
! 3108: ** At the end of this call, the rollback journal still exists on the
! 3109: ** disk and we are still holding all locks, so the transaction has not
! 3110: ** committed. See sqlite3BtreeCommitPhaseTwo() for the second phase of the
! 3111: ** commit process.
! 3112: **
! 3113: ** This call is a no-op if no write-transaction is currently active on pBt.
! 3114: **
! 3115: ** Otherwise, sync the database file for the btree pBt. zMaster points to
! 3116: ** the name of a master journal file that should be written into the
! 3117: ** individual journal file, or is NULL, indicating no master journal file
! 3118: ** (single database transaction).
! 3119: **
! 3120: ** When this is called, the master journal should already have been
! 3121: ** created, populated with this journal pointer and synced to disk.
! 3122: **
! 3123: ** Once this is routine has returned, the only thing required to commit
! 3124: ** the write-transaction for this database file is to delete the journal.
! 3125: */
! 3126: int sqlite3BtreeCommitPhaseOne(Btree *p, const char *zMaster){
! 3127: int rc = SQLITE_OK;
! 3128: if( p->inTrans==TRANS_WRITE ){
! 3129: BtShared *pBt = p->pBt;
! 3130: sqlite3BtreeEnter(p);
! 3131: #ifndef SQLITE_OMIT_AUTOVACUUM
! 3132: if( pBt->autoVacuum ){
! 3133: rc = autoVacuumCommit(pBt);
! 3134: if( rc!=SQLITE_OK ){
! 3135: sqlite3BtreeLeave(p);
! 3136: return rc;
! 3137: }
! 3138: }
! 3139: #endif
! 3140: rc = sqlite3PagerCommitPhaseOne(pBt->pPager, zMaster, 0);
! 3141: sqlite3BtreeLeave(p);
! 3142: }
! 3143: return rc;
! 3144: }
! 3145:
! 3146: /*
! 3147: ** This function is called from both BtreeCommitPhaseTwo() and BtreeRollback()
! 3148: ** at the conclusion of a transaction.
! 3149: */
! 3150: static void btreeEndTransaction(Btree *p){
! 3151: BtShared *pBt = p->pBt;
! 3152: assert( sqlite3BtreeHoldsMutex(p) );
! 3153:
! 3154: btreeClearHasContent(pBt);
! 3155: if( p->inTrans>TRANS_NONE && p->db->activeVdbeCnt>1 ){
! 3156: /* If there are other active statements that belong to this database
! 3157: ** handle, downgrade to a read-only transaction. The other statements
! 3158: ** may still be reading from the database. */
! 3159: downgradeAllSharedCacheTableLocks(p);
! 3160: p->inTrans = TRANS_READ;
! 3161: }else{
! 3162: /* If the handle had any kind of transaction open, decrement the
! 3163: ** transaction count of the shared btree. If the transaction count
! 3164: ** reaches 0, set the shared state to TRANS_NONE. The unlockBtreeIfUnused()
! 3165: ** call below will unlock the pager. */
! 3166: if( p->inTrans!=TRANS_NONE ){
! 3167: clearAllSharedCacheTableLocks(p);
! 3168: pBt->nTransaction--;
! 3169: if( 0==pBt->nTransaction ){
! 3170: pBt->inTransaction = TRANS_NONE;
! 3171: }
! 3172: }
! 3173:
! 3174: /* Set the current transaction state to TRANS_NONE and unlock the
! 3175: ** pager if this call closed the only read or write transaction. */
! 3176: p->inTrans = TRANS_NONE;
! 3177: unlockBtreeIfUnused(pBt);
! 3178: }
! 3179:
! 3180: btreeIntegrity(p);
! 3181: }
! 3182:
! 3183: /*
! 3184: ** Commit the transaction currently in progress.
! 3185: **
! 3186: ** This routine implements the second phase of a 2-phase commit. The
! 3187: ** sqlite3BtreeCommitPhaseOne() routine does the first phase and should
! 3188: ** be invoked prior to calling this routine. The sqlite3BtreeCommitPhaseOne()
! 3189: ** routine did all the work of writing information out to disk and flushing the
! 3190: ** contents so that they are written onto the disk platter. All this
! 3191: ** routine has to do is delete or truncate or zero the header in the
! 3192: ** the rollback journal (which causes the transaction to commit) and
! 3193: ** drop locks.
! 3194: **
! 3195: ** Normally, if an error occurs while the pager layer is attempting to
! 3196: ** finalize the underlying journal file, this function returns an error and
! 3197: ** the upper layer will attempt a rollback. However, if the second argument
! 3198: ** is non-zero then this b-tree transaction is part of a multi-file
! 3199: ** transaction. In this case, the transaction has already been committed
! 3200: ** (by deleting a master journal file) and the caller will ignore this
! 3201: ** functions return code. So, even if an error occurs in the pager layer,
! 3202: ** reset the b-tree objects internal state to indicate that the write
! 3203: ** transaction has been closed. This is quite safe, as the pager will have
! 3204: ** transitioned to the error state.
! 3205: **
! 3206: ** This will release the write lock on the database file. If there
! 3207: ** are no active cursors, it also releases the read lock.
! 3208: */
! 3209: int sqlite3BtreeCommitPhaseTwo(Btree *p, int bCleanup){
! 3210:
! 3211: if( p->inTrans==TRANS_NONE ) return SQLITE_OK;
! 3212: sqlite3BtreeEnter(p);
! 3213: btreeIntegrity(p);
! 3214:
! 3215: /* If the handle has a write-transaction open, commit the shared-btrees
! 3216: ** transaction and set the shared state to TRANS_READ.
! 3217: */
! 3218: if( p->inTrans==TRANS_WRITE ){
! 3219: int rc;
! 3220: BtShared *pBt = p->pBt;
! 3221: assert( pBt->inTransaction==TRANS_WRITE );
! 3222: assert( pBt->nTransaction>0 );
! 3223: rc = sqlite3PagerCommitPhaseTwo(pBt->pPager);
! 3224: if( rc!=SQLITE_OK && bCleanup==0 ){
! 3225: sqlite3BtreeLeave(p);
! 3226: return rc;
! 3227: }
! 3228: pBt->inTransaction = TRANS_READ;
! 3229: }
! 3230:
! 3231: btreeEndTransaction(p);
! 3232: sqlite3BtreeLeave(p);
! 3233: return SQLITE_OK;
! 3234: }
! 3235:
! 3236: /*
! 3237: ** Do both phases of a commit.
! 3238: */
! 3239: int sqlite3BtreeCommit(Btree *p){
! 3240: int rc;
! 3241: sqlite3BtreeEnter(p);
! 3242: rc = sqlite3BtreeCommitPhaseOne(p, 0);
! 3243: if( rc==SQLITE_OK ){
! 3244: rc = sqlite3BtreeCommitPhaseTwo(p, 0);
! 3245: }
! 3246: sqlite3BtreeLeave(p);
! 3247: return rc;
! 3248: }
! 3249:
! 3250: #ifndef NDEBUG
! 3251: /*
! 3252: ** Return the number of write-cursors open on this handle. This is for use
! 3253: ** in assert() expressions, so it is only compiled if NDEBUG is not
! 3254: ** defined.
! 3255: **
! 3256: ** For the purposes of this routine, a write-cursor is any cursor that
! 3257: ** is capable of writing to the databse. That means the cursor was
! 3258: ** originally opened for writing and the cursor has not be disabled
! 3259: ** by having its state changed to CURSOR_FAULT.
! 3260: */
! 3261: static int countWriteCursors(BtShared *pBt){
! 3262: BtCursor *pCur;
! 3263: int r = 0;
! 3264: for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
! 3265: if( pCur->wrFlag && pCur->eState!=CURSOR_FAULT ) r++;
! 3266: }
! 3267: return r;
! 3268: }
! 3269: #endif
! 3270:
! 3271: /*
! 3272: ** This routine sets the state to CURSOR_FAULT and the error
! 3273: ** code to errCode for every cursor on BtShared that pBtree
! 3274: ** references.
! 3275: **
! 3276: ** Every cursor is tripped, including cursors that belong
! 3277: ** to other database connections that happen to be sharing
! 3278: ** the cache with pBtree.
! 3279: **
! 3280: ** This routine gets called when a rollback occurs.
! 3281: ** All cursors using the same cache must be tripped
! 3282: ** to prevent them from trying to use the btree after
! 3283: ** the rollback. The rollback may have deleted tables
! 3284: ** or moved root pages, so it is not sufficient to
! 3285: ** save the state of the cursor. The cursor must be
! 3286: ** invalidated.
! 3287: */
! 3288: void sqlite3BtreeTripAllCursors(Btree *pBtree, int errCode){
! 3289: BtCursor *p;
! 3290: sqlite3BtreeEnter(pBtree);
! 3291: for(p=pBtree->pBt->pCursor; p; p=p->pNext){
! 3292: int i;
! 3293: sqlite3BtreeClearCursor(p);
! 3294: p->eState = CURSOR_FAULT;
! 3295: p->skipNext = errCode;
! 3296: for(i=0; i<=p->iPage; i++){
! 3297: releasePage(p->apPage[i]);
! 3298: p->apPage[i] = 0;
! 3299: }
! 3300: }
! 3301: sqlite3BtreeLeave(pBtree);
! 3302: }
! 3303:
! 3304: /*
! 3305: ** Rollback the transaction in progress. All cursors will be
! 3306: ** invalided by this operation. Any attempt to use a cursor
! 3307: ** that was open at the beginning of this operation will result
! 3308: ** in an error.
! 3309: **
! 3310: ** This will release the write lock on the database file. If there
! 3311: ** are no active cursors, it also releases the read lock.
! 3312: */
! 3313: int sqlite3BtreeRollback(Btree *p){
! 3314: int rc;
! 3315: BtShared *pBt = p->pBt;
! 3316: MemPage *pPage1;
! 3317:
! 3318: sqlite3BtreeEnter(p);
! 3319: rc = saveAllCursors(pBt, 0, 0);
! 3320: #ifndef SQLITE_OMIT_SHARED_CACHE
! 3321: if( rc!=SQLITE_OK ){
! 3322: /* This is a horrible situation. An IO or malloc() error occurred whilst
! 3323: ** trying to save cursor positions. If this is an automatic rollback (as
! 3324: ** the result of a constraint, malloc() failure or IO error) then
! 3325: ** the cache may be internally inconsistent (not contain valid trees) so
! 3326: ** we cannot simply return the error to the caller. Instead, abort
! 3327: ** all queries that may be using any of the cursors that failed to save.
! 3328: */
! 3329: sqlite3BtreeTripAllCursors(p, rc);
! 3330: }
! 3331: #endif
! 3332: btreeIntegrity(p);
! 3333:
! 3334: if( p->inTrans==TRANS_WRITE ){
! 3335: int rc2;
! 3336:
! 3337: assert( TRANS_WRITE==pBt->inTransaction );
! 3338: rc2 = sqlite3PagerRollback(pBt->pPager);
! 3339: if( rc2!=SQLITE_OK ){
! 3340: rc = rc2;
! 3341: }
! 3342:
! 3343: /* The rollback may have destroyed the pPage1->aData value. So
! 3344: ** call btreeGetPage() on page 1 again to make
! 3345: ** sure pPage1->aData is set correctly. */
! 3346: if( btreeGetPage(pBt, 1, &pPage1, 0)==SQLITE_OK ){
! 3347: int nPage = get4byte(28+(u8*)pPage1->aData);
! 3348: testcase( nPage==0 );
! 3349: if( nPage==0 ) sqlite3PagerPagecount(pBt->pPager, &nPage);
! 3350: testcase( pBt->nPage!=nPage );
! 3351: pBt->nPage = nPage;
! 3352: releasePage(pPage1);
! 3353: }
! 3354: assert( countWriteCursors(pBt)==0 );
! 3355: pBt->inTransaction = TRANS_READ;
! 3356: }
! 3357:
! 3358: btreeEndTransaction(p);
! 3359: sqlite3BtreeLeave(p);
! 3360: return rc;
! 3361: }
! 3362:
! 3363: /*
! 3364: ** Start a statement subtransaction. The subtransaction can can be rolled
! 3365: ** back independently of the main transaction. You must start a transaction
! 3366: ** before starting a subtransaction. The subtransaction is ended automatically
! 3367: ** if the main transaction commits or rolls back.
! 3368: **
! 3369: ** Statement subtransactions are used around individual SQL statements
! 3370: ** that are contained within a BEGIN...COMMIT block. If a constraint
! 3371: ** error occurs within the statement, the effect of that one statement
! 3372: ** can be rolled back without having to rollback the entire transaction.
! 3373: **
! 3374: ** A statement sub-transaction is implemented as an anonymous savepoint. The
! 3375: ** value passed as the second parameter is the total number of savepoints,
! 3376: ** including the new anonymous savepoint, open on the B-Tree. i.e. if there
! 3377: ** are no active savepoints and no other statement-transactions open,
! 3378: ** iStatement is 1. This anonymous savepoint can be released or rolled back
! 3379: ** using the sqlite3BtreeSavepoint() function.
! 3380: */
! 3381: int sqlite3BtreeBeginStmt(Btree *p, int iStatement){
! 3382: int rc;
! 3383: BtShared *pBt = p->pBt;
! 3384: sqlite3BtreeEnter(p);
! 3385: assert( p->inTrans==TRANS_WRITE );
! 3386: assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
! 3387: assert( iStatement>0 );
! 3388: assert( iStatement>p->db->nSavepoint );
! 3389: assert( pBt->inTransaction==TRANS_WRITE );
! 3390: /* At the pager level, a statement transaction is a savepoint with
! 3391: ** an index greater than all savepoints created explicitly using
! 3392: ** SQL statements. It is illegal to open, release or rollback any
! 3393: ** such savepoints while the statement transaction savepoint is active.
! 3394: */
! 3395: rc = sqlite3PagerOpenSavepoint(pBt->pPager, iStatement);
! 3396: sqlite3BtreeLeave(p);
! 3397: return rc;
! 3398: }
! 3399:
! 3400: /*
! 3401: ** The second argument to this function, op, is always SAVEPOINT_ROLLBACK
! 3402: ** or SAVEPOINT_RELEASE. This function either releases or rolls back the
! 3403: ** savepoint identified by parameter iSavepoint, depending on the value
! 3404: ** of op.
! 3405: **
! 3406: ** Normally, iSavepoint is greater than or equal to zero. However, if op is
! 3407: ** SAVEPOINT_ROLLBACK, then iSavepoint may also be -1. In this case the
! 3408: ** contents of the entire transaction are rolled back. This is different
! 3409: ** from a normal transaction rollback, as no locks are released and the
! 3410: ** transaction remains open.
! 3411: */
! 3412: int sqlite3BtreeSavepoint(Btree *p, int op, int iSavepoint){
! 3413: int rc = SQLITE_OK;
! 3414: if( p && p->inTrans==TRANS_WRITE ){
! 3415: BtShared *pBt = p->pBt;
! 3416: assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
! 3417: assert( iSavepoint>=0 || (iSavepoint==-1 && op==SAVEPOINT_ROLLBACK) );
! 3418: sqlite3BtreeEnter(p);
! 3419: rc = sqlite3PagerSavepoint(pBt->pPager, op, iSavepoint);
! 3420: if( rc==SQLITE_OK ){
! 3421: if( iSavepoint<0 && (pBt->btsFlags & BTS_INITIALLY_EMPTY)!=0 ){
! 3422: pBt->nPage = 0;
! 3423: }
! 3424: rc = newDatabase(pBt);
! 3425: pBt->nPage = get4byte(28 + pBt->pPage1->aData);
! 3426:
! 3427: /* The database size was written into the offset 28 of the header
! 3428: ** when the transaction started, so we know that the value at offset
! 3429: ** 28 is nonzero. */
! 3430: assert( pBt->nPage>0 );
! 3431: }
! 3432: sqlite3BtreeLeave(p);
! 3433: }
! 3434: return rc;
! 3435: }
! 3436:
! 3437: /*
! 3438: ** Create a new cursor for the BTree whose root is on the page
! 3439: ** iTable. If a read-only cursor is requested, it is assumed that
! 3440: ** the caller already has at least a read-only transaction open
! 3441: ** on the database already. If a write-cursor is requested, then
! 3442: ** the caller is assumed to have an open write transaction.
! 3443: **
! 3444: ** If wrFlag==0, then the cursor can only be used for reading.
! 3445: ** If wrFlag==1, then the cursor can be used for reading or for
! 3446: ** writing if other conditions for writing are also met. These
! 3447: ** are the conditions that must be met in order for writing to
! 3448: ** be allowed:
! 3449: **
! 3450: ** 1: The cursor must have been opened with wrFlag==1
! 3451: **
! 3452: ** 2: Other database connections that share the same pager cache
! 3453: ** but which are not in the READ_UNCOMMITTED state may not have
! 3454: ** cursors open with wrFlag==0 on the same table. Otherwise
! 3455: ** the changes made by this write cursor would be visible to
! 3456: ** the read cursors in the other database connection.
! 3457: **
! 3458: ** 3: The database must be writable (not on read-only media)
! 3459: **
! 3460: ** 4: There must be an active transaction.
! 3461: **
! 3462: ** No checking is done to make sure that page iTable really is the
! 3463: ** root page of a b-tree. If it is not, then the cursor acquired
! 3464: ** will not work correctly.
! 3465: **
! 3466: ** It is assumed that the sqlite3BtreeCursorZero() has been called
! 3467: ** on pCur to initialize the memory space prior to invoking this routine.
! 3468: */
! 3469: static int btreeCursor(
! 3470: Btree *p, /* The btree */
! 3471: int iTable, /* Root page of table to open */
! 3472: int wrFlag, /* 1 to write. 0 read-only */
! 3473: struct KeyInfo *pKeyInfo, /* First arg to comparison function */
! 3474: BtCursor *pCur /* Space for new cursor */
! 3475: ){
! 3476: BtShared *pBt = p->pBt; /* Shared b-tree handle */
! 3477:
! 3478: assert( sqlite3BtreeHoldsMutex(p) );
! 3479: assert( wrFlag==0 || wrFlag==1 );
! 3480:
! 3481: /* The following assert statements verify that if this is a sharable
! 3482: ** b-tree database, the connection is holding the required table locks,
! 3483: ** and that no other connection has any open cursor that conflicts with
! 3484: ** this lock. */
! 3485: assert( hasSharedCacheTableLock(p, iTable, pKeyInfo!=0, wrFlag+1) );
! 3486: assert( wrFlag==0 || !hasReadConflicts(p, iTable) );
! 3487:
! 3488: /* Assert that the caller has opened the required transaction. */
! 3489: assert( p->inTrans>TRANS_NONE );
! 3490: assert( wrFlag==0 || p->inTrans==TRANS_WRITE );
! 3491: assert( pBt->pPage1 && pBt->pPage1->aData );
! 3492:
! 3493: if( NEVER(wrFlag && (pBt->btsFlags & BTS_READ_ONLY)!=0) ){
! 3494: return SQLITE_READONLY;
! 3495: }
! 3496: if( iTable==1 && btreePagecount(pBt)==0 ){
! 3497: assert( wrFlag==0 );
! 3498: iTable = 0;
! 3499: }
! 3500:
! 3501: /* Now that no other errors can occur, finish filling in the BtCursor
! 3502: ** variables and link the cursor into the BtShared list. */
! 3503: pCur->pgnoRoot = (Pgno)iTable;
! 3504: pCur->iPage = -1;
! 3505: pCur->pKeyInfo = pKeyInfo;
! 3506: pCur->pBtree = p;
! 3507: pCur->pBt = pBt;
! 3508: pCur->wrFlag = (u8)wrFlag;
! 3509: pCur->pNext = pBt->pCursor;
! 3510: if( pCur->pNext ){
! 3511: pCur->pNext->pPrev = pCur;
! 3512: }
! 3513: pBt->pCursor = pCur;
! 3514: pCur->eState = CURSOR_INVALID;
! 3515: pCur->cachedRowid = 0;
! 3516: return SQLITE_OK;
! 3517: }
! 3518: int sqlite3BtreeCursor(
! 3519: Btree *p, /* The btree */
! 3520: int iTable, /* Root page of table to open */
! 3521: int wrFlag, /* 1 to write. 0 read-only */
! 3522: struct KeyInfo *pKeyInfo, /* First arg to xCompare() */
! 3523: BtCursor *pCur /* Write new cursor here */
! 3524: ){
! 3525: int rc;
! 3526: sqlite3BtreeEnter(p);
! 3527: rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
! 3528: sqlite3BtreeLeave(p);
! 3529: return rc;
! 3530: }
! 3531:
! 3532: /*
! 3533: ** Return the size of a BtCursor object in bytes.
! 3534: **
! 3535: ** This interfaces is needed so that users of cursors can preallocate
! 3536: ** sufficient storage to hold a cursor. The BtCursor object is opaque
! 3537: ** to users so they cannot do the sizeof() themselves - they must call
! 3538: ** this routine.
! 3539: */
! 3540: int sqlite3BtreeCursorSize(void){
! 3541: return ROUND8(sizeof(BtCursor));
! 3542: }
! 3543:
! 3544: /*
! 3545: ** Initialize memory that will be converted into a BtCursor object.
! 3546: **
! 3547: ** The simple approach here would be to memset() the entire object
! 3548: ** to zero. But it turns out that the apPage[] and aiIdx[] arrays
! 3549: ** do not need to be zeroed and they are large, so we can save a lot
! 3550: ** of run-time by skipping the initialization of those elements.
! 3551: */
! 3552: void sqlite3BtreeCursorZero(BtCursor *p){
! 3553: memset(p, 0, offsetof(BtCursor, iPage));
! 3554: }
! 3555:
! 3556: /*
! 3557: ** Set the cached rowid value of every cursor in the same database file
! 3558: ** as pCur and having the same root page number as pCur. The value is
! 3559: ** set to iRowid.
! 3560: **
! 3561: ** Only positive rowid values are considered valid for this cache.
! 3562: ** The cache is initialized to zero, indicating an invalid cache.
! 3563: ** A btree will work fine with zero or negative rowids. We just cannot
! 3564: ** cache zero or negative rowids, which means tables that use zero or
! 3565: ** negative rowids might run a little slower. But in practice, zero
! 3566: ** or negative rowids are very uncommon so this should not be a problem.
! 3567: */
! 3568: void sqlite3BtreeSetCachedRowid(BtCursor *pCur, sqlite3_int64 iRowid){
! 3569: BtCursor *p;
! 3570: for(p=pCur->pBt->pCursor; p; p=p->pNext){
! 3571: if( p->pgnoRoot==pCur->pgnoRoot ) p->cachedRowid = iRowid;
! 3572: }
! 3573: assert( pCur->cachedRowid==iRowid );
! 3574: }
! 3575:
! 3576: /*
! 3577: ** Return the cached rowid for the given cursor. A negative or zero
! 3578: ** return value indicates that the rowid cache is invalid and should be
! 3579: ** ignored. If the rowid cache has never before been set, then a
! 3580: ** zero is returned.
! 3581: */
! 3582: sqlite3_int64 sqlite3BtreeGetCachedRowid(BtCursor *pCur){
! 3583: return pCur->cachedRowid;
! 3584: }
! 3585:
! 3586: /*
! 3587: ** Close a cursor. The read lock on the database file is released
! 3588: ** when the last cursor is closed.
! 3589: */
! 3590: int sqlite3BtreeCloseCursor(BtCursor *pCur){
! 3591: Btree *pBtree = pCur->pBtree;
! 3592: if( pBtree ){
! 3593: int i;
! 3594: BtShared *pBt = pCur->pBt;
! 3595: sqlite3BtreeEnter(pBtree);
! 3596: sqlite3BtreeClearCursor(pCur);
! 3597: if( pCur->pPrev ){
! 3598: pCur->pPrev->pNext = pCur->pNext;
! 3599: }else{
! 3600: pBt->pCursor = pCur->pNext;
! 3601: }
! 3602: if( pCur->pNext ){
! 3603: pCur->pNext->pPrev = pCur->pPrev;
! 3604: }
! 3605: for(i=0; i<=pCur->iPage; i++){
! 3606: releasePage(pCur->apPage[i]);
! 3607: }
! 3608: unlockBtreeIfUnused(pBt);
! 3609: invalidateOverflowCache(pCur);
! 3610: /* sqlite3_free(pCur); */
! 3611: sqlite3BtreeLeave(pBtree);
! 3612: }
! 3613: return SQLITE_OK;
! 3614: }
! 3615:
! 3616: /*
! 3617: ** Make sure the BtCursor* given in the argument has a valid
! 3618: ** BtCursor.info structure. If it is not already valid, call
! 3619: ** btreeParseCell() to fill it in.
! 3620: **
! 3621: ** BtCursor.info is a cache of the information in the current cell.
! 3622: ** Using this cache reduces the number of calls to btreeParseCell().
! 3623: **
! 3624: ** 2007-06-25: There is a bug in some versions of MSVC that cause the
! 3625: ** compiler to crash when getCellInfo() is implemented as a macro.
! 3626: ** But there is a measureable speed advantage to using the macro on gcc
! 3627: ** (when less compiler optimizations like -Os or -O0 are used and the
! 3628: ** compiler is not doing agressive inlining.) So we use a real function
! 3629: ** for MSVC and a macro for everything else. Ticket #2457.
! 3630: */
! 3631: #ifndef NDEBUG
! 3632: static void assertCellInfo(BtCursor *pCur){
! 3633: CellInfo info;
! 3634: int iPage = pCur->iPage;
! 3635: memset(&info, 0, sizeof(info));
! 3636: btreeParseCell(pCur->apPage[iPage], pCur->aiIdx[iPage], &info);
! 3637: assert( memcmp(&info, &pCur->info, sizeof(info))==0 );
! 3638: }
! 3639: #else
! 3640: #define assertCellInfo(x)
! 3641: #endif
! 3642: #ifdef _MSC_VER
! 3643: /* Use a real function in MSVC to work around bugs in that compiler. */
! 3644: static void getCellInfo(BtCursor *pCur){
! 3645: if( pCur->info.nSize==0 ){
! 3646: int iPage = pCur->iPage;
! 3647: btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info);
! 3648: pCur->validNKey = 1;
! 3649: }else{
! 3650: assertCellInfo(pCur);
! 3651: }
! 3652: }
! 3653: #else /* if not _MSC_VER */
! 3654: /* Use a macro in all other compilers so that the function is inlined */
! 3655: #define getCellInfo(pCur) \
! 3656: if( pCur->info.nSize==0 ){ \
! 3657: int iPage = pCur->iPage; \
! 3658: btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info); \
! 3659: pCur->validNKey = 1; \
! 3660: }else{ \
! 3661: assertCellInfo(pCur); \
! 3662: }
! 3663: #endif /* _MSC_VER */
! 3664:
! 3665: #ifndef NDEBUG /* The next routine used only within assert() statements */
! 3666: /*
! 3667: ** Return true if the given BtCursor is valid. A valid cursor is one
! 3668: ** that is currently pointing to a row in a (non-empty) table.
! 3669: ** This is a verification routine is used only within assert() statements.
! 3670: */
! 3671: int sqlite3BtreeCursorIsValid(BtCursor *pCur){
! 3672: return pCur && pCur->eState==CURSOR_VALID;
! 3673: }
! 3674: #endif /* NDEBUG */
! 3675:
! 3676: /*
! 3677: ** Set *pSize to the size of the buffer needed to hold the value of
! 3678: ** the key for the current entry. If the cursor is not pointing
! 3679: ** to a valid entry, *pSize is set to 0.
! 3680: **
! 3681: ** For a table with the INTKEY flag set, this routine returns the key
! 3682: ** itself, not the number of bytes in the key.
! 3683: **
! 3684: ** The caller must position the cursor prior to invoking this routine.
! 3685: **
! 3686: ** This routine cannot fail. It always returns SQLITE_OK.
! 3687: */
! 3688: int sqlite3BtreeKeySize(BtCursor *pCur, i64 *pSize){
! 3689: assert( cursorHoldsMutex(pCur) );
! 3690: assert( pCur->eState==CURSOR_INVALID || pCur->eState==CURSOR_VALID );
! 3691: if( pCur->eState!=CURSOR_VALID ){
! 3692: *pSize = 0;
! 3693: }else{
! 3694: getCellInfo(pCur);
! 3695: *pSize = pCur->info.nKey;
! 3696: }
! 3697: return SQLITE_OK;
! 3698: }
! 3699:
! 3700: /*
! 3701: ** Set *pSize to the number of bytes of data in the entry the
! 3702: ** cursor currently points to.
! 3703: **
! 3704: ** The caller must guarantee that the cursor is pointing to a non-NULL
! 3705: ** valid entry. In other words, the calling procedure must guarantee
! 3706: ** that the cursor has Cursor.eState==CURSOR_VALID.
! 3707: **
! 3708: ** Failure is not possible. This function always returns SQLITE_OK.
! 3709: ** It might just as well be a procedure (returning void) but we continue
! 3710: ** to return an integer result code for historical reasons.
! 3711: */
! 3712: int sqlite3BtreeDataSize(BtCursor *pCur, u32 *pSize){
! 3713: assert( cursorHoldsMutex(pCur) );
! 3714: assert( pCur->eState==CURSOR_VALID );
! 3715: getCellInfo(pCur);
! 3716: *pSize = pCur->info.nData;
! 3717: return SQLITE_OK;
! 3718: }
! 3719:
! 3720: /*
! 3721: ** Given the page number of an overflow page in the database (parameter
! 3722: ** ovfl), this function finds the page number of the next page in the
! 3723: ** linked list of overflow pages. If possible, it uses the auto-vacuum
! 3724: ** pointer-map data instead of reading the content of page ovfl to do so.
! 3725: **
! 3726: ** If an error occurs an SQLite error code is returned. Otherwise:
! 3727: **
! 3728: ** The page number of the next overflow page in the linked list is
! 3729: ** written to *pPgnoNext. If page ovfl is the last page in its linked
! 3730: ** list, *pPgnoNext is set to zero.
! 3731: **
! 3732: ** If ppPage is not NULL, and a reference to the MemPage object corresponding
! 3733: ** to page number pOvfl was obtained, then *ppPage is set to point to that
! 3734: ** reference. It is the responsibility of the caller to call releasePage()
! 3735: ** on *ppPage to free the reference. In no reference was obtained (because
! 3736: ** the pointer-map was used to obtain the value for *pPgnoNext), then
! 3737: ** *ppPage is set to zero.
! 3738: */
! 3739: static int getOverflowPage(
! 3740: BtShared *pBt, /* The database file */
! 3741: Pgno ovfl, /* Current overflow page number */
! 3742: MemPage **ppPage, /* OUT: MemPage handle (may be NULL) */
! 3743: Pgno *pPgnoNext /* OUT: Next overflow page number */
! 3744: ){
! 3745: Pgno next = 0;
! 3746: MemPage *pPage = 0;
! 3747: int rc = SQLITE_OK;
! 3748:
! 3749: assert( sqlite3_mutex_held(pBt->mutex) );
! 3750: assert(pPgnoNext);
! 3751:
! 3752: #ifndef SQLITE_OMIT_AUTOVACUUM
! 3753: /* Try to find the next page in the overflow list using the
! 3754: ** autovacuum pointer-map pages. Guess that the next page in
! 3755: ** the overflow list is page number (ovfl+1). If that guess turns
! 3756: ** out to be wrong, fall back to loading the data of page
! 3757: ** number ovfl to determine the next page number.
! 3758: */
! 3759: if( pBt->autoVacuum ){
! 3760: Pgno pgno;
! 3761: Pgno iGuess = ovfl+1;
! 3762: u8 eType;
! 3763:
! 3764: while( PTRMAP_ISPAGE(pBt, iGuess) || iGuess==PENDING_BYTE_PAGE(pBt) ){
! 3765: iGuess++;
! 3766: }
! 3767:
! 3768: if( iGuess<=btreePagecount(pBt) ){
! 3769: rc = ptrmapGet(pBt, iGuess, &eType, &pgno);
! 3770: if( rc==SQLITE_OK && eType==PTRMAP_OVERFLOW2 && pgno==ovfl ){
! 3771: next = iGuess;
! 3772: rc = SQLITE_DONE;
! 3773: }
! 3774: }
! 3775: }
! 3776: #endif
! 3777:
! 3778: assert( next==0 || rc==SQLITE_DONE );
! 3779: if( rc==SQLITE_OK ){
! 3780: rc = btreeGetPage(pBt, ovfl, &pPage, 0);
! 3781: assert( rc==SQLITE_OK || pPage==0 );
! 3782: if( rc==SQLITE_OK ){
! 3783: next = get4byte(pPage->aData);
! 3784: }
! 3785: }
! 3786:
! 3787: *pPgnoNext = next;
! 3788: if( ppPage ){
! 3789: *ppPage = pPage;
! 3790: }else{
! 3791: releasePage(pPage);
! 3792: }
! 3793: return (rc==SQLITE_DONE ? SQLITE_OK : rc);
! 3794: }
! 3795:
! 3796: /*
! 3797: ** Copy data from a buffer to a page, or from a page to a buffer.
! 3798: **
! 3799: ** pPayload is a pointer to data stored on database page pDbPage.
! 3800: ** If argument eOp is false, then nByte bytes of data are copied
! 3801: ** from pPayload to the buffer pointed at by pBuf. If eOp is true,
! 3802: ** then sqlite3PagerWrite() is called on pDbPage and nByte bytes
! 3803: ** of data are copied from the buffer pBuf to pPayload.
! 3804: **
! 3805: ** SQLITE_OK is returned on success, otherwise an error code.
! 3806: */
! 3807: static int copyPayload(
! 3808: void *pPayload, /* Pointer to page data */
! 3809: void *pBuf, /* Pointer to buffer */
! 3810: int nByte, /* Number of bytes to copy */
! 3811: int eOp, /* 0 -> copy from page, 1 -> copy to page */
! 3812: DbPage *pDbPage /* Page containing pPayload */
! 3813: ){
! 3814: if( eOp ){
! 3815: /* Copy data from buffer to page (a write operation) */
! 3816: int rc = sqlite3PagerWrite(pDbPage);
! 3817: if( rc!=SQLITE_OK ){
! 3818: return rc;
! 3819: }
! 3820: memcpy(pPayload, pBuf, nByte);
! 3821: }else{
! 3822: /* Copy data from page to buffer (a read operation) */
! 3823: memcpy(pBuf, pPayload, nByte);
! 3824: }
! 3825: return SQLITE_OK;
! 3826: }
! 3827:
! 3828: /*
! 3829: ** This function is used to read or overwrite payload information
! 3830: ** for the entry that the pCur cursor is pointing to. If the eOp
! 3831: ** parameter is 0, this is a read operation (data copied into
! 3832: ** buffer pBuf). If it is non-zero, a write (data copied from
! 3833: ** buffer pBuf).
! 3834: **
! 3835: ** A total of "amt" bytes are read or written beginning at "offset".
! 3836: ** Data is read to or from the buffer pBuf.
! 3837: **
! 3838: ** The content being read or written might appear on the main page
! 3839: ** or be scattered out on multiple overflow pages.
! 3840: **
! 3841: ** If the BtCursor.isIncrblobHandle flag is set, and the current
! 3842: ** cursor entry uses one or more overflow pages, this function
! 3843: ** allocates space for and lazily popluates the overflow page-list
! 3844: ** cache array (BtCursor.aOverflow). Subsequent calls use this
! 3845: ** cache to make seeking to the supplied offset more efficient.
! 3846: **
! 3847: ** Once an overflow page-list cache has been allocated, it may be
! 3848: ** invalidated if some other cursor writes to the same table, or if
! 3849: ** the cursor is moved to a different row. Additionally, in auto-vacuum
! 3850: ** mode, the following events may invalidate an overflow page-list cache.
! 3851: **
! 3852: ** * An incremental vacuum,
! 3853: ** * A commit in auto_vacuum="full" mode,
! 3854: ** * Creating a table (may require moving an overflow page).
! 3855: */
! 3856: static int accessPayload(
! 3857: BtCursor *pCur, /* Cursor pointing to entry to read from */
! 3858: u32 offset, /* Begin reading this far into payload */
! 3859: u32 amt, /* Read this many bytes */
! 3860: unsigned char *pBuf, /* Write the bytes into this buffer */
! 3861: int eOp /* zero to read. non-zero to write. */
! 3862: ){
! 3863: unsigned char *aPayload;
! 3864: int rc = SQLITE_OK;
! 3865: u32 nKey;
! 3866: int iIdx = 0;
! 3867: MemPage *pPage = pCur->apPage[pCur->iPage]; /* Btree page of current entry */
! 3868: BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */
! 3869:
! 3870: assert( pPage );
! 3871: assert( pCur->eState==CURSOR_VALID );
! 3872: assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
! 3873: assert( cursorHoldsMutex(pCur) );
! 3874:
! 3875: getCellInfo(pCur);
! 3876: aPayload = pCur->info.pCell + pCur->info.nHeader;
! 3877: nKey = (pPage->intKey ? 0 : (int)pCur->info.nKey);
! 3878:
! 3879: if( NEVER(offset+amt > nKey+pCur->info.nData)
! 3880: || &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize]
! 3881: ){
! 3882: /* Trying to read or write past the end of the data is an error */
! 3883: return SQLITE_CORRUPT_BKPT;
! 3884: }
! 3885:
! 3886: /* Check if data must be read/written to/from the btree page itself. */
! 3887: if( offset<pCur->info.nLocal ){
! 3888: int a = amt;
! 3889: if( a+offset>pCur->info.nLocal ){
! 3890: a = pCur->info.nLocal - offset;
! 3891: }
! 3892: rc = copyPayload(&aPayload[offset], pBuf, a, eOp, pPage->pDbPage);
! 3893: offset = 0;
! 3894: pBuf += a;
! 3895: amt -= a;
! 3896: }else{
! 3897: offset -= pCur->info.nLocal;
! 3898: }
! 3899:
! 3900: if( rc==SQLITE_OK && amt>0 ){
! 3901: const u32 ovflSize = pBt->usableSize - 4; /* Bytes content per ovfl page */
! 3902: Pgno nextPage;
! 3903:
! 3904: nextPage = get4byte(&aPayload[pCur->info.nLocal]);
! 3905:
! 3906: #ifndef SQLITE_OMIT_INCRBLOB
! 3907: /* If the isIncrblobHandle flag is set and the BtCursor.aOverflow[]
! 3908: ** has not been allocated, allocate it now. The array is sized at
! 3909: ** one entry for each overflow page in the overflow chain. The
! 3910: ** page number of the first overflow page is stored in aOverflow[0],
! 3911: ** etc. A value of 0 in the aOverflow[] array means "not yet known"
! 3912: ** (the cache is lazily populated).
! 3913: */
! 3914: if( pCur->isIncrblobHandle && !pCur->aOverflow ){
! 3915: int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;
! 3916: pCur->aOverflow = (Pgno *)sqlite3MallocZero(sizeof(Pgno)*nOvfl);
! 3917: /* nOvfl is always positive. If it were zero, fetchPayload would have
! 3918: ** been used instead of this routine. */
! 3919: if( ALWAYS(nOvfl) && !pCur->aOverflow ){
! 3920: rc = SQLITE_NOMEM;
! 3921: }
! 3922: }
! 3923:
! 3924: /* If the overflow page-list cache has been allocated and the
! 3925: ** entry for the first required overflow page is valid, skip
! 3926: ** directly to it.
! 3927: */
! 3928: if( pCur->aOverflow && pCur->aOverflow[offset/ovflSize] ){
! 3929: iIdx = (offset/ovflSize);
! 3930: nextPage = pCur->aOverflow[iIdx];
! 3931: offset = (offset%ovflSize);
! 3932: }
! 3933: #endif
! 3934:
! 3935: for( ; rc==SQLITE_OK && amt>0 && nextPage; iIdx++){
! 3936:
! 3937: #ifndef SQLITE_OMIT_INCRBLOB
! 3938: /* If required, populate the overflow page-list cache. */
! 3939: if( pCur->aOverflow ){
! 3940: assert(!pCur->aOverflow[iIdx] || pCur->aOverflow[iIdx]==nextPage);
! 3941: pCur->aOverflow[iIdx] = nextPage;
! 3942: }
! 3943: #endif
! 3944:
! 3945: if( offset>=ovflSize ){
! 3946: /* The only reason to read this page is to obtain the page
! 3947: ** number for the next page in the overflow chain. The page
! 3948: ** data is not required. So first try to lookup the overflow
! 3949: ** page-list cache, if any, then fall back to the getOverflowPage()
! 3950: ** function.
! 3951: */
! 3952: #ifndef SQLITE_OMIT_INCRBLOB
! 3953: if( pCur->aOverflow && pCur->aOverflow[iIdx+1] ){
! 3954: nextPage = pCur->aOverflow[iIdx+1];
! 3955: } else
! 3956: #endif
! 3957: rc = getOverflowPage(pBt, nextPage, 0, &nextPage);
! 3958: offset -= ovflSize;
! 3959: }else{
! 3960: /* Need to read this page properly. It contains some of the
! 3961: ** range of data that is being read (eOp==0) or written (eOp!=0).
! 3962: */
! 3963: #ifdef SQLITE_DIRECT_OVERFLOW_READ
! 3964: sqlite3_file *fd;
! 3965: #endif
! 3966: int a = amt;
! 3967: if( a + offset > ovflSize ){
! 3968: a = ovflSize - offset;
! 3969: }
! 3970:
! 3971: #ifdef SQLITE_DIRECT_OVERFLOW_READ
! 3972: /* If all the following are true:
! 3973: **
! 3974: ** 1) this is a read operation, and
! 3975: ** 2) data is required from the start of this overflow page, and
! 3976: ** 3) the database is file-backed, and
! 3977: ** 4) there is no open write-transaction, and
! 3978: ** 5) the database is not a WAL database,
! 3979: **
! 3980: ** then data can be read directly from the database file into the
! 3981: ** output buffer, bypassing the page-cache altogether. This speeds
! 3982: ** up loading large records that span many overflow pages.
! 3983: */
! 3984: if( eOp==0 /* (1) */
! 3985: && offset==0 /* (2) */
! 3986: && pBt->inTransaction==TRANS_READ /* (4) */
! 3987: && (fd = sqlite3PagerFile(pBt->pPager))->pMethods /* (3) */
! 3988: && pBt->pPage1->aData[19]==0x01 /* (5) */
! 3989: ){
! 3990: u8 aSave[4];
! 3991: u8 *aWrite = &pBuf[-4];
! 3992: memcpy(aSave, aWrite, 4);
! 3993: rc = sqlite3OsRead(fd, aWrite, a+4, (i64)pBt->pageSize*(nextPage-1));
! 3994: nextPage = get4byte(aWrite);
! 3995: memcpy(aWrite, aSave, 4);
! 3996: }else
! 3997: #endif
! 3998:
! 3999: {
! 4000: DbPage *pDbPage;
! 4001: rc = sqlite3PagerGet(pBt->pPager, nextPage, &pDbPage);
! 4002: if( rc==SQLITE_OK ){
! 4003: aPayload = sqlite3PagerGetData(pDbPage);
! 4004: nextPage = get4byte(aPayload);
! 4005: rc = copyPayload(&aPayload[offset+4], pBuf, a, eOp, pDbPage);
! 4006: sqlite3PagerUnref(pDbPage);
! 4007: offset = 0;
! 4008: }
! 4009: }
! 4010: amt -= a;
! 4011: pBuf += a;
! 4012: }
! 4013: }
! 4014: }
! 4015:
! 4016: if( rc==SQLITE_OK && amt>0 ){
! 4017: return SQLITE_CORRUPT_BKPT;
! 4018: }
! 4019: return rc;
! 4020: }
! 4021:
! 4022: /*
! 4023: ** Read part of the key associated with cursor pCur. Exactly
! 4024: ** "amt" bytes will be transfered into pBuf[]. The transfer
! 4025: ** begins at "offset".
! 4026: **
! 4027: ** The caller must ensure that pCur is pointing to a valid row
! 4028: ** in the table.
! 4029: **
! 4030: ** Return SQLITE_OK on success or an error code if anything goes
! 4031: ** wrong. An error is returned if "offset+amt" is larger than
! 4032: ** the available payload.
! 4033: */
! 4034: int sqlite3BtreeKey(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
! 4035: assert( cursorHoldsMutex(pCur) );
! 4036: assert( pCur->eState==CURSOR_VALID );
! 4037: assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
! 4038: assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
! 4039: return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);
! 4040: }
! 4041:
! 4042: /*
! 4043: ** Read part of the data associated with cursor pCur. Exactly
! 4044: ** "amt" bytes will be transfered into pBuf[]. The transfer
! 4045: ** begins at "offset".
! 4046: **
! 4047: ** Return SQLITE_OK on success or an error code if anything goes
! 4048: ** wrong. An error is returned if "offset+amt" is larger than
! 4049: ** the available payload.
! 4050: */
! 4051: int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
! 4052: int rc;
! 4053:
! 4054: #ifndef SQLITE_OMIT_INCRBLOB
! 4055: if ( pCur->eState==CURSOR_INVALID ){
! 4056: return SQLITE_ABORT;
! 4057: }
! 4058: #endif
! 4059:
! 4060: assert( cursorHoldsMutex(pCur) );
! 4061: rc = restoreCursorPosition(pCur);
! 4062: if( rc==SQLITE_OK ){
! 4063: assert( pCur->eState==CURSOR_VALID );
! 4064: assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
! 4065: assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
! 4066: rc = accessPayload(pCur, offset, amt, pBuf, 0);
! 4067: }
! 4068: return rc;
! 4069: }
! 4070:
! 4071: /*
! 4072: ** Return a pointer to payload information from the entry that the
! 4073: ** pCur cursor is pointing to. The pointer is to the beginning of
! 4074: ** the key if skipKey==0 and it points to the beginning of data if
! 4075: ** skipKey==1. The number of bytes of available key/data is written
! 4076: ** into *pAmt. If *pAmt==0, then the value returned will not be
! 4077: ** a valid pointer.
! 4078: **
! 4079: ** This routine is an optimization. It is common for the entire key
! 4080: ** and data to fit on the local page and for there to be no overflow
! 4081: ** pages. When that is so, this routine can be used to access the
! 4082: ** key and data without making a copy. If the key and/or data spills
! 4083: ** onto overflow pages, then accessPayload() must be used to reassemble
! 4084: ** the key/data and copy it into a preallocated buffer.
! 4085: **
! 4086: ** The pointer returned by this routine looks directly into the cached
! 4087: ** page of the database. The data might change or move the next time
! 4088: ** any btree routine is called.
! 4089: */
! 4090: static const unsigned char *fetchPayload(
! 4091: BtCursor *pCur, /* Cursor pointing to entry to read from */
! 4092: int *pAmt, /* Write the number of available bytes here */
! 4093: int skipKey /* read beginning at data if this is true */
! 4094: ){
! 4095: unsigned char *aPayload;
! 4096: MemPage *pPage;
! 4097: u32 nKey;
! 4098: u32 nLocal;
! 4099:
! 4100: assert( pCur!=0 && pCur->iPage>=0 && pCur->apPage[pCur->iPage]);
! 4101: assert( pCur->eState==CURSOR_VALID );
! 4102: assert( cursorHoldsMutex(pCur) );
! 4103: pPage = pCur->apPage[pCur->iPage];
! 4104: assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
! 4105: if( NEVER(pCur->info.nSize==0) ){
! 4106: btreeParseCell(pCur->apPage[pCur->iPage], pCur->aiIdx[pCur->iPage],
! 4107: &pCur->info);
! 4108: }
! 4109: aPayload = pCur->info.pCell;
! 4110: aPayload += pCur->info.nHeader;
! 4111: if( pPage->intKey ){
! 4112: nKey = 0;
! 4113: }else{
! 4114: nKey = (int)pCur->info.nKey;
! 4115: }
! 4116: if( skipKey ){
! 4117: aPayload += nKey;
! 4118: nLocal = pCur->info.nLocal - nKey;
! 4119: }else{
! 4120: nLocal = pCur->info.nLocal;
! 4121: assert( nLocal<=nKey );
! 4122: }
! 4123: *pAmt = nLocal;
! 4124: return aPayload;
! 4125: }
! 4126:
! 4127:
! 4128: /*
! 4129: ** For the entry that cursor pCur is point to, return as
! 4130: ** many bytes of the key or data as are available on the local
! 4131: ** b-tree page. Write the number of available bytes into *pAmt.
! 4132: **
! 4133: ** The pointer returned is ephemeral. The key/data may move
! 4134: ** or be destroyed on the next call to any Btree routine,
! 4135: ** including calls from other threads against the same cache.
! 4136: ** Hence, a mutex on the BtShared should be held prior to calling
! 4137: ** this routine.
! 4138: **
! 4139: ** These routines is used to get quick access to key and data
! 4140: ** in the common case where no overflow pages are used.
! 4141: */
! 4142: const void *sqlite3BtreeKeyFetch(BtCursor *pCur, int *pAmt){
! 4143: const void *p = 0;
! 4144: assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
! 4145: assert( cursorHoldsMutex(pCur) );
! 4146: if( ALWAYS(pCur->eState==CURSOR_VALID) ){
! 4147: p = (const void*)fetchPayload(pCur, pAmt, 0);
! 4148: }
! 4149: return p;
! 4150: }
! 4151: const void *sqlite3BtreeDataFetch(BtCursor *pCur, int *pAmt){
! 4152: const void *p = 0;
! 4153: assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
! 4154: assert( cursorHoldsMutex(pCur) );
! 4155: if( ALWAYS(pCur->eState==CURSOR_VALID) ){
! 4156: p = (const void*)fetchPayload(pCur, pAmt, 1);
! 4157: }
! 4158: return p;
! 4159: }
! 4160:
! 4161:
! 4162: /*
! 4163: ** Move the cursor down to a new child page. The newPgno argument is the
! 4164: ** page number of the child page to move to.
! 4165: **
! 4166: ** This function returns SQLITE_CORRUPT if the page-header flags field of
! 4167: ** the new child page does not match the flags field of the parent (i.e.
! 4168: ** if an intkey page appears to be the parent of a non-intkey page, or
! 4169: ** vice-versa).
! 4170: */
! 4171: static int moveToChild(BtCursor *pCur, u32 newPgno){
! 4172: int rc;
! 4173: int i = pCur->iPage;
! 4174: MemPage *pNewPage;
! 4175: BtShared *pBt = pCur->pBt;
! 4176:
! 4177: assert( cursorHoldsMutex(pCur) );
! 4178: assert( pCur->eState==CURSOR_VALID );
! 4179: assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
! 4180: if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
! 4181: return SQLITE_CORRUPT_BKPT;
! 4182: }
! 4183: rc = getAndInitPage(pBt, newPgno, &pNewPage);
! 4184: if( rc ) return rc;
! 4185: pCur->apPage[i+1] = pNewPage;
! 4186: pCur->aiIdx[i+1] = 0;
! 4187: pCur->iPage++;
! 4188:
! 4189: pCur->info.nSize = 0;
! 4190: pCur->validNKey = 0;
! 4191: if( pNewPage->nCell<1 || pNewPage->intKey!=pCur->apPage[i]->intKey ){
! 4192: return SQLITE_CORRUPT_BKPT;
! 4193: }
! 4194: return SQLITE_OK;
! 4195: }
! 4196:
! 4197: #if 0
! 4198: /*
! 4199: ** Page pParent is an internal (non-leaf) tree page. This function
! 4200: ** asserts that page number iChild is the left-child if the iIdx'th
! 4201: ** cell in page pParent. Or, if iIdx is equal to the total number of
! 4202: ** cells in pParent, that page number iChild is the right-child of
! 4203: ** the page.
! 4204: */
! 4205: static void assertParentIndex(MemPage *pParent, int iIdx, Pgno iChild){
! 4206: assert( iIdx<=pParent->nCell );
! 4207: if( iIdx==pParent->nCell ){
! 4208: assert( get4byte(&pParent->aData[pParent->hdrOffset+8])==iChild );
! 4209: }else{
! 4210: assert( get4byte(findCell(pParent, iIdx))==iChild );
! 4211: }
! 4212: }
! 4213: #else
! 4214: # define assertParentIndex(x,y,z)
! 4215: #endif
! 4216:
! 4217: /*
! 4218: ** Move the cursor up to the parent page.
! 4219: **
! 4220: ** pCur->idx is set to the cell index that contains the pointer
! 4221: ** to the page we are coming from. If we are coming from the
! 4222: ** right-most child page then pCur->idx is set to one more than
! 4223: ** the largest cell index.
! 4224: */
! 4225: static void moveToParent(BtCursor *pCur){
! 4226: assert( cursorHoldsMutex(pCur) );
! 4227: assert( pCur->eState==CURSOR_VALID );
! 4228: assert( pCur->iPage>0 );
! 4229: assert( pCur->apPage[pCur->iPage] );
! 4230:
! 4231: /* UPDATE: It is actually possible for the condition tested by the assert
! 4232: ** below to be untrue if the database file is corrupt. This can occur if
! 4233: ** one cursor has modified page pParent while a reference to it is held
! 4234: ** by a second cursor. Which can only happen if a single page is linked
! 4235: ** into more than one b-tree structure in a corrupt database. */
! 4236: #if 0
! 4237: assertParentIndex(
! 4238: pCur->apPage[pCur->iPage-1],
! 4239: pCur->aiIdx[pCur->iPage-1],
! 4240: pCur->apPage[pCur->iPage]->pgno
! 4241: );
! 4242: #endif
! 4243: testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell );
! 4244:
! 4245: releasePage(pCur->apPage[pCur->iPage]);
! 4246: pCur->iPage--;
! 4247: pCur->info.nSize = 0;
! 4248: pCur->validNKey = 0;
! 4249: }
! 4250:
! 4251: /*
! 4252: ** Move the cursor to point to the root page of its b-tree structure.
! 4253: **
! 4254: ** If the table has a virtual root page, then the cursor is moved to point
! 4255: ** to the virtual root page instead of the actual root page. A table has a
! 4256: ** virtual root page when the actual root page contains no cells and a
! 4257: ** single child page. This can only happen with the table rooted at page 1.
! 4258: **
! 4259: ** If the b-tree structure is empty, the cursor state is set to
! 4260: ** CURSOR_INVALID. Otherwise, the cursor is set to point to the first
! 4261: ** cell located on the root (or virtual root) page and the cursor state
! 4262: ** is set to CURSOR_VALID.
! 4263: **
! 4264: ** If this function returns successfully, it may be assumed that the
! 4265: ** page-header flags indicate that the [virtual] root-page is the expected
! 4266: ** kind of b-tree page (i.e. if when opening the cursor the caller did not
! 4267: ** specify a KeyInfo structure the flags byte is set to 0x05 or 0x0D,
! 4268: ** indicating a table b-tree, or if the caller did specify a KeyInfo
! 4269: ** structure the flags byte is set to 0x02 or 0x0A, indicating an index
! 4270: ** b-tree).
! 4271: */
! 4272: static int moveToRoot(BtCursor *pCur){
! 4273: MemPage *pRoot;
! 4274: int rc = SQLITE_OK;
! 4275: Btree *p = pCur->pBtree;
! 4276: BtShared *pBt = p->pBt;
! 4277:
! 4278: assert( cursorHoldsMutex(pCur) );
! 4279: assert( CURSOR_INVALID < CURSOR_REQUIRESEEK );
! 4280: assert( CURSOR_VALID < CURSOR_REQUIRESEEK );
! 4281: assert( CURSOR_FAULT > CURSOR_REQUIRESEEK );
! 4282: if( pCur->eState>=CURSOR_REQUIRESEEK ){
! 4283: if( pCur->eState==CURSOR_FAULT ){
! 4284: assert( pCur->skipNext!=SQLITE_OK );
! 4285: return pCur->skipNext;
! 4286: }
! 4287: sqlite3BtreeClearCursor(pCur);
! 4288: }
! 4289:
! 4290: if( pCur->iPage>=0 ){
! 4291: int i;
! 4292: for(i=1; i<=pCur->iPage; i++){
! 4293: releasePage(pCur->apPage[i]);
! 4294: }
! 4295: pCur->iPage = 0;
! 4296: }else if( pCur->pgnoRoot==0 ){
! 4297: pCur->eState = CURSOR_INVALID;
! 4298: return SQLITE_OK;
! 4299: }else{
! 4300: rc = getAndInitPage(pBt, pCur->pgnoRoot, &pCur->apPage[0]);
! 4301: if( rc!=SQLITE_OK ){
! 4302: pCur->eState = CURSOR_INVALID;
! 4303: return rc;
! 4304: }
! 4305: pCur->iPage = 0;
! 4306:
! 4307: /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
! 4308: ** expected to open it on an index b-tree. Otherwise, if pKeyInfo is
! 4309: ** NULL, the caller expects a table b-tree. If this is not the case,
! 4310: ** return an SQLITE_CORRUPT error. */
! 4311: assert( pCur->apPage[0]->intKey==1 || pCur->apPage[0]->intKey==0 );
! 4312: if( (pCur->pKeyInfo==0)!=pCur->apPage[0]->intKey ){
! 4313: return SQLITE_CORRUPT_BKPT;
! 4314: }
! 4315: }
! 4316:
! 4317: /* Assert that the root page is of the correct type. This must be the
! 4318: ** case as the call to this function that loaded the root-page (either
! 4319: ** this call or a previous invocation) would have detected corruption
! 4320: ** if the assumption were not true, and it is not possible for the flags
! 4321: ** byte to have been modified while this cursor is holding a reference
! 4322: ** to the page. */
! 4323: pRoot = pCur->apPage[0];
! 4324: assert( pRoot->pgno==pCur->pgnoRoot );
! 4325: assert( pRoot->isInit && (pCur->pKeyInfo==0)==pRoot->intKey );
! 4326:
! 4327: pCur->aiIdx[0] = 0;
! 4328: pCur->info.nSize = 0;
! 4329: pCur->atLast = 0;
! 4330: pCur->validNKey = 0;
! 4331:
! 4332: if( pRoot->nCell==0 && !pRoot->leaf ){
! 4333: Pgno subpage;
! 4334: if( pRoot->pgno!=1 ) return SQLITE_CORRUPT_BKPT;
! 4335: subpage = get4byte(&pRoot->aData[pRoot->hdrOffset+8]);
! 4336: pCur->eState = CURSOR_VALID;
! 4337: rc = moveToChild(pCur, subpage);
! 4338: }else{
! 4339: pCur->eState = ((pRoot->nCell>0)?CURSOR_VALID:CURSOR_INVALID);
! 4340: }
! 4341: return rc;
! 4342: }
! 4343:
! 4344: /*
! 4345: ** Move the cursor down to the left-most leaf entry beneath the
! 4346: ** entry to which it is currently pointing.
! 4347: **
! 4348: ** The left-most leaf is the one with the smallest key - the first
! 4349: ** in ascending order.
! 4350: */
! 4351: static int moveToLeftmost(BtCursor *pCur){
! 4352: Pgno pgno;
! 4353: int rc = SQLITE_OK;
! 4354: MemPage *pPage;
! 4355:
! 4356: assert( cursorHoldsMutex(pCur) );
! 4357: assert( pCur->eState==CURSOR_VALID );
! 4358: while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
! 4359: assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
! 4360: pgno = get4byte(findCell(pPage, pCur->aiIdx[pCur->iPage]));
! 4361: rc = moveToChild(pCur, pgno);
! 4362: }
! 4363: return rc;
! 4364: }
! 4365:
! 4366: /*
! 4367: ** Move the cursor down to the right-most leaf entry beneath the
! 4368: ** page to which it is currently pointing. Notice the difference
! 4369: ** between moveToLeftmost() and moveToRightmost(). moveToLeftmost()
! 4370: ** finds the left-most entry beneath the *entry* whereas moveToRightmost()
! 4371: ** finds the right-most entry beneath the *page*.
! 4372: **
! 4373: ** The right-most entry is the one with the largest key - the last
! 4374: ** key in ascending order.
! 4375: */
! 4376: static int moveToRightmost(BtCursor *pCur){
! 4377: Pgno pgno;
! 4378: int rc = SQLITE_OK;
! 4379: MemPage *pPage = 0;
! 4380:
! 4381: assert( cursorHoldsMutex(pCur) );
! 4382: assert( pCur->eState==CURSOR_VALID );
! 4383: while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
! 4384: pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
! 4385: pCur->aiIdx[pCur->iPage] = pPage->nCell;
! 4386: rc = moveToChild(pCur, pgno);
! 4387: }
! 4388: if( rc==SQLITE_OK ){
! 4389: pCur->aiIdx[pCur->iPage] = pPage->nCell-1;
! 4390: pCur->info.nSize = 0;
! 4391: pCur->validNKey = 0;
! 4392: }
! 4393: return rc;
! 4394: }
! 4395:
! 4396: /* Move the cursor to the first entry in the table. Return SQLITE_OK
! 4397: ** on success. Set *pRes to 0 if the cursor actually points to something
! 4398: ** or set *pRes to 1 if the table is empty.
! 4399: */
! 4400: int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
! 4401: int rc;
! 4402:
! 4403: assert( cursorHoldsMutex(pCur) );
! 4404: assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
! 4405: rc = moveToRoot(pCur);
! 4406: if( rc==SQLITE_OK ){
! 4407: if( pCur->eState==CURSOR_INVALID ){
! 4408: assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
! 4409: *pRes = 1;
! 4410: }else{
! 4411: assert( pCur->apPage[pCur->iPage]->nCell>0 );
! 4412: *pRes = 0;
! 4413: rc = moveToLeftmost(pCur);
! 4414: }
! 4415: }
! 4416: return rc;
! 4417: }
! 4418:
! 4419: /* Move the cursor to the last entry in the table. Return SQLITE_OK
! 4420: ** on success. Set *pRes to 0 if the cursor actually points to something
! 4421: ** or set *pRes to 1 if the table is empty.
! 4422: */
! 4423: int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
! 4424: int rc;
! 4425:
! 4426: assert( cursorHoldsMutex(pCur) );
! 4427: assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
! 4428:
! 4429: /* If the cursor already points to the last entry, this is a no-op. */
! 4430: if( CURSOR_VALID==pCur->eState && pCur->atLast ){
! 4431: #ifdef SQLITE_DEBUG
! 4432: /* This block serves to assert() that the cursor really does point
! 4433: ** to the last entry in the b-tree. */
! 4434: int ii;
! 4435: for(ii=0; ii<pCur->iPage; ii++){
! 4436: assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
! 4437: }
! 4438: assert( pCur->aiIdx[pCur->iPage]==pCur->apPage[pCur->iPage]->nCell-1 );
! 4439: assert( pCur->apPage[pCur->iPage]->leaf );
! 4440: #endif
! 4441: return SQLITE_OK;
! 4442: }
! 4443:
! 4444: rc = moveToRoot(pCur);
! 4445: if( rc==SQLITE_OK ){
! 4446: if( CURSOR_INVALID==pCur->eState ){
! 4447: assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
! 4448: *pRes = 1;
! 4449: }else{
! 4450: assert( pCur->eState==CURSOR_VALID );
! 4451: *pRes = 0;
! 4452: rc = moveToRightmost(pCur);
! 4453: pCur->atLast = rc==SQLITE_OK ?1:0;
! 4454: }
! 4455: }
! 4456: return rc;
! 4457: }
! 4458:
! 4459: /* Move the cursor so that it points to an entry near the key
! 4460: ** specified by pIdxKey or intKey. Return a success code.
! 4461: **
! 4462: ** For INTKEY tables, the intKey parameter is used. pIdxKey
! 4463: ** must be NULL. For index tables, pIdxKey is used and intKey
! 4464: ** is ignored.
! 4465: **
! 4466: ** If an exact match is not found, then the cursor is always
! 4467: ** left pointing at a leaf page which would hold the entry if it
! 4468: ** were present. The cursor might point to an entry that comes
! 4469: ** before or after the key.
! 4470: **
! 4471: ** An integer is written into *pRes which is the result of
! 4472: ** comparing the key with the entry to which the cursor is
! 4473: ** pointing. The meaning of the integer written into
! 4474: ** *pRes is as follows:
! 4475: **
! 4476: ** *pRes<0 The cursor is left pointing at an entry that
! 4477: ** is smaller than intKey/pIdxKey or if the table is empty
! 4478: ** and the cursor is therefore left point to nothing.
! 4479: **
! 4480: ** *pRes==0 The cursor is left pointing at an entry that
! 4481: ** exactly matches intKey/pIdxKey.
! 4482: **
! 4483: ** *pRes>0 The cursor is left pointing at an entry that
! 4484: ** is larger than intKey/pIdxKey.
! 4485: **
! 4486: */
! 4487: int sqlite3BtreeMovetoUnpacked(
! 4488: BtCursor *pCur, /* The cursor to be moved */
! 4489: UnpackedRecord *pIdxKey, /* Unpacked index key */
! 4490: i64 intKey, /* The table key */
! 4491: int biasRight, /* If true, bias the search to the high end */
! 4492: int *pRes /* Write search results here */
! 4493: ){
! 4494: int rc;
! 4495:
! 4496: assert( cursorHoldsMutex(pCur) );
! 4497: assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
! 4498: assert( pRes );
! 4499: assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
! 4500:
! 4501: /* If the cursor is already positioned at the point we are trying
! 4502: ** to move to, then just return without doing any work */
! 4503: if( pCur->eState==CURSOR_VALID && pCur->validNKey
! 4504: && pCur->apPage[0]->intKey
! 4505: ){
! 4506: if( pCur->info.nKey==intKey ){
! 4507: *pRes = 0;
! 4508: return SQLITE_OK;
! 4509: }
! 4510: if( pCur->atLast && pCur->info.nKey<intKey ){
! 4511: *pRes = -1;
! 4512: return SQLITE_OK;
! 4513: }
! 4514: }
! 4515:
! 4516: rc = moveToRoot(pCur);
! 4517: if( rc ){
! 4518: return rc;
! 4519: }
! 4520: assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage] );
! 4521: assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->isInit );
! 4522: assert( pCur->eState==CURSOR_INVALID || pCur->apPage[pCur->iPage]->nCell>0 );
! 4523: if( pCur->eState==CURSOR_INVALID ){
! 4524: *pRes = -1;
! 4525: assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
! 4526: return SQLITE_OK;
! 4527: }
! 4528: assert( pCur->apPage[0]->intKey || pIdxKey );
! 4529: for(;;){
! 4530: int lwr, upr, idx;
! 4531: Pgno chldPg;
! 4532: MemPage *pPage = pCur->apPage[pCur->iPage];
! 4533: int c;
! 4534:
! 4535: /* pPage->nCell must be greater than zero. If this is the root-page
! 4536: ** the cursor would have been INVALID above and this for(;;) loop
! 4537: ** not run. If this is not the root-page, then the moveToChild() routine
! 4538: ** would have already detected db corruption. Similarly, pPage must
! 4539: ** be the right kind (index or table) of b-tree page. Otherwise
! 4540: ** a moveToChild() or moveToRoot() call would have detected corruption. */
! 4541: assert( pPage->nCell>0 );
! 4542: assert( pPage->intKey==(pIdxKey==0) );
! 4543: lwr = 0;
! 4544: upr = pPage->nCell-1;
! 4545: if( biasRight ){
! 4546: pCur->aiIdx[pCur->iPage] = (u16)(idx = upr);
! 4547: }else{
! 4548: pCur->aiIdx[pCur->iPage] = (u16)(idx = (upr+lwr)/2);
! 4549: }
! 4550: for(;;){
! 4551: u8 *pCell; /* Pointer to current cell in pPage */
! 4552:
! 4553: assert( idx==pCur->aiIdx[pCur->iPage] );
! 4554: pCur->info.nSize = 0;
! 4555: pCell = findCell(pPage, idx) + pPage->childPtrSize;
! 4556: if( pPage->intKey ){
! 4557: i64 nCellKey;
! 4558: if( pPage->hasData ){
! 4559: u32 dummy;
! 4560: pCell += getVarint32(pCell, dummy);
! 4561: }
! 4562: getVarint(pCell, (u64*)&nCellKey);
! 4563: if( nCellKey==intKey ){
! 4564: c = 0;
! 4565: }else if( nCellKey<intKey ){
! 4566: c = -1;
! 4567: }else{
! 4568: assert( nCellKey>intKey );
! 4569: c = +1;
! 4570: }
! 4571: pCur->validNKey = 1;
! 4572: pCur->info.nKey = nCellKey;
! 4573: }else{
! 4574: /* The maximum supported page-size is 65536 bytes. This means that
! 4575: ** the maximum number of record bytes stored on an index B-Tree
! 4576: ** page is less than 16384 bytes and may be stored as a 2-byte
! 4577: ** varint. This information is used to attempt to avoid parsing
! 4578: ** the entire cell by checking for the cases where the record is
! 4579: ** stored entirely within the b-tree page by inspecting the first
! 4580: ** 2 bytes of the cell.
! 4581: */
! 4582: int nCell = pCell[0];
! 4583: if( nCell<=pPage->max1bytePayload
! 4584: /* && (pCell+nCell)<pPage->aDataEnd */
! 4585: ){
! 4586: /* This branch runs if the record-size field of the cell is a
! 4587: ** single byte varint and the record fits entirely on the main
! 4588: ** b-tree page. */
! 4589: testcase( pCell+nCell+1==pPage->aDataEnd );
! 4590: c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[1], pIdxKey);
! 4591: }else if( !(pCell[1] & 0x80)
! 4592: && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal
! 4593: /* && (pCell+nCell+2)<=pPage->aDataEnd */
! 4594: ){
! 4595: /* The record-size field is a 2 byte varint and the record
! 4596: ** fits entirely on the main b-tree page. */
! 4597: testcase( pCell+nCell+2==pPage->aDataEnd );
! 4598: c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[2], pIdxKey);
! 4599: }else{
! 4600: /* The record flows over onto one or more overflow pages. In
! 4601: ** this case the whole cell needs to be parsed, a buffer allocated
! 4602: ** and accessPayload() used to retrieve the record into the
! 4603: ** buffer before VdbeRecordCompare() can be called. */
! 4604: void *pCellKey;
! 4605: u8 * const pCellBody = pCell - pPage->childPtrSize;
! 4606: btreeParseCellPtr(pPage, pCellBody, &pCur->info);
! 4607: nCell = (int)pCur->info.nKey;
! 4608: pCellKey = sqlite3Malloc( nCell );
! 4609: if( pCellKey==0 ){
! 4610: rc = SQLITE_NOMEM;
! 4611: goto moveto_finish;
! 4612: }
! 4613: rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0);
! 4614: if( rc ){
! 4615: sqlite3_free(pCellKey);
! 4616: goto moveto_finish;
! 4617: }
! 4618: c = sqlite3VdbeRecordCompare(nCell, pCellKey, pIdxKey);
! 4619: sqlite3_free(pCellKey);
! 4620: }
! 4621: }
! 4622: if( c==0 ){
! 4623: if( pPage->intKey && !pPage->leaf ){
! 4624: lwr = idx;
! 4625: break;
! 4626: }else{
! 4627: *pRes = 0;
! 4628: rc = SQLITE_OK;
! 4629: goto moveto_finish;
! 4630: }
! 4631: }
! 4632: if( c<0 ){
! 4633: lwr = idx+1;
! 4634: }else{
! 4635: upr = idx-1;
! 4636: }
! 4637: if( lwr>upr ){
! 4638: break;
! 4639: }
! 4640: pCur->aiIdx[pCur->iPage] = (u16)(idx = (lwr+upr)/2);
! 4641: }
! 4642: assert( lwr==upr+1 || (pPage->intKey && !pPage->leaf) );
! 4643: assert( pPage->isInit );
! 4644: if( pPage->leaf ){
! 4645: chldPg = 0;
! 4646: }else if( lwr>=pPage->nCell ){
! 4647: chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]);
! 4648: }else{
! 4649: chldPg = get4byte(findCell(pPage, lwr));
! 4650: }
! 4651: if( chldPg==0 ){
! 4652: assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
! 4653: *pRes = c;
! 4654: rc = SQLITE_OK;
! 4655: goto moveto_finish;
! 4656: }
! 4657: pCur->aiIdx[pCur->iPage] = (u16)lwr;
! 4658: pCur->info.nSize = 0;
! 4659: pCur->validNKey = 0;
! 4660: rc = moveToChild(pCur, chldPg);
! 4661: if( rc ) goto moveto_finish;
! 4662: }
! 4663: moveto_finish:
! 4664: return rc;
! 4665: }
! 4666:
! 4667:
! 4668: /*
! 4669: ** Return TRUE if the cursor is not pointing at an entry of the table.
! 4670: **
! 4671: ** TRUE will be returned after a call to sqlite3BtreeNext() moves
! 4672: ** past the last entry in the table or sqlite3BtreePrev() moves past
! 4673: ** the first entry. TRUE is also returned if the table is empty.
! 4674: */
! 4675: int sqlite3BtreeEof(BtCursor *pCur){
! 4676: /* TODO: What if the cursor is in CURSOR_REQUIRESEEK but all table entries
! 4677: ** have been deleted? This API will need to change to return an error code
! 4678: ** as well as the boolean result value.
! 4679: */
! 4680: return (CURSOR_VALID!=pCur->eState);
! 4681: }
! 4682:
! 4683: /*
! 4684: ** Advance the cursor to the next entry in the database. If
! 4685: ** successful then set *pRes=0. If the cursor
! 4686: ** was already pointing to the last entry in the database before
! 4687: ** this routine was called, then set *pRes=1.
! 4688: */
! 4689: int sqlite3BtreeNext(BtCursor *pCur, int *pRes){
! 4690: int rc;
! 4691: int idx;
! 4692: MemPage *pPage;
! 4693:
! 4694: assert( cursorHoldsMutex(pCur) );
! 4695: rc = restoreCursorPosition(pCur);
! 4696: if( rc!=SQLITE_OK ){
! 4697: return rc;
! 4698: }
! 4699: assert( pRes!=0 );
! 4700: if( CURSOR_INVALID==pCur->eState ){
! 4701: *pRes = 1;
! 4702: return SQLITE_OK;
! 4703: }
! 4704: if( pCur->skipNext>0 ){
! 4705: pCur->skipNext = 0;
! 4706: *pRes = 0;
! 4707: return SQLITE_OK;
! 4708: }
! 4709: pCur->skipNext = 0;
! 4710:
! 4711: pPage = pCur->apPage[pCur->iPage];
! 4712: idx = ++pCur->aiIdx[pCur->iPage];
! 4713: assert( pPage->isInit );
! 4714:
! 4715: /* If the database file is corrupt, it is possible for the value of idx
! 4716: ** to be invalid here. This can only occur if a second cursor modifies
! 4717: ** the page while cursor pCur is holding a reference to it. Which can
! 4718: ** only happen if the database is corrupt in such a way as to link the
! 4719: ** page into more than one b-tree structure. */
! 4720: testcase( idx>pPage->nCell );
! 4721:
! 4722: pCur->info.nSize = 0;
! 4723: pCur->validNKey = 0;
! 4724: if( idx>=pPage->nCell ){
! 4725: if( !pPage->leaf ){
! 4726: rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
! 4727: if( rc ) return rc;
! 4728: rc = moveToLeftmost(pCur);
! 4729: *pRes = 0;
! 4730: return rc;
! 4731: }
! 4732: do{
! 4733: if( pCur->iPage==0 ){
! 4734: *pRes = 1;
! 4735: pCur->eState = CURSOR_INVALID;
! 4736: return SQLITE_OK;
! 4737: }
! 4738: moveToParent(pCur);
! 4739: pPage = pCur->apPage[pCur->iPage];
! 4740: }while( pCur->aiIdx[pCur->iPage]>=pPage->nCell );
! 4741: *pRes = 0;
! 4742: if( pPage->intKey ){
! 4743: rc = sqlite3BtreeNext(pCur, pRes);
! 4744: }else{
! 4745: rc = SQLITE_OK;
! 4746: }
! 4747: return rc;
! 4748: }
! 4749: *pRes = 0;
! 4750: if( pPage->leaf ){
! 4751: return SQLITE_OK;
! 4752: }
! 4753: rc = moveToLeftmost(pCur);
! 4754: return rc;
! 4755: }
! 4756:
! 4757:
! 4758: /*
! 4759: ** Step the cursor to the back to the previous entry in the database. If
! 4760: ** successful then set *pRes=0. If the cursor
! 4761: ** was already pointing to the first entry in the database before
! 4762: ** this routine was called, then set *pRes=1.
! 4763: */
! 4764: int sqlite3BtreePrevious(BtCursor *pCur, int *pRes){
! 4765: int rc;
! 4766: MemPage *pPage;
! 4767:
! 4768: assert( cursorHoldsMutex(pCur) );
! 4769: rc = restoreCursorPosition(pCur);
! 4770: if( rc!=SQLITE_OK ){
! 4771: return rc;
! 4772: }
! 4773: pCur->atLast = 0;
! 4774: if( CURSOR_INVALID==pCur->eState ){
! 4775: *pRes = 1;
! 4776: return SQLITE_OK;
! 4777: }
! 4778: if( pCur->skipNext<0 ){
! 4779: pCur->skipNext = 0;
! 4780: *pRes = 0;
! 4781: return SQLITE_OK;
! 4782: }
! 4783: pCur->skipNext = 0;
! 4784:
! 4785: pPage = pCur->apPage[pCur->iPage];
! 4786: assert( pPage->isInit );
! 4787: if( !pPage->leaf ){
! 4788: int idx = pCur->aiIdx[pCur->iPage];
! 4789: rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
! 4790: if( rc ){
! 4791: return rc;
! 4792: }
! 4793: rc = moveToRightmost(pCur);
! 4794: }else{
! 4795: while( pCur->aiIdx[pCur->iPage]==0 ){
! 4796: if( pCur->iPage==0 ){
! 4797: pCur->eState = CURSOR_INVALID;
! 4798: *pRes = 1;
! 4799: return SQLITE_OK;
! 4800: }
! 4801: moveToParent(pCur);
! 4802: }
! 4803: pCur->info.nSize = 0;
! 4804: pCur->validNKey = 0;
! 4805:
! 4806: pCur->aiIdx[pCur->iPage]--;
! 4807: pPage = pCur->apPage[pCur->iPage];
! 4808: if( pPage->intKey && !pPage->leaf ){
! 4809: rc = sqlite3BtreePrevious(pCur, pRes);
! 4810: }else{
! 4811: rc = SQLITE_OK;
! 4812: }
! 4813: }
! 4814: *pRes = 0;
! 4815: return rc;
! 4816: }
! 4817:
! 4818: /*
! 4819: ** Allocate a new page from the database file.
! 4820: **
! 4821: ** The new page is marked as dirty. (In other words, sqlite3PagerWrite()
! 4822: ** has already been called on the new page.) The new page has also
! 4823: ** been referenced and the calling routine is responsible for calling
! 4824: ** sqlite3PagerUnref() on the new page when it is done.
! 4825: **
! 4826: ** SQLITE_OK is returned on success. Any other return value indicates
! 4827: ** an error. *ppPage and *pPgno are undefined in the event of an error.
! 4828: ** Do not invoke sqlite3PagerUnref() on *ppPage if an error is returned.
! 4829: **
! 4830: ** If the "nearby" parameter is not 0, then a (feeble) effort is made to
! 4831: ** locate a page close to the page number "nearby". This can be used in an
! 4832: ** attempt to keep related pages close to each other in the database file,
! 4833: ** which in turn can make database access faster.
! 4834: **
! 4835: ** If the "exact" parameter is not 0, and the page-number nearby exists
! 4836: ** anywhere on the free-list, then it is guarenteed to be returned. This
! 4837: ** is only used by auto-vacuum databases when allocating a new table.
! 4838: */
! 4839: static int allocateBtreePage(
! 4840: BtShared *pBt,
! 4841: MemPage **ppPage,
! 4842: Pgno *pPgno,
! 4843: Pgno nearby,
! 4844: u8 exact
! 4845: ){
! 4846: MemPage *pPage1;
! 4847: int rc;
! 4848: u32 n; /* Number of pages on the freelist */
! 4849: u32 k; /* Number of leaves on the trunk of the freelist */
! 4850: MemPage *pTrunk = 0;
! 4851: MemPage *pPrevTrunk = 0;
! 4852: Pgno mxPage; /* Total size of the database file */
! 4853:
! 4854: assert( sqlite3_mutex_held(pBt->mutex) );
! 4855: pPage1 = pBt->pPage1;
! 4856: mxPage = btreePagecount(pBt);
! 4857: n = get4byte(&pPage1->aData[36]);
! 4858: testcase( n==mxPage-1 );
! 4859: if( n>=mxPage ){
! 4860: return SQLITE_CORRUPT_BKPT;
! 4861: }
! 4862: if( n>0 ){
! 4863: /* There are pages on the freelist. Reuse one of those pages. */
! 4864: Pgno iTrunk;
! 4865: u8 searchList = 0; /* If the free-list must be searched for 'nearby' */
! 4866:
! 4867: /* If the 'exact' parameter was true and a query of the pointer-map
! 4868: ** shows that the page 'nearby' is somewhere on the free-list, then
! 4869: ** the entire-list will be searched for that page.
! 4870: */
! 4871: #ifndef SQLITE_OMIT_AUTOVACUUM
! 4872: if( exact && nearby<=mxPage ){
! 4873: u8 eType;
! 4874: assert( nearby>0 );
! 4875: assert( pBt->autoVacuum );
! 4876: rc = ptrmapGet(pBt, nearby, &eType, 0);
! 4877: if( rc ) return rc;
! 4878: if( eType==PTRMAP_FREEPAGE ){
! 4879: searchList = 1;
! 4880: }
! 4881: *pPgno = nearby;
! 4882: }
! 4883: #endif
! 4884:
! 4885: /* Decrement the free-list count by 1. Set iTrunk to the index of the
! 4886: ** first free-list trunk page. iPrevTrunk is initially 1.
! 4887: */
! 4888: rc = sqlite3PagerWrite(pPage1->pDbPage);
! 4889: if( rc ) return rc;
! 4890: put4byte(&pPage1->aData[36], n-1);
! 4891:
! 4892: /* The code within this loop is run only once if the 'searchList' variable
! 4893: ** is not true. Otherwise, it runs once for each trunk-page on the
! 4894: ** free-list until the page 'nearby' is located.
! 4895: */
! 4896: do {
! 4897: pPrevTrunk = pTrunk;
! 4898: if( pPrevTrunk ){
! 4899: iTrunk = get4byte(&pPrevTrunk->aData[0]);
! 4900: }else{
! 4901: iTrunk = get4byte(&pPage1->aData[32]);
! 4902: }
! 4903: testcase( iTrunk==mxPage );
! 4904: if( iTrunk>mxPage ){
! 4905: rc = SQLITE_CORRUPT_BKPT;
! 4906: }else{
! 4907: rc = btreeGetPage(pBt, iTrunk, &pTrunk, 0);
! 4908: }
! 4909: if( rc ){
! 4910: pTrunk = 0;
! 4911: goto end_allocate_page;
! 4912: }
! 4913: assert( pTrunk!=0 );
! 4914: assert( pTrunk->aData!=0 );
! 4915:
! 4916: k = get4byte(&pTrunk->aData[4]); /* # of leaves on this trunk page */
! 4917: if( k==0 && !searchList ){
! 4918: /* The trunk has no leaves and the list is not being searched.
! 4919: ** So extract the trunk page itself and use it as the newly
! 4920: ** allocated page */
! 4921: assert( pPrevTrunk==0 );
! 4922: rc = sqlite3PagerWrite(pTrunk->pDbPage);
! 4923: if( rc ){
! 4924: goto end_allocate_page;
! 4925: }
! 4926: *pPgno = iTrunk;
! 4927: memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
! 4928: *ppPage = pTrunk;
! 4929: pTrunk = 0;
! 4930: TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1));
! 4931: }else if( k>(u32)(pBt->usableSize/4 - 2) ){
! 4932: /* Value of k is out of range. Database corruption */
! 4933: rc = SQLITE_CORRUPT_BKPT;
! 4934: goto end_allocate_page;
! 4935: #ifndef SQLITE_OMIT_AUTOVACUUM
! 4936: }else if( searchList && nearby==iTrunk ){
! 4937: /* The list is being searched and this trunk page is the page
! 4938: ** to allocate, regardless of whether it has leaves.
! 4939: */
! 4940: assert( *pPgno==iTrunk );
! 4941: *ppPage = pTrunk;
! 4942: searchList = 0;
! 4943: rc = sqlite3PagerWrite(pTrunk->pDbPage);
! 4944: if( rc ){
! 4945: goto end_allocate_page;
! 4946: }
! 4947: if( k==0 ){
! 4948: if( !pPrevTrunk ){
! 4949: memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
! 4950: }else{
! 4951: rc = sqlite3PagerWrite(pPrevTrunk->pDbPage);
! 4952: if( rc!=SQLITE_OK ){
! 4953: goto end_allocate_page;
! 4954: }
! 4955: memcpy(&pPrevTrunk->aData[0], &pTrunk->aData[0], 4);
! 4956: }
! 4957: }else{
! 4958: /* The trunk page is required by the caller but it contains
! 4959: ** pointers to free-list leaves. The first leaf becomes a trunk
! 4960: ** page in this case.
! 4961: */
! 4962: MemPage *pNewTrunk;
! 4963: Pgno iNewTrunk = get4byte(&pTrunk->aData[8]);
! 4964: if( iNewTrunk>mxPage ){
! 4965: rc = SQLITE_CORRUPT_BKPT;
! 4966: goto end_allocate_page;
! 4967: }
! 4968: testcase( iNewTrunk==mxPage );
! 4969: rc = btreeGetPage(pBt, iNewTrunk, &pNewTrunk, 0);
! 4970: if( rc!=SQLITE_OK ){
! 4971: goto end_allocate_page;
! 4972: }
! 4973: rc = sqlite3PagerWrite(pNewTrunk->pDbPage);
! 4974: if( rc!=SQLITE_OK ){
! 4975: releasePage(pNewTrunk);
! 4976: goto end_allocate_page;
! 4977: }
! 4978: memcpy(&pNewTrunk->aData[0], &pTrunk->aData[0], 4);
! 4979: put4byte(&pNewTrunk->aData[4], k-1);
! 4980: memcpy(&pNewTrunk->aData[8], &pTrunk->aData[12], (k-1)*4);
! 4981: releasePage(pNewTrunk);
! 4982: if( !pPrevTrunk ){
! 4983: assert( sqlite3PagerIswriteable(pPage1->pDbPage) );
! 4984: put4byte(&pPage1->aData[32], iNewTrunk);
! 4985: }else{
! 4986: rc = sqlite3PagerWrite(pPrevTrunk->pDbPage);
! 4987: if( rc ){
! 4988: goto end_allocate_page;
! 4989: }
! 4990: put4byte(&pPrevTrunk->aData[0], iNewTrunk);
! 4991: }
! 4992: }
! 4993: pTrunk = 0;
! 4994: TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1));
! 4995: #endif
! 4996: }else if( k>0 ){
! 4997: /* Extract a leaf from the trunk */
! 4998: u32 closest;
! 4999: Pgno iPage;
! 5000: unsigned char *aData = pTrunk->aData;
! 5001: if( nearby>0 ){
! 5002: u32 i;
! 5003: int dist;
! 5004: closest = 0;
! 5005: dist = sqlite3AbsInt32(get4byte(&aData[8]) - nearby);
! 5006: for(i=1; i<k; i++){
! 5007: int d2 = sqlite3AbsInt32(get4byte(&aData[8+i*4]) - nearby);
! 5008: if( d2<dist ){
! 5009: closest = i;
! 5010: dist = d2;
! 5011: }
! 5012: }
! 5013: }else{
! 5014: closest = 0;
! 5015: }
! 5016:
! 5017: iPage = get4byte(&aData[8+closest*4]);
! 5018: testcase( iPage==mxPage );
! 5019: if( iPage>mxPage ){
! 5020: rc = SQLITE_CORRUPT_BKPT;
! 5021: goto end_allocate_page;
! 5022: }
! 5023: testcase( iPage==mxPage );
! 5024: if( !searchList || iPage==nearby ){
! 5025: int noContent;
! 5026: *pPgno = iPage;
! 5027: TRACE(("ALLOCATE: %d was leaf %d of %d on trunk %d"
! 5028: ": %d more free pages\n",
! 5029: *pPgno, closest+1, k, pTrunk->pgno, n-1));
! 5030: rc = sqlite3PagerWrite(pTrunk->pDbPage);
! 5031: if( rc ) goto end_allocate_page;
! 5032: if( closest<k-1 ){
! 5033: memcpy(&aData[8+closest*4], &aData[4+k*4], 4);
! 5034: }
! 5035: put4byte(&aData[4], k-1);
! 5036: noContent = !btreeGetHasContent(pBt, *pPgno);
! 5037: rc = btreeGetPage(pBt, *pPgno, ppPage, noContent);
! 5038: if( rc==SQLITE_OK ){
! 5039: rc = sqlite3PagerWrite((*ppPage)->pDbPage);
! 5040: if( rc!=SQLITE_OK ){
! 5041: releasePage(*ppPage);
! 5042: }
! 5043: }
! 5044: searchList = 0;
! 5045: }
! 5046: }
! 5047: releasePage(pPrevTrunk);
! 5048: pPrevTrunk = 0;
! 5049: }while( searchList );
! 5050: }else{
! 5051: /* There are no pages on the freelist, so create a new page at the
! 5052: ** end of the file */
! 5053: rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
! 5054: if( rc ) return rc;
! 5055: pBt->nPage++;
! 5056: if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ) pBt->nPage++;
! 5057:
! 5058: #ifndef SQLITE_OMIT_AUTOVACUUM
! 5059: if( pBt->autoVacuum && PTRMAP_ISPAGE(pBt, pBt->nPage) ){
! 5060: /* If *pPgno refers to a pointer-map page, allocate two new pages
! 5061: ** at the end of the file instead of one. The first allocated page
! 5062: ** becomes a new pointer-map page, the second is used by the caller.
! 5063: */
! 5064: MemPage *pPg = 0;
! 5065: TRACE(("ALLOCATE: %d from end of file (pointer-map page)\n", pBt->nPage));
! 5066: assert( pBt->nPage!=PENDING_BYTE_PAGE(pBt) );
! 5067: rc = btreeGetPage(pBt, pBt->nPage, &pPg, 1);
! 5068: if( rc==SQLITE_OK ){
! 5069: rc = sqlite3PagerWrite(pPg->pDbPage);
! 5070: releasePage(pPg);
! 5071: }
! 5072: if( rc ) return rc;
! 5073: pBt->nPage++;
! 5074: if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ){ pBt->nPage++; }
! 5075: }
! 5076: #endif
! 5077: put4byte(28 + (u8*)pBt->pPage1->aData, pBt->nPage);
! 5078: *pPgno = pBt->nPage;
! 5079:
! 5080: assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
! 5081: rc = btreeGetPage(pBt, *pPgno, ppPage, 1);
! 5082: if( rc ) return rc;
! 5083: rc = sqlite3PagerWrite((*ppPage)->pDbPage);
! 5084: if( rc!=SQLITE_OK ){
! 5085: releasePage(*ppPage);
! 5086: }
! 5087: TRACE(("ALLOCATE: %d from end of file\n", *pPgno));
! 5088: }
! 5089:
! 5090: assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
! 5091:
! 5092: end_allocate_page:
! 5093: releasePage(pTrunk);
! 5094: releasePage(pPrevTrunk);
! 5095: if( rc==SQLITE_OK ){
! 5096: if( sqlite3PagerPageRefcount((*ppPage)->pDbPage)>1 ){
! 5097: releasePage(*ppPage);
! 5098: return SQLITE_CORRUPT_BKPT;
! 5099: }
! 5100: (*ppPage)->isInit = 0;
! 5101: }else{
! 5102: *ppPage = 0;
! 5103: }
! 5104: assert( rc!=SQLITE_OK || sqlite3PagerIswriteable((*ppPage)->pDbPage) );
! 5105: return rc;
! 5106: }
! 5107:
! 5108: /*
! 5109: ** This function is used to add page iPage to the database file free-list.
! 5110: ** It is assumed that the page is not already a part of the free-list.
! 5111: **
! 5112: ** The value passed as the second argument to this function is optional.
! 5113: ** If the caller happens to have a pointer to the MemPage object
! 5114: ** corresponding to page iPage handy, it may pass it as the second value.
! 5115: ** Otherwise, it may pass NULL.
! 5116: **
! 5117: ** If a pointer to a MemPage object is passed as the second argument,
! 5118: ** its reference count is not altered by this function.
! 5119: */
! 5120: static int freePage2(BtShared *pBt, MemPage *pMemPage, Pgno iPage){
! 5121: MemPage *pTrunk = 0; /* Free-list trunk page */
! 5122: Pgno iTrunk = 0; /* Page number of free-list trunk page */
! 5123: MemPage *pPage1 = pBt->pPage1; /* Local reference to page 1 */
! 5124: MemPage *pPage; /* Page being freed. May be NULL. */
! 5125: int rc; /* Return Code */
! 5126: int nFree; /* Initial number of pages on free-list */
! 5127:
! 5128: assert( sqlite3_mutex_held(pBt->mutex) );
! 5129: assert( iPage>1 );
! 5130: assert( !pMemPage || pMemPage->pgno==iPage );
! 5131:
! 5132: if( pMemPage ){
! 5133: pPage = pMemPage;
! 5134: sqlite3PagerRef(pPage->pDbPage);
! 5135: }else{
! 5136: pPage = btreePageLookup(pBt, iPage);
! 5137: }
! 5138:
! 5139: /* Increment the free page count on pPage1 */
! 5140: rc = sqlite3PagerWrite(pPage1->pDbPage);
! 5141: if( rc ) goto freepage_out;
! 5142: nFree = get4byte(&pPage1->aData[36]);
! 5143: put4byte(&pPage1->aData[36], nFree+1);
! 5144:
! 5145: if( pBt->btsFlags & BTS_SECURE_DELETE ){
! 5146: /* If the secure_delete option is enabled, then
! 5147: ** always fully overwrite deleted information with zeros.
! 5148: */
! 5149: if( (!pPage && ((rc = btreeGetPage(pBt, iPage, &pPage, 0))!=0) )
! 5150: || ((rc = sqlite3PagerWrite(pPage->pDbPage))!=0)
! 5151: ){
! 5152: goto freepage_out;
! 5153: }
! 5154: memset(pPage->aData, 0, pPage->pBt->pageSize);
! 5155: }
! 5156:
! 5157: /* If the database supports auto-vacuum, write an entry in the pointer-map
! 5158: ** to indicate that the page is free.
! 5159: */
! 5160: if( ISAUTOVACUUM ){
! 5161: ptrmapPut(pBt, iPage, PTRMAP_FREEPAGE, 0, &rc);
! 5162: if( rc ) goto freepage_out;
! 5163: }
! 5164:
! 5165: /* Now manipulate the actual database free-list structure. There are two
! 5166: ** possibilities. If the free-list is currently empty, or if the first
! 5167: ** trunk page in the free-list is full, then this page will become a
! 5168: ** new free-list trunk page. Otherwise, it will become a leaf of the
! 5169: ** first trunk page in the current free-list. This block tests if it
! 5170: ** is possible to add the page as a new free-list leaf.
! 5171: */
! 5172: if( nFree!=0 ){
! 5173: u32 nLeaf; /* Initial number of leaf cells on trunk page */
! 5174:
! 5175: iTrunk = get4byte(&pPage1->aData[32]);
! 5176: rc = btreeGetPage(pBt, iTrunk, &pTrunk, 0);
! 5177: if( rc!=SQLITE_OK ){
! 5178: goto freepage_out;
! 5179: }
! 5180:
! 5181: nLeaf = get4byte(&pTrunk->aData[4]);
! 5182: assert( pBt->usableSize>32 );
! 5183: if( nLeaf > (u32)pBt->usableSize/4 - 2 ){
! 5184: rc = SQLITE_CORRUPT_BKPT;
! 5185: goto freepage_out;
! 5186: }
! 5187: if( nLeaf < (u32)pBt->usableSize/4 - 8 ){
! 5188: /* In this case there is room on the trunk page to insert the page
! 5189: ** being freed as a new leaf.
! 5190: **
! 5191: ** Note that the trunk page is not really full until it contains
! 5192: ** usableSize/4 - 2 entries, not usableSize/4 - 8 entries as we have
! 5193: ** coded. But due to a coding error in versions of SQLite prior to
! 5194: ** 3.6.0, databases with freelist trunk pages holding more than
! 5195: ** usableSize/4 - 8 entries will be reported as corrupt. In order
! 5196: ** to maintain backwards compatibility with older versions of SQLite,
! 5197: ** we will continue to restrict the number of entries to usableSize/4 - 8
! 5198: ** for now. At some point in the future (once everyone has upgraded
! 5199: ** to 3.6.0 or later) we should consider fixing the conditional above
! 5200: ** to read "usableSize/4-2" instead of "usableSize/4-8".
! 5201: */
! 5202: rc = sqlite3PagerWrite(pTrunk->pDbPage);
! 5203: if( rc==SQLITE_OK ){
! 5204: put4byte(&pTrunk->aData[4], nLeaf+1);
! 5205: put4byte(&pTrunk->aData[8+nLeaf*4], iPage);
! 5206: if( pPage && (pBt->btsFlags & BTS_SECURE_DELETE)==0 ){
! 5207: sqlite3PagerDontWrite(pPage->pDbPage);
! 5208: }
! 5209: rc = btreeSetHasContent(pBt, iPage);
! 5210: }
! 5211: TRACE(("FREE-PAGE: %d leaf on trunk page %d\n",pPage->pgno,pTrunk->pgno));
! 5212: goto freepage_out;
! 5213: }
! 5214: }
! 5215:
! 5216: /* If control flows to this point, then it was not possible to add the
! 5217: ** the page being freed as a leaf page of the first trunk in the free-list.
! 5218: ** Possibly because the free-list is empty, or possibly because the
! 5219: ** first trunk in the free-list is full. Either way, the page being freed
! 5220: ** will become the new first trunk page in the free-list.
! 5221: */
! 5222: if( pPage==0 && SQLITE_OK!=(rc = btreeGetPage(pBt, iPage, &pPage, 0)) ){
! 5223: goto freepage_out;
! 5224: }
! 5225: rc = sqlite3PagerWrite(pPage->pDbPage);
! 5226: if( rc!=SQLITE_OK ){
! 5227: goto freepage_out;
! 5228: }
! 5229: put4byte(pPage->aData, iTrunk);
! 5230: put4byte(&pPage->aData[4], 0);
! 5231: put4byte(&pPage1->aData[32], iPage);
! 5232: TRACE(("FREE-PAGE: %d new trunk page replacing %d\n", pPage->pgno, iTrunk));
! 5233:
! 5234: freepage_out:
! 5235: if( pPage ){
! 5236: pPage->isInit = 0;
! 5237: }
! 5238: releasePage(pPage);
! 5239: releasePage(pTrunk);
! 5240: return rc;
! 5241: }
! 5242: static void freePage(MemPage *pPage, int *pRC){
! 5243: if( (*pRC)==SQLITE_OK ){
! 5244: *pRC = freePage2(pPage->pBt, pPage, pPage->pgno);
! 5245: }
! 5246: }
! 5247:
! 5248: /*
! 5249: ** Free any overflow pages associated with the given Cell.
! 5250: */
! 5251: static int clearCell(MemPage *pPage, unsigned char *pCell){
! 5252: BtShared *pBt = pPage->pBt;
! 5253: CellInfo info;
! 5254: Pgno ovflPgno;
! 5255: int rc;
! 5256: int nOvfl;
! 5257: u32 ovflPageSize;
! 5258:
! 5259: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
! 5260: btreeParseCellPtr(pPage, pCell, &info);
! 5261: if( info.iOverflow==0 ){
! 5262: return SQLITE_OK; /* No overflow pages. Return without doing anything */
! 5263: }
! 5264: if( pCell+info.iOverflow+3 > pPage->aData+pPage->maskPage ){
! 5265: return SQLITE_CORRUPT; /* Cell extends past end of page */
! 5266: }
! 5267: ovflPgno = get4byte(&pCell[info.iOverflow]);
! 5268: assert( pBt->usableSize > 4 );
! 5269: ovflPageSize = pBt->usableSize - 4;
! 5270: nOvfl = (info.nPayload - info.nLocal + ovflPageSize - 1)/ovflPageSize;
! 5271: assert( ovflPgno==0 || nOvfl>0 );
! 5272: while( nOvfl-- ){
! 5273: Pgno iNext = 0;
! 5274: MemPage *pOvfl = 0;
! 5275: if( ovflPgno<2 || ovflPgno>btreePagecount(pBt) ){
! 5276: /* 0 is not a legal page number and page 1 cannot be an
! 5277: ** overflow page. Therefore if ovflPgno<2 or past the end of the
! 5278: ** file the database must be corrupt. */
! 5279: return SQLITE_CORRUPT_BKPT;
! 5280: }
! 5281: if( nOvfl ){
! 5282: rc = getOverflowPage(pBt, ovflPgno, &pOvfl, &iNext);
! 5283: if( rc ) return rc;
! 5284: }
! 5285:
! 5286: if( ( pOvfl || ((pOvfl = btreePageLookup(pBt, ovflPgno))!=0) )
! 5287: && sqlite3PagerPageRefcount(pOvfl->pDbPage)!=1
! 5288: ){
! 5289: /* There is no reason any cursor should have an outstanding reference
! 5290: ** to an overflow page belonging to a cell that is being deleted/updated.
! 5291: ** So if there exists more than one reference to this page, then it
! 5292: ** must not really be an overflow page and the database must be corrupt.
! 5293: ** It is helpful to detect this before calling freePage2(), as
! 5294: ** freePage2() may zero the page contents if secure-delete mode is
! 5295: ** enabled. If this 'overflow' page happens to be a page that the
! 5296: ** caller is iterating through or using in some other way, this
! 5297: ** can be problematic.
! 5298: */
! 5299: rc = SQLITE_CORRUPT_BKPT;
! 5300: }else{
! 5301: rc = freePage2(pBt, pOvfl, ovflPgno);
! 5302: }
! 5303:
! 5304: if( pOvfl ){
! 5305: sqlite3PagerUnref(pOvfl->pDbPage);
! 5306: }
! 5307: if( rc ) return rc;
! 5308: ovflPgno = iNext;
! 5309: }
! 5310: return SQLITE_OK;
! 5311: }
! 5312:
! 5313: /*
! 5314: ** Create the byte sequence used to represent a cell on page pPage
! 5315: ** and write that byte sequence into pCell[]. Overflow pages are
! 5316: ** allocated and filled in as necessary. The calling procedure
! 5317: ** is responsible for making sure sufficient space has been allocated
! 5318: ** for pCell[].
! 5319: **
! 5320: ** Note that pCell does not necessary need to point to the pPage->aData
! 5321: ** area. pCell might point to some temporary storage. The cell will
! 5322: ** be constructed in this temporary area then copied into pPage->aData
! 5323: ** later.
! 5324: */
! 5325: static int fillInCell(
! 5326: MemPage *pPage, /* The page that contains the cell */
! 5327: unsigned char *pCell, /* Complete text of the cell */
! 5328: const void *pKey, i64 nKey, /* The key */
! 5329: const void *pData,int nData, /* The data */
! 5330: int nZero, /* Extra zero bytes to append to pData */
! 5331: int *pnSize /* Write cell size here */
! 5332: ){
! 5333: int nPayload;
! 5334: const u8 *pSrc;
! 5335: int nSrc, n, rc;
! 5336: int spaceLeft;
! 5337: MemPage *pOvfl = 0;
! 5338: MemPage *pToRelease = 0;
! 5339: unsigned char *pPrior;
! 5340: unsigned char *pPayload;
! 5341: BtShared *pBt = pPage->pBt;
! 5342: Pgno pgnoOvfl = 0;
! 5343: int nHeader;
! 5344: CellInfo info;
! 5345:
! 5346: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
! 5347:
! 5348: /* pPage is not necessarily writeable since pCell might be auxiliary
! 5349: ** buffer space that is separate from the pPage buffer area */
! 5350: assert( pCell<pPage->aData || pCell>=&pPage->aData[pBt->pageSize]
! 5351: || sqlite3PagerIswriteable(pPage->pDbPage) );
! 5352:
! 5353: /* Fill in the header. */
! 5354: nHeader = 0;
! 5355: if( !pPage->leaf ){
! 5356: nHeader += 4;
! 5357: }
! 5358: if( pPage->hasData ){
! 5359: nHeader += putVarint(&pCell[nHeader], nData+nZero);
! 5360: }else{
! 5361: nData = nZero = 0;
! 5362: }
! 5363: nHeader += putVarint(&pCell[nHeader], *(u64*)&nKey);
! 5364: btreeParseCellPtr(pPage, pCell, &info);
! 5365: assert( info.nHeader==nHeader );
! 5366: assert( info.nKey==nKey );
! 5367: assert( info.nData==(u32)(nData+nZero) );
! 5368:
! 5369: /* Fill in the payload */
! 5370: nPayload = nData + nZero;
! 5371: if( pPage->intKey ){
! 5372: pSrc = pData;
! 5373: nSrc = nData;
! 5374: nData = 0;
! 5375: }else{
! 5376: if( NEVER(nKey>0x7fffffff || pKey==0) ){
! 5377: return SQLITE_CORRUPT_BKPT;
! 5378: }
! 5379: nPayload += (int)nKey;
! 5380: pSrc = pKey;
! 5381: nSrc = (int)nKey;
! 5382: }
! 5383: *pnSize = info.nSize;
! 5384: spaceLeft = info.nLocal;
! 5385: pPayload = &pCell[nHeader];
! 5386: pPrior = &pCell[info.iOverflow];
! 5387:
! 5388: while( nPayload>0 ){
! 5389: if( spaceLeft==0 ){
! 5390: #ifndef SQLITE_OMIT_AUTOVACUUM
! 5391: Pgno pgnoPtrmap = pgnoOvfl; /* Overflow page pointer-map entry page */
! 5392: if( pBt->autoVacuum ){
! 5393: do{
! 5394: pgnoOvfl++;
! 5395: } while(
! 5396: PTRMAP_ISPAGE(pBt, pgnoOvfl) || pgnoOvfl==PENDING_BYTE_PAGE(pBt)
! 5397: );
! 5398: }
! 5399: #endif
! 5400: rc = allocateBtreePage(pBt, &pOvfl, &pgnoOvfl, pgnoOvfl, 0);
! 5401: #ifndef SQLITE_OMIT_AUTOVACUUM
! 5402: /* If the database supports auto-vacuum, and the second or subsequent
! 5403: ** overflow page is being allocated, add an entry to the pointer-map
! 5404: ** for that page now.
! 5405: **
! 5406: ** If this is the first overflow page, then write a partial entry
! 5407: ** to the pointer-map. If we write nothing to this pointer-map slot,
! 5408: ** then the optimistic overflow chain processing in clearCell()
! 5409: ** may misinterpret the uninitialised values and delete the
! 5410: ** wrong pages from the database.
! 5411: */
! 5412: if( pBt->autoVacuum && rc==SQLITE_OK ){
! 5413: u8 eType = (pgnoPtrmap?PTRMAP_OVERFLOW2:PTRMAP_OVERFLOW1);
! 5414: ptrmapPut(pBt, pgnoOvfl, eType, pgnoPtrmap, &rc);
! 5415: if( rc ){
! 5416: releasePage(pOvfl);
! 5417: }
! 5418: }
! 5419: #endif
! 5420: if( rc ){
! 5421: releasePage(pToRelease);
! 5422: return rc;
! 5423: }
! 5424:
! 5425: /* If pToRelease is not zero than pPrior points into the data area
! 5426: ** of pToRelease. Make sure pToRelease is still writeable. */
! 5427: assert( pToRelease==0 || sqlite3PagerIswriteable(pToRelease->pDbPage) );
! 5428:
! 5429: /* If pPrior is part of the data area of pPage, then make sure pPage
! 5430: ** is still writeable */
! 5431: assert( pPrior<pPage->aData || pPrior>=&pPage->aData[pBt->pageSize]
! 5432: || sqlite3PagerIswriteable(pPage->pDbPage) );
! 5433:
! 5434: put4byte(pPrior, pgnoOvfl);
! 5435: releasePage(pToRelease);
! 5436: pToRelease = pOvfl;
! 5437: pPrior = pOvfl->aData;
! 5438: put4byte(pPrior, 0);
! 5439: pPayload = &pOvfl->aData[4];
! 5440: spaceLeft = pBt->usableSize - 4;
! 5441: }
! 5442: n = nPayload;
! 5443: if( n>spaceLeft ) n = spaceLeft;
! 5444:
! 5445: /* If pToRelease is not zero than pPayload points into the data area
! 5446: ** of pToRelease. Make sure pToRelease is still writeable. */
! 5447: assert( pToRelease==0 || sqlite3PagerIswriteable(pToRelease->pDbPage) );
! 5448:
! 5449: /* If pPayload is part of the data area of pPage, then make sure pPage
! 5450: ** is still writeable */
! 5451: assert( pPayload<pPage->aData || pPayload>=&pPage->aData[pBt->pageSize]
! 5452: || sqlite3PagerIswriteable(pPage->pDbPage) );
! 5453:
! 5454: if( nSrc>0 ){
! 5455: if( n>nSrc ) n = nSrc;
! 5456: assert( pSrc );
! 5457: memcpy(pPayload, pSrc, n);
! 5458: }else{
! 5459: memset(pPayload, 0, n);
! 5460: }
! 5461: nPayload -= n;
! 5462: pPayload += n;
! 5463: pSrc += n;
! 5464: nSrc -= n;
! 5465: spaceLeft -= n;
! 5466: if( nSrc==0 ){
! 5467: nSrc = nData;
! 5468: pSrc = pData;
! 5469: }
! 5470: }
! 5471: releasePage(pToRelease);
! 5472: return SQLITE_OK;
! 5473: }
! 5474:
! 5475: /*
! 5476: ** Remove the i-th cell from pPage. This routine effects pPage only.
! 5477: ** The cell content is not freed or deallocated. It is assumed that
! 5478: ** the cell content has been copied someplace else. This routine just
! 5479: ** removes the reference to the cell from pPage.
! 5480: **
! 5481: ** "sz" must be the number of bytes in the cell.
! 5482: */
! 5483: static void dropCell(MemPage *pPage, int idx, int sz, int *pRC){
! 5484: u32 pc; /* Offset to cell content of cell being deleted */
! 5485: u8 *data; /* pPage->aData */
! 5486: u8 *ptr; /* Used to move bytes around within data[] */
! 5487: u8 *endPtr; /* End of loop */
! 5488: int rc; /* The return code */
! 5489: int hdr; /* Beginning of the header. 0 most pages. 100 page 1 */
! 5490:
! 5491: if( *pRC ) return;
! 5492:
! 5493: assert( idx>=0 && idx<pPage->nCell );
! 5494: assert( sz==cellSize(pPage, idx) );
! 5495: assert( sqlite3PagerIswriteable(pPage->pDbPage) );
! 5496: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
! 5497: data = pPage->aData;
! 5498: ptr = &pPage->aCellIdx[2*idx];
! 5499: pc = get2byte(ptr);
! 5500: hdr = pPage->hdrOffset;
! 5501: testcase( pc==get2byte(&data[hdr+5]) );
! 5502: testcase( pc+sz==pPage->pBt->usableSize );
! 5503: if( pc < (u32)get2byte(&data[hdr+5]) || pc+sz > pPage->pBt->usableSize ){
! 5504: *pRC = SQLITE_CORRUPT_BKPT;
! 5505: return;
! 5506: }
! 5507: rc = freeSpace(pPage, pc, sz);
! 5508: if( rc ){
! 5509: *pRC = rc;
! 5510: return;
! 5511: }
! 5512: endPtr = &pPage->aCellIdx[2*pPage->nCell - 2];
! 5513: assert( (SQLITE_PTR_TO_INT(ptr)&1)==0 ); /* ptr is always 2-byte aligned */
! 5514: while( ptr<endPtr ){
! 5515: *(u16*)ptr = *(u16*)&ptr[2];
! 5516: ptr += 2;
! 5517: }
! 5518: pPage->nCell--;
! 5519: put2byte(&data[hdr+3], pPage->nCell);
! 5520: pPage->nFree += 2;
! 5521: }
! 5522:
! 5523: /*
! 5524: ** Insert a new cell on pPage at cell index "i". pCell points to the
! 5525: ** content of the cell.
! 5526: **
! 5527: ** If the cell content will fit on the page, then put it there. If it
! 5528: ** will not fit, then make a copy of the cell content into pTemp if
! 5529: ** pTemp is not null. Regardless of pTemp, allocate a new entry
! 5530: ** in pPage->aOvfl[] and make it point to the cell content (either
! 5531: ** in pTemp or the original pCell) and also record its index.
! 5532: ** Allocating a new entry in pPage->aCell[] implies that
! 5533: ** pPage->nOverflow is incremented.
! 5534: **
! 5535: ** If nSkip is non-zero, then do not copy the first nSkip bytes of the
! 5536: ** cell. The caller will overwrite them after this function returns. If
! 5537: ** nSkip is non-zero, then pCell may not point to an invalid memory location
! 5538: ** (but pCell+nSkip is always valid).
! 5539: */
! 5540: static void insertCell(
! 5541: MemPage *pPage, /* Page into which we are copying */
! 5542: int i, /* New cell becomes the i-th cell of the page */
! 5543: u8 *pCell, /* Content of the new cell */
! 5544: int sz, /* Bytes of content in pCell */
! 5545: u8 *pTemp, /* Temp storage space for pCell, if needed */
! 5546: Pgno iChild, /* If non-zero, replace first 4 bytes with this value */
! 5547: int *pRC /* Read and write return code from here */
! 5548: ){
! 5549: int idx = 0; /* Where to write new cell content in data[] */
! 5550: int j; /* Loop counter */
! 5551: int end; /* First byte past the last cell pointer in data[] */
! 5552: int ins; /* Index in data[] where new cell pointer is inserted */
! 5553: int cellOffset; /* Address of first cell pointer in data[] */
! 5554: u8 *data; /* The content of the whole page */
! 5555: u8 *ptr; /* Used for moving information around in data[] */
! 5556: u8 *endPtr; /* End of the loop */
! 5557:
! 5558: int nSkip = (iChild ? 4 : 0);
! 5559:
! 5560: if( *pRC ) return;
! 5561:
! 5562: assert( i>=0 && i<=pPage->nCell+pPage->nOverflow );
! 5563: assert( pPage->nCell<=MX_CELL(pPage->pBt) && MX_CELL(pPage->pBt)<=10921 );
! 5564: assert( pPage->nOverflow<=ArraySize(pPage->aOvfl) );
! 5565: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
! 5566: /* The cell should normally be sized correctly. However, when moving a
! 5567: ** malformed cell from a leaf page to an interior page, if the cell size
! 5568: ** wanted to be less than 4 but got rounded up to 4 on the leaf, then size
! 5569: ** might be less than 8 (leaf-size + pointer) on the interior node. Hence
! 5570: ** the term after the || in the following assert(). */
! 5571: assert( sz==cellSizePtr(pPage, pCell) || (sz==8 && iChild>0) );
! 5572: if( pPage->nOverflow || sz+2>pPage->nFree ){
! 5573: if( pTemp ){
! 5574: memcpy(pTemp+nSkip, pCell+nSkip, sz-nSkip);
! 5575: pCell = pTemp;
! 5576: }
! 5577: if( iChild ){
! 5578: put4byte(pCell, iChild);
! 5579: }
! 5580: j = pPage->nOverflow++;
! 5581: assert( j<(int)(sizeof(pPage->aOvfl)/sizeof(pPage->aOvfl[0])) );
! 5582: pPage->aOvfl[j].pCell = pCell;
! 5583: pPage->aOvfl[j].idx = (u16)i;
! 5584: }else{
! 5585: int rc = sqlite3PagerWrite(pPage->pDbPage);
! 5586: if( rc!=SQLITE_OK ){
! 5587: *pRC = rc;
! 5588: return;
! 5589: }
! 5590: assert( sqlite3PagerIswriteable(pPage->pDbPage) );
! 5591: data = pPage->aData;
! 5592: cellOffset = pPage->cellOffset;
! 5593: end = cellOffset + 2*pPage->nCell;
! 5594: ins = cellOffset + 2*i;
! 5595: rc = allocateSpace(pPage, sz, &idx);
! 5596: if( rc ){ *pRC = rc; return; }
! 5597: /* The allocateSpace() routine guarantees the following two properties
! 5598: ** if it returns success */
! 5599: assert( idx >= end+2 );
! 5600: assert( idx+sz <= (int)pPage->pBt->usableSize );
! 5601: pPage->nCell++;
! 5602: pPage->nFree -= (u16)(2 + sz);
! 5603: memcpy(&data[idx+nSkip], pCell+nSkip, sz-nSkip);
! 5604: if( iChild ){
! 5605: put4byte(&data[idx], iChild);
! 5606: }
! 5607: ptr = &data[end];
! 5608: endPtr = &data[ins];
! 5609: assert( (SQLITE_PTR_TO_INT(ptr)&1)==0 ); /* ptr is always 2-byte aligned */
! 5610: while( ptr>endPtr ){
! 5611: *(u16*)ptr = *(u16*)&ptr[-2];
! 5612: ptr -= 2;
! 5613: }
! 5614: put2byte(&data[ins], idx);
! 5615: put2byte(&data[pPage->hdrOffset+3], pPage->nCell);
! 5616: #ifndef SQLITE_OMIT_AUTOVACUUM
! 5617: if( pPage->pBt->autoVacuum ){
! 5618: /* The cell may contain a pointer to an overflow page. If so, write
! 5619: ** the entry for the overflow page into the pointer map.
! 5620: */
! 5621: ptrmapPutOvflPtr(pPage, pCell, pRC);
! 5622: }
! 5623: #endif
! 5624: }
! 5625: }
! 5626:
! 5627: /*
! 5628: ** Add a list of cells to a page. The page should be initially empty.
! 5629: ** The cells are guaranteed to fit on the page.
! 5630: */
! 5631: static void assemblePage(
! 5632: MemPage *pPage, /* The page to be assemblied */
! 5633: int nCell, /* The number of cells to add to this page */
! 5634: u8 **apCell, /* Pointers to cell bodies */
! 5635: u16 *aSize /* Sizes of the cells */
! 5636: ){
! 5637: int i; /* Loop counter */
! 5638: u8 *pCellptr; /* Address of next cell pointer */
! 5639: int cellbody; /* Address of next cell body */
! 5640: u8 * const data = pPage->aData; /* Pointer to data for pPage */
! 5641: const int hdr = pPage->hdrOffset; /* Offset of header on pPage */
! 5642: const int nUsable = pPage->pBt->usableSize; /* Usable size of page */
! 5643:
! 5644: assert( pPage->nOverflow==0 );
! 5645: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
! 5646: assert( nCell>=0 && nCell<=(int)MX_CELL(pPage->pBt)
! 5647: && (int)MX_CELL(pPage->pBt)<=10921);
! 5648: assert( sqlite3PagerIswriteable(pPage->pDbPage) );
! 5649:
! 5650: /* Check that the page has just been zeroed by zeroPage() */
! 5651: assert( pPage->nCell==0 );
! 5652: assert( get2byteNotZero(&data[hdr+5])==nUsable );
! 5653:
! 5654: pCellptr = &pPage->aCellIdx[nCell*2];
! 5655: cellbody = nUsable;
! 5656: for(i=nCell-1; i>=0; i--){
! 5657: u16 sz = aSize[i];
! 5658: pCellptr -= 2;
! 5659: cellbody -= sz;
! 5660: put2byte(pCellptr, cellbody);
! 5661: memcpy(&data[cellbody], apCell[i], sz);
! 5662: }
! 5663: put2byte(&data[hdr+3], nCell);
! 5664: put2byte(&data[hdr+5], cellbody);
! 5665: pPage->nFree -= (nCell*2 + nUsable - cellbody);
! 5666: pPage->nCell = (u16)nCell;
! 5667: }
! 5668:
! 5669: /*
! 5670: ** The following parameters determine how many adjacent pages get involved
! 5671: ** in a balancing operation. NN is the number of neighbors on either side
! 5672: ** of the page that participate in the balancing operation. NB is the
! 5673: ** total number of pages that participate, including the target page and
! 5674: ** NN neighbors on either side.
! 5675: **
! 5676: ** The minimum value of NN is 1 (of course). Increasing NN above 1
! 5677: ** (to 2 or 3) gives a modest improvement in SELECT and DELETE performance
! 5678: ** in exchange for a larger degradation in INSERT and UPDATE performance.
! 5679: ** The value of NN appears to give the best results overall.
! 5680: */
! 5681: #define NN 1 /* Number of neighbors on either side of pPage */
! 5682: #define NB (NN*2+1) /* Total pages involved in the balance */
! 5683:
! 5684:
! 5685: #ifndef SQLITE_OMIT_QUICKBALANCE
! 5686: /*
! 5687: ** This version of balance() handles the common special case where
! 5688: ** a new entry is being inserted on the extreme right-end of the
! 5689: ** tree, in other words, when the new entry will become the largest
! 5690: ** entry in the tree.
! 5691: **
! 5692: ** Instead of trying to balance the 3 right-most leaf pages, just add
! 5693: ** a new page to the right-hand side and put the one new entry in
! 5694: ** that page. This leaves the right side of the tree somewhat
! 5695: ** unbalanced. But odds are that we will be inserting new entries
! 5696: ** at the end soon afterwards so the nearly empty page will quickly
! 5697: ** fill up. On average.
! 5698: **
! 5699: ** pPage is the leaf page which is the right-most page in the tree.
! 5700: ** pParent is its parent. pPage must have a single overflow entry
! 5701: ** which is also the right-most entry on the page.
! 5702: **
! 5703: ** The pSpace buffer is used to store a temporary copy of the divider
! 5704: ** cell that will be inserted into pParent. Such a cell consists of a 4
! 5705: ** byte page number followed by a variable length integer. In other
! 5706: ** words, at most 13 bytes. Hence the pSpace buffer must be at
! 5707: ** least 13 bytes in size.
! 5708: */
! 5709: static int balance_quick(MemPage *pParent, MemPage *pPage, u8 *pSpace){
! 5710: BtShared *const pBt = pPage->pBt; /* B-Tree Database */
! 5711: MemPage *pNew; /* Newly allocated page */
! 5712: int rc; /* Return Code */
! 5713: Pgno pgnoNew; /* Page number of pNew */
! 5714:
! 5715: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
! 5716: assert( sqlite3PagerIswriteable(pParent->pDbPage) );
! 5717: assert( pPage->nOverflow==1 );
! 5718:
! 5719: /* This error condition is now caught prior to reaching this function */
! 5720: if( pPage->nCell<=0 ) return SQLITE_CORRUPT_BKPT;
! 5721:
! 5722: /* Allocate a new page. This page will become the right-sibling of
! 5723: ** pPage. Make the parent page writable, so that the new divider cell
! 5724: ** may be inserted. If both these operations are successful, proceed.
! 5725: */
! 5726: rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0);
! 5727:
! 5728: if( rc==SQLITE_OK ){
! 5729:
! 5730: u8 *pOut = &pSpace[4];
! 5731: u8 *pCell = pPage->aOvfl[0].pCell;
! 5732: u16 szCell = cellSizePtr(pPage, pCell);
! 5733: u8 *pStop;
! 5734:
! 5735: assert( sqlite3PagerIswriteable(pNew->pDbPage) );
! 5736: assert( pPage->aData[0]==(PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF) );
! 5737: zeroPage(pNew, PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF);
! 5738: assemblePage(pNew, 1, &pCell, &szCell);
! 5739:
! 5740: /* If this is an auto-vacuum database, update the pointer map
! 5741: ** with entries for the new page, and any pointer from the
! 5742: ** cell on the page to an overflow page. If either of these
! 5743: ** operations fails, the return code is set, but the contents
! 5744: ** of the parent page are still manipulated by thh code below.
! 5745: ** That is Ok, at this point the parent page is guaranteed to
! 5746: ** be marked as dirty. Returning an error code will cause a
! 5747: ** rollback, undoing any changes made to the parent page.
! 5748: */
! 5749: if( ISAUTOVACUUM ){
! 5750: ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno, &rc);
! 5751: if( szCell>pNew->minLocal ){
! 5752: ptrmapPutOvflPtr(pNew, pCell, &rc);
! 5753: }
! 5754: }
! 5755:
! 5756: /* Create a divider cell to insert into pParent. The divider cell
! 5757: ** consists of a 4-byte page number (the page number of pPage) and
! 5758: ** a variable length key value (which must be the same value as the
! 5759: ** largest key on pPage).
! 5760: **
! 5761: ** To find the largest key value on pPage, first find the right-most
! 5762: ** cell on pPage. The first two fields of this cell are the
! 5763: ** record-length (a variable length integer at most 32-bits in size)
! 5764: ** and the key value (a variable length integer, may have any value).
! 5765: ** The first of the while(...) loops below skips over the record-length
! 5766: ** field. The second while(...) loop copies the key value from the
! 5767: ** cell on pPage into the pSpace buffer.
! 5768: */
! 5769: pCell = findCell(pPage, pPage->nCell-1);
! 5770: pStop = &pCell[9];
! 5771: while( (*(pCell++)&0x80) && pCell<pStop );
! 5772: pStop = &pCell[9];
! 5773: while( ((*(pOut++) = *(pCell++))&0x80) && pCell<pStop );
! 5774:
! 5775: /* Insert the new divider cell into pParent. */
! 5776: insertCell(pParent, pParent->nCell, pSpace, (int)(pOut-pSpace),
! 5777: 0, pPage->pgno, &rc);
! 5778:
! 5779: /* Set the right-child pointer of pParent to point to the new page. */
! 5780: put4byte(&pParent->aData[pParent->hdrOffset+8], pgnoNew);
! 5781:
! 5782: /* Release the reference to the new page. */
! 5783: releasePage(pNew);
! 5784: }
! 5785:
! 5786: return rc;
! 5787: }
! 5788: #endif /* SQLITE_OMIT_QUICKBALANCE */
! 5789:
! 5790: #if 0
! 5791: /*
! 5792: ** This function does not contribute anything to the operation of SQLite.
! 5793: ** it is sometimes activated temporarily while debugging code responsible
! 5794: ** for setting pointer-map entries.
! 5795: */
! 5796: static int ptrmapCheckPages(MemPage **apPage, int nPage){
! 5797: int i, j;
! 5798: for(i=0; i<nPage; i++){
! 5799: Pgno n;
! 5800: u8 e;
! 5801: MemPage *pPage = apPage[i];
! 5802: BtShared *pBt = pPage->pBt;
! 5803: assert( pPage->isInit );
! 5804:
! 5805: for(j=0; j<pPage->nCell; j++){
! 5806: CellInfo info;
! 5807: u8 *z;
! 5808:
! 5809: z = findCell(pPage, j);
! 5810: btreeParseCellPtr(pPage, z, &info);
! 5811: if( info.iOverflow ){
! 5812: Pgno ovfl = get4byte(&z[info.iOverflow]);
! 5813: ptrmapGet(pBt, ovfl, &e, &n);
! 5814: assert( n==pPage->pgno && e==PTRMAP_OVERFLOW1 );
! 5815: }
! 5816: if( !pPage->leaf ){
! 5817: Pgno child = get4byte(z);
! 5818: ptrmapGet(pBt, child, &e, &n);
! 5819: assert( n==pPage->pgno && e==PTRMAP_BTREE );
! 5820: }
! 5821: }
! 5822: if( !pPage->leaf ){
! 5823: Pgno child = get4byte(&pPage->aData[pPage->hdrOffset+8]);
! 5824: ptrmapGet(pBt, child, &e, &n);
! 5825: assert( n==pPage->pgno && e==PTRMAP_BTREE );
! 5826: }
! 5827: }
! 5828: return 1;
! 5829: }
! 5830: #endif
! 5831:
! 5832: /*
! 5833: ** This function is used to copy the contents of the b-tree node stored
! 5834: ** on page pFrom to page pTo. If page pFrom was not a leaf page, then
! 5835: ** the pointer-map entries for each child page are updated so that the
! 5836: ** parent page stored in the pointer map is page pTo. If pFrom contained
! 5837: ** any cells with overflow page pointers, then the corresponding pointer
! 5838: ** map entries are also updated so that the parent page is page pTo.
! 5839: **
! 5840: ** If pFrom is currently carrying any overflow cells (entries in the
! 5841: ** MemPage.aOvfl[] array), they are not copied to pTo.
! 5842: **
! 5843: ** Before returning, page pTo is reinitialized using btreeInitPage().
! 5844: **
! 5845: ** The performance of this function is not critical. It is only used by
! 5846: ** the balance_shallower() and balance_deeper() procedures, neither of
! 5847: ** which are called often under normal circumstances.
! 5848: */
! 5849: static void copyNodeContent(MemPage *pFrom, MemPage *pTo, int *pRC){
! 5850: if( (*pRC)==SQLITE_OK ){
! 5851: BtShared * const pBt = pFrom->pBt;
! 5852: u8 * const aFrom = pFrom->aData;
! 5853: u8 * const aTo = pTo->aData;
! 5854: int const iFromHdr = pFrom->hdrOffset;
! 5855: int const iToHdr = ((pTo->pgno==1) ? 100 : 0);
! 5856: int rc;
! 5857: int iData;
! 5858:
! 5859:
! 5860: assert( pFrom->isInit );
! 5861: assert( pFrom->nFree>=iToHdr );
! 5862: assert( get2byte(&aFrom[iFromHdr+5]) <= (int)pBt->usableSize );
! 5863:
! 5864: /* Copy the b-tree node content from page pFrom to page pTo. */
! 5865: iData = get2byte(&aFrom[iFromHdr+5]);
! 5866: memcpy(&aTo[iData], &aFrom[iData], pBt->usableSize-iData);
! 5867: memcpy(&aTo[iToHdr], &aFrom[iFromHdr], pFrom->cellOffset + 2*pFrom->nCell);
! 5868:
! 5869: /* Reinitialize page pTo so that the contents of the MemPage structure
! 5870: ** match the new data. The initialization of pTo can actually fail under
! 5871: ** fairly obscure circumstances, even though it is a copy of initialized
! 5872: ** page pFrom.
! 5873: */
! 5874: pTo->isInit = 0;
! 5875: rc = btreeInitPage(pTo);
! 5876: if( rc!=SQLITE_OK ){
! 5877: *pRC = rc;
! 5878: return;
! 5879: }
! 5880:
! 5881: /* If this is an auto-vacuum database, update the pointer-map entries
! 5882: ** for any b-tree or overflow pages that pTo now contains the pointers to.
! 5883: */
! 5884: if( ISAUTOVACUUM ){
! 5885: *pRC = setChildPtrmaps(pTo);
! 5886: }
! 5887: }
! 5888: }
! 5889:
! 5890: /*
! 5891: ** This routine redistributes cells on the iParentIdx'th child of pParent
! 5892: ** (hereafter "the page") and up to 2 siblings so that all pages have about the
! 5893: ** same amount of free space. Usually a single sibling on either side of the
! 5894: ** page are used in the balancing, though both siblings might come from one
! 5895: ** side if the page is the first or last child of its parent. If the page
! 5896: ** has fewer than 2 siblings (something which can only happen if the page
! 5897: ** is a root page or a child of a root page) then all available siblings
! 5898: ** participate in the balancing.
! 5899: **
! 5900: ** The number of siblings of the page might be increased or decreased by
! 5901: ** one or two in an effort to keep pages nearly full but not over full.
! 5902: **
! 5903: ** Note that when this routine is called, some of the cells on the page
! 5904: ** might not actually be stored in MemPage.aData[]. This can happen
! 5905: ** if the page is overfull. This routine ensures that all cells allocated
! 5906: ** to the page and its siblings fit into MemPage.aData[] before returning.
! 5907: **
! 5908: ** In the course of balancing the page and its siblings, cells may be
! 5909: ** inserted into or removed from the parent page (pParent). Doing so
! 5910: ** may cause the parent page to become overfull or underfull. If this
! 5911: ** happens, it is the responsibility of the caller to invoke the correct
! 5912: ** balancing routine to fix this problem (see the balance() routine).
! 5913: **
! 5914: ** If this routine fails for any reason, it might leave the database
! 5915: ** in a corrupted state. So if this routine fails, the database should
! 5916: ** be rolled back.
! 5917: **
! 5918: ** The third argument to this function, aOvflSpace, is a pointer to a
! 5919: ** buffer big enough to hold one page. If while inserting cells into the parent
! 5920: ** page (pParent) the parent page becomes overfull, this buffer is
! 5921: ** used to store the parent's overflow cells. Because this function inserts
! 5922: ** a maximum of four divider cells into the parent page, and the maximum
! 5923: ** size of a cell stored within an internal node is always less than 1/4
! 5924: ** of the page-size, the aOvflSpace[] buffer is guaranteed to be large
! 5925: ** enough for all overflow cells.
! 5926: **
! 5927: ** If aOvflSpace is set to a null pointer, this function returns
! 5928: ** SQLITE_NOMEM.
! 5929: */
! 5930: static int balance_nonroot(
! 5931: MemPage *pParent, /* Parent page of siblings being balanced */
! 5932: int iParentIdx, /* Index of "the page" in pParent */
! 5933: u8 *aOvflSpace, /* page-size bytes of space for parent ovfl */
! 5934: int isRoot /* True if pParent is a root-page */
! 5935: ){
! 5936: BtShared *pBt; /* The whole database */
! 5937: int nCell = 0; /* Number of cells in apCell[] */
! 5938: int nMaxCells = 0; /* Allocated size of apCell, szCell, aFrom. */
! 5939: int nNew = 0; /* Number of pages in apNew[] */
! 5940: int nOld; /* Number of pages in apOld[] */
! 5941: int i, j, k; /* Loop counters */
! 5942: int nxDiv; /* Next divider slot in pParent->aCell[] */
! 5943: int rc = SQLITE_OK; /* The return code */
! 5944: u16 leafCorrection; /* 4 if pPage is a leaf. 0 if not */
! 5945: int leafData; /* True if pPage is a leaf of a LEAFDATA tree */
! 5946: int usableSpace; /* Bytes in pPage beyond the header */
! 5947: int pageFlags; /* Value of pPage->aData[0] */
! 5948: int subtotal; /* Subtotal of bytes in cells on one page */
! 5949: int iSpace1 = 0; /* First unused byte of aSpace1[] */
! 5950: int iOvflSpace = 0; /* First unused byte of aOvflSpace[] */
! 5951: int szScratch; /* Size of scratch memory requested */
! 5952: MemPage *apOld[NB]; /* pPage and up to two siblings */
! 5953: MemPage *apCopy[NB]; /* Private copies of apOld[] pages */
! 5954: MemPage *apNew[NB+2]; /* pPage and up to NB siblings after balancing */
! 5955: u8 *pRight; /* Location in parent of right-sibling pointer */
! 5956: u8 *apDiv[NB-1]; /* Divider cells in pParent */
! 5957: int cntNew[NB+2]; /* Index in aCell[] of cell after i-th page */
! 5958: int szNew[NB+2]; /* Combined size of cells place on i-th page */
! 5959: u8 **apCell = 0; /* All cells begin balanced */
! 5960: u16 *szCell; /* Local size of all cells in apCell[] */
! 5961: u8 *aSpace1; /* Space for copies of dividers cells */
! 5962: Pgno pgno; /* Temp var to store a page number in */
! 5963:
! 5964: pBt = pParent->pBt;
! 5965: assert( sqlite3_mutex_held(pBt->mutex) );
! 5966: assert( sqlite3PagerIswriteable(pParent->pDbPage) );
! 5967:
! 5968: #if 0
! 5969: TRACE(("BALANCE: begin page %d child of %d\n", pPage->pgno, pParent->pgno));
! 5970: #endif
! 5971:
! 5972: /* At this point pParent may have at most one overflow cell. And if
! 5973: ** this overflow cell is present, it must be the cell with
! 5974: ** index iParentIdx. This scenario comes about when this function
! 5975: ** is called (indirectly) from sqlite3BtreeDelete().
! 5976: */
! 5977: assert( pParent->nOverflow==0 || pParent->nOverflow==1 );
! 5978: assert( pParent->nOverflow==0 || pParent->aOvfl[0].idx==iParentIdx );
! 5979:
! 5980: if( !aOvflSpace ){
! 5981: return SQLITE_NOMEM;
! 5982: }
! 5983:
! 5984: /* Find the sibling pages to balance. Also locate the cells in pParent
! 5985: ** that divide the siblings. An attempt is made to find NN siblings on
! 5986: ** either side of pPage. More siblings are taken from one side, however,
! 5987: ** if there are fewer than NN siblings on the other side. If pParent
! 5988: ** has NB or fewer children then all children of pParent are taken.
! 5989: **
! 5990: ** This loop also drops the divider cells from the parent page. This
! 5991: ** way, the remainder of the function does not have to deal with any
! 5992: ** overflow cells in the parent page, since if any existed they will
! 5993: ** have already been removed.
! 5994: */
! 5995: i = pParent->nOverflow + pParent->nCell;
! 5996: if( i<2 ){
! 5997: nxDiv = 0;
! 5998: nOld = i+1;
! 5999: }else{
! 6000: nOld = 3;
! 6001: if( iParentIdx==0 ){
! 6002: nxDiv = 0;
! 6003: }else if( iParentIdx==i ){
! 6004: nxDiv = i-2;
! 6005: }else{
! 6006: nxDiv = iParentIdx-1;
! 6007: }
! 6008: i = 2;
! 6009: }
! 6010: if( (i+nxDiv-pParent->nOverflow)==pParent->nCell ){
! 6011: pRight = &pParent->aData[pParent->hdrOffset+8];
! 6012: }else{
! 6013: pRight = findCell(pParent, i+nxDiv-pParent->nOverflow);
! 6014: }
! 6015: pgno = get4byte(pRight);
! 6016: while( 1 ){
! 6017: rc = getAndInitPage(pBt, pgno, &apOld[i]);
! 6018: if( rc ){
! 6019: memset(apOld, 0, (i+1)*sizeof(MemPage*));
! 6020: goto balance_cleanup;
! 6021: }
! 6022: nMaxCells += 1+apOld[i]->nCell+apOld[i]->nOverflow;
! 6023: if( (i--)==0 ) break;
! 6024:
! 6025: if( i+nxDiv==pParent->aOvfl[0].idx && pParent->nOverflow ){
! 6026: apDiv[i] = pParent->aOvfl[0].pCell;
! 6027: pgno = get4byte(apDiv[i]);
! 6028: szNew[i] = cellSizePtr(pParent, apDiv[i]);
! 6029: pParent->nOverflow = 0;
! 6030: }else{
! 6031: apDiv[i] = findCell(pParent, i+nxDiv-pParent->nOverflow);
! 6032: pgno = get4byte(apDiv[i]);
! 6033: szNew[i] = cellSizePtr(pParent, apDiv[i]);
! 6034:
! 6035: /* Drop the cell from the parent page. apDiv[i] still points to
! 6036: ** the cell within the parent, even though it has been dropped.
! 6037: ** This is safe because dropping a cell only overwrites the first
! 6038: ** four bytes of it, and this function does not need the first
! 6039: ** four bytes of the divider cell. So the pointer is safe to use
! 6040: ** later on.
! 6041: **
! 6042: ** But not if we are in secure-delete mode. In secure-delete mode,
! 6043: ** the dropCell() routine will overwrite the entire cell with zeroes.
! 6044: ** In this case, temporarily copy the cell into the aOvflSpace[]
! 6045: ** buffer. It will be copied out again as soon as the aSpace[] buffer
! 6046: ** is allocated. */
! 6047: if( pBt->btsFlags & BTS_SECURE_DELETE ){
! 6048: int iOff;
! 6049:
! 6050: iOff = SQLITE_PTR_TO_INT(apDiv[i]) - SQLITE_PTR_TO_INT(pParent->aData);
! 6051: if( (iOff+szNew[i])>(int)pBt->usableSize ){
! 6052: rc = SQLITE_CORRUPT_BKPT;
! 6053: memset(apOld, 0, (i+1)*sizeof(MemPage*));
! 6054: goto balance_cleanup;
! 6055: }else{
! 6056: memcpy(&aOvflSpace[iOff], apDiv[i], szNew[i]);
! 6057: apDiv[i] = &aOvflSpace[apDiv[i]-pParent->aData];
! 6058: }
! 6059: }
! 6060: dropCell(pParent, i+nxDiv-pParent->nOverflow, szNew[i], &rc);
! 6061: }
! 6062: }
! 6063:
! 6064: /* Make nMaxCells a multiple of 4 in order to preserve 8-byte
! 6065: ** alignment */
! 6066: nMaxCells = (nMaxCells + 3)&~3;
! 6067:
! 6068: /*
! 6069: ** Allocate space for memory structures
! 6070: */
! 6071: k = pBt->pageSize + ROUND8(sizeof(MemPage));
! 6072: szScratch =
! 6073: nMaxCells*sizeof(u8*) /* apCell */
! 6074: + nMaxCells*sizeof(u16) /* szCell */
! 6075: + pBt->pageSize /* aSpace1 */
! 6076: + k*nOld; /* Page copies (apCopy) */
! 6077: apCell = sqlite3ScratchMalloc( szScratch );
! 6078: if( apCell==0 ){
! 6079: rc = SQLITE_NOMEM;
! 6080: goto balance_cleanup;
! 6081: }
! 6082: szCell = (u16*)&apCell[nMaxCells];
! 6083: aSpace1 = (u8*)&szCell[nMaxCells];
! 6084: assert( EIGHT_BYTE_ALIGNMENT(aSpace1) );
! 6085:
! 6086: /*
! 6087: ** Load pointers to all cells on sibling pages and the divider cells
! 6088: ** into the local apCell[] array. Make copies of the divider cells
! 6089: ** into space obtained from aSpace1[] and remove the the divider Cells
! 6090: ** from pParent.
! 6091: **
! 6092: ** If the siblings are on leaf pages, then the child pointers of the
! 6093: ** divider cells are stripped from the cells before they are copied
! 6094: ** into aSpace1[]. In this way, all cells in apCell[] are without
! 6095: ** child pointers. If siblings are not leaves, then all cell in
! 6096: ** apCell[] include child pointers. Either way, all cells in apCell[]
! 6097: ** are alike.
! 6098: **
! 6099: ** leafCorrection: 4 if pPage is a leaf. 0 if pPage is not a leaf.
! 6100: ** leafData: 1 if pPage holds key+data and pParent holds only keys.
! 6101: */
! 6102: leafCorrection = apOld[0]->leaf*4;
! 6103: leafData = apOld[0]->hasData;
! 6104: for(i=0; i<nOld; i++){
! 6105: int limit;
! 6106:
! 6107: /* Before doing anything else, take a copy of the i'th original sibling
! 6108: ** The rest of this function will use data from the copies rather
! 6109: ** that the original pages since the original pages will be in the
! 6110: ** process of being overwritten. */
! 6111: MemPage *pOld = apCopy[i] = (MemPage*)&aSpace1[pBt->pageSize + k*i];
! 6112: memcpy(pOld, apOld[i], sizeof(MemPage));
! 6113: pOld->aData = (void*)&pOld[1];
! 6114: memcpy(pOld->aData, apOld[i]->aData, pBt->pageSize);
! 6115:
! 6116: limit = pOld->nCell+pOld->nOverflow;
! 6117: if( pOld->nOverflow>0 ){
! 6118: for(j=0; j<limit; j++){
! 6119: assert( nCell<nMaxCells );
! 6120: apCell[nCell] = findOverflowCell(pOld, j);
! 6121: szCell[nCell] = cellSizePtr(pOld, apCell[nCell]);
! 6122: nCell++;
! 6123: }
! 6124: }else{
! 6125: u8 *aData = pOld->aData;
! 6126: u16 maskPage = pOld->maskPage;
! 6127: u16 cellOffset = pOld->cellOffset;
! 6128: for(j=0; j<limit; j++){
! 6129: assert( nCell<nMaxCells );
! 6130: apCell[nCell] = findCellv2(aData, maskPage, cellOffset, j);
! 6131: szCell[nCell] = cellSizePtr(pOld, apCell[nCell]);
! 6132: nCell++;
! 6133: }
! 6134: }
! 6135: if( i<nOld-1 && !leafData){
! 6136: u16 sz = (u16)szNew[i];
! 6137: u8 *pTemp;
! 6138: assert( nCell<nMaxCells );
! 6139: szCell[nCell] = sz;
! 6140: pTemp = &aSpace1[iSpace1];
! 6141: iSpace1 += sz;
! 6142: assert( sz<=pBt->maxLocal+23 );
! 6143: assert( iSpace1 <= (int)pBt->pageSize );
! 6144: memcpy(pTemp, apDiv[i], sz);
! 6145: apCell[nCell] = pTemp+leafCorrection;
! 6146: assert( leafCorrection==0 || leafCorrection==4 );
! 6147: szCell[nCell] = szCell[nCell] - leafCorrection;
! 6148: if( !pOld->leaf ){
! 6149: assert( leafCorrection==0 );
! 6150: assert( pOld->hdrOffset==0 );
! 6151: /* The right pointer of the child page pOld becomes the left
! 6152: ** pointer of the divider cell */
! 6153: memcpy(apCell[nCell], &pOld->aData[8], 4);
! 6154: }else{
! 6155: assert( leafCorrection==4 );
! 6156: if( szCell[nCell]<4 ){
! 6157: /* Do not allow any cells smaller than 4 bytes. */
! 6158: szCell[nCell] = 4;
! 6159: }
! 6160: }
! 6161: nCell++;
! 6162: }
! 6163: }
! 6164:
! 6165: /*
! 6166: ** Figure out the number of pages needed to hold all nCell cells.
! 6167: ** Store this number in "k". Also compute szNew[] which is the total
! 6168: ** size of all cells on the i-th page and cntNew[] which is the index
! 6169: ** in apCell[] of the cell that divides page i from page i+1.
! 6170: ** cntNew[k] should equal nCell.
! 6171: **
! 6172: ** Values computed by this block:
! 6173: **
! 6174: ** k: The total number of sibling pages
! 6175: ** szNew[i]: Spaced used on the i-th sibling page.
! 6176: ** cntNew[i]: Index in apCell[] and szCell[] for the first cell to
! 6177: ** the right of the i-th sibling page.
! 6178: ** usableSpace: Number of bytes of space available on each sibling.
! 6179: **
! 6180: */
! 6181: usableSpace = pBt->usableSize - 12 + leafCorrection;
! 6182: for(subtotal=k=i=0; i<nCell; i++){
! 6183: assert( i<nMaxCells );
! 6184: subtotal += szCell[i] + 2;
! 6185: if( subtotal > usableSpace ){
! 6186: szNew[k] = subtotal - szCell[i];
! 6187: cntNew[k] = i;
! 6188: if( leafData ){ i--; }
! 6189: subtotal = 0;
! 6190: k++;
! 6191: if( k>NB+1 ){ rc = SQLITE_CORRUPT_BKPT; goto balance_cleanup; }
! 6192: }
! 6193: }
! 6194: szNew[k] = subtotal;
! 6195: cntNew[k] = nCell;
! 6196: k++;
! 6197:
! 6198: /*
! 6199: ** The packing computed by the previous block is biased toward the siblings
! 6200: ** on the left side. The left siblings are always nearly full, while the
! 6201: ** right-most sibling might be nearly empty. This block of code attempts
! 6202: ** to adjust the packing of siblings to get a better balance.
! 6203: **
! 6204: ** This adjustment is more than an optimization. The packing above might
! 6205: ** be so out of balance as to be illegal. For example, the right-most
! 6206: ** sibling might be completely empty. This adjustment is not optional.
! 6207: */
! 6208: for(i=k-1; i>0; i--){
! 6209: int szRight = szNew[i]; /* Size of sibling on the right */
! 6210: int szLeft = szNew[i-1]; /* Size of sibling on the left */
! 6211: int r; /* Index of right-most cell in left sibling */
! 6212: int d; /* Index of first cell to the left of right sibling */
! 6213:
! 6214: r = cntNew[i-1] - 1;
! 6215: d = r + 1 - leafData;
! 6216: assert( d<nMaxCells );
! 6217: assert( r<nMaxCells );
! 6218: while( szRight==0 || szRight+szCell[d]+2<=szLeft-(szCell[r]+2) ){
! 6219: szRight += szCell[d] + 2;
! 6220: szLeft -= szCell[r] + 2;
! 6221: cntNew[i-1]--;
! 6222: r = cntNew[i-1] - 1;
! 6223: d = r + 1 - leafData;
! 6224: }
! 6225: szNew[i] = szRight;
! 6226: szNew[i-1] = szLeft;
! 6227: }
! 6228:
! 6229: /* Either we found one or more cells (cntnew[0])>0) or pPage is
! 6230: ** a virtual root page. A virtual root page is when the real root
! 6231: ** page is page 1 and we are the only child of that page.
! 6232: **
! 6233: ** UPDATE: The assert() below is not necessarily true if the database
! 6234: ** file is corrupt. The corruption will be detected and reported later
! 6235: ** in this procedure so there is no need to act upon it now.
! 6236: */
! 6237: #if 0
! 6238: assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) );
! 6239: #endif
! 6240:
! 6241: TRACE(("BALANCE: old: %d %d %d ",
! 6242: apOld[0]->pgno,
! 6243: nOld>=2 ? apOld[1]->pgno : 0,
! 6244: nOld>=3 ? apOld[2]->pgno : 0
! 6245: ));
! 6246:
! 6247: /*
! 6248: ** Allocate k new pages. Reuse old pages where possible.
! 6249: */
! 6250: if( apOld[0]->pgno<=1 ){
! 6251: rc = SQLITE_CORRUPT_BKPT;
! 6252: goto balance_cleanup;
! 6253: }
! 6254: pageFlags = apOld[0]->aData[0];
! 6255: for(i=0; i<k; i++){
! 6256: MemPage *pNew;
! 6257: if( i<nOld ){
! 6258: pNew = apNew[i] = apOld[i];
! 6259: apOld[i] = 0;
! 6260: rc = sqlite3PagerWrite(pNew->pDbPage);
! 6261: nNew++;
! 6262: if( rc ) goto balance_cleanup;
! 6263: }else{
! 6264: assert( i>0 );
! 6265: rc = allocateBtreePage(pBt, &pNew, &pgno, pgno, 0);
! 6266: if( rc ) goto balance_cleanup;
! 6267: apNew[i] = pNew;
! 6268: nNew++;
! 6269:
! 6270: /* Set the pointer-map entry for the new sibling page. */
! 6271: if( ISAUTOVACUUM ){
! 6272: ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno, &rc);
! 6273: if( rc!=SQLITE_OK ){
! 6274: goto balance_cleanup;
! 6275: }
! 6276: }
! 6277: }
! 6278: }
! 6279:
! 6280: /* Free any old pages that were not reused as new pages.
! 6281: */
! 6282: while( i<nOld ){
! 6283: freePage(apOld[i], &rc);
! 6284: if( rc ) goto balance_cleanup;
! 6285: releasePage(apOld[i]);
! 6286: apOld[i] = 0;
! 6287: i++;
! 6288: }
! 6289:
! 6290: /*
! 6291: ** Put the new pages in accending order. This helps to
! 6292: ** keep entries in the disk file in order so that a scan
! 6293: ** of the table is a linear scan through the file. That
! 6294: ** in turn helps the operating system to deliver pages
! 6295: ** from the disk more rapidly.
! 6296: **
! 6297: ** An O(n^2) insertion sort algorithm is used, but since
! 6298: ** n is never more than NB (a small constant), that should
! 6299: ** not be a problem.
! 6300: **
! 6301: ** When NB==3, this one optimization makes the database
! 6302: ** about 25% faster for large insertions and deletions.
! 6303: */
! 6304: for(i=0; i<k-1; i++){
! 6305: int minV = apNew[i]->pgno;
! 6306: int minI = i;
! 6307: for(j=i+1; j<k; j++){
! 6308: if( apNew[j]->pgno<(unsigned)minV ){
! 6309: minI = j;
! 6310: minV = apNew[j]->pgno;
! 6311: }
! 6312: }
! 6313: if( minI>i ){
! 6314: MemPage *pT;
! 6315: pT = apNew[i];
! 6316: apNew[i] = apNew[minI];
! 6317: apNew[minI] = pT;
! 6318: }
! 6319: }
! 6320: TRACE(("new: %d(%d) %d(%d) %d(%d) %d(%d) %d(%d)\n",
! 6321: apNew[0]->pgno, szNew[0],
! 6322: nNew>=2 ? apNew[1]->pgno : 0, nNew>=2 ? szNew[1] : 0,
! 6323: nNew>=3 ? apNew[2]->pgno : 0, nNew>=3 ? szNew[2] : 0,
! 6324: nNew>=4 ? apNew[3]->pgno : 0, nNew>=4 ? szNew[3] : 0,
! 6325: nNew>=5 ? apNew[4]->pgno : 0, nNew>=5 ? szNew[4] : 0));
! 6326:
! 6327: assert( sqlite3PagerIswriteable(pParent->pDbPage) );
! 6328: put4byte(pRight, apNew[nNew-1]->pgno);
! 6329:
! 6330: /*
! 6331: ** Evenly distribute the data in apCell[] across the new pages.
! 6332: ** Insert divider cells into pParent as necessary.
! 6333: */
! 6334: j = 0;
! 6335: for(i=0; i<nNew; i++){
! 6336: /* Assemble the new sibling page. */
! 6337: MemPage *pNew = apNew[i];
! 6338: assert( j<nMaxCells );
! 6339: zeroPage(pNew, pageFlags);
! 6340: assemblePage(pNew, cntNew[i]-j, &apCell[j], &szCell[j]);
! 6341: assert( pNew->nCell>0 || (nNew==1 && cntNew[0]==0) );
! 6342: assert( pNew->nOverflow==0 );
! 6343:
! 6344: j = cntNew[i];
! 6345:
! 6346: /* If the sibling page assembled above was not the right-most sibling,
! 6347: ** insert a divider cell into the parent page.
! 6348: */
! 6349: assert( i<nNew-1 || j==nCell );
! 6350: if( j<nCell ){
! 6351: u8 *pCell;
! 6352: u8 *pTemp;
! 6353: int sz;
! 6354:
! 6355: assert( j<nMaxCells );
! 6356: pCell = apCell[j];
! 6357: sz = szCell[j] + leafCorrection;
! 6358: pTemp = &aOvflSpace[iOvflSpace];
! 6359: if( !pNew->leaf ){
! 6360: memcpy(&pNew->aData[8], pCell, 4);
! 6361: }else if( leafData ){
! 6362: /* If the tree is a leaf-data tree, and the siblings are leaves,
! 6363: ** then there is no divider cell in apCell[]. Instead, the divider
! 6364: ** cell consists of the integer key for the right-most cell of
! 6365: ** the sibling-page assembled above only.
! 6366: */
! 6367: CellInfo info;
! 6368: j--;
! 6369: btreeParseCellPtr(pNew, apCell[j], &info);
! 6370: pCell = pTemp;
! 6371: sz = 4 + putVarint(&pCell[4], info.nKey);
! 6372: pTemp = 0;
! 6373: }else{
! 6374: pCell -= 4;
! 6375: /* Obscure case for non-leaf-data trees: If the cell at pCell was
! 6376: ** previously stored on a leaf node, and its reported size was 4
! 6377: ** bytes, then it may actually be smaller than this
! 6378: ** (see btreeParseCellPtr(), 4 bytes is the minimum size of
! 6379: ** any cell). But it is important to pass the correct size to
! 6380: ** insertCell(), so reparse the cell now.
! 6381: **
! 6382: ** Note that this can never happen in an SQLite data file, as all
! 6383: ** cells are at least 4 bytes. It only happens in b-trees used
! 6384: ** to evaluate "IN (SELECT ...)" and similar clauses.
! 6385: */
! 6386: if( szCell[j]==4 ){
! 6387: assert(leafCorrection==4);
! 6388: sz = cellSizePtr(pParent, pCell);
! 6389: }
! 6390: }
! 6391: iOvflSpace += sz;
! 6392: assert( sz<=pBt->maxLocal+23 );
! 6393: assert( iOvflSpace <= (int)pBt->pageSize );
! 6394: insertCell(pParent, nxDiv, pCell, sz, pTemp, pNew->pgno, &rc);
! 6395: if( rc!=SQLITE_OK ) goto balance_cleanup;
! 6396: assert( sqlite3PagerIswriteable(pParent->pDbPage) );
! 6397:
! 6398: j++;
! 6399: nxDiv++;
! 6400: }
! 6401: }
! 6402: assert( j==nCell );
! 6403: assert( nOld>0 );
! 6404: assert( nNew>0 );
! 6405: if( (pageFlags & PTF_LEAF)==0 ){
! 6406: u8 *zChild = &apCopy[nOld-1]->aData[8];
! 6407: memcpy(&apNew[nNew-1]->aData[8], zChild, 4);
! 6408: }
! 6409:
! 6410: if( isRoot && pParent->nCell==0 && pParent->hdrOffset<=apNew[0]->nFree ){
! 6411: /* The root page of the b-tree now contains no cells. The only sibling
! 6412: ** page is the right-child of the parent. Copy the contents of the
! 6413: ** child page into the parent, decreasing the overall height of the
! 6414: ** b-tree structure by one. This is described as the "balance-shallower"
! 6415: ** sub-algorithm in some documentation.
! 6416: **
! 6417: ** If this is an auto-vacuum database, the call to copyNodeContent()
! 6418: ** sets all pointer-map entries corresponding to database image pages
! 6419: ** for which the pointer is stored within the content being copied.
! 6420: **
! 6421: ** The second assert below verifies that the child page is defragmented
! 6422: ** (it must be, as it was just reconstructed using assemblePage()). This
! 6423: ** is important if the parent page happens to be page 1 of the database
! 6424: ** image. */
! 6425: assert( nNew==1 );
! 6426: assert( apNew[0]->nFree ==
! 6427: (get2byte(&apNew[0]->aData[5])-apNew[0]->cellOffset-apNew[0]->nCell*2)
! 6428: );
! 6429: copyNodeContent(apNew[0], pParent, &rc);
! 6430: freePage(apNew[0], &rc);
! 6431: }else if( ISAUTOVACUUM ){
! 6432: /* Fix the pointer-map entries for all the cells that were shifted around.
! 6433: ** There are several different types of pointer-map entries that need to
! 6434: ** be dealt with by this routine. Some of these have been set already, but
! 6435: ** many have not. The following is a summary:
! 6436: **
! 6437: ** 1) The entries associated with new sibling pages that were not
! 6438: ** siblings when this function was called. These have already
! 6439: ** been set. We don't need to worry about old siblings that were
! 6440: ** moved to the free-list - the freePage() code has taken care
! 6441: ** of those.
! 6442: **
! 6443: ** 2) The pointer-map entries associated with the first overflow
! 6444: ** page in any overflow chains used by new divider cells. These
! 6445: ** have also already been taken care of by the insertCell() code.
! 6446: **
! 6447: ** 3) If the sibling pages are not leaves, then the child pages of
! 6448: ** cells stored on the sibling pages may need to be updated.
! 6449: **
! 6450: ** 4) If the sibling pages are not internal intkey nodes, then any
! 6451: ** overflow pages used by these cells may need to be updated
! 6452: ** (internal intkey nodes never contain pointers to overflow pages).
! 6453: **
! 6454: ** 5) If the sibling pages are not leaves, then the pointer-map
! 6455: ** entries for the right-child pages of each sibling may need
! 6456: ** to be updated.
! 6457: **
! 6458: ** Cases 1 and 2 are dealt with above by other code. The next
! 6459: ** block deals with cases 3 and 4 and the one after that, case 5. Since
! 6460: ** setting a pointer map entry is a relatively expensive operation, this
! 6461: ** code only sets pointer map entries for child or overflow pages that have
! 6462: ** actually moved between pages. */
! 6463: MemPage *pNew = apNew[0];
! 6464: MemPage *pOld = apCopy[0];
! 6465: int nOverflow = pOld->nOverflow;
! 6466: int iNextOld = pOld->nCell + nOverflow;
! 6467: int iOverflow = (nOverflow ? pOld->aOvfl[0].idx : -1);
! 6468: j = 0; /* Current 'old' sibling page */
! 6469: k = 0; /* Current 'new' sibling page */
! 6470: for(i=0; i<nCell; i++){
! 6471: int isDivider = 0;
! 6472: while( i==iNextOld ){
! 6473: /* Cell i is the cell immediately following the last cell on old
! 6474: ** sibling page j. If the siblings are not leaf pages of an
! 6475: ** intkey b-tree, then cell i was a divider cell. */
! 6476: assert( j+1 < ArraySize(apCopy) );
! 6477: pOld = apCopy[++j];
! 6478: iNextOld = i + !leafData + pOld->nCell + pOld->nOverflow;
! 6479: if( pOld->nOverflow ){
! 6480: nOverflow = pOld->nOverflow;
! 6481: iOverflow = i + !leafData + pOld->aOvfl[0].idx;
! 6482: }
! 6483: isDivider = !leafData;
! 6484: }
! 6485:
! 6486: assert(nOverflow>0 || iOverflow<i );
! 6487: assert(nOverflow<2 || pOld->aOvfl[0].idx==pOld->aOvfl[1].idx-1);
! 6488: assert(nOverflow<3 || pOld->aOvfl[1].idx==pOld->aOvfl[2].idx-1);
! 6489: if( i==iOverflow ){
! 6490: isDivider = 1;
! 6491: if( (--nOverflow)>0 ){
! 6492: iOverflow++;
! 6493: }
! 6494: }
! 6495:
! 6496: if( i==cntNew[k] ){
! 6497: /* Cell i is the cell immediately following the last cell on new
! 6498: ** sibling page k. If the siblings are not leaf pages of an
! 6499: ** intkey b-tree, then cell i is a divider cell. */
! 6500: pNew = apNew[++k];
! 6501: if( !leafData ) continue;
! 6502: }
! 6503: assert( j<nOld );
! 6504: assert( k<nNew );
! 6505:
! 6506: /* If the cell was originally divider cell (and is not now) or
! 6507: ** an overflow cell, or if the cell was located on a different sibling
! 6508: ** page before the balancing, then the pointer map entries associated
! 6509: ** with any child or overflow pages need to be updated. */
! 6510: if( isDivider || pOld->pgno!=pNew->pgno ){
! 6511: if( !leafCorrection ){
! 6512: ptrmapPut(pBt, get4byte(apCell[i]), PTRMAP_BTREE, pNew->pgno, &rc);
! 6513: }
! 6514: if( szCell[i]>pNew->minLocal ){
! 6515: ptrmapPutOvflPtr(pNew, apCell[i], &rc);
! 6516: }
! 6517: }
! 6518: }
! 6519:
! 6520: if( !leafCorrection ){
! 6521: for(i=0; i<nNew; i++){
! 6522: u32 key = get4byte(&apNew[i]->aData[8]);
! 6523: ptrmapPut(pBt, key, PTRMAP_BTREE, apNew[i]->pgno, &rc);
! 6524: }
! 6525: }
! 6526:
! 6527: #if 0
! 6528: /* The ptrmapCheckPages() contains assert() statements that verify that
! 6529: ** all pointer map pages are set correctly. This is helpful while
! 6530: ** debugging. This is usually disabled because a corrupt database may
! 6531: ** cause an assert() statement to fail. */
! 6532: ptrmapCheckPages(apNew, nNew);
! 6533: ptrmapCheckPages(&pParent, 1);
! 6534: #endif
! 6535: }
! 6536:
! 6537: assert( pParent->isInit );
! 6538: TRACE(("BALANCE: finished: old=%d new=%d cells=%d\n",
! 6539: nOld, nNew, nCell));
! 6540:
! 6541: /*
! 6542: ** Cleanup before returning.
! 6543: */
! 6544: balance_cleanup:
! 6545: sqlite3ScratchFree(apCell);
! 6546: for(i=0; i<nOld; i++){
! 6547: releasePage(apOld[i]);
! 6548: }
! 6549: for(i=0; i<nNew; i++){
! 6550: releasePage(apNew[i]);
! 6551: }
! 6552:
! 6553: return rc;
! 6554: }
! 6555:
! 6556:
! 6557: /*
! 6558: ** This function is called when the root page of a b-tree structure is
! 6559: ** overfull (has one or more overflow pages).
! 6560: **
! 6561: ** A new child page is allocated and the contents of the current root
! 6562: ** page, including overflow cells, are copied into the child. The root
! 6563: ** page is then overwritten to make it an empty page with the right-child
! 6564: ** pointer pointing to the new page.
! 6565: **
! 6566: ** Before returning, all pointer-map entries corresponding to pages
! 6567: ** that the new child-page now contains pointers to are updated. The
! 6568: ** entry corresponding to the new right-child pointer of the root
! 6569: ** page is also updated.
! 6570: **
! 6571: ** If successful, *ppChild is set to contain a reference to the child
! 6572: ** page and SQLITE_OK is returned. In this case the caller is required
! 6573: ** to call releasePage() on *ppChild exactly once. If an error occurs,
! 6574: ** an error code is returned and *ppChild is set to 0.
! 6575: */
! 6576: static int balance_deeper(MemPage *pRoot, MemPage **ppChild){
! 6577: int rc; /* Return value from subprocedures */
! 6578: MemPage *pChild = 0; /* Pointer to a new child page */
! 6579: Pgno pgnoChild = 0; /* Page number of the new child page */
! 6580: BtShared *pBt = pRoot->pBt; /* The BTree */
! 6581:
! 6582: assert( pRoot->nOverflow>0 );
! 6583: assert( sqlite3_mutex_held(pBt->mutex) );
! 6584:
! 6585: /* Make pRoot, the root page of the b-tree, writable. Allocate a new
! 6586: ** page that will become the new right-child of pPage. Copy the contents
! 6587: ** of the node stored on pRoot into the new child page.
! 6588: */
! 6589: rc = sqlite3PagerWrite(pRoot->pDbPage);
! 6590: if( rc==SQLITE_OK ){
! 6591: rc = allocateBtreePage(pBt,&pChild,&pgnoChild,pRoot->pgno,0);
! 6592: copyNodeContent(pRoot, pChild, &rc);
! 6593: if( ISAUTOVACUUM ){
! 6594: ptrmapPut(pBt, pgnoChild, PTRMAP_BTREE, pRoot->pgno, &rc);
! 6595: }
! 6596: }
! 6597: if( rc ){
! 6598: *ppChild = 0;
! 6599: releasePage(pChild);
! 6600: return rc;
! 6601: }
! 6602: assert( sqlite3PagerIswriteable(pChild->pDbPage) );
! 6603: assert( sqlite3PagerIswriteable(pRoot->pDbPage) );
! 6604: assert( pChild->nCell==pRoot->nCell );
! 6605:
! 6606: TRACE(("BALANCE: copy root %d into %d\n", pRoot->pgno, pChild->pgno));
! 6607:
! 6608: /* Copy the overflow cells from pRoot to pChild */
! 6609: memcpy(pChild->aOvfl, pRoot->aOvfl, pRoot->nOverflow*sizeof(pRoot->aOvfl[0]));
! 6610: pChild->nOverflow = pRoot->nOverflow;
! 6611:
! 6612: /* Zero the contents of pRoot. Then install pChild as the right-child. */
! 6613: zeroPage(pRoot, pChild->aData[0] & ~PTF_LEAF);
! 6614: put4byte(&pRoot->aData[pRoot->hdrOffset+8], pgnoChild);
! 6615:
! 6616: *ppChild = pChild;
! 6617: return SQLITE_OK;
! 6618: }
! 6619:
! 6620: /*
! 6621: ** The page that pCur currently points to has just been modified in
! 6622: ** some way. This function figures out if this modification means the
! 6623: ** tree needs to be balanced, and if so calls the appropriate balancing
! 6624: ** routine. Balancing routines are:
! 6625: **
! 6626: ** balance_quick()
! 6627: ** balance_deeper()
! 6628: ** balance_nonroot()
! 6629: */
! 6630: static int balance(BtCursor *pCur){
! 6631: int rc = SQLITE_OK;
! 6632: const int nMin = pCur->pBt->usableSize * 2 / 3;
! 6633: u8 aBalanceQuickSpace[13];
! 6634: u8 *pFree = 0;
! 6635:
! 6636: TESTONLY( int balance_quick_called = 0 );
! 6637: TESTONLY( int balance_deeper_called = 0 );
! 6638:
! 6639: do {
! 6640: int iPage = pCur->iPage;
! 6641: MemPage *pPage = pCur->apPage[iPage];
! 6642:
! 6643: if( iPage==0 ){
! 6644: if( pPage->nOverflow ){
! 6645: /* The root page of the b-tree is overfull. In this case call the
! 6646: ** balance_deeper() function to create a new child for the root-page
! 6647: ** and copy the current contents of the root-page to it. The
! 6648: ** next iteration of the do-loop will balance the child page.
! 6649: */
! 6650: assert( (balance_deeper_called++)==0 );
! 6651: rc = balance_deeper(pPage, &pCur->apPage[1]);
! 6652: if( rc==SQLITE_OK ){
! 6653: pCur->iPage = 1;
! 6654: pCur->aiIdx[0] = 0;
! 6655: pCur->aiIdx[1] = 0;
! 6656: assert( pCur->apPage[1]->nOverflow );
! 6657: }
! 6658: }else{
! 6659: break;
! 6660: }
! 6661: }else if( pPage->nOverflow==0 && pPage->nFree<=nMin ){
! 6662: break;
! 6663: }else{
! 6664: MemPage * const pParent = pCur->apPage[iPage-1];
! 6665: int const iIdx = pCur->aiIdx[iPage-1];
! 6666:
! 6667: rc = sqlite3PagerWrite(pParent->pDbPage);
! 6668: if( rc==SQLITE_OK ){
! 6669: #ifndef SQLITE_OMIT_QUICKBALANCE
! 6670: if( pPage->hasData
! 6671: && pPage->nOverflow==1
! 6672: && pPage->aOvfl[0].idx==pPage->nCell
! 6673: && pParent->pgno!=1
! 6674: && pParent->nCell==iIdx
! 6675: ){
! 6676: /* Call balance_quick() to create a new sibling of pPage on which
! 6677: ** to store the overflow cell. balance_quick() inserts a new cell
! 6678: ** into pParent, which may cause pParent overflow. If this
! 6679: ** happens, the next interation of the do-loop will balance pParent
! 6680: ** use either balance_nonroot() or balance_deeper(). Until this
! 6681: ** happens, the overflow cell is stored in the aBalanceQuickSpace[]
! 6682: ** buffer.
! 6683: **
! 6684: ** The purpose of the following assert() is to check that only a
! 6685: ** single call to balance_quick() is made for each call to this
! 6686: ** function. If this were not verified, a subtle bug involving reuse
! 6687: ** of the aBalanceQuickSpace[] might sneak in.
! 6688: */
! 6689: assert( (balance_quick_called++)==0 );
! 6690: rc = balance_quick(pParent, pPage, aBalanceQuickSpace);
! 6691: }else
! 6692: #endif
! 6693: {
! 6694: /* In this case, call balance_nonroot() to redistribute cells
! 6695: ** between pPage and up to 2 of its sibling pages. This involves
! 6696: ** modifying the contents of pParent, which may cause pParent to
! 6697: ** become overfull or underfull. The next iteration of the do-loop
! 6698: ** will balance the parent page to correct this.
! 6699: **
! 6700: ** If the parent page becomes overfull, the overflow cell or cells
! 6701: ** are stored in the pSpace buffer allocated immediately below.
! 6702: ** A subsequent iteration of the do-loop will deal with this by
! 6703: ** calling balance_nonroot() (balance_deeper() may be called first,
! 6704: ** but it doesn't deal with overflow cells - just moves them to a
! 6705: ** different page). Once this subsequent call to balance_nonroot()
! 6706: ** has completed, it is safe to release the pSpace buffer used by
! 6707: ** the previous call, as the overflow cell data will have been
! 6708: ** copied either into the body of a database page or into the new
! 6709: ** pSpace buffer passed to the latter call to balance_nonroot().
! 6710: */
! 6711: u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
! 6712: rc = balance_nonroot(pParent, iIdx, pSpace, iPage==1);
! 6713: if( pFree ){
! 6714: /* If pFree is not NULL, it points to the pSpace buffer used
! 6715: ** by a previous call to balance_nonroot(). Its contents are
! 6716: ** now stored either on real database pages or within the
! 6717: ** new pSpace buffer, so it may be safely freed here. */
! 6718: sqlite3PageFree(pFree);
! 6719: }
! 6720:
! 6721: /* The pSpace buffer will be freed after the next call to
! 6722: ** balance_nonroot(), or just before this function returns, whichever
! 6723: ** comes first. */
! 6724: pFree = pSpace;
! 6725: }
! 6726: }
! 6727:
! 6728: pPage->nOverflow = 0;
! 6729:
! 6730: /* The next iteration of the do-loop balances the parent page. */
! 6731: releasePage(pPage);
! 6732: pCur->iPage--;
! 6733: }
! 6734: }while( rc==SQLITE_OK );
! 6735:
! 6736: if( pFree ){
! 6737: sqlite3PageFree(pFree);
! 6738: }
! 6739: return rc;
! 6740: }
! 6741:
! 6742:
! 6743: /*
! 6744: ** Insert a new record into the BTree. The key is given by (pKey,nKey)
! 6745: ** and the data is given by (pData,nData). The cursor is used only to
! 6746: ** define what table the record should be inserted into. The cursor
! 6747: ** is left pointing at a random location.
! 6748: **
! 6749: ** For an INTKEY table, only the nKey value of the key is used. pKey is
! 6750: ** ignored. For a ZERODATA table, the pData and nData are both ignored.
! 6751: **
! 6752: ** If the seekResult parameter is non-zero, then a successful call to
! 6753: ** MovetoUnpacked() to seek cursor pCur to (pKey, nKey) has already
! 6754: ** been performed. seekResult is the search result returned (a negative
! 6755: ** number if pCur points at an entry that is smaller than (pKey, nKey), or
! 6756: ** a positive value if pCur points at an etry that is larger than
! 6757: ** (pKey, nKey)).
! 6758: **
! 6759: ** If the seekResult parameter is non-zero, then the caller guarantees that
! 6760: ** cursor pCur is pointing at the existing copy of a row that is to be
! 6761: ** overwritten. If the seekResult parameter is 0, then cursor pCur may
! 6762: ** point to any entry or to no entry at all and so this function has to seek
! 6763: ** the cursor before the new key can be inserted.
! 6764: */
! 6765: int sqlite3BtreeInsert(
! 6766: BtCursor *pCur, /* Insert data into the table of this cursor */
! 6767: const void *pKey, i64 nKey, /* The key of the new record */
! 6768: const void *pData, int nData, /* The data of the new record */
! 6769: int nZero, /* Number of extra 0 bytes to append to data */
! 6770: int appendBias, /* True if this is likely an append */
! 6771: int seekResult /* Result of prior MovetoUnpacked() call */
! 6772: ){
! 6773: int rc;
! 6774: int loc = seekResult; /* -1: before desired location +1: after */
! 6775: int szNew = 0;
! 6776: int idx;
! 6777: MemPage *pPage;
! 6778: Btree *p = pCur->pBtree;
! 6779: BtShared *pBt = p->pBt;
! 6780: unsigned char *oldCell;
! 6781: unsigned char *newCell = 0;
! 6782:
! 6783: if( pCur->eState==CURSOR_FAULT ){
! 6784: assert( pCur->skipNext!=SQLITE_OK );
! 6785: return pCur->skipNext;
! 6786: }
! 6787:
! 6788: assert( cursorHoldsMutex(pCur) );
! 6789: assert( pCur->wrFlag && pBt->inTransaction==TRANS_WRITE
! 6790: && (pBt->btsFlags & BTS_READ_ONLY)==0 );
! 6791: assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
! 6792:
! 6793: /* Assert that the caller has been consistent. If this cursor was opened
! 6794: ** expecting an index b-tree, then the caller should be inserting blob
! 6795: ** keys with no associated data. If the cursor was opened expecting an
! 6796: ** intkey table, the caller should be inserting integer keys with a
! 6797: ** blob of associated data. */
! 6798: assert( (pKey==0)==(pCur->pKeyInfo==0) );
! 6799:
! 6800: /* If this is an insert into a table b-tree, invalidate any incrblob
! 6801: ** cursors open on the row being replaced (assuming this is a replace
! 6802: ** operation - if it is not, the following is a no-op). */
! 6803: if( pCur->pKeyInfo==0 ){
! 6804: invalidateIncrblobCursors(p, nKey, 0);
! 6805: }
! 6806:
! 6807: /* Save the positions of any other cursors open on this table.
! 6808: **
! 6809: ** In some cases, the call to btreeMoveto() below is a no-op. For
! 6810: ** example, when inserting data into a table with auto-generated integer
! 6811: ** keys, the VDBE layer invokes sqlite3BtreeLast() to figure out the
! 6812: ** integer key to use. It then calls this function to actually insert the
! 6813: ** data into the intkey B-Tree. In this case btreeMoveto() recognizes
! 6814: ** that the cursor is already where it needs to be and returns without
! 6815: ** doing any work. To avoid thwarting these optimizations, it is important
! 6816: ** not to clear the cursor here.
! 6817: */
! 6818: rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
! 6819: if( rc ) return rc;
! 6820: if( !loc ){
! 6821: rc = btreeMoveto(pCur, pKey, nKey, appendBias, &loc);
! 6822: if( rc ) return rc;
! 6823: }
! 6824: assert( pCur->eState==CURSOR_VALID || (pCur->eState==CURSOR_INVALID && loc) );
! 6825:
! 6826: pPage = pCur->apPage[pCur->iPage];
! 6827: assert( pPage->intKey || nKey>=0 );
! 6828: assert( pPage->leaf || !pPage->intKey );
! 6829:
! 6830: TRACE(("INSERT: table=%d nkey=%lld ndata=%d page=%d %s\n",
! 6831: pCur->pgnoRoot, nKey, nData, pPage->pgno,
! 6832: loc==0 ? "overwrite" : "new entry"));
! 6833: assert( pPage->isInit );
! 6834: allocateTempSpace(pBt);
! 6835: newCell = pBt->pTmpSpace;
! 6836: if( newCell==0 ) return SQLITE_NOMEM;
! 6837: rc = fillInCell(pPage, newCell, pKey, nKey, pData, nData, nZero, &szNew);
! 6838: if( rc ) goto end_insert;
! 6839: assert( szNew==cellSizePtr(pPage, newCell) );
! 6840: assert( szNew <= MX_CELL_SIZE(pBt) );
! 6841: idx = pCur->aiIdx[pCur->iPage];
! 6842: if( loc==0 ){
! 6843: u16 szOld;
! 6844: assert( idx<pPage->nCell );
! 6845: rc = sqlite3PagerWrite(pPage->pDbPage);
! 6846: if( rc ){
! 6847: goto end_insert;
! 6848: }
! 6849: oldCell = findCell(pPage, idx);
! 6850: if( !pPage->leaf ){
! 6851: memcpy(newCell, oldCell, 4);
! 6852: }
! 6853: szOld = cellSizePtr(pPage, oldCell);
! 6854: rc = clearCell(pPage, oldCell);
! 6855: dropCell(pPage, idx, szOld, &rc);
! 6856: if( rc ) goto end_insert;
! 6857: }else if( loc<0 && pPage->nCell>0 ){
! 6858: assert( pPage->leaf );
! 6859: idx = ++pCur->aiIdx[pCur->iPage];
! 6860: }else{
! 6861: assert( pPage->leaf );
! 6862: }
! 6863: insertCell(pPage, idx, newCell, szNew, 0, 0, &rc);
! 6864: assert( rc!=SQLITE_OK || pPage->nCell>0 || pPage->nOverflow>0 );
! 6865:
! 6866: /* If no error has occured and pPage has an overflow cell, call balance()
! 6867: ** to redistribute the cells within the tree. Since balance() may move
! 6868: ** the cursor, zero the BtCursor.info.nSize and BtCursor.validNKey
! 6869: ** variables.
! 6870: **
! 6871: ** Previous versions of SQLite called moveToRoot() to move the cursor
! 6872: ** back to the root page as balance() used to invalidate the contents
! 6873: ** of BtCursor.apPage[] and BtCursor.aiIdx[]. Instead of doing that,
! 6874: ** set the cursor state to "invalid". This makes common insert operations
! 6875: ** slightly faster.
! 6876: **
! 6877: ** There is a subtle but important optimization here too. When inserting
! 6878: ** multiple records into an intkey b-tree using a single cursor (as can
! 6879: ** happen while processing an "INSERT INTO ... SELECT" statement), it
! 6880: ** is advantageous to leave the cursor pointing to the last entry in
! 6881: ** the b-tree if possible. If the cursor is left pointing to the last
! 6882: ** entry in the table, and the next row inserted has an integer key
! 6883: ** larger than the largest existing key, it is possible to insert the
! 6884: ** row without seeking the cursor. This can be a big performance boost.
! 6885: */
! 6886: pCur->info.nSize = 0;
! 6887: pCur->validNKey = 0;
! 6888: if( rc==SQLITE_OK && pPage->nOverflow ){
! 6889: rc = balance(pCur);
! 6890:
! 6891: /* Must make sure nOverflow is reset to zero even if the balance()
! 6892: ** fails. Internal data structure corruption will result otherwise.
! 6893: ** Also, set the cursor state to invalid. This stops saveCursorPosition()
! 6894: ** from trying to save the current position of the cursor. */
! 6895: pCur->apPage[pCur->iPage]->nOverflow = 0;
! 6896: pCur->eState = CURSOR_INVALID;
! 6897: }
! 6898: assert( pCur->apPage[pCur->iPage]->nOverflow==0 );
! 6899:
! 6900: end_insert:
! 6901: return rc;
! 6902: }
! 6903:
! 6904: /*
! 6905: ** Delete the entry that the cursor is pointing to. The cursor
! 6906: ** is left pointing at a arbitrary location.
! 6907: */
! 6908: int sqlite3BtreeDelete(BtCursor *pCur){
! 6909: Btree *p = pCur->pBtree;
! 6910: BtShared *pBt = p->pBt;
! 6911: int rc; /* Return code */
! 6912: MemPage *pPage; /* Page to delete cell from */
! 6913: unsigned char *pCell; /* Pointer to cell to delete */
! 6914: int iCellIdx; /* Index of cell to delete */
! 6915: int iCellDepth; /* Depth of node containing pCell */
! 6916:
! 6917: assert( cursorHoldsMutex(pCur) );
! 6918: assert( pBt->inTransaction==TRANS_WRITE );
! 6919: assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
! 6920: assert( pCur->wrFlag );
! 6921: assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
! 6922: assert( !hasReadConflicts(p, pCur->pgnoRoot) );
! 6923:
! 6924: if( NEVER(pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell)
! 6925: || NEVER(pCur->eState!=CURSOR_VALID)
! 6926: ){
! 6927: return SQLITE_ERROR; /* Something has gone awry. */
! 6928: }
! 6929:
! 6930: /* If this is a delete operation to remove a row from a table b-tree,
! 6931: ** invalidate any incrblob cursors open on the row being deleted. */
! 6932: if( pCur->pKeyInfo==0 ){
! 6933: invalidateIncrblobCursors(p, pCur->info.nKey, 0);
! 6934: }
! 6935:
! 6936: iCellDepth = pCur->iPage;
! 6937: iCellIdx = pCur->aiIdx[iCellDepth];
! 6938: pPage = pCur->apPage[iCellDepth];
! 6939: pCell = findCell(pPage, iCellIdx);
! 6940:
! 6941: /* If the page containing the entry to delete is not a leaf page, move
! 6942: ** the cursor to the largest entry in the tree that is smaller than
! 6943: ** the entry being deleted. This cell will replace the cell being deleted
! 6944: ** from the internal node. The 'previous' entry is used for this instead
! 6945: ** of the 'next' entry, as the previous entry is always a part of the
! 6946: ** sub-tree headed by the child page of the cell being deleted. This makes
! 6947: ** balancing the tree following the delete operation easier. */
! 6948: if( !pPage->leaf ){
! 6949: int notUsed;
! 6950: rc = sqlite3BtreePrevious(pCur, ¬Used);
! 6951: if( rc ) return rc;
! 6952: }
! 6953:
! 6954: /* Save the positions of any other cursors open on this table before
! 6955: ** making any modifications. Make the page containing the entry to be
! 6956: ** deleted writable. Then free any overflow pages associated with the
! 6957: ** entry and finally remove the cell itself from within the page.
! 6958: */
! 6959: rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
! 6960: if( rc ) return rc;
! 6961: rc = sqlite3PagerWrite(pPage->pDbPage);
! 6962: if( rc ) return rc;
! 6963: rc = clearCell(pPage, pCell);
! 6964: dropCell(pPage, iCellIdx, cellSizePtr(pPage, pCell), &rc);
! 6965: if( rc ) return rc;
! 6966:
! 6967: /* If the cell deleted was not located on a leaf page, then the cursor
! 6968: ** is currently pointing to the largest entry in the sub-tree headed
! 6969: ** by the child-page of the cell that was just deleted from an internal
! 6970: ** node. The cell from the leaf node needs to be moved to the internal
! 6971: ** node to replace the deleted cell. */
! 6972: if( !pPage->leaf ){
! 6973: MemPage *pLeaf = pCur->apPage[pCur->iPage];
! 6974: int nCell;
! 6975: Pgno n = pCur->apPage[iCellDepth+1]->pgno;
! 6976: unsigned char *pTmp;
! 6977:
! 6978: pCell = findCell(pLeaf, pLeaf->nCell-1);
! 6979: nCell = cellSizePtr(pLeaf, pCell);
! 6980: assert( MX_CELL_SIZE(pBt) >= nCell );
! 6981:
! 6982: allocateTempSpace(pBt);
! 6983: pTmp = pBt->pTmpSpace;
! 6984:
! 6985: rc = sqlite3PagerWrite(pLeaf->pDbPage);
! 6986: insertCell(pPage, iCellIdx, pCell-4, nCell+4, pTmp, n, &rc);
! 6987: dropCell(pLeaf, pLeaf->nCell-1, nCell, &rc);
! 6988: if( rc ) return rc;
! 6989: }
! 6990:
! 6991: /* Balance the tree. If the entry deleted was located on a leaf page,
! 6992: ** then the cursor still points to that page. In this case the first
! 6993: ** call to balance() repairs the tree, and the if(...) condition is
! 6994: ** never true.
! 6995: **
! 6996: ** Otherwise, if the entry deleted was on an internal node page, then
! 6997: ** pCur is pointing to the leaf page from which a cell was removed to
! 6998: ** replace the cell deleted from the internal node. This is slightly
! 6999: ** tricky as the leaf node may be underfull, and the internal node may
! 7000: ** be either under or overfull. In this case run the balancing algorithm
! 7001: ** on the leaf node first. If the balance proceeds far enough up the
! 7002: ** tree that we can be sure that any problem in the internal node has
! 7003: ** been corrected, so be it. Otherwise, after balancing the leaf node,
! 7004: ** walk the cursor up the tree to the internal node and balance it as
! 7005: ** well. */
! 7006: rc = balance(pCur);
! 7007: if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
! 7008: while( pCur->iPage>iCellDepth ){
! 7009: releasePage(pCur->apPage[pCur->iPage--]);
! 7010: }
! 7011: rc = balance(pCur);
! 7012: }
! 7013:
! 7014: if( rc==SQLITE_OK ){
! 7015: moveToRoot(pCur);
! 7016: }
! 7017: return rc;
! 7018: }
! 7019:
! 7020: /*
! 7021: ** Create a new BTree table. Write into *piTable the page
! 7022: ** number for the root page of the new table.
! 7023: **
! 7024: ** The type of type is determined by the flags parameter. Only the
! 7025: ** following values of flags are currently in use. Other values for
! 7026: ** flags might not work:
! 7027: **
! 7028: ** BTREE_INTKEY|BTREE_LEAFDATA Used for SQL tables with rowid keys
! 7029: ** BTREE_ZERODATA Used for SQL indices
! 7030: */
! 7031: static int btreeCreateTable(Btree *p, int *piTable, int createTabFlags){
! 7032: BtShared *pBt = p->pBt;
! 7033: MemPage *pRoot;
! 7034: Pgno pgnoRoot;
! 7035: int rc;
! 7036: int ptfFlags; /* Page-type flage for the root page of new table */
! 7037:
! 7038: assert( sqlite3BtreeHoldsMutex(p) );
! 7039: assert( pBt->inTransaction==TRANS_WRITE );
! 7040: assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
! 7041:
! 7042: #ifdef SQLITE_OMIT_AUTOVACUUM
! 7043: rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0);
! 7044: if( rc ){
! 7045: return rc;
! 7046: }
! 7047: #else
! 7048: if( pBt->autoVacuum ){
! 7049: Pgno pgnoMove; /* Move a page here to make room for the root-page */
! 7050: MemPage *pPageMove; /* The page to move to. */
! 7051:
! 7052: /* Creating a new table may probably require moving an existing database
! 7053: ** to make room for the new tables root page. In case this page turns
! 7054: ** out to be an overflow page, delete all overflow page-map caches
! 7055: ** held by open cursors.
! 7056: */
! 7057: invalidateAllOverflowCache(pBt);
! 7058:
! 7059: /* Read the value of meta[3] from the database to determine where the
! 7060: ** root page of the new table should go. meta[3] is the largest root-page
! 7061: ** created so far, so the new root-page is (meta[3]+1).
! 7062: */
! 7063: sqlite3BtreeGetMeta(p, BTREE_LARGEST_ROOT_PAGE, &pgnoRoot);
! 7064: pgnoRoot++;
! 7065:
! 7066: /* The new root-page may not be allocated on a pointer-map page, or the
! 7067: ** PENDING_BYTE page.
! 7068: */
! 7069: while( pgnoRoot==PTRMAP_PAGENO(pBt, pgnoRoot) ||
! 7070: pgnoRoot==PENDING_BYTE_PAGE(pBt) ){
! 7071: pgnoRoot++;
! 7072: }
! 7073: assert( pgnoRoot>=3 );
! 7074:
! 7075: /* Allocate a page. The page that currently resides at pgnoRoot will
! 7076: ** be moved to the allocated page (unless the allocated page happens
! 7077: ** to reside at pgnoRoot).
! 7078: */
! 7079: rc = allocateBtreePage(pBt, &pPageMove, &pgnoMove, pgnoRoot, 1);
! 7080: if( rc!=SQLITE_OK ){
! 7081: return rc;
! 7082: }
! 7083:
! 7084: if( pgnoMove!=pgnoRoot ){
! 7085: /* pgnoRoot is the page that will be used for the root-page of
! 7086: ** the new table (assuming an error did not occur). But we were
! 7087: ** allocated pgnoMove. If required (i.e. if it was not allocated
! 7088: ** by extending the file), the current page at position pgnoMove
! 7089: ** is already journaled.
! 7090: */
! 7091: u8 eType = 0;
! 7092: Pgno iPtrPage = 0;
! 7093:
! 7094: releasePage(pPageMove);
! 7095:
! 7096: /* Move the page currently at pgnoRoot to pgnoMove. */
! 7097: rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0);
! 7098: if( rc!=SQLITE_OK ){
! 7099: return rc;
! 7100: }
! 7101: rc = ptrmapGet(pBt, pgnoRoot, &eType, &iPtrPage);
! 7102: if( eType==PTRMAP_ROOTPAGE || eType==PTRMAP_FREEPAGE ){
! 7103: rc = SQLITE_CORRUPT_BKPT;
! 7104: }
! 7105: if( rc!=SQLITE_OK ){
! 7106: releasePage(pRoot);
! 7107: return rc;
! 7108: }
! 7109: assert( eType!=PTRMAP_ROOTPAGE );
! 7110: assert( eType!=PTRMAP_FREEPAGE );
! 7111: rc = relocatePage(pBt, pRoot, eType, iPtrPage, pgnoMove, 0);
! 7112: releasePage(pRoot);
! 7113:
! 7114: /* Obtain the page at pgnoRoot */
! 7115: if( rc!=SQLITE_OK ){
! 7116: return rc;
! 7117: }
! 7118: rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0);
! 7119: if( rc!=SQLITE_OK ){
! 7120: return rc;
! 7121: }
! 7122: rc = sqlite3PagerWrite(pRoot->pDbPage);
! 7123: if( rc!=SQLITE_OK ){
! 7124: releasePage(pRoot);
! 7125: return rc;
! 7126: }
! 7127: }else{
! 7128: pRoot = pPageMove;
! 7129: }
! 7130:
! 7131: /* Update the pointer-map and meta-data with the new root-page number. */
! 7132: ptrmapPut(pBt, pgnoRoot, PTRMAP_ROOTPAGE, 0, &rc);
! 7133: if( rc ){
! 7134: releasePage(pRoot);
! 7135: return rc;
! 7136: }
! 7137:
! 7138: /* When the new root page was allocated, page 1 was made writable in
! 7139: ** order either to increase the database filesize, or to decrement the
! 7140: ** freelist count. Hence, the sqlite3BtreeUpdateMeta() call cannot fail.
! 7141: */
! 7142: assert( sqlite3PagerIswriteable(pBt->pPage1->pDbPage) );
! 7143: rc = sqlite3BtreeUpdateMeta(p, 4, pgnoRoot);
! 7144: if( NEVER(rc) ){
! 7145: releasePage(pRoot);
! 7146: return rc;
! 7147: }
! 7148:
! 7149: }else{
! 7150: rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0);
! 7151: if( rc ) return rc;
! 7152: }
! 7153: #endif
! 7154: assert( sqlite3PagerIswriteable(pRoot->pDbPage) );
! 7155: if( createTabFlags & BTREE_INTKEY ){
! 7156: ptfFlags = PTF_INTKEY | PTF_LEAFDATA | PTF_LEAF;
! 7157: }else{
! 7158: ptfFlags = PTF_ZERODATA | PTF_LEAF;
! 7159: }
! 7160: zeroPage(pRoot, ptfFlags);
! 7161: sqlite3PagerUnref(pRoot->pDbPage);
! 7162: assert( (pBt->openFlags & BTREE_SINGLE)==0 || pgnoRoot==2 );
! 7163: *piTable = (int)pgnoRoot;
! 7164: return SQLITE_OK;
! 7165: }
! 7166: int sqlite3BtreeCreateTable(Btree *p, int *piTable, int flags){
! 7167: int rc;
! 7168: sqlite3BtreeEnter(p);
! 7169: rc = btreeCreateTable(p, piTable, flags);
! 7170: sqlite3BtreeLeave(p);
! 7171: return rc;
! 7172: }
! 7173:
! 7174: /*
! 7175: ** Erase the given database page and all its children. Return
! 7176: ** the page to the freelist.
! 7177: */
! 7178: static int clearDatabasePage(
! 7179: BtShared *pBt, /* The BTree that contains the table */
! 7180: Pgno pgno, /* Page number to clear */
! 7181: int freePageFlag, /* Deallocate page if true */
! 7182: int *pnChange /* Add number of Cells freed to this counter */
! 7183: ){
! 7184: MemPage *pPage;
! 7185: int rc;
! 7186: unsigned char *pCell;
! 7187: int i;
! 7188:
! 7189: assert( sqlite3_mutex_held(pBt->mutex) );
! 7190: if( pgno>btreePagecount(pBt) ){
! 7191: return SQLITE_CORRUPT_BKPT;
! 7192: }
! 7193:
! 7194: rc = getAndInitPage(pBt, pgno, &pPage);
! 7195: if( rc ) return rc;
! 7196: for(i=0; i<pPage->nCell; i++){
! 7197: pCell = findCell(pPage, i);
! 7198: if( !pPage->leaf ){
! 7199: rc = clearDatabasePage(pBt, get4byte(pCell), 1, pnChange);
! 7200: if( rc ) goto cleardatabasepage_out;
! 7201: }
! 7202: rc = clearCell(pPage, pCell);
! 7203: if( rc ) goto cleardatabasepage_out;
! 7204: }
! 7205: if( !pPage->leaf ){
! 7206: rc = clearDatabasePage(pBt, get4byte(&pPage->aData[8]), 1, pnChange);
! 7207: if( rc ) goto cleardatabasepage_out;
! 7208: }else if( pnChange ){
! 7209: assert( pPage->intKey );
! 7210: *pnChange += pPage->nCell;
! 7211: }
! 7212: if( freePageFlag ){
! 7213: freePage(pPage, &rc);
! 7214: }else if( (rc = sqlite3PagerWrite(pPage->pDbPage))==0 ){
! 7215: zeroPage(pPage, pPage->aData[0] | PTF_LEAF);
! 7216: }
! 7217:
! 7218: cleardatabasepage_out:
! 7219: releasePage(pPage);
! 7220: return rc;
! 7221: }
! 7222:
! 7223: /*
! 7224: ** Delete all information from a single table in the database. iTable is
! 7225: ** the page number of the root of the table. After this routine returns,
! 7226: ** the root page is empty, but still exists.
! 7227: **
! 7228: ** This routine will fail with SQLITE_LOCKED if there are any open
! 7229: ** read cursors on the table. Open write cursors are moved to the
! 7230: ** root of the table.
! 7231: **
! 7232: ** If pnChange is not NULL, then table iTable must be an intkey table. The
! 7233: ** integer value pointed to by pnChange is incremented by the number of
! 7234: ** entries in the table.
! 7235: */
! 7236: int sqlite3BtreeClearTable(Btree *p, int iTable, int *pnChange){
! 7237: int rc;
! 7238: BtShared *pBt = p->pBt;
! 7239: sqlite3BtreeEnter(p);
! 7240: assert( p->inTrans==TRANS_WRITE );
! 7241:
! 7242: /* Invalidate all incrblob cursors open on table iTable (assuming iTable
! 7243: ** is the root of a table b-tree - if it is not, the following call is
! 7244: ** a no-op). */
! 7245: invalidateIncrblobCursors(p, 0, 1);
! 7246:
! 7247: rc = saveAllCursors(pBt, (Pgno)iTable, 0);
! 7248: if( SQLITE_OK==rc ){
! 7249: rc = clearDatabasePage(pBt, (Pgno)iTable, 0, pnChange);
! 7250: }
! 7251: sqlite3BtreeLeave(p);
! 7252: return rc;
! 7253: }
! 7254:
! 7255: /*
! 7256: ** Erase all information in a table and add the root of the table to
! 7257: ** the freelist. Except, the root of the principle table (the one on
! 7258: ** page 1) is never added to the freelist.
! 7259: **
! 7260: ** This routine will fail with SQLITE_LOCKED if there are any open
! 7261: ** cursors on the table.
! 7262: **
! 7263: ** If AUTOVACUUM is enabled and the page at iTable is not the last
! 7264: ** root page in the database file, then the last root page
! 7265: ** in the database file is moved into the slot formerly occupied by
! 7266: ** iTable and that last slot formerly occupied by the last root page
! 7267: ** is added to the freelist instead of iTable. In this say, all
! 7268: ** root pages are kept at the beginning of the database file, which
! 7269: ** is necessary for AUTOVACUUM to work right. *piMoved is set to the
! 7270: ** page number that used to be the last root page in the file before
! 7271: ** the move. If no page gets moved, *piMoved is set to 0.
! 7272: ** The last root page is recorded in meta[3] and the value of
! 7273: ** meta[3] is updated by this procedure.
! 7274: */
! 7275: static int btreeDropTable(Btree *p, Pgno iTable, int *piMoved){
! 7276: int rc;
! 7277: MemPage *pPage = 0;
! 7278: BtShared *pBt = p->pBt;
! 7279:
! 7280: assert( sqlite3BtreeHoldsMutex(p) );
! 7281: assert( p->inTrans==TRANS_WRITE );
! 7282:
! 7283: /* It is illegal to drop a table if any cursors are open on the
! 7284: ** database. This is because in auto-vacuum mode the backend may
! 7285: ** need to move another root-page to fill a gap left by the deleted
! 7286: ** root page. If an open cursor was using this page a problem would
! 7287: ** occur.
! 7288: **
! 7289: ** This error is caught long before control reaches this point.
! 7290: */
! 7291: if( NEVER(pBt->pCursor) ){
! 7292: sqlite3ConnectionBlocked(p->db, pBt->pCursor->pBtree->db);
! 7293: return SQLITE_LOCKED_SHAREDCACHE;
! 7294: }
! 7295:
! 7296: rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0);
! 7297: if( rc ) return rc;
! 7298: rc = sqlite3BtreeClearTable(p, iTable, 0);
! 7299: if( rc ){
! 7300: releasePage(pPage);
! 7301: return rc;
! 7302: }
! 7303:
! 7304: *piMoved = 0;
! 7305:
! 7306: if( iTable>1 ){
! 7307: #ifdef SQLITE_OMIT_AUTOVACUUM
! 7308: freePage(pPage, &rc);
! 7309: releasePage(pPage);
! 7310: #else
! 7311: if( pBt->autoVacuum ){
! 7312: Pgno maxRootPgno;
! 7313: sqlite3BtreeGetMeta(p, BTREE_LARGEST_ROOT_PAGE, &maxRootPgno);
! 7314:
! 7315: if( iTable==maxRootPgno ){
! 7316: /* If the table being dropped is the table with the largest root-page
! 7317: ** number in the database, put the root page on the free list.
! 7318: */
! 7319: freePage(pPage, &rc);
! 7320: releasePage(pPage);
! 7321: if( rc!=SQLITE_OK ){
! 7322: return rc;
! 7323: }
! 7324: }else{
! 7325: /* The table being dropped does not have the largest root-page
! 7326: ** number in the database. So move the page that does into the
! 7327: ** gap left by the deleted root-page.
! 7328: */
! 7329: MemPage *pMove;
! 7330: releasePage(pPage);
! 7331: rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0);
! 7332: if( rc!=SQLITE_OK ){
! 7333: return rc;
! 7334: }
! 7335: rc = relocatePage(pBt, pMove, PTRMAP_ROOTPAGE, 0, iTable, 0);
! 7336: releasePage(pMove);
! 7337: if( rc!=SQLITE_OK ){
! 7338: return rc;
! 7339: }
! 7340: pMove = 0;
! 7341: rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0);
! 7342: freePage(pMove, &rc);
! 7343: releasePage(pMove);
! 7344: if( rc!=SQLITE_OK ){
! 7345: return rc;
! 7346: }
! 7347: *piMoved = maxRootPgno;
! 7348: }
! 7349:
! 7350: /* Set the new 'max-root-page' value in the database header. This
! 7351: ** is the old value less one, less one more if that happens to
! 7352: ** be a root-page number, less one again if that is the
! 7353: ** PENDING_BYTE_PAGE.
! 7354: */
! 7355: maxRootPgno--;
! 7356: while( maxRootPgno==PENDING_BYTE_PAGE(pBt)
! 7357: || PTRMAP_ISPAGE(pBt, maxRootPgno) ){
! 7358: maxRootPgno--;
! 7359: }
! 7360: assert( maxRootPgno!=PENDING_BYTE_PAGE(pBt) );
! 7361:
! 7362: rc = sqlite3BtreeUpdateMeta(p, 4, maxRootPgno);
! 7363: }else{
! 7364: freePage(pPage, &rc);
! 7365: releasePage(pPage);
! 7366: }
! 7367: #endif
! 7368: }else{
! 7369: /* If sqlite3BtreeDropTable was called on page 1.
! 7370: ** This really never should happen except in a corrupt
! 7371: ** database.
! 7372: */
! 7373: zeroPage(pPage, PTF_INTKEY|PTF_LEAF );
! 7374: releasePage(pPage);
! 7375: }
! 7376: return rc;
! 7377: }
! 7378: int sqlite3BtreeDropTable(Btree *p, int iTable, int *piMoved){
! 7379: int rc;
! 7380: sqlite3BtreeEnter(p);
! 7381: rc = btreeDropTable(p, iTable, piMoved);
! 7382: sqlite3BtreeLeave(p);
! 7383: return rc;
! 7384: }
! 7385:
! 7386:
! 7387: /*
! 7388: ** This function may only be called if the b-tree connection already
! 7389: ** has a read or write transaction open on the database.
! 7390: **
! 7391: ** Read the meta-information out of a database file. Meta[0]
! 7392: ** is the number of free pages currently in the database. Meta[1]
! 7393: ** through meta[15] are available for use by higher layers. Meta[0]
! 7394: ** is read-only, the others are read/write.
! 7395: **
! 7396: ** The schema layer numbers meta values differently. At the schema
! 7397: ** layer (and the SetCookie and ReadCookie opcodes) the number of
! 7398: ** free pages is not visible. So Cookie[0] is the same as Meta[1].
! 7399: */
! 7400: void sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){
! 7401: BtShared *pBt = p->pBt;
! 7402:
! 7403: sqlite3BtreeEnter(p);
! 7404: assert( p->inTrans>TRANS_NONE );
! 7405: assert( SQLITE_OK==querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK) );
! 7406: assert( pBt->pPage1 );
! 7407: assert( idx>=0 && idx<=15 );
! 7408:
! 7409: *pMeta = get4byte(&pBt->pPage1->aData[36 + idx*4]);
! 7410:
! 7411: /* If auto-vacuum is disabled in this build and this is an auto-vacuum
! 7412: ** database, mark the database as read-only. */
! 7413: #ifdef SQLITE_OMIT_AUTOVACUUM
! 7414: if( idx==BTREE_LARGEST_ROOT_PAGE && *pMeta>0 ){
! 7415: pBt->btsFlags |= BTS_READ_ONLY;
! 7416: }
! 7417: #endif
! 7418:
! 7419: sqlite3BtreeLeave(p);
! 7420: }
! 7421:
! 7422: /*
! 7423: ** Write meta-information back into the database. Meta[0] is
! 7424: ** read-only and may not be written.
! 7425: */
! 7426: int sqlite3BtreeUpdateMeta(Btree *p, int idx, u32 iMeta){
! 7427: BtShared *pBt = p->pBt;
! 7428: unsigned char *pP1;
! 7429: int rc;
! 7430: assert( idx>=1 && idx<=15 );
! 7431: sqlite3BtreeEnter(p);
! 7432: assert( p->inTrans==TRANS_WRITE );
! 7433: assert( pBt->pPage1!=0 );
! 7434: pP1 = pBt->pPage1->aData;
! 7435: rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
! 7436: if( rc==SQLITE_OK ){
! 7437: put4byte(&pP1[36 + idx*4], iMeta);
! 7438: #ifndef SQLITE_OMIT_AUTOVACUUM
! 7439: if( idx==BTREE_INCR_VACUUM ){
! 7440: assert( pBt->autoVacuum || iMeta==0 );
! 7441: assert( iMeta==0 || iMeta==1 );
! 7442: pBt->incrVacuum = (u8)iMeta;
! 7443: }
! 7444: #endif
! 7445: }
! 7446: sqlite3BtreeLeave(p);
! 7447: return rc;
! 7448: }
! 7449:
! 7450: #ifndef SQLITE_OMIT_BTREECOUNT
! 7451: /*
! 7452: ** The first argument, pCur, is a cursor opened on some b-tree. Count the
! 7453: ** number of entries in the b-tree and write the result to *pnEntry.
! 7454: **
! 7455: ** SQLITE_OK is returned if the operation is successfully executed.
! 7456: ** Otherwise, if an error is encountered (i.e. an IO error or database
! 7457: ** corruption) an SQLite error code is returned.
! 7458: */
! 7459: int sqlite3BtreeCount(BtCursor *pCur, i64 *pnEntry){
! 7460: i64 nEntry = 0; /* Value to return in *pnEntry */
! 7461: int rc; /* Return code */
! 7462:
! 7463: if( pCur->pgnoRoot==0 ){
! 7464: *pnEntry = 0;
! 7465: return SQLITE_OK;
! 7466: }
! 7467: rc = moveToRoot(pCur);
! 7468:
! 7469: /* Unless an error occurs, the following loop runs one iteration for each
! 7470: ** page in the B-Tree structure (not including overflow pages).
! 7471: */
! 7472: while( rc==SQLITE_OK ){
! 7473: int iIdx; /* Index of child node in parent */
! 7474: MemPage *pPage; /* Current page of the b-tree */
! 7475:
! 7476: /* If this is a leaf page or the tree is not an int-key tree, then
! 7477: ** this page contains countable entries. Increment the entry counter
! 7478: ** accordingly.
! 7479: */
! 7480: pPage = pCur->apPage[pCur->iPage];
! 7481: if( pPage->leaf || !pPage->intKey ){
! 7482: nEntry += pPage->nCell;
! 7483: }
! 7484:
! 7485: /* pPage is a leaf node. This loop navigates the cursor so that it
! 7486: ** points to the first interior cell that it points to the parent of
! 7487: ** the next page in the tree that has not yet been visited. The
! 7488: ** pCur->aiIdx[pCur->iPage] value is set to the index of the parent cell
! 7489: ** of the page, or to the number of cells in the page if the next page
! 7490: ** to visit is the right-child of its parent.
! 7491: **
! 7492: ** If all pages in the tree have been visited, return SQLITE_OK to the
! 7493: ** caller.
! 7494: */
! 7495: if( pPage->leaf ){
! 7496: do {
! 7497: if( pCur->iPage==0 ){
! 7498: /* All pages of the b-tree have been visited. Return successfully. */
! 7499: *pnEntry = nEntry;
! 7500: return SQLITE_OK;
! 7501: }
! 7502: moveToParent(pCur);
! 7503: }while ( pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell );
! 7504:
! 7505: pCur->aiIdx[pCur->iPage]++;
! 7506: pPage = pCur->apPage[pCur->iPage];
! 7507: }
! 7508:
! 7509: /* Descend to the child node of the cell that the cursor currently
! 7510: ** points at. This is the right-child if (iIdx==pPage->nCell).
! 7511: */
! 7512: iIdx = pCur->aiIdx[pCur->iPage];
! 7513: if( iIdx==pPage->nCell ){
! 7514: rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
! 7515: }else{
! 7516: rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx)));
! 7517: }
! 7518: }
! 7519:
! 7520: /* An error has occurred. Return an error code. */
! 7521: return rc;
! 7522: }
! 7523: #endif
! 7524:
! 7525: /*
! 7526: ** Return the pager associated with a BTree. This routine is used for
! 7527: ** testing and debugging only.
! 7528: */
! 7529: Pager *sqlite3BtreePager(Btree *p){
! 7530: return p->pBt->pPager;
! 7531: }
! 7532:
! 7533: #ifndef SQLITE_OMIT_INTEGRITY_CHECK
! 7534: /*
! 7535: ** Append a message to the error message string.
! 7536: */
! 7537: static void checkAppendMsg(
! 7538: IntegrityCk *pCheck,
! 7539: char *zMsg1,
! 7540: const char *zFormat,
! 7541: ...
! 7542: ){
! 7543: va_list ap;
! 7544: if( !pCheck->mxErr ) return;
! 7545: pCheck->mxErr--;
! 7546: pCheck->nErr++;
! 7547: va_start(ap, zFormat);
! 7548: if( pCheck->errMsg.nChar ){
! 7549: sqlite3StrAccumAppend(&pCheck->errMsg, "\n", 1);
! 7550: }
! 7551: if( zMsg1 ){
! 7552: sqlite3StrAccumAppend(&pCheck->errMsg, zMsg1, -1);
! 7553: }
! 7554: sqlite3VXPrintf(&pCheck->errMsg, 1, zFormat, ap);
! 7555: va_end(ap);
! 7556: if( pCheck->errMsg.mallocFailed ){
! 7557: pCheck->mallocFailed = 1;
! 7558: }
! 7559: }
! 7560: #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
! 7561:
! 7562: #ifndef SQLITE_OMIT_INTEGRITY_CHECK
! 7563: /*
! 7564: ** Add 1 to the reference count for page iPage. If this is the second
! 7565: ** reference to the page, add an error message to pCheck->zErrMsg.
! 7566: ** Return 1 if there are 2 ore more references to the page and 0 if
! 7567: ** if this is the first reference to the page.
! 7568: **
! 7569: ** Also check that the page number is in bounds.
! 7570: */
! 7571: static int checkRef(IntegrityCk *pCheck, Pgno iPage, char *zContext){
! 7572: if( iPage==0 ) return 1;
! 7573: if( iPage>pCheck->nPage ){
! 7574: checkAppendMsg(pCheck, zContext, "invalid page number %d", iPage);
! 7575: return 1;
! 7576: }
! 7577: if( pCheck->anRef[iPage]==1 ){
! 7578: checkAppendMsg(pCheck, zContext, "2nd reference to page %d", iPage);
! 7579: return 1;
! 7580: }
! 7581: return (pCheck->anRef[iPage]++)>1;
! 7582: }
! 7583:
! 7584: #ifndef SQLITE_OMIT_AUTOVACUUM
! 7585: /*
! 7586: ** Check that the entry in the pointer-map for page iChild maps to
! 7587: ** page iParent, pointer type ptrType. If not, append an error message
! 7588: ** to pCheck.
! 7589: */
! 7590: static void checkPtrmap(
! 7591: IntegrityCk *pCheck, /* Integrity check context */
! 7592: Pgno iChild, /* Child page number */
! 7593: u8 eType, /* Expected pointer map type */
! 7594: Pgno iParent, /* Expected pointer map parent page number */
! 7595: char *zContext /* Context description (used for error msg) */
! 7596: ){
! 7597: int rc;
! 7598: u8 ePtrmapType;
! 7599: Pgno iPtrmapParent;
! 7600:
! 7601: rc = ptrmapGet(pCheck->pBt, iChild, &ePtrmapType, &iPtrmapParent);
! 7602: if( rc!=SQLITE_OK ){
! 7603: if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ) pCheck->mallocFailed = 1;
! 7604: checkAppendMsg(pCheck, zContext, "Failed to read ptrmap key=%d", iChild);
! 7605: return;
! 7606: }
! 7607:
! 7608: if( ePtrmapType!=eType || iPtrmapParent!=iParent ){
! 7609: checkAppendMsg(pCheck, zContext,
! 7610: "Bad ptr map entry key=%d expected=(%d,%d) got=(%d,%d)",
! 7611: iChild, eType, iParent, ePtrmapType, iPtrmapParent);
! 7612: }
! 7613: }
! 7614: #endif
! 7615:
! 7616: /*
! 7617: ** Check the integrity of the freelist or of an overflow page list.
! 7618: ** Verify that the number of pages on the list is N.
! 7619: */
! 7620: static void checkList(
! 7621: IntegrityCk *pCheck, /* Integrity checking context */
! 7622: int isFreeList, /* True for a freelist. False for overflow page list */
! 7623: int iPage, /* Page number for first page in the list */
! 7624: int N, /* Expected number of pages in the list */
! 7625: char *zContext /* Context for error messages */
! 7626: ){
! 7627: int i;
! 7628: int expected = N;
! 7629: int iFirst = iPage;
! 7630: while( N-- > 0 && pCheck->mxErr ){
! 7631: DbPage *pOvflPage;
! 7632: unsigned char *pOvflData;
! 7633: if( iPage<1 ){
! 7634: checkAppendMsg(pCheck, zContext,
! 7635: "%d of %d pages missing from overflow list starting at %d",
! 7636: N+1, expected, iFirst);
! 7637: break;
! 7638: }
! 7639: if( checkRef(pCheck, iPage, zContext) ) break;
! 7640: if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage) ){
! 7641: checkAppendMsg(pCheck, zContext, "failed to get page %d", iPage);
! 7642: break;
! 7643: }
! 7644: pOvflData = (unsigned char *)sqlite3PagerGetData(pOvflPage);
! 7645: if( isFreeList ){
! 7646: int n = get4byte(&pOvflData[4]);
! 7647: #ifndef SQLITE_OMIT_AUTOVACUUM
! 7648: if( pCheck->pBt->autoVacuum ){
! 7649: checkPtrmap(pCheck, iPage, PTRMAP_FREEPAGE, 0, zContext);
! 7650: }
! 7651: #endif
! 7652: if( n>(int)pCheck->pBt->usableSize/4-2 ){
! 7653: checkAppendMsg(pCheck, zContext,
! 7654: "freelist leaf count too big on page %d", iPage);
! 7655: N--;
! 7656: }else{
! 7657: for(i=0; i<n; i++){
! 7658: Pgno iFreePage = get4byte(&pOvflData[8+i*4]);
! 7659: #ifndef SQLITE_OMIT_AUTOVACUUM
! 7660: if( pCheck->pBt->autoVacuum ){
! 7661: checkPtrmap(pCheck, iFreePage, PTRMAP_FREEPAGE, 0, zContext);
! 7662: }
! 7663: #endif
! 7664: checkRef(pCheck, iFreePage, zContext);
! 7665: }
! 7666: N -= n;
! 7667: }
! 7668: }
! 7669: #ifndef SQLITE_OMIT_AUTOVACUUM
! 7670: else{
! 7671: /* If this database supports auto-vacuum and iPage is not the last
! 7672: ** page in this overflow list, check that the pointer-map entry for
! 7673: ** the following page matches iPage.
! 7674: */
! 7675: if( pCheck->pBt->autoVacuum && N>0 ){
! 7676: i = get4byte(pOvflData);
! 7677: checkPtrmap(pCheck, i, PTRMAP_OVERFLOW2, iPage, zContext);
! 7678: }
! 7679: }
! 7680: #endif
! 7681: iPage = get4byte(pOvflData);
! 7682: sqlite3PagerUnref(pOvflPage);
! 7683: }
! 7684: }
! 7685: #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
! 7686:
! 7687: #ifndef SQLITE_OMIT_INTEGRITY_CHECK
! 7688: /*
! 7689: ** Do various sanity checks on a single page of a tree. Return
! 7690: ** the tree depth. Root pages return 0. Parents of root pages
! 7691: ** return 1, and so forth.
! 7692: **
! 7693: ** These checks are done:
! 7694: **
! 7695: ** 1. Make sure that cells and freeblocks do not overlap
! 7696: ** but combine to completely cover the page.
! 7697: ** NO 2. Make sure cell keys are in order.
! 7698: ** NO 3. Make sure no key is less than or equal to zLowerBound.
! 7699: ** NO 4. Make sure no key is greater than or equal to zUpperBound.
! 7700: ** 5. Check the integrity of overflow pages.
! 7701: ** 6. Recursively call checkTreePage on all children.
! 7702: ** 7. Verify that the depth of all children is the same.
! 7703: ** 8. Make sure this page is at least 33% full or else it is
! 7704: ** the root of the tree.
! 7705: */
! 7706: static int checkTreePage(
! 7707: IntegrityCk *pCheck, /* Context for the sanity check */
! 7708: int iPage, /* Page number of the page to check */
! 7709: char *zParentContext, /* Parent context */
! 7710: i64 *pnParentMinKey,
! 7711: i64 *pnParentMaxKey
! 7712: ){
! 7713: MemPage *pPage;
! 7714: int i, rc, depth, d2, pgno, cnt;
! 7715: int hdr, cellStart;
! 7716: int nCell;
! 7717: u8 *data;
! 7718: BtShared *pBt;
! 7719: int usableSize;
! 7720: char zContext[100];
! 7721: char *hit = 0;
! 7722: i64 nMinKey = 0;
! 7723: i64 nMaxKey = 0;
! 7724:
! 7725: sqlite3_snprintf(sizeof(zContext), zContext, "Page %d: ", iPage);
! 7726:
! 7727: /* Check that the page exists
! 7728: */
! 7729: pBt = pCheck->pBt;
! 7730: usableSize = pBt->usableSize;
! 7731: if( iPage==0 ) return 0;
! 7732: if( checkRef(pCheck, iPage, zParentContext) ) return 0;
! 7733: if( (rc = btreeGetPage(pBt, (Pgno)iPage, &pPage, 0))!=0 ){
! 7734: checkAppendMsg(pCheck, zContext,
! 7735: "unable to get the page. error code=%d", rc);
! 7736: return 0;
! 7737: }
! 7738:
! 7739: /* Clear MemPage.isInit to make sure the corruption detection code in
! 7740: ** btreeInitPage() is executed. */
! 7741: pPage->isInit = 0;
! 7742: if( (rc = btreeInitPage(pPage))!=0 ){
! 7743: assert( rc==SQLITE_CORRUPT ); /* The only possible error from InitPage */
! 7744: checkAppendMsg(pCheck, zContext,
! 7745: "btreeInitPage() returns error code %d", rc);
! 7746: releasePage(pPage);
! 7747: return 0;
! 7748: }
! 7749:
! 7750: /* Check out all the cells.
! 7751: */
! 7752: depth = 0;
! 7753: for(i=0; i<pPage->nCell && pCheck->mxErr; i++){
! 7754: u8 *pCell;
! 7755: u32 sz;
! 7756: CellInfo info;
! 7757:
! 7758: /* Check payload overflow pages
! 7759: */
! 7760: sqlite3_snprintf(sizeof(zContext), zContext,
! 7761: "On tree page %d cell %d: ", iPage, i);
! 7762: pCell = findCell(pPage,i);
! 7763: btreeParseCellPtr(pPage, pCell, &info);
! 7764: sz = info.nData;
! 7765: if( !pPage->intKey ) sz += (int)info.nKey;
! 7766: /* For intKey pages, check that the keys are in order.
! 7767: */
! 7768: else if( i==0 ) nMinKey = nMaxKey = info.nKey;
! 7769: else{
! 7770: if( info.nKey <= nMaxKey ){
! 7771: checkAppendMsg(pCheck, zContext,
! 7772: "Rowid %lld out of order (previous was %lld)", info.nKey, nMaxKey);
! 7773: }
! 7774: nMaxKey = info.nKey;
! 7775: }
! 7776: assert( sz==info.nPayload );
! 7777: if( (sz>info.nLocal)
! 7778: && (&pCell[info.iOverflow]<=&pPage->aData[pBt->usableSize])
! 7779: ){
! 7780: int nPage = (sz - info.nLocal + usableSize - 5)/(usableSize - 4);
! 7781: Pgno pgnoOvfl = get4byte(&pCell[info.iOverflow]);
! 7782: #ifndef SQLITE_OMIT_AUTOVACUUM
! 7783: if( pBt->autoVacuum ){
! 7784: checkPtrmap(pCheck, pgnoOvfl, PTRMAP_OVERFLOW1, iPage, zContext);
! 7785: }
! 7786: #endif
! 7787: checkList(pCheck, 0, pgnoOvfl, nPage, zContext);
! 7788: }
! 7789:
! 7790: /* Check sanity of left child page.
! 7791: */
! 7792: if( !pPage->leaf ){
! 7793: pgno = get4byte(pCell);
! 7794: #ifndef SQLITE_OMIT_AUTOVACUUM
! 7795: if( pBt->autoVacuum ){
! 7796: checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, zContext);
! 7797: }
! 7798: #endif
! 7799: d2 = checkTreePage(pCheck, pgno, zContext, &nMinKey, i==0 ? NULL : &nMaxKey);
! 7800: if( i>0 && d2!=depth ){
! 7801: checkAppendMsg(pCheck, zContext, "Child page depth differs");
! 7802: }
! 7803: depth = d2;
! 7804: }
! 7805: }
! 7806:
! 7807: if( !pPage->leaf ){
! 7808: pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
! 7809: sqlite3_snprintf(sizeof(zContext), zContext,
! 7810: "On page %d at right child: ", iPage);
! 7811: #ifndef SQLITE_OMIT_AUTOVACUUM
! 7812: if( pBt->autoVacuum ){
! 7813: checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, zContext);
! 7814: }
! 7815: #endif
! 7816: checkTreePage(pCheck, pgno, zContext, NULL, !pPage->nCell ? NULL : &nMaxKey);
! 7817: }
! 7818:
! 7819: /* For intKey leaf pages, check that the min/max keys are in order
! 7820: ** with any left/parent/right pages.
! 7821: */
! 7822: if( pPage->leaf && pPage->intKey ){
! 7823: /* if we are a left child page */
! 7824: if( pnParentMinKey ){
! 7825: /* if we are the left most child page */
! 7826: if( !pnParentMaxKey ){
! 7827: if( nMaxKey > *pnParentMinKey ){
! 7828: checkAppendMsg(pCheck, zContext,
! 7829: "Rowid %lld out of order (max larger than parent min of %lld)",
! 7830: nMaxKey, *pnParentMinKey);
! 7831: }
! 7832: }else{
! 7833: if( nMinKey <= *pnParentMinKey ){
! 7834: checkAppendMsg(pCheck, zContext,
! 7835: "Rowid %lld out of order (min less than parent min of %lld)",
! 7836: nMinKey, *pnParentMinKey);
! 7837: }
! 7838: if( nMaxKey > *pnParentMaxKey ){
! 7839: checkAppendMsg(pCheck, zContext,
! 7840: "Rowid %lld out of order (max larger than parent max of %lld)",
! 7841: nMaxKey, *pnParentMaxKey);
! 7842: }
! 7843: *pnParentMinKey = nMaxKey;
! 7844: }
! 7845: /* else if we're a right child page */
! 7846: } else if( pnParentMaxKey ){
! 7847: if( nMinKey <= *pnParentMaxKey ){
! 7848: checkAppendMsg(pCheck, zContext,
! 7849: "Rowid %lld out of order (min less than parent max of %lld)",
! 7850: nMinKey, *pnParentMaxKey);
! 7851: }
! 7852: }
! 7853: }
! 7854:
! 7855: /* Check for complete coverage of the page
! 7856: */
! 7857: data = pPage->aData;
! 7858: hdr = pPage->hdrOffset;
! 7859: hit = sqlite3PageMalloc( pBt->pageSize );
! 7860: if( hit==0 ){
! 7861: pCheck->mallocFailed = 1;
! 7862: }else{
! 7863: int contentOffset = get2byteNotZero(&data[hdr+5]);
! 7864: assert( contentOffset<=usableSize ); /* Enforced by btreeInitPage() */
! 7865: memset(hit+contentOffset, 0, usableSize-contentOffset);
! 7866: memset(hit, 1, contentOffset);
! 7867: nCell = get2byte(&data[hdr+3]);
! 7868: cellStart = hdr + 12 - 4*pPage->leaf;
! 7869: for(i=0; i<nCell; i++){
! 7870: int pc = get2byte(&data[cellStart+i*2]);
! 7871: u32 size = 65536;
! 7872: int j;
! 7873: if( pc<=usableSize-4 ){
! 7874: size = cellSizePtr(pPage, &data[pc]);
! 7875: }
! 7876: if( (int)(pc+size-1)>=usableSize ){
! 7877: checkAppendMsg(pCheck, 0,
! 7878: "Corruption detected in cell %d on page %d",i,iPage);
! 7879: }else{
! 7880: for(j=pc+size-1; j>=pc; j--) hit[j]++;
! 7881: }
! 7882: }
! 7883: i = get2byte(&data[hdr+1]);
! 7884: while( i>0 ){
! 7885: int size, j;
! 7886: assert( i<=usableSize-4 ); /* Enforced by btreeInitPage() */
! 7887: size = get2byte(&data[i+2]);
! 7888: assert( i+size<=usableSize ); /* Enforced by btreeInitPage() */
! 7889: for(j=i+size-1; j>=i; j--) hit[j]++;
! 7890: j = get2byte(&data[i]);
! 7891: assert( j==0 || j>i+size ); /* Enforced by btreeInitPage() */
! 7892: assert( j<=usableSize-4 ); /* Enforced by btreeInitPage() */
! 7893: i = j;
! 7894: }
! 7895: for(i=cnt=0; i<usableSize; i++){
! 7896: if( hit[i]==0 ){
! 7897: cnt++;
! 7898: }else if( hit[i]>1 ){
! 7899: checkAppendMsg(pCheck, 0,
! 7900: "Multiple uses for byte %d of page %d", i, iPage);
! 7901: break;
! 7902: }
! 7903: }
! 7904: if( cnt!=data[hdr+7] ){
! 7905: checkAppendMsg(pCheck, 0,
! 7906: "Fragmentation of %d bytes reported as %d on page %d",
! 7907: cnt, data[hdr+7], iPage);
! 7908: }
! 7909: }
! 7910: sqlite3PageFree(hit);
! 7911: releasePage(pPage);
! 7912: return depth+1;
! 7913: }
! 7914: #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
! 7915:
! 7916: #ifndef SQLITE_OMIT_INTEGRITY_CHECK
! 7917: /*
! 7918: ** This routine does a complete check of the given BTree file. aRoot[] is
! 7919: ** an array of pages numbers were each page number is the root page of
! 7920: ** a table. nRoot is the number of entries in aRoot.
! 7921: **
! 7922: ** A read-only or read-write transaction must be opened before calling
! 7923: ** this function.
! 7924: **
! 7925: ** Write the number of error seen in *pnErr. Except for some memory
! 7926: ** allocation errors, an error message held in memory obtained from
! 7927: ** malloc is returned if *pnErr is non-zero. If *pnErr==0 then NULL is
! 7928: ** returned. If a memory allocation error occurs, NULL is returned.
! 7929: */
! 7930: char *sqlite3BtreeIntegrityCheck(
! 7931: Btree *p, /* The btree to be checked */
! 7932: int *aRoot, /* An array of root pages numbers for individual trees */
! 7933: int nRoot, /* Number of entries in aRoot[] */
! 7934: int mxErr, /* Stop reporting errors after this many */
! 7935: int *pnErr /* Write number of errors seen to this variable */
! 7936: ){
! 7937: Pgno i;
! 7938: int nRef;
! 7939: IntegrityCk sCheck;
! 7940: BtShared *pBt = p->pBt;
! 7941: char zErr[100];
! 7942:
! 7943: sqlite3BtreeEnter(p);
! 7944: assert( p->inTrans>TRANS_NONE && pBt->inTransaction>TRANS_NONE );
! 7945: nRef = sqlite3PagerRefcount(pBt->pPager);
! 7946: sCheck.pBt = pBt;
! 7947: sCheck.pPager = pBt->pPager;
! 7948: sCheck.nPage = btreePagecount(sCheck.pBt);
! 7949: sCheck.mxErr = mxErr;
! 7950: sCheck.nErr = 0;
! 7951: sCheck.mallocFailed = 0;
! 7952: *pnErr = 0;
! 7953: if( sCheck.nPage==0 ){
! 7954: sqlite3BtreeLeave(p);
! 7955: return 0;
! 7956: }
! 7957: sCheck.anRef = sqlite3Malloc( (sCheck.nPage+1)*sizeof(sCheck.anRef[0]) );
! 7958: if( !sCheck.anRef ){
! 7959: *pnErr = 1;
! 7960: sqlite3BtreeLeave(p);
! 7961: return 0;
! 7962: }
! 7963: for(i=0; i<=sCheck.nPage; i++){ sCheck.anRef[i] = 0; }
! 7964: i = PENDING_BYTE_PAGE(pBt);
! 7965: if( i<=sCheck.nPage ){
! 7966: sCheck.anRef[i] = 1;
! 7967: }
! 7968: sqlite3StrAccumInit(&sCheck.errMsg, zErr, sizeof(zErr), 20000);
! 7969: sCheck.errMsg.useMalloc = 2;
! 7970:
! 7971: /* Check the integrity of the freelist
! 7972: */
! 7973: checkList(&sCheck, 1, get4byte(&pBt->pPage1->aData[32]),
! 7974: get4byte(&pBt->pPage1->aData[36]), "Main freelist: ");
! 7975:
! 7976: /* Check all the tables.
! 7977: */
! 7978: for(i=0; (int)i<nRoot && sCheck.mxErr; i++){
! 7979: if( aRoot[i]==0 ) continue;
! 7980: #ifndef SQLITE_OMIT_AUTOVACUUM
! 7981: if( pBt->autoVacuum && aRoot[i]>1 ){
! 7982: checkPtrmap(&sCheck, aRoot[i], PTRMAP_ROOTPAGE, 0, 0);
! 7983: }
! 7984: #endif
! 7985: checkTreePage(&sCheck, aRoot[i], "List of tree roots: ", NULL, NULL);
! 7986: }
! 7987:
! 7988: /* Make sure every page in the file is referenced
! 7989: */
! 7990: for(i=1; i<=sCheck.nPage && sCheck.mxErr; i++){
! 7991: #ifdef SQLITE_OMIT_AUTOVACUUM
! 7992: if( sCheck.anRef[i]==0 ){
! 7993: checkAppendMsg(&sCheck, 0, "Page %d is never used", i);
! 7994: }
! 7995: #else
! 7996: /* If the database supports auto-vacuum, make sure no tables contain
! 7997: ** references to pointer-map pages.
! 7998: */
! 7999: if( sCheck.anRef[i]==0 &&
! 8000: (PTRMAP_PAGENO(pBt, i)!=i || !pBt->autoVacuum) ){
! 8001: checkAppendMsg(&sCheck, 0, "Page %d is never used", i);
! 8002: }
! 8003: if( sCheck.anRef[i]!=0 &&
! 8004: (PTRMAP_PAGENO(pBt, i)==i && pBt->autoVacuum) ){
! 8005: checkAppendMsg(&sCheck, 0, "Pointer map page %d is referenced", i);
! 8006: }
! 8007: #endif
! 8008: }
! 8009:
! 8010: /* Make sure this analysis did not leave any unref() pages.
! 8011: ** This is an internal consistency check; an integrity check
! 8012: ** of the integrity check.
! 8013: */
! 8014: if( NEVER(nRef != sqlite3PagerRefcount(pBt->pPager)) ){
! 8015: checkAppendMsg(&sCheck, 0,
! 8016: "Outstanding page count goes from %d to %d during this analysis",
! 8017: nRef, sqlite3PagerRefcount(pBt->pPager)
! 8018: );
! 8019: }
! 8020:
! 8021: /* Clean up and report errors.
! 8022: */
! 8023: sqlite3BtreeLeave(p);
! 8024: sqlite3_free(sCheck.anRef);
! 8025: if( sCheck.mallocFailed ){
! 8026: sqlite3StrAccumReset(&sCheck.errMsg);
! 8027: *pnErr = sCheck.nErr+1;
! 8028: return 0;
! 8029: }
! 8030: *pnErr = sCheck.nErr;
! 8031: if( sCheck.nErr==0 ) sqlite3StrAccumReset(&sCheck.errMsg);
! 8032: return sqlite3StrAccumFinish(&sCheck.errMsg);
! 8033: }
! 8034: #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
! 8035:
! 8036: /*
! 8037: ** Return the full pathname of the underlying database file.
! 8038: **
! 8039: ** The pager filename is invariant as long as the pager is
! 8040: ** open so it is safe to access without the BtShared mutex.
! 8041: */
! 8042: const char *sqlite3BtreeGetFilename(Btree *p){
! 8043: assert( p->pBt->pPager!=0 );
! 8044: return sqlite3PagerFilename(p->pBt->pPager);
! 8045: }
! 8046:
! 8047: /*
! 8048: ** Return the pathname of the journal file for this database. The return
! 8049: ** value of this routine is the same regardless of whether the journal file
! 8050: ** has been created or not.
! 8051: **
! 8052: ** The pager journal filename is invariant as long as the pager is
! 8053: ** open so it is safe to access without the BtShared mutex.
! 8054: */
! 8055: const char *sqlite3BtreeGetJournalname(Btree *p){
! 8056: assert( p->pBt->pPager!=0 );
! 8057: return sqlite3PagerJournalname(p->pBt->pPager);
! 8058: }
! 8059:
! 8060: /*
! 8061: ** Return non-zero if a transaction is active.
! 8062: */
! 8063: int sqlite3BtreeIsInTrans(Btree *p){
! 8064: assert( p==0 || sqlite3_mutex_held(p->db->mutex) );
! 8065: return (p && (p->inTrans==TRANS_WRITE));
! 8066: }
! 8067:
! 8068: #ifndef SQLITE_OMIT_WAL
! 8069: /*
! 8070: ** Run a checkpoint on the Btree passed as the first argument.
! 8071: **
! 8072: ** Return SQLITE_LOCKED if this or any other connection has an open
! 8073: ** transaction on the shared-cache the argument Btree is connected to.
! 8074: **
! 8075: ** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART.
! 8076: */
! 8077: int sqlite3BtreeCheckpoint(Btree *p, int eMode, int *pnLog, int *pnCkpt){
! 8078: int rc = SQLITE_OK;
! 8079: if( p ){
! 8080: BtShared *pBt = p->pBt;
! 8081: sqlite3BtreeEnter(p);
! 8082: if( pBt->inTransaction!=TRANS_NONE ){
! 8083: rc = SQLITE_LOCKED;
! 8084: }else{
! 8085: rc = sqlite3PagerCheckpoint(pBt->pPager, eMode, pnLog, pnCkpt);
! 8086: }
! 8087: sqlite3BtreeLeave(p);
! 8088: }
! 8089: return rc;
! 8090: }
! 8091: #endif
! 8092:
! 8093: /*
! 8094: ** Return non-zero if a read (or write) transaction is active.
! 8095: */
! 8096: int sqlite3BtreeIsInReadTrans(Btree *p){
! 8097: assert( p );
! 8098: assert( sqlite3_mutex_held(p->db->mutex) );
! 8099: return p->inTrans!=TRANS_NONE;
! 8100: }
! 8101:
! 8102: int sqlite3BtreeIsInBackup(Btree *p){
! 8103: assert( p );
! 8104: assert( sqlite3_mutex_held(p->db->mutex) );
! 8105: return p->nBackup!=0;
! 8106: }
! 8107:
! 8108: /*
! 8109: ** This function returns a pointer to a blob of memory associated with
! 8110: ** a single shared-btree. The memory is used by client code for its own
! 8111: ** purposes (for example, to store a high-level schema associated with
! 8112: ** the shared-btree). The btree layer manages reference counting issues.
! 8113: **
! 8114: ** The first time this is called on a shared-btree, nBytes bytes of memory
! 8115: ** are allocated, zeroed, and returned to the caller. For each subsequent
! 8116: ** call the nBytes parameter is ignored and a pointer to the same blob
! 8117: ** of memory returned.
! 8118: **
! 8119: ** If the nBytes parameter is 0 and the blob of memory has not yet been
! 8120: ** allocated, a null pointer is returned. If the blob has already been
! 8121: ** allocated, it is returned as normal.
! 8122: **
! 8123: ** Just before the shared-btree is closed, the function passed as the
! 8124: ** xFree argument when the memory allocation was made is invoked on the
! 8125: ** blob of allocated memory. The xFree function should not call sqlite3_free()
! 8126: ** on the memory, the btree layer does that.
! 8127: */
! 8128: void *sqlite3BtreeSchema(Btree *p, int nBytes, void(*xFree)(void *)){
! 8129: BtShared *pBt = p->pBt;
! 8130: sqlite3BtreeEnter(p);
! 8131: if( !pBt->pSchema && nBytes ){
! 8132: pBt->pSchema = sqlite3DbMallocZero(0, nBytes);
! 8133: pBt->xFreeSchema = xFree;
! 8134: }
! 8135: sqlite3BtreeLeave(p);
! 8136: return pBt->pSchema;
! 8137: }
! 8138:
! 8139: /*
! 8140: ** Return SQLITE_LOCKED_SHAREDCACHE if another user of the same shared
! 8141: ** btree as the argument handle holds an exclusive lock on the
! 8142: ** sqlite_master table. Otherwise SQLITE_OK.
! 8143: */
! 8144: int sqlite3BtreeSchemaLocked(Btree *p){
! 8145: int rc;
! 8146: assert( sqlite3_mutex_held(p->db->mutex) );
! 8147: sqlite3BtreeEnter(p);
! 8148: rc = querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK);
! 8149: assert( rc==SQLITE_OK || rc==SQLITE_LOCKED_SHAREDCACHE );
! 8150: sqlite3BtreeLeave(p);
! 8151: return rc;
! 8152: }
! 8153:
! 8154:
! 8155: #ifndef SQLITE_OMIT_SHARED_CACHE
! 8156: /*
! 8157: ** Obtain a lock on the table whose root page is iTab. The
! 8158: ** lock is a write lock if isWritelock is true or a read lock
! 8159: ** if it is false.
! 8160: */
! 8161: int sqlite3BtreeLockTable(Btree *p, int iTab, u8 isWriteLock){
! 8162: int rc = SQLITE_OK;
! 8163: assert( p->inTrans!=TRANS_NONE );
! 8164: if( p->sharable ){
! 8165: u8 lockType = READ_LOCK + isWriteLock;
! 8166: assert( READ_LOCK+1==WRITE_LOCK );
! 8167: assert( isWriteLock==0 || isWriteLock==1 );
! 8168:
! 8169: sqlite3BtreeEnter(p);
! 8170: rc = querySharedCacheTableLock(p, iTab, lockType);
! 8171: if( rc==SQLITE_OK ){
! 8172: rc = setSharedCacheTableLock(p, iTab, lockType);
! 8173: }
! 8174: sqlite3BtreeLeave(p);
! 8175: }
! 8176: return rc;
! 8177: }
! 8178: #endif
! 8179:
! 8180: #ifndef SQLITE_OMIT_INCRBLOB
! 8181: /*
! 8182: ** Argument pCsr must be a cursor opened for writing on an
! 8183: ** INTKEY table currently pointing at a valid table entry.
! 8184: ** This function modifies the data stored as part of that entry.
! 8185: **
! 8186: ** Only the data content may only be modified, it is not possible to
! 8187: ** change the length of the data stored. If this function is called with
! 8188: ** parameters that attempt to write past the end of the existing data,
! 8189: ** no modifications are made and SQLITE_CORRUPT is returned.
! 8190: */
! 8191: int sqlite3BtreePutData(BtCursor *pCsr, u32 offset, u32 amt, void *z){
! 8192: int rc;
! 8193: assert( cursorHoldsMutex(pCsr) );
! 8194: assert( sqlite3_mutex_held(pCsr->pBtree->db->mutex) );
! 8195: assert( pCsr->isIncrblobHandle );
! 8196:
! 8197: rc = restoreCursorPosition(pCsr);
! 8198: if( rc!=SQLITE_OK ){
! 8199: return rc;
! 8200: }
! 8201: assert( pCsr->eState!=CURSOR_REQUIRESEEK );
! 8202: if( pCsr->eState!=CURSOR_VALID ){
! 8203: return SQLITE_ABORT;
! 8204: }
! 8205:
! 8206: /* Check some assumptions:
! 8207: ** (a) the cursor is open for writing,
! 8208: ** (b) there is a read/write transaction open,
! 8209: ** (c) the connection holds a write-lock on the table (if required),
! 8210: ** (d) there are no conflicting read-locks, and
! 8211: ** (e) the cursor points at a valid row of an intKey table.
! 8212: */
! 8213: if( !pCsr->wrFlag ){
! 8214: return SQLITE_READONLY;
! 8215: }
! 8216: assert( (pCsr->pBt->btsFlags & BTS_READ_ONLY)==0
! 8217: && pCsr->pBt->inTransaction==TRANS_WRITE );
! 8218: assert( hasSharedCacheTableLock(pCsr->pBtree, pCsr->pgnoRoot, 0, 2) );
! 8219: assert( !hasReadConflicts(pCsr->pBtree, pCsr->pgnoRoot) );
! 8220: assert( pCsr->apPage[pCsr->iPage]->intKey );
! 8221:
! 8222: return accessPayload(pCsr, offset, amt, (unsigned char *)z, 1);
! 8223: }
! 8224:
! 8225: /*
! 8226: ** Set a flag on this cursor to cache the locations of pages from the
! 8227: ** overflow list for the current row. This is used by cursors opened
! 8228: ** for incremental blob IO only.
! 8229: **
! 8230: ** This function sets a flag only. The actual page location cache
! 8231: ** (stored in BtCursor.aOverflow[]) is allocated and used by function
! 8232: ** accessPayload() (the worker function for sqlite3BtreeData() and
! 8233: ** sqlite3BtreePutData()).
! 8234: */
! 8235: void sqlite3BtreeCacheOverflow(BtCursor *pCur){
! 8236: assert( cursorHoldsMutex(pCur) );
! 8237: assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
! 8238: invalidateOverflowCache(pCur);
! 8239: pCur->isIncrblobHandle = 1;
! 8240: }
! 8241: #endif
! 8242:
! 8243: /*
! 8244: ** Set both the "read version" (single byte at byte offset 18) and
! 8245: ** "write version" (single byte at byte offset 19) fields in the database
! 8246: ** header to iVersion.
! 8247: */
! 8248: int sqlite3BtreeSetVersion(Btree *pBtree, int iVersion){
! 8249: BtShared *pBt = pBtree->pBt;
! 8250: int rc; /* Return code */
! 8251:
! 8252: assert( iVersion==1 || iVersion==2 );
! 8253:
! 8254: /* If setting the version fields to 1, do not automatically open the
! 8255: ** WAL connection, even if the version fields are currently set to 2.
! 8256: */
! 8257: pBt->btsFlags &= ~BTS_NO_WAL;
! 8258: if( iVersion==1 ) pBt->btsFlags |= BTS_NO_WAL;
! 8259:
! 8260: rc = sqlite3BtreeBeginTrans(pBtree, 0);
! 8261: if( rc==SQLITE_OK ){
! 8262: u8 *aData = pBt->pPage1->aData;
! 8263: if( aData[18]!=(u8)iVersion || aData[19]!=(u8)iVersion ){
! 8264: rc = sqlite3BtreeBeginTrans(pBtree, 2);
! 8265: if( rc==SQLITE_OK ){
! 8266: rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
! 8267: if( rc==SQLITE_OK ){
! 8268: aData[18] = (u8)iVersion;
! 8269: aData[19] = (u8)iVersion;
! 8270: }
! 8271: }
! 8272: }
! 8273: }
! 8274:
! 8275: pBt->btsFlags &= ~BTS_NO_WAL;
! 8276: return rc;
! 8277: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to btree.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src