diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/btree.c | 309 | ||||
| -rw-r--r-- | src/pager.c | 265 | ||||
| -rw-r--r-- | src/pager.h | 98 | ||||
| -rw-r--r-- | src/pragma.c | 4 | ||||
| -rw-r--r-- | src/test2.c | 62 | ||||
| -rw-r--r-- | src/test3.c | 12 | ||||
| -rw-r--r-- | src/util.c | 4 |
7 files changed, 392 insertions, 362 deletions
diff --git a/src/btree.c b/src/btree.c index 12aa538df..c5adb26d6 100644 --- a/src/btree.c +++ b/src/btree.c @@ -9,7 +9,7 @@ ** May you share freely, never taking more than you give. ** ************************************************************************* -** $Id: btree.c,v 1.340 2007/03/19 11:54:10 drh Exp $ +** $Id: btree.c,v 1.341 2007/03/19 17:44:27 danielk1977 Exp $ ** ** This file implements a external (disk-based) database using BTrees. ** For a detailed discussion of BTrees, refer to @@ -291,6 +291,7 @@ struct MemPage { } aOvfl[5]; BtShared *pBt; /* Pointer back to BTree structure */ u8 *aData; /* Pointer back to the start of the page */ + DbPage *pDbPage; /* Pager page handle */ Pgno pgno; /* Page number for this page */ MemPage *pParent; /* The parent of this page. NULL for root */ }; @@ -815,9 +816,10 @@ static Pgno ptrmapPageno(BtShared *pBt, Pgno pgno){ ** An error code is returned if something goes wrong, otherwise SQLITE_OK. */ static int ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent){ - u8 *pPtrmap; /* The pointer map page */ - Pgno iPtrmap; /* The pointer map page number */ - int offset; /* Offset in pointer map page */ + DbPage *pDbPage; /* The pointer map page */ + u8 *pPtrmap; /* The pointer map data */ + Pgno iPtrmap; /* The pointer map page number */ + int offset; /* Offset in pointer map page */ int rc; /* The master-journal page number must never be used as a pointer map page */ @@ -828,22 +830,23 @@ static int ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent){ return SQLITE_CORRUPT_BKPT; } iPtrmap = PTRMAP_PAGENO(pBt, key); - rc = sqlite3pager_get(pBt->pPager, iPtrmap, (void **)&pPtrmap); + rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage); if( rc!=SQLITE_OK ){ return rc; } offset = PTRMAP_PTROFFSET(pBt, key); + pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage); if( eType!=pPtrmap[offset] || get4byte(&pPtrmap[offset+1])!=parent ){ TRACE(("PTRMAP_UPDATE: %d->(%d,%d)\n", key, eType, parent)); - rc = sqlite3pager_write(pPtrmap); + rc = sqlite3PagerWrite(pDbPage); if( rc==SQLITE_OK ){ pPtrmap[offset] = eType; put4byte(&pPtrmap[offset+1], parent); } } - sqlite3pager_unref(pPtrmap); + sqlite3PagerUnref(pDbPage); return rc; } @@ -855,23 +858,25 @@ static int ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent){ ** An error code is returned if something goes wrong, otherwise SQLITE_OK. */ static int ptrmapGet(BtShared *pBt, Pgno key, u8 *pEType, Pgno *pPgno){ + DbPage *pDbPage; /* The pointer map page */ int iPtrmap; /* Pointer map page index */ u8 *pPtrmap; /* Pointer map page data */ int offset; /* Offset of entry in pointer map */ int rc; iPtrmap = PTRMAP_PAGENO(pBt, key); - rc = sqlite3pager_get(pBt->pPager, iPtrmap, (void **)&pPtrmap); + rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage); if( rc!=0 ){ return rc; } + pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage); offset = PTRMAP_PTROFFSET(pBt, key); assert( pEType!=0 ); *pEType = pPtrmap[offset]; if( pPgno ) *pPgno = get4byte(&pPtrmap[offset+1]); - sqlite3pager_unref(pPtrmap); + sqlite3PagerUnref(pDbPage); if( *pEType<1 || *pEType>5 ) return SQLITE_CORRUPT_BKPT; return SQLITE_OK; } @@ -1071,7 +1076,7 @@ static int defragmentPage(MemPage *pPage){ unsigned char *data; /* The page data */ unsigned char *temp; /* Temp area for cell content */ - assert( sqlite3pager_iswriteable(pPage->aData) ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); assert( pPage->pBt!=0 ); assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE ); assert( pPage->nOverflow==0 ); @@ -1129,7 +1134,7 @@ static int allocateSpace(MemPage *pPage, int nByte){ unsigned char *data; data = pPage->aData; - assert( sqlite3pager_iswriteable(data) ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); assert( pPage->pBt ); if( nByte<4 ) nByte = 4; if( pPage->nFree<nByte || pPage->nOverflow>0 ) return 0; @@ -1186,7 +1191,7 @@ static void freeSpace(MemPage *pPage, int start, int size){ unsigned char *data = pPage->aData; assert( pPage->pBt!=0 ); - assert( sqlite3pager_iswriteable(data) ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); assert( start>=pPage->hdrOffset+6+(pPage->leaf?0:4) ); assert( (start + size)<=pPage->pBt->usableSize ); if( size<4 ) size = 4; @@ -1295,7 +1300,7 @@ static int initPage( pBt = pPage->pBt; assert( pBt!=0 ); assert( pParent==0 || pParent->pBt==pBt ); - assert( pPage->pgno==sqlite3pager_pagenumber(pPage->aData) ); + assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) ); assert( pPage->aData == &((unsigned char*)pPage)[-pBt->pageSize] ); if( pPage->pParent!=pParent && (pPage->pParent!=0 || pPage->isInit) ){ /* The parent page should never change unless the file is corrupt */ @@ -1304,7 +1309,7 @@ static int initPage( if( pPage->isInit ) return SQLITE_OK; if( pPage->pParent==0 && pParent!=0 ){ pPage->pParent = pParent; - sqlite3pager_ref(pParent->aData); + sqlite3PagerRef(pParent->pDbPage); } hdr = pPage->hdrOffset; data = pPage->aData; @@ -1362,9 +1367,9 @@ static void zeroPage(MemPage *pPage, int flags){ int hdr = pPage->hdrOffset; int first; - assert( sqlite3pager_pagenumber(data)==pPage->pgno ); + assert( sqlite3PagerPagenumber(pPage->pDbPage)==pPage->pgno ); assert( &data[pBt->pageSize] == (unsigned char*)pPage ); - assert( sqlite3pager_iswriteable(data) ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); memset(&data[hdr], 0, pBt->usableSize - hdr); data[hdr] = flags; first = hdr + 8 + 4*((flags&PTF_LEAF)==0); @@ -1387,18 +1392,20 @@ static void zeroPage(MemPage *pPage, int flags){ */ static int getPage(BtShared *pBt, Pgno pgno, MemPage **ppPage, int clrFlag){ int rc; - unsigned char *aData; MemPage *pPage; - rc = sqlite3pager_acquire(pBt->pPager, pgno, (void**)&aData, clrFlag); + DbPage *pDbPage; + + rc = sqlite3PagerAcquire(pBt->pPager, pgno, (DbPage**)&pDbPage, clrFlag); if( rc ) return rc; - pPage = (MemPage*)&aData[pBt->pageSize]; - pPage->aData = aData; + pPage = (MemPage *)sqlite3PagerGetExtra(pDbPage); + pPage->aData = sqlite3PagerGetData(pDbPage); + pPage->pDbPage = pDbPage; pPage->pBt = pBt; pPage->pgno = pgno; pPage->hdrOffset = pPage->pgno==1 ? 100 : 0; *ppPage = pPage; if( clrFlag ){ - sqlite3pager_dont_rollback(aData); + sqlite3PagerDontRollback(pPage->pDbPage); } return SQLITE_OK; } @@ -1434,7 +1441,7 @@ static void releasePage(MemPage *pPage){ assert( pPage->aData ); assert( pPage->pBt ); assert( &pPage->aData[pPage->pBt->pageSize]==(unsigned char*)pPage ); - sqlite3pager_unref(pPage->aData); + sqlite3PagerUnref(pPage->pDbPage); } } @@ -1443,10 +1450,10 @@ static void releasePage(MemPage *pPage){ ** reaches zero. We need to unref the pParent pointer when that ** happens. */ -static void pageDestructor(void *pData, int pageSize){ +static void pageDestructor(DbPage *pData, int pageSize){ MemPage *pPage; assert( (pageSize & 7)==0 ); - pPage = (MemPage*)&((char*)pData)[pageSize]; + pPage = (MemPage *)sqlite3PagerGetExtra(pData); if( pPage->pParent ){ MemPage *pParent = pPage->pParent; pPage->pParent = 0; @@ -1463,10 +1470,10 @@ static void pageDestructor(void *pData, int pageSize){ ** This routine needs to reset the extra data section at the end of the ** page to agree with the restored data. */ -static void pageReinit(void *pData, int pageSize){ +static void pageReinit(DbPage *pData, int pageSize){ MemPage *pPage; assert( (pageSize & 7)==0 ); - pPage = (MemPage*)&((char*)pData)[pageSize]; + pPage = (MemPage *)sqlite3PagerGetExtra(pData); if( pPage->isInit ){ pPage->isInit = 0; initPage(pPage, pPage->pParent); @@ -1526,7 +1533,7 @@ int sqlite3BtreeOpen( } for(pBt=pTsdro->pBtree; pBt; pBt=pBt->pNext){ assert( pBt->nRef>0 ); - if( 0==strcmp(zFullPathname, sqlite3pager_filename(pBt->pPager)) ){ + if( 0==strcmp(zFullPathname, sqlite3PagerFilename(pBt->pPager)) ){ p->pBt = pBt; *ppBtree = p; pBt->nRef++; @@ -1555,13 +1562,13 @@ int sqlite3BtreeOpen( sqliteFree(p); return SQLITE_NOMEM; } - rc = sqlite3pager_open(&pBt->pPager, zFilename, EXTRA_SIZE, flags); + rc = sqlite3PagerOpen(&pBt->pPager, zFilename, EXTRA_SIZE, flags); if( rc==SQLITE_OK ){ - rc = sqlite3pager_read_fileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader); + rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader); } if( rc!=SQLITE_OK ){ if( pBt->pPager ){ - sqlite3pager_close(pBt->pPager); + sqlite3PagerClose(pBt->pPager); } sqliteFree(pBt); sqliteFree(p); @@ -1570,11 +1577,11 @@ int sqlite3BtreeOpen( } p->pBt = pBt; - sqlite3pager_set_destructor(pBt->pPager, pageDestructor); - sqlite3pager_set_reiniter(pBt->pPager, pageReinit); + sqlite3PagerSetDestructor(pBt->pPager, pageDestructor); + sqlite3PagerSetReiniter(pBt->pPager, pageReinit); pBt->pCursor = 0; pBt->pPage1 = 0; - pBt->readOnly = sqlite3pager_isreadonly(pBt->pPager); + pBt->readOnly = sqlite3PagerIsreadonly(pBt->pPager); pBt->pageSize = get2byte(&zDbHeader[16]); if( pBt->pageSize<512 || pBt->pageSize>SQLITE_MAX_PAGE_SIZE || ((pBt->pageSize-1)&pBt->pageSize)!=0 ){ @@ -1606,7 +1613,7 @@ int sqlite3BtreeOpen( } pBt->usableSize = pBt->pageSize - nReserve; assert( (pBt->pageSize & 7)==0 ); /* 8-byte alignment of pageSize */ - sqlite3pager_set_pagesize(pBt->pPager, pBt->pageSize); + sqlite3PagerSetPagesize(pBt->pPager, pBt->pageSize); #if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO) /* Add the new btree to the linked list starting at ThreadData.pBtree. @@ -1683,7 +1690,7 @@ int sqlite3BtreeClose(Btree *p){ /* Close the pager and free the shared-btree structure */ assert( !pBt->pCursor ); - sqlite3pager_close(pBt->pPager); + sqlite3PagerClose(pBt->pPager); if( pBt->xFreeSchema && pBt->pSchema ){ pBt->xFreeSchema(pBt->pSchema); } @@ -1698,7 +1705,7 @@ int sqlite3BtreeClose(Btree *p){ int sqlite3BtreeSetBusyHandler(Btree *p, BusyHandler *pHandler){ BtShared *pBt = p->pBt; pBt->pBusyHandler = pHandler; - sqlite3pager_set_busyhandler(pBt->pPager, pHandler); + sqlite3PagerSetBusyhandler(pBt->pPager, pHandler); return SQLITE_OK; } @@ -1719,7 +1726,7 @@ int sqlite3BtreeSetBusyHandler(Btree *p, BusyHandler *pHandler){ */ int sqlite3BtreeSetCacheSize(Btree *p, int mxPage){ BtShared *pBt = p->pBt; - sqlite3pager_set_cachesize(pBt->pPager, mxPage); + sqlite3PagerSetCachesize(pBt->pPager, mxPage); return SQLITE_OK; } @@ -1734,7 +1741,7 @@ int sqlite3BtreeSetCacheSize(Btree *p, int mxPage){ #ifndef SQLITE_OMIT_PAGER_PRAGMAS int sqlite3BtreeSetSafetyLevel(Btree *p, int level, int fullSync){ BtShared *pBt = p->pBt; - sqlite3pager_set_safety_level(pBt->pPager, level, fullSync); + sqlite3PagerSetSafetyLevel(pBt->pPager, level, fullSync); return SQLITE_OK; } #endif @@ -1746,7 +1753,7 @@ int sqlite3BtreeSetSafetyLevel(Btree *p, int level, int fullSync){ int sqlite3BtreeSyncDisabled(Btree *p){ BtShared *pBt = p->pBt; assert( pBt && pBt->pPager ); - return sqlite3pager_nosync(pBt->pPager); + return sqlite3PagerNosync(pBt->pPager); } #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) || !defined(SQLITE_OMIT_VACUUM) @@ -1777,7 +1784,7 @@ int sqlite3BtreeSetPageSize(Btree *p, int pageSize, int nReserve){ ((pageSize-1)&pageSize)==0 ){ assert( (pageSize & 7)==0 ); assert( !pBt->pPage1 && !pBt->pCursor ); - pBt->pageSize = sqlite3pager_set_pagesize(pBt->pPager, pageSize); + pBt->pageSize = sqlite3PagerSetPagesize(pBt->pPager, pageSize); } pBt->usableSize = pBt->pageSize - nReserve; return SQLITE_OK; @@ -1848,7 +1855,7 @@ static int lockBtree(BtShared *pBt){ ** a valid database file. */ rc = SQLITE_NOTADB; - if( sqlite3pager_pagecount(pBt->pPager)>0 ){ + if( sqlite3PagerPagecount(pBt->pPager)>0 ){ u8 *page1 = pPage1->aData; if( memcmp(page1, zMagicHeader, 16)!=0 ){ goto page1_init_failed; @@ -1937,7 +1944,7 @@ static int lockBtreeWithRetry(Btree *pRef){ */ static void unlockBtreeIfUnused(BtShared *pBt){ if( pBt->inTransaction==TRANS_NONE && pBt->pCursor==0 && pBt->pPage1!=0 ){ - if( sqlite3pager_refcount(pBt->pPager)>=1 ){ + if( sqlite3PagerRefcount(pBt->pPager)>=1 ){ if( pBt->pPage1->aData==0 ){ MemPage *pPage = pBt->pPage1; pPage->aData = &((u8*)pPage)[-pBt->pageSize]; @@ -1959,11 +1966,11 @@ static int newDatabase(BtShared *pBt){ MemPage *pP1; unsigned char *data; int rc; - if( sqlite3pager_pagecount(pBt->pPager)>0 ) return SQLITE_OK; + if( sqlite3PagerPagecount(pBt->pPager)>0 ) return SQLITE_OK; pP1 = pBt->pPage1; assert( pP1!=0 ); data = pP1->aData; - rc = sqlite3pager_write(data); + rc = sqlite3PagerWrite(pP1->pDbPage); if( rc ) return rc; memcpy(data, zMagicHeader, sizeof(zMagicHeader)); assert( sizeof(zMagicHeader)==16 ); @@ -2053,7 +2060,7 @@ int sqlite3BtreeBeginTrans(Btree *p, int wrflag){ } if( rc==SQLITE_OK && wrflag ){ - rc = sqlite3pager_begin(pBt->pPage1->aData, wrflag>1); + rc = sqlite3PagerBegin(pBt->pPage1->pDbPage, wrflag>1); if( rc==SQLITE_OK ){ rc = newDatabase(pBt); } @@ -2209,7 +2216,7 @@ static int relocatePage( /* Move page iDbPage from it's current location to page number iFreePage */ TRACE(("AUTOVACUUM: Moving %d to free page %d (ptr page %d type %d)\n", iDbPage, iFreePage, iPtrPage, eType)); - rc = sqlite3pager_movepage(pPager, pDbPage->aData, iFreePage); + rc = sqlite3PagerMovepage(pPager, pDbPage->pDbPage, iFreePage); if( rc!=SQLITE_OK ){ return rc; } @@ -2247,7 +2254,7 @@ static int relocatePage( if( rc!=SQLITE_OK ){ return rc; } - rc = sqlite3pager_write(pPtrPage->aData); + rc = sqlite3PagerWrite(pPtrPage->pDbPage); if( rc!=SQLITE_OK ){ releasePage(pPtrPage); return rc; @@ -2265,7 +2272,7 @@ static int relocatePage( static int allocatePage(BtShared *, MemPage **, Pgno *, Pgno, u8); /* -** This routine is called prior to sqlite3pager_commit when a transaction +** This routine is called prior to sqlite3PagerCommit when a transaction ** is commited for an auto-vacuum database. */ static int autoVacuumCommit(BtShared *pBt, Pgno *nTrunc){ @@ -2284,11 +2291,11 @@ static int autoVacuumCommit(BtShared *pBt, Pgno *nTrunc){ MemPage *pFreeMemPage = 0; /* "" */ #ifndef NDEBUG - int nRef = sqlite3pager_refcount(pPager); + int nRef = sqlite3PagerRefcount(pPager); #endif assert( pBt->autoVacuum ); - if( PTRMAP_ISPAGE(pBt, sqlite3pager_pagecount(pPager)) ){ + if( PTRMAP_ISPAGE(pBt, sqlite3PagerPagecount(pPager)) ){ return SQLITE_CORRUPT_BKPT; } @@ -2310,7 +2317,7 @@ static int autoVacuumCommit(BtShared *pBt, Pgno *nTrunc){ ** be required, less 1 if the pending-byte page was part of the database ** but is not after the truncation. **/ - origSize = sqlite3pager_pagecount(pPager); + origSize = sqlite3PagerPagecount(pPager); if( origSize==PENDING_BYTE_PAGE(pBt) ){ origSize--; } @@ -2384,7 +2391,7 @@ static int autoVacuumCommit(BtShared *pBt, Pgno *nTrunc){ ** truncate the database file to finSize pages and consider the ** free-list empty. */ - rc = sqlite3pager_write(pBt->pPage1->aData); + rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); if( rc!=SQLITE_OK ) goto autovacuum_out; put4byte(&pBt->pPage1->aData[32], 0); put4byte(&pBt->pPage1->aData[36], 0); @@ -2392,9 +2399,9 @@ static int autoVacuumCommit(BtShared *pBt, Pgno *nTrunc){ assert( finSize!=PENDING_BYTE_PAGE(pBt) ); autovacuum_out: - assert( nRef==sqlite3pager_refcount(pPager) ); + assert( nRef==sqlite3PagerRefcount(pPager) ); if( rc!=SQLITE_OK ){ - sqlite3pager_rollback(pPager); + sqlite3PagerRollback(pPager); } return rc; } @@ -2418,7 +2425,7 @@ int sqlite3BtreeCommit(Btree *p){ int rc; assert( pBt->inTransaction==TRANS_WRITE ); assert( pBt->nTransaction>0 ); - rc = sqlite3pager_commit(pBt->pPager); + rc = sqlite3PagerCommit(pBt->pPager); if( rc!=SQLITE_OK ){ return rc; } @@ -2523,7 +2530,7 @@ int sqlite3BtreeRollback(Btree *p){ int rc2; assert( TRANS_WRITE==pBt->inTransaction ); - rc2 = sqlite3pager_rollback(pBt->pPager); + rc2 = sqlite3PagerRollback(pBt->pPager); if( rc2!=SQLITE_OK ){ rc = rc2; } @@ -2576,7 +2583,7 @@ int sqlite3BtreeBeginStmt(Btree *p){ return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; } assert( pBt->inTransaction==TRANS_WRITE ); - rc = pBt->readOnly ? SQLITE_OK : sqlite3pager_stmt_begin(pBt->pPager); + rc = pBt->readOnly ? SQLITE_OK : sqlite3PagerStmtBegin(pBt->pPager); pBt->inStmt = 1; return rc; } @@ -2590,7 +2597,7 @@ int sqlite3BtreeCommitStmt(Btree *p){ int rc; BtShared *pBt = p->pBt; if( pBt->inStmt && !pBt->readOnly ){ - rc = sqlite3pager_stmt_commit(pBt->pPager); + rc = sqlite3PagerStmtCommit(pBt->pPager); }else{ rc = SQLITE_OK; } @@ -2611,7 +2618,7 @@ int sqlite3BtreeRollbackStmt(Btree *p){ BtShared *pBt = p->pBt; sqlite3MallocDisallow(); if( pBt->inStmt && !pBt->readOnly ){ - rc = sqlite3pager_stmt_rollback(pBt->pPager); + rc = sqlite3PagerStmtRollback(pBt->pPager); assert( countWriteCursors(pBt)==0 ); pBt->inStmt = 0; } @@ -2703,7 +2710,7 @@ int sqlite3BtreeCursor( goto create_cursor_exception; } pCur->pgnoRoot = (Pgno)iTable; - if( iTable==1 && sqlite3pager_pagecount(pBt->pPager)==0 ){ + if( iTable==1 && sqlite3PagerPagecount(pBt->pPager)==0 ){ rc = SQLITE_EMPTY; goto create_cursor_exception; } @@ -2782,7 +2789,7 @@ static void getTempCursor(BtCursor *pCur, BtCursor *pTempCur){ pTempCur->pNext = 0; pTempCur->pPrev = 0; if( pTempCur->pPage ){ - sqlite3pager_ref(pTempCur->pPage->aData); + sqlite3PagerRef(pTempCur->pPage->pDbPage); } } @@ -2792,7 +2799,7 @@ static void getTempCursor(BtCursor *pCur, BtCursor *pTempCur){ */ static void releaseTempCursor(BtCursor *pCur){ if( pCur->pPage ){ - sqlite3pager_unref(pCur->pPage->aData); + sqlite3PagerUnref(pCur->pPage->pDbPage); } } @@ -2922,10 +2929,12 @@ static int getPayload( if( amt>0 ){ nextPage = get4byte(&aPayload[pCur->info.nLocal]); while( amt>0 && nextPage ){ - rc = sqlite3pager_get(pBt->pPager, nextPage, (void**)&aPayload); + DbPage *pDbPage; + rc = sqlite3PagerGet(pBt->pPager, nextPage, &pDbPage); if( rc!=0 ){ return rc; } + aPayload = sqlite3PagerGetData(pDbPage); nextPage = get4byte(aPayload); if( offset<ovflSize ){ int a = amt; @@ -2939,7 +2948,7 @@ static int getPayload( }else{ offset -= ovflSize; } - sqlite3pager_unref(aPayload); + sqlite3PagerUnref(pDbPage); } } @@ -3136,7 +3145,7 @@ static void moveToParent(BtCursor *pCur){ pParent = pPage->pParent; assert( pParent!=0 ); idxParent = pPage->idxParent; - sqlite3pager_ref(pParent->aData); + sqlite3PagerRef(pParent->pDbPage); releasePage(pPage); pCur->pPage = pParent; pCur->info.nSize = 0; @@ -3540,14 +3549,14 @@ int sqlite3BtreePrevious(BtCursor *pCur, int *pRes){ /* ** Allocate a new page from the database file. ** -** The new page is marked as dirty. (In other words, sqlite3pager_write() +** The new page is marked as dirty. (In other words, sqlite3PagerWrite() ** has already been called on the new page.) The new page has also ** been referenced and the calling routine is responsible for calling -** sqlite3pager_unref() on the new page when it is done. +** sqlite3PagerUnref() on the new page when it is done. ** ** SQLITE_OK is returned on success. Any other return value indicates ** an error. *ppPage and *pPgno are undefined in the event of an error. -** Do not invoke sqlite3pager_unref() on *ppPage if an error is returned. +** Do not invoke sqlite3PagerUnref() on *ppPage if an error is returned. ** ** If the "nearby" parameter is not 0, then a (feeble) effort is made to ** locate a page close to the page number "nearby". This can be used in an @@ -3600,7 +3609,7 @@ static int allocatePage( /* Decrement the free-list count by 1. Set iTrunk to the index of the ** first free-list trunk page. iPrevTrunk is initially 1. */ - rc = sqlite3pager_write(pPage1->aData); + rc = sqlite3PagerWrite(pPage1->pDbPage); if( rc ) return rc; put4byte(&pPage1->aData[36], n-1); @@ -3627,7 +3636,7 @@ static int allocatePage( ** So extract the trunk page itself and use it as the newly ** allocated page */ assert( pPrevTrunk==0 ); - rc = sqlite3pager_write(pTrunk->aData); + rc = sqlite3PagerWrite(pTrunk->pDbPage); if( rc ){ goto end_allocate_page; } @@ -3648,7 +3657,7 @@ static int allocatePage( assert( *pPgno==iTrunk ); *ppPage = pTrunk; searchList = 0; - rc = sqlite3pager_write(pTrunk->aData); + rc = sqlite3PagerWrite(pTrunk->pDbPage); if( rc ){ goto end_allocate_page; } @@ -3669,7 +3678,7 @@ static int allocatePage( if( rc!=SQLITE_OK ){ goto end_allocate_page; } - rc = sqlite3pager_write(pNewTrunk->aData); + rc = sqlite3PagerWrite(pNewTrunk->pDbPage); if( rc!=SQLITE_OK ){ releasePage(pNewTrunk); goto end_allocate_page; @@ -3681,7 +3690,7 @@ static int allocatePage( if( !pPrevTrunk ){ put4byte(&pPage1->aData[32], iNewTrunk); }else{ - rc = sqlite3pager_write(pPrevTrunk->aData); + rc = sqlite3PagerWrite(pPrevTrunk->pDbPage); if( rc ){ goto end_allocate_page; } @@ -3696,7 +3705,7 @@ static int allocatePage( int closest; Pgno iPage; unsigned char *aData = pTrunk->aData; - rc = sqlite3pager_write(aData); + rc = sqlite3PagerWrite(pTrunk->pDbPage); if( rc ){ goto end_allocate_page; } @@ -3720,7 +3729,7 @@ static int allocatePage( iPage = get4byte(&aData[8+closest*4]); if( !searchList || iPage==nearby ){ *pPgno = iPage; - if( *pPgno>sqlite3pager_pagecount(pBt->pPager) ){ + if( *pPgno>sqlite3PagerPagecount(pBt->pPager) ){ /* Free page off the end of the file */ return SQLITE_CORRUPT_BKPT; } @@ -3733,7 +3742,7 @@ static int allocatePage( put4byte(&aData[4], k-1); rc = getPage(pBt, *pPgno, ppPage, 1); if( rc==SQLITE_OK ){ - rc = sqlite3pager_write((*ppPage)->aData); + rc = sqlite3PagerWrite((*ppPage)->pDbPage); if( rc!=SQLITE_OK ){ releasePage(*ppPage); } @@ -3747,7 +3756,7 @@ static int allocatePage( }else{ /* There are no pages on the freelist, so create a new page at the ** end of the file */ - *pPgno = sqlite3pager_pagecount(pBt->pPager) + 1; + *pPgno = sqlite3PagerPagecount(pBt->pPager) + 1; #ifndef SQLITE_OMIT_AUTOVACUUM if( pBt->autoVacuum && PTRMAP_ISPAGE(pBt, *pPgno) ){ @@ -3764,7 +3773,7 @@ static int allocatePage( assert( *pPgno!=PENDING_BYTE_PAGE(pBt) ); rc = getPage(pBt, *pPgno, ppPage, 0); if( rc ) return rc; - rc = sqlite3pager_write((*ppPage)->aData); + rc = sqlite3PagerWrite((*ppPage)->pDbPage); if( rc!=SQLITE_OK ){ releasePage(*ppPage); } @@ -3782,7 +3791,7 @@ end_allocate_page: /* ** Add a page of the database file to the freelist. ** -** sqlite3pager_unref() is NOT called for pPage. +** sqlite3PagerUnref() is NOT called for pPage. */ static int freePage(MemPage *pPage){ BtShared *pBt = pPage->pBt; @@ -3796,7 +3805,7 @@ static int freePage(MemPage *pPage){ pPage->pParent = 0; /* Increment the free page count on pPage1 */ - rc = sqlite3pager_write(pPage1->aData); + rc = sqlite3PagerWrite(pPage1->pDbPage); if( rc ) return rc; n = get4byte(&pPage1->aData[36]); put4byte(&pPage1->aData[36], n+1); @@ -3805,7 +3814,7 @@ static int freePage(MemPage *pPage){ /* If the SQLITE_SECURE_DELETE compile-time option is enabled, then ** always fully overwrite deleted information with zeros. */ - rc = sqlite3pager_write(pPage->aData); + rc = sqlite3PagerWrite(pPage->pDbPage); if( rc ) return rc; memset(pPage->aData, 0, pPage->pBt->pageSize); #endif @@ -3822,7 +3831,7 @@ static int freePage(MemPage *pPage){ if( n==0 ){ /* This is the first free page */ - rc = sqlite3pager_write(pPage->aData); + rc = sqlite3PagerWrite(pPage->pDbPage); if( rc ) return rc; memset(pPage->aData, 0, 8); put4byte(&pPage1->aData[32], pPage->pgno); @@ -3837,7 +3846,7 @@ static int freePage(MemPage *pPage){ if( k>=pBt->usableSize/4 - 8 ){ /* The trunk is full. Turn the page being freed into a new ** trunk page with no leaves. */ - rc = sqlite3pager_write(pPage->aData); + rc = sqlite3PagerWrite(pPage->pDbPage); if( rc ) return rc; put4byte(pPage->aData, pTrunk->pgno); put4byte(&pPage->aData[4], 0); @@ -3846,12 +3855,12 @@ static int freePage(MemPage *pPage){ pPage->pgno, pTrunk->pgno)); }else{ /* Add the newly freed page as a leaf on the current trunk */ - rc = sqlite3pager_write(pTrunk->aData); + rc = sqlite3PagerWrite(pTrunk->pDbPage); if( rc ) return rc; put4byte(&pTrunk->aData[4], k+1); put4byte(&pTrunk->aData[8+k*4], pPage->pgno); #ifndef SQLITE_SECURE_DELETE - sqlite3pager_dont_write(pBt->pPager, pPage->pgno); + sqlite3PagerDontWrite(pBt->pPager, pPage->pgno); #endif TRACE(("FREE-PAGE: %d leaf on trunk page %d\n",pPage->pgno,pTrunk->pgno)); } @@ -3881,7 +3890,7 @@ static int clearCell(MemPage *pPage, unsigned char *pCell){ assert( ovflPgno==0 || nOvfl>0 ); while( nOvfl-- ){ MemPage *pOvfl; - if( ovflPgno==0 || ovflPgno>sqlite3pager_pagecount(pBt->pPager) ){ + if( ovflPgno==0 || ovflPgno>sqlite3PagerPagecount(pBt->pPager) ){ return SQLITE_CORRUPT_BKPT; } rc = getPage(pBt, ovflPgno, &pOvfl, 0); @@ -3890,7 +3899,7 @@ static int clearCell(MemPage *pPage, unsigned char *pCell){ ovflPgno = get4byte(pOvfl->aData); } rc = freePage(pOvfl); - sqlite3pager_unref(pOvfl->aData); + sqlite3PagerUnref(pOvfl->pDbPage); if( rc ) return rc; } return SQLITE_OK; @@ -4014,24 +4023,24 @@ static int fillInCell( */ static int reparentPage(BtShared *pBt, Pgno pgno, MemPage *pNewParent, int idx){ MemPage *pThis; - unsigned char *aData; + DbPage *pDbPage; assert( pNewParent!=0 ); if( pgno==0 ) return SQLITE_OK; assert( pBt->pPager!=0 ); - aData = sqlite3pager_lookup(pBt->pPager, pgno); - if( aData ){ - pThis = (MemPage*)&aData[pBt->pageSize]; + pDbPage = sqlite3PagerLookup(pBt->pPager, pgno); + if( pDbPage ){ + pThis = (MemPage *)sqlite3PagerGetExtra(pDbPage); if( pThis->isInit ){ - assert( pThis->aData==aData ); + assert( pThis->aData==(sqlite3PagerGetData(pDbPage)) ); if( pThis->pParent!=pNewParent ){ - if( pThis->pParent ) sqlite3pager_unref(pThis->pParent->aData); + if( pThis->pParent ) sqlite3PagerUnref(pThis->pParent->pDbPage); pThis->pParent = pNewParent; - sqlite3pager_ref(pNewParent->aData); + sqlite3PagerRef(pNewParent->pDbPage); } pThis->idxParent = idx; } - sqlite3pager_unref(aData); + sqlite3PagerUnref(pDbPage); } #ifndef SQLITE_OMIT_AUTOVACUUM @@ -4092,7 +4101,7 @@ static void dropCell(MemPage *pPage, int idx, int sz){ assert( idx>=0 && idx<pPage->nCell ); assert( sz==cellSize(pPage, idx) ); - assert( sqlite3pager_iswriteable(pPage->aData) ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); data = pPage->aData; ptr = &data[pPage->cellOffset + 2*idx]; pc = get2byte(ptr); @@ -4145,7 +4154,7 @@ static int insertCell( assert( i>=0 && i<=pPage->nCell+pPage->nOverflow ); assert( sz==cellSizePtr(pPage, pCell) ); - assert( sqlite3pager_iswriteable(pPage->aData) ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); if( pPage->nOverflow || sz+2>pPage->nFree ){ if( pTemp ){ memcpy(pTemp+nSkip, pCell+nSkip, sz-nSkip); @@ -4309,7 +4318,7 @@ static int balance_quick(MemPage *pPage, MemPage *pParent){ /* Set the parent of the newly allocated page to pParent. */ pNew->pParent = pParent; - sqlite3pager_ref(pParent->aData); + sqlite3PagerRef(pParent->pDbPage); /* pPage is currently the right-child of pParent. Change this ** so that the right-child is the new page allocated above and @@ -4434,11 +4443,11 @@ static int balance_nonroot(MemPage *pPage){ ** Find the parent page. */ assert( pPage->isInit ); - assert( sqlite3pager_iswriteable(pPage->aData) ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); pBt = pPage->pBt; pParent = pPage->pParent; assert( pParent ); - if( SQLITE_OK!=(rc = sqlite3pager_write(pParent->aData)) ){ + if( SQLITE_OK!=(rc = sqlite3PagerWrite(pParent->pDbPage)) ){ return rc; } TRACE(("BALANCE: begin page %d child of %d\n", pPage->pgno, pParent->pgno)); @@ -4476,7 +4485,7 @@ static int balance_nonroot(MemPage *pPage){ if( pParent->idxShift ){ Pgno pgno; pgno = pPage->pgno; - assert( pgno==sqlite3pager_pagenumber(pPage->aData) ); + assert( pgno==sqlite3PagerPagenumber(pPage->pDbPage) ); for(idx=0; idx<pParent->nCell; idx++){ if( get4byte(findCell(pParent, idx))==pgno ){ break; @@ -4493,7 +4502,7 @@ static int balance_nonroot(MemPage *pPage){ ** directly to balance_cleanup at any moment. */ nOld = nNew = 0; - sqlite3pager_ref(pParent->aData); + sqlite3PagerRef(pParent->pDbPage); /* ** Find sibling pages to pPage and the cells in pParent that divide @@ -4737,7 +4746,7 @@ static int balance_nonroot(MemPage *pPage){ pNew = apNew[i] = apOld[i]; pgnoNew[i] = pgnoOld[i]; apOld[i] = 0; - rc = sqlite3pager_write(pNew->aData); + rc = sqlite3PagerWrite(pNew->pDbPage); if( rc ) goto balance_cleanup; }else{ assert( i>0 ); @@ -4980,7 +4989,7 @@ static int balance_shallower(MemPage *pPage){ */ pgnoChild = get4byte(&pPage->aData[pPage->hdrOffset+8]); assert( pgnoChild>0 ); - assert( pgnoChild<=sqlite3pager_pagecount(pPage->pBt->pPager) ); + assert( pgnoChild<=sqlite3PagerPagecount(pPage->pBt->pPager) ); rc = getPage(pPage->pBt, pgnoChild, &pChild, 0); if( rc ) goto end_shallow_balance; if( pPage->pgno==1 ){ @@ -5064,7 +5073,7 @@ static int balance_deeper(MemPage *pPage){ pBt = pPage->pBt; rc = allocatePage(pBt, &pChild, &pgnoChild, pPage->pgno, 0); if( rc ) return rc; - assert( sqlite3pager_iswriteable(pChild->aData) ); + assert( sqlite3PagerIswriteable(pChild->pDbPage) ); usableSize = pBt->usableSize; data = pPage->aData; hdr = pPage->hdrOffset; @@ -5213,7 +5222,7 @@ int sqlite3BtreeInsert( pCur->pgnoRoot, nKey, nData, pPage->pgno, loc==0 ? "overwrite" : "new entry")); assert( pPage->isInit ); - rc = sqlite3pager_write(pPage->aData); + rc = sqlite3PagerWrite(pPage->pDbPage); if( rc ) return rc; newCell = sqliteMallocRaw( MX_CELL_SIZE(pBt) ); if( newCell==0 ) return SQLITE_NOMEM; @@ -5281,13 +5290,13 @@ int sqlite3BtreeDelete(BtCursor *pCur){ /* Restore the current cursor position (a no-op if the cursor is not in ** CURSOR_REQUIRESEEK state) and save the positions of any other cursors - ** open on the same table. Then call sqlite3pager_write() on the page + ** open on the same table. Then call sqlite3PagerWrite() on the page ** that the entry will be deleted from. */ if( (rc = restoreOrClearCursorPosition(pCur, 1))!=0 || (rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur))!=0 || - (rc = sqlite3pager_write(pPage->aData))!=0 + (rc = sqlite3PagerWrite(pPage->pDbPage))!=0 ){ return rc; } @@ -5327,7 +5336,7 @@ int sqlite3BtreeDelete(BtCursor *pCur){ } } if( rc==SQLITE_OK ){ - rc = sqlite3pager_write(leafCur.pPage->aData); + rc = sqlite3PagerWrite(leafCur.pPage->pDbPage); } if( rc==SQLITE_OK ){ TRACE(("DELETE: table=%d delete internal from %d replace from leaf %d\n", @@ -5447,7 +5456,7 @@ int sqlite3BtreeCreateTable(Btree *p, int *piTable, int flags){ } assert( eType!=PTRMAP_ROOTPAGE ); assert( eType!=PTRMAP_FREEPAGE ); - rc = sqlite3pager_write(pRoot->aData); + rc = sqlite3PagerWrite(pRoot->pDbPage); if( rc!=SQLITE_OK ){ releasePage(pRoot); return rc; @@ -5461,7 +5470,7 @@ int sqlite3BtreeCreateTable(Btree *p, int *piTable, int flags){ if( rc!=SQLITE_OK ){ return rc; } - rc = sqlite3pager_write(pRoot->aData); + rc = sqlite3PagerWrite(pRoot->pDbPage); if( rc!=SQLITE_OK ){ releasePage(pRoot); return rc; @@ -5487,9 +5496,9 @@ int sqlite3BtreeCreateTable(Btree *p, int *piTable, int flags){ if( rc ) return rc; } #endif - assert( sqlite3pager_iswriteable(pRoot->aData) ); + assert( sqlite3PagerIswriteable(pRoot->pDbPage) ); zeroPage(pRoot, flags | PTF_LEAF); - sqlite3pager_unref(pRoot->aData); + sqlite3PagerUnref(pRoot->pDbPage); *piTable = (int)pgnoRoot; return SQLITE_OK; } @@ -5509,7 +5518,7 @@ static int clearDatabasePage( unsigned char *pCell; int i; - if( pgno>sqlite3pager_pagecount(pBt->pPager) ){ + if( pgno>sqlite3PagerPagecount(pBt->pPager) ){ return SQLITE_CORRUPT_BKPT; } @@ -5530,7 +5539,7 @@ static int clearDatabasePage( } if( freePageFlag ){ rc = freePage(pPage); - }else if( (rc = sqlite3pager_write(pPage->aData))==0 ){ + }else if( (rc = sqlite3PagerWrite(pPage->pDbPage))==0 ){ zeroPage(pPage, pPage->aData[0] | PTF_LEAF); } @@ -5706,6 +5715,7 @@ int sqlite3BtreeDropTable(Btree *p, int iTable, int *piMoved){ ** free pages is not visible. So Cookie[0] is the same as Meta[1]. */ int sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){ + DbPage *pDbPage; int rc; unsigned char *pP1; BtShared *pBt = p->pBt; @@ -5721,10 +5731,11 @@ int sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){ } assert( idx>=0 && idx<=15 ); - rc = sqlite3pager_get(pBt->pPager, 1, (void**)&pP1); + rc = sqlite3PagerGet(pBt->pPager, 1, &pDbPage); if( rc ) return rc; + pP1 = (unsigned char *)sqlite3PagerGetData(pDbPage); *pMeta = get4byte(&pP1[36 + idx*4]); - sqlite3pager_unref(pP1); + sqlite3PagerUnref(pDbPage); /* If autovacuumed is disabled in this build but we are trying to ** access an autovacuumed database, then make the database readonly. @@ -5752,7 +5763,7 @@ int sqlite3BtreeUpdateMeta(Btree *p, int idx, u32 iMeta){ } assert( pBt->pPage1!=0 ); pP1 = pBt->pPage1->aData; - rc = sqlite3pager_write(pP1); + rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); if( rc ) return rc; put4byte(&pP1[36 + idx*4], iMeta); return SQLITE_OK; @@ -5867,7 +5878,7 @@ static int btreePageDump(BtShared *pBt, int pgno, int recursive, MemPage *pParen btreePageDump(pBt, get4byte(&data[hdr+8]), 1, pPage); } pPage->isInit = isInit; - sqlite3pager_unref(data); + sqlite3PagerUnref(pPage->pDbPage); fflush(stdout); return SQLITE_OK; } @@ -5911,7 +5922,7 @@ int sqlite3BtreeCursorInfo(BtCursor *pCur, int *aResult, int upCnt){ moveToParent(&tmpCur); } pPage = tmpCur.pPage; - aResult[0] = sqlite3pager_pagenumber(pPage->aData); + aResult[0] = sqlite3PagerPagenumber(pPage->pDbPage); assert( aResult[0]==pPage->pgno ); aResult[1] = tmpCur.idx; aResult[2] = pPage->nCell; @@ -6072,7 +6083,8 @@ static void checkList( int expected = N; int iFirst = iPage; while( N-- > 0 && pCheck->mxErr ){ - unsigned char *pOvfl; + DbPage *pOvflPage; + unsigned char *pOvflData; if( iPage<1 ){ checkAppendMsg(pCheck, zContext, "%d of %d pages missing from overflow list starting at %d", @@ -6080,12 +6092,13 @@ static void checkList( break; } if( checkRef(pCheck, iPage, zContext) ) break; - if( sqlite3pager_get(pCheck->pPager, (Pgno)iPage, (void**)&pOvfl) ){ + if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage) ){ checkAppendMsg(pCheck, zContext, "failed to get page %d", iPage); break; } + pOvflData = (unsigned char *)sqlite3PagerGetData(pOvflPage); if( isFreeList ){ - int n = get4byte(&pOvfl[4]); + int n = get4byte(&pOvflData[4]); #ifndef SQLITE_OMIT_AUTOVACUUM if( pCheck->pBt->autoVacuum ){ checkPtrmap(pCheck, iPage, PTRMAP_FREEPAGE, 0, zContext); @@ -6097,7 +6110,7 @@ static void checkList( N--; }else{ for(i=0; i<n; i++){ - Pgno iFreePage = get4byte(&pOvfl[8+i*4]); + Pgno iFreePage = get4byte(&pOvflData[8+i*4]); #ifndef SQLITE_OMIT_AUTOVACUUM if( pCheck->pBt->autoVacuum ){ checkPtrmap(pCheck, iFreePage, PTRMAP_FREEPAGE, 0, zContext); @@ -6115,13 +6128,13 @@ static void checkList( ** the following page matches iPage. */ if( pCheck->pBt->autoVacuum && N>0 ){ - i = get4byte(pOvfl); + i = get4byte(pOvflData); checkPtrmap(pCheck, i, PTRMAP_OVERFLOW2, iPage, zContext); } } #endif - iPage = get4byte(pOvfl); - sqlite3pager_unref(pOvfl); + iPage = get4byte(pOvflData); + sqlite3PagerUnref(pOvflPage); } } #endif /* SQLITE_OMIT_INTEGRITY_CHECK */ @@ -6311,13 +6324,13 @@ char *sqlite3BtreeIntegrityCheck( IntegrityCk sCheck; BtShared *pBt = p->pBt; - nRef = sqlite3pager_refcount(pBt->pPager); + nRef = sqlite3PagerRefcount(pBt->pPager); if( lockBtreeWithRetry(p)!=SQLITE_OK ){ return sqliteStrDup("Unable to acquire a read lock on the database"); } sCheck.pBt = pBt; sCheck.pPager = pBt->pPager; - sCheck.nPage = sqlite3pager_pagecount(sCheck.pPager); + sCheck.nPage = sqlite3PagerPagecount(sCheck.pPager); sCheck.mxErr = mxErr; sCheck.nErr = 0; *pnErr = 0; @@ -6381,10 +6394,10 @@ char *sqlite3BtreeIntegrityCheck( /* Make sure this analysis did not leave any unref() pages */ unlockBtreeIfUnused(pBt); - if( nRef != sqlite3pager_refcount(pBt->pPager) ){ + if( nRef != sqlite3PagerRefcount(pBt->pPager) ){ checkAppendMsg(&sCheck, 0, "Outstanding page count goes from %d to %d during this analysis", - nRef, sqlite3pager_refcount(pBt->pPager) + nRef, sqlite3PagerRefcount(pBt->pPager) ); } @@ -6401,7 +6414,7 @@ char *sqlite3BtreeIntegrityCheck( */ const char *sqlite3BtreeGetFilename(Btree *p){ assert( p->pBt->pPager!=0 ); - return sqlite3pager_filename(p->pBt->pPager); + return sqlite3PagerFilename(p->pBt->pPager); } /* @@ -6409,7 +6422,7 @@ const char *sqlite3BtreeGetFilename(Btree *p){ */ const char *sqlite3BtreeGetDirname(Btree *p){ assert( p->pBt->pPager!=0 ); - return sqlite3pager_dirname(p->pBt->pPager); + return sqlite3PagerDirname(p->pBt->pPager); } /* @@ -6419,7 +6432,7 @@ const char *sqlite3BtreeGetDirname(Btree *p){ */ const char *sqlite3BtreeGetJournalname(Btree *p){ assert( p->pBt->pPager!=0 ); - return sqlite3pager_journalname(p->pBt->pPager); + return sqlite3PagerJournalname(p->pBt->pPager); } #ifndef SQLITE_OMIT_VACUUM @@ -6441,28 +6454,28 @@ int sqlite3BtreeCopyFile(Btree *pTo, Btree *pFrom){ return SQLITE_ERROR; } if( pBtTo->pCursor ) return SQLITE_BUSY; - nToPage = sqlite3pager_pagecount(pBtTo->pPager); - nPage = sqlite3pager_pagecount(pBtFrom->pPager); + nToPage = sqlite3PagerPagecount(pBtTo->pPager); + nPage = sqlite3PagerPagecount(pBtFrom->pPager); iSkip = PENDING_BYTE_PAGE(pBtTo); for(i=1; rc==SQLITE_OK && i<=nPage; i++){ - void *pPage; + DbPage *pDbPage; if( i==iSkip ) continue; - rc = sqlite3pager_get(pBtFrom->pPager, i, &pPage); + rc = sqlite3PagerGet(pBtFrom->pPager, i, &pDbPage); if( rc ) break; - rc = sqlite3pager_overwrite(pBtTo->pPager, i, pPage); - sqlite3pager_unref(pPage); + rc = sqlite3PagerOverwrite(pBtTo->pPager, i, sqlite3PagerGetData(pDbPage)); + sqlite3PagerUnref(pDbPage); } for(i=nPage+1; rc==SQLITE_OK && i<=nToPage; i++){ - void *pPage; + DbPage *pDbPage; if( i==iSkip ) continue; - rc = sqlite3pager_get(pBtTo->pPager, i, &pPage); + rc = sqlite3PagerGet(pBtTo->pPager, i, &pDbPage); if( rc ) break; - rc = sqlite3pager_write(pPage); - sqlite3pager_unref(pPage); - sqlite3pager_dont_write(pBtTo->pPager, i); + rc = sqlite3PagerWrite(pDbPage); + sqlite3PagerUnref(pDbPage); + sqlite3PagerDontWrite(pBtTo->pPager, i); } if( !rc && nPage<nToPage ){ - rc = sqlite3pager_truncate(pBtTo->pPager, nPage); + rc = sqlite3PagerTruncate(pBtTo->pPager, nPage); } if( rc ){ sqlite3BtreeRollback(pTo); @@ -6519,7 +6532,7 @@ int sqlite3BtreeSync(Btree *p, const char *zMaster){ } } #endif - rc = sqlite3pager_sync(pBt->pPager, zMaster, nTrunc); + rc = sqlite3PagerSync(pBt->pPager, zMaster, nTrunc); } return rc; } @@ -6594,7 +6607,7 @@ int sqlite3_shared_cache_report( BtShared *pBt; Tcl_Obj *pRet = Tcl_NewObj(); for(pBt=pTd->pBtree; pBt; pBt=pBt->pNext){ - const char *zFile = sqlite3pager_filename(pBt->pPager); + const char *zFile = sqlite3PagerFilename(pBt->pPager); Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj(zFile, -1)); Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(pBt->nRef)); } diff --git a/src/pager.c b/src/pager.c index 68c06947a..bf29bdb03 100644 --- a/src/pager.c +++ b/src/pager.c @@ -18,7 +18,7 @@ ** file simultaneously, or one process from reading the database while ** another is writing. ** -** @(#) $Id: pager.c,v 1.291 2007/03/19 13:53:38 danielk1977 Exp $ +** @(#) $Id: pager.c,v 1.292 2007/03/19 17:44:27 danielk1977 Exp $ */ #ifndef SQLITE_OMIT_DISKIO #include "sqliteInt.h" @@ -90,15 +90,15 @@ ** committed. ** ** The page cache comes up in PAGER_UNLOCK. The first time a -** sqlite3pager_get() occurs, the state transitions to PAGER_SHARED. +** sqlite3PagerGet() occurs, the state transitions to PAGER_SHARED. ** After all pages have been released using sqlite_page_unref(), ** the state transitions back to PAGER_UNLOCK. The first time -** that sqlite3pager_write() is called, the state transitions to +** that sqlite3PagerWrite() is called, the state transitions to ** PAGER_RESERVED. (Note that sqlite_page_write() can only be ** called on an outstanding page which means that the pager must ** be in PAGER_SHARED before it transitions to PAGER_RESERVED.) ** The transition to PAGER_EXCLUSIVE occurs when before any changes -** are made to the database file. After an sqlite3pager_rollback() +** are made to the database file. After an sqlite3PagerRollback() ** or sqlite_pager_commit(), the state goes back to PAGER_SHARED. */ #define PAGER_UNLOCK 0 @@ -135,8 +135,8 @@ ** This header is only visible to this pager module. The client ** code that calls pager sees only the data that follows the header. ** -** Client code should call sqlite3pager_write() on a page prior to making -** any modifications to that page. The first time sqlite3pager_write() +** Client code should call sqlite3PagerWrite() on a page prior to making +** any modifications to that page. The first time sqlite3PagerWrite() ** is called, the original page contents are written into the rollback ** journal and PgHdr.inJournal and PgHdr.needSync are set. Later, once ** the journal page has made it onto the disk surface, PgHdr.needSync @@ -144,7 +144,7 @@ ** database file until the journal pages has been synced to disk and the ** PgHdr.needSync has been cleared. ** -** The PgHdr.dirty flag is set when sqlite3pager_write() is called and +** The PgHdr.dirty flag is set when sqlite3PagerWrite() is called and ** is cleared again when the page content is written back to the original ** database file. */ @@ -217,7 +217,7 @@ struct PgHistory { ** and is returned as the result of every major pager API call. The ** SQLITE_FULL return code is slightly different. It persists only until the ** next successful rollback is performed on the pager cache. Also, -** SQLITE_FULL does not affect the sqlite3pager_get() and sqlite3pager_lookup() +** SQLITE_FULL does not affect the sqlite3PagerGet() and sqlite3PagerLookup() ** APIs, they may still be used successfully. */ struct Pager { @@ -275,8 +275,8 @@ struct Pager { int nHit, nMiss, nOvfl; /* Cache hits, missing, and LRU overflows */ int nRead,nWrite; /* Database pages read/written */ #endif - void (*xDestructor)(void*,int); /* Call this routine when freeing pages */ - void (*xReiniter)(void*,int); /* Call this routine when reloading pages */ + void (*xDestructor)(DbPage*,int); /* Call this routine when freeing pages */ + void (*xReiniter)(DbPage*,int); /* Call this routine when reloading pages */ void *(*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */ void *pCodecArg; /* First argument to xCodec() */ int nHash; /* Size of the pager hash table */ @@ -801,7 +801,7 @@ static int writeMasterJournal(Pager *pPager, const char *zMaster){ ** statement journal. ** ** The Pager keeps a separate list of pages that are currently in -** the statement journal. This helps the sqlite3pager_stmt_commit() +** the statement journal. This helps the sqlite3PagerStmtCommit() ** routine run MUCH faster for the common case where there are many ** pages in memory but only a few are in the statement journal. */ @@ -890,7 +890,7 @@ static void pager_reset(Pager *pPager){ pPager->nPage = 0; pPager->aHash = 0; if( pPager->state>=PAGER_RESERVED ){ - sqlite3pager_rollback(pPager); + sqlite3PagerRollback(pPager); } pager_unlock(pPager); pPager->nRef = 0; @@ -914,7 +914,7 @@ static int pager_unwritelock(Pager *pPager){ if( pPager->state<PAGER_RESERVED ){ return SQLITE_OK; } - sqlite3pager_stmt_commit(pPager); + sqlite3PagerStmtCommit(pPager); if( pPager->stmtOpen ){ sqlite3OsClose(&pPager->stfd); pPager->stmtOpen = 0; @@ -1069,14 +1069,14 @@ static int pager_playback_one_page(Pager *pPager, OsFile *jfd, int useCksum){ ** for page 1 which is held in use in order to keep the lock on the ** database active. However such a page may be rolled back as a result ** of an internal error resulting in an automatic call to - ** sqlite3pager_rollback(). + ** sqlite3PagerRollback(). */ void *pData; /* assert( pPg->nRef==0 || pPg->pgno==1 ); */ pData = PGHDR_TO_DATA(pPg); memcpy(pData, aData, pPager->pageSize); if( pPager->xDestructor ){ /*** FIX ME: Should this be xReinit? ***/ - pPager->xDestructor(pData, pPager->pageSize); + pPager->xDestructor(pPg, pPager->pageSize); } #ifdef SQLITE_CHECK_PAGES pPg->pageHash = pager_pagehash(pPg); @@ -1201,7 +1201,7 @@ static int pager_reload_cache(Pager *pPager){ if( pPg->nRef==0 || memcmp(zBuf, PGHDR_TO_DATA(pPg), pPager->pageSize) ){ memcpy(PGHDR_TO_DATA(pPg), zBuf, pPager->pageSize); if( pPager->xReiniter ){ - pPager->xReiniter(PGHDR_TO_DATA(pPg), pPager->pageSize); + pPager->xReiniter(pPg, pPager->pageSize); }else{ memset(PGHDR_TO_EXTRA(pPg, pPager), 0, pPager->nExtra); } @@ -1513,7 +1513,7 @@ end_stmt_playback: /* ** Change the maximum number of in-memory pages that are allowed. */ -void sqlite3pager_set_cachesize(Pager *pPager, int mxPage){ +void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){ if( mxPage>10 ){ pPager->mxPage = mxPage; }else{ @@ -1548,7 +1548,7 @@ void sqlite3pager_set_cachesize(Pager *pPager, int mxPage){ ** and FULL=3. */ #ifndef SQLITE_OMIT_PAGER_PRAGMAS -void sqlite3pager_set_safety_level(Pager *pPager, int level, int full_fsync){ +void sqlite3PagerSetSafetyLevel(Pager *pPager, int level, int full_fsync){ pPager->noSync = level==1 || pPager->tempFile; pPager->fullSync = level==3 && !pPager->tempFile; pPager->full_fsync = full_fsync; @@ -1574,7 +1574,7 @@ int sqlite3_opentemp_count = 0; ** The OS will automatically delete the temporary file when it is ** closed. */ -static int sqlite3pager_opentemp(OsFile **pFd){ +static int sqlite3PagerOpentemp(OsFile **pFd){ int cnt = 8; int rc; char zFile[SQLITE_TEMPNAME_SIZE]; @@ -1593,8 +1593,8 @@ static int sqlite3pager_opentemp(OsFile **pFd){ /* ** Create a new page cache and put a pointer to the page cache in *ppPager. ** The file to be cached need not exist. The file is not locked until -** the first call to sqlite3pager_get() and is only held open until the -** last page is released using sqlite3pager_unref(). +** the first call to sqlite3PagerGet() and is only held open until the +** last page is released using sqlite3PagerUnref(). ** ** If zFilename is NULL then a randomly-named temporary file is created ** and used as the file to be cached. The file will be deleted @@ -1604,7 +1604,7 @@ static int sqlite3pager_opentemp(OsFile **pFd){ ** It is never written to disk. This can be used to implement an ** in-memory database. */ -int sqlite3pager_open( +int sqlite3PagerOpen( Pager **ppPager, /* Return the Pager structure here */ const char *zFilename, /* Name of the database file to open */ int nExtra, /* Extra bytes append to each in-memory page */ @@ -1661,7 +1661,7 @@ int sqlite3pager_open( } } }else{ - rc = sqlite3pager_opentemp(&fd); + rc = sqlite3PagerOpentemp(&fd); sqlite3OsTempFileName(zTemp); zFilename = zTemp; zFullPathname = sqlite3OsFullPathname(zFilename); @@ -1752,7 +1752,7 @@ int sqlite3pager_open( /* ** Set the busy handler function. */ -void sqlite3pager_set_busyhandler(Pager *pPager, BusyHandler *pBusyHandler){ +void sqlite3PagerSetBusyhandler(Pager *pPager, BusyHandler *pBusyHandler){ pPager->pBusyHandler = pBusyHandler; } @@ -1761,10 +1761,10 @@ void sqlite3pager_set_busyhandler(Pager *pPager, BusyHandler *pBusyHandler){ ** when the reference count on each page reaches zero. The destructor can ** be used to clean up information in the extra segment appended to each page. ** -** The destructor is not called as a result sqlite3pager_close(). -** Destructors are only called by sqlite3pager_unref(). +** The destructor is not called as a result sqlite3PagerClose(). +** Destructors are only called by sqlite3PagerUnref(). */ -void sqlite3pager_set_destructor(Pager *pPager, void (*xDesc)(void*,int)){ +void sqlite3PagerSetDestructor(Pager *pPager, void (*xDesc)(DbPage*,int)){ pPager->xDestructor = xDesc; } @@ -1775,7 +1775,7 @@ void sqlite3pager_set_destructor(Pager *pPager, void (*xDesc)(void*,int)){ ** an opportunity to restore the EXTRA section to agree with the restored ** page data. */ -void sqlite3pager_set_reiniter(Pager *pPager, void (*xReinit)(void*,int)){ +void sqlite3PagerSetReiniter(Pager *pPager, void (*xReinit)(DbPage*,int)){ pPager->xReiniter = xReinit; } @@ -1784,7 +1784,7 @@ void sqlite3pager_set_reiniter(Pager *pPager, void (*xReinit)(void*,int)){ ** size is inappropriate, then an alternative page size is selected ** and returned. */ -int sqlite3pager_set_pagesize(Pager *pPager, int pageSize){ +int sqlite3PagerSetPagesize(Pager *pPager, int pageSize){ assert( pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE ); if( !pPager->memDb ){ pPager->pageSize = pageSize; @@ -1831,7 +1831,7 @@ void enable_simulated_io_errors(void){ ** response is to zero the memory at pDest and continue. A real IO error ** will presumably recur and be picked up later (Todo: Think about this). */ -int sqlite3pager_read_fileheader(Pager *pPager, int N, unsigned char *pDest){ +int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){ int rc = SQLITE_OK; memset(pDest, 0, N); if( MEMDB==0 ){ @@ -1856,7 +1856,7 @@ int sqlite3pager_read_fileheader(Pager *pPager, int N, unsigned char *pDest){ ** PENDING_BYTE is byte 4096 (the first byte of page 5) and the size of the ** file is 4096 bytes, 5 is returned instead of 4. */ -int sqlite3pager_pagecount(Pager *pPager){ +int sqlite3PagerPagecount(Pager *pPager){ i64 n; int rc; assert( pPager!=0 ); @@ -1908,7 +1908,7 @@ static int syncJournal(Pager*); /* ** Unlink pPg from it's hash chain. Also set the page number to 0 to indicate ** that the page is not part of any hash chain. This is required because the -** sqlite3pager_movepage() routine can leave a page in the +** sqlite3PagerMovepage() routine can leave a page in the ** pNextFree/pPrevFree list that is not a part of any hash-chain. */ static void unlinkHashChain(Pager *pPager, PgHdr *pPg){ @@ -2033,10 +2033,10 @@ static int pager_wait_on_lock(Pager *pPager, int locktype){ /* ** Truncate the file to the number of pages specified. */ -int sqlite3pager_truncate(Pager *pPager, Pgno nPage){ +int sqlite3PagerTruncate(Pager *pPager, Pgno nPage){ int rc; assert( pPager->state>=PAGER_SHARED || MEMDB ); - sqlite3pager_pagecount(pPager); + sqlite3PagerPagecount(pPager); if( pPager->errCode ){ rc = pPager->errCode; return rc; @@ -2081,7 +2081,7 @@ int sqlite3pager_truncate(Pager *pPager, Pgno nPage){ ** a hot journal may be left in the filesystem but no error is returned ** to the caller. */ -int sqlite3pager_close(Pager *pPager){ +int sqlite3PagerClose(Pager *pPager){ #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT /* A malloc() cannot fail in sqlite3ThreadData() as one or more calls to ** malloc() must have already been made by this thread before it gets @@ -2135,8 +2135,7 @@ int sqlite3pager_close(Pager *pPager){ /* ** Return the page number for the given page data. */ -Pgno sqlite3pager_pagenumber(void *pData){ - PgHdr *p = DATA_TO_PGHDR(pData); +Pgno sqlite3PagerPagenumber(DbPage *p){ return p->pgno; } @@ -2189,8 +2188,7 @@ static void _page_ref(PgHdr *pPg){ ** Increment the reference count for a page. The input pointer is ** a reference to the page data. */ -int sqlite3pager_ref(void *pData){ - PgHdr *pPg = DATA_TO_PGHDR(pData); +int sqlite3PagerRef(DbPage *pPg){ page_ref(pPg); return SQLITE_OK; } @@ -2394,7 +2392,7 @@ static int pager_write_pagelist(PgHdr *pList){ rc = sqlite3OsSeek(pPager->fd, (pList->pgno-1)*(i64)pPager->pageSize); if( rc ) return rc; /* If there are dirty pages in the page cache with page numbers greater - ** than Pager.dbSize, this means sqlite3pager_truncate() was called to + ** than Pager.dbSize, this means sqlite3PagerTruncate() was called to ** make the file smaller (presumably by auto-vacuum code). Do not write ** any such pages to the file. */ @@ -2441,7 +2439,7 @@ static int hasHotJournal(Pager *pPager){ if( !pPager->useJournal ) return 0; if( !sqlite3OsFileExists(pPager->zJournal) ) return 0; if( sqlite3OsCheckReservedLock(pPager->fd) ) return 0; - if( sqlite3pager_pagecount(pPager)==0 ){ + if( sqlite3PagerPagecount(pPager)==0 ){ sqlite3OsDelete(pPager->zJournal); return 0; }else{ @@ -2545,7 +2543,7 @@ static int pager_recycle(Pager *pPager, int syncOk, PgHdr **ppPg){ ** of bytes of memory released. */ #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT -int sqlite3pager_release_memory(int nReq){ +int sqlite3PagerReleaseMemory(int nReq){ const ThreadData *pTsdro = sqlite3ThreadDataReadOnly(); Pager *p; int nReleased = 0; @@ -2632,7 +2630,7 @@ int sqlite3pager_release_memory(int nReq){ ** The acquisition might fail for several reasons. In all cases, ** an appropriate error code is returned and *ppPage is set to NULL. ** -** See also sqlite3pager_lookup(). Both this routine and _lookup() attempt +** See also sqlite3PagerLookup(). Both this routine and _lookup() attempt ** to find a page in the in-memory cache first. If the page is not already ** in memory, this routine goes to disk to read it in whereas _lookup() ** just returns 0. This routine acquires a read-lock the first time it @@ -2645,7 +2643,7 @@ int sqlite3pager_release_memory(int nReq){ ** rewritten without first being read so there is no point it doing ** the disk I/O. */ -int sqlite3pager_acquire(Pager *pPager, Pgno pgno, void **ppPage, int clrFlag){ +int sqlite3PagerAcquire(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag){ PgHdr *pPg; int rc; @@ -2797,7 +2795,7 @@ int sqlite3pager_acquire(Pager *pPager, Pgno pgno, void **ppPage, int clrFlag){ memset(PGHDR_TO_EXTRA(pPg, pPager), 0, pPager->nExtra); } if( pPager->errCode ){ - sqlite3pager_unref(PGHDR_TO_DATA(pPg)); + sqlite3PagerUnref(pPg); rc = pPager->errCode; return rc; } @@ -2805,7 +2803,7 @@ int sqlite3pager_acquire(Pager *pPager, Pgno pgno, void **ppPage, int clrFlag){ /* Populate the page with data, either by reading from the database ** file, or by setting the entire page to zero. */ - if( sqlite3pager_pagecount(pPager)<(int)pgno || MEMDB + if( sqlite3PagerPagecount(pPager)<(int)pgno || MEMDB || (clrFlag && !pPager->alwaysRollback) ){ memset(PGHDR_TO_DATA(pPg), 0, pPager->pageSize); @@ -2821,7 +2819,7 @@ int sqlite3pager_acquire(Pager *pPager, Pgno pgno, void **ppPage, int clrFlag){ CODEC1(pPager, PGHDR_TO_DATA(pPg), pPg->pgno, 3); if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){ pPg->pgno = 0; - sqlite3pager_unref(PGHDR_TO_DATA(pPg)); + sqlite3PagerUnref(pPg); return rc; }else{ TEST_INCR(pPager->nRead); @@ -2846,7 +2844,7 @@ int sqlite3pager_acquire(Pager *pPager, Pgno pgno, void **ppPage, int clrFlag){ TEST_INCR(pPager->nHit); page_ref(pPg); } - *ppPage = PGHDR_TO_DATA(pPg); + *ppPage = pPg; return SQLITE_OK; } @@ -2855,13 +2853,13 @@ int sqlite3pager_acquire(Pager *pPager, Pgno pgno, void **ppPage, int clrFlag){ ** not read the page from disk. Return a pointer to the page, ** or 0 if the page is not in cache. ** -** See also sqlite3pager_get(). The difference between this routine -** and sqlite3pager_get() is that _get() will go to the disk and read +** See also sqlite3PagerGet(). The difference between this routine +** and sqlite3PagerGet() is that _get() will go to the disk and read ** in the page if the page is not already in cache. This routine ** returns NULL if the page is not in cache or if a disk I/O error ** has ever happened. */ -void *sqlite3pager_lookup(Pager *pPager, Pgno pgno){ +DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){ PgHdr *pPg; assert( pPager!=0 ); @@ -2872,7 +2870,7 @@ void *sqlite3pager_lookup(Pager *pPager, Pgno pgno){ pPg = pager_lookup(pPager, pgno); if( pPg==0 ) return 0; page_ref(pPg); - return PGHDR_TO_DATA(pPg); + return pPg; } /* @@ -2883,12 +2881,10 @@ void *sqlite3pager_lookup(Pager *pPager, Pgno pgno){ ** are released, a rollback occurs and the lock on the database is ** removed. */ -int sqlite3pager_unref(void *pData){ - PgHdr *pPg; +int sqlite3PagerUnref(DbPage *pPg){ /* Decrement the reference count for this page */ - pPg = DATA_TO_PGHDR(pData); assert( pPg->nRef>0 ); pPg->nRef--; REFINFO(pPg); @@ -2913,7 +2909,7 @@ int sqlite3pager_unref(void *pData){ pPager->pFirstSynced = pPg; } if( pPager->xDestructor ){ - pPager->xDestructor(pData, pPager->pageSize); + pPager->xDestructor(pPg, pPager->pageSize); } /* When all pages reach the freelist, drop the read lock from @@ -2942,7 +2938,7 @@ static int pager_open_journal(Pager *pPager){ assert( pPager->journalOpen==0 ); assert( pPager->useJournal ); assert( pPager->aInJournal==0 ); - sqlite3pager_pagecount(pPager); + sqlite3PagerPagecount(pPager); pPager->aInJournal = sqliteMalloc( pPager->dbSize/8 + 1 ); if( pPager->aInJournal==0 ){ rc = SQLITE_NOMEM; @@ -2973,7 +2969,7 @@ static int pager_open_journal(Pager *pPager){ rc = writeJournalHdr(pPager); if( pPager->stmtAutoopen && rc==SQLITE_OK ){ - rc = sqlite3pager_stmt_begin(pPager); + rc = sqlite3PagerStmtBegin(pPager); } if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM ){ rc = pager_unwritelock(pPager); @@ -3003,10 +2999,10 @@ failed_to_open_journal: ** Acquire a write-lock on the database. The lock is removed when ** the any of the following happen: ** -** * sqlite3pager_commit() is called. -** * sqlite3pager_rollback() is called. -** * sqlite3pager_close() is called. -** * sqlite3pager_unref() is called to on every outstanding page. +** * sqlite3PagerCommit() is called. +** * sqlite3PagerRollback() is called. +** * sqlite3PagerClose() is called. +** * sqlite3PagerUnref() is called to on every outstanding page. ** ** The first parameter to this routine is a pointer to any open page of the ** database file. Nothing changes about the page - it is used merely to @@ -3026,8 +3022,7 @@ failed_to_open_journal: ** immediately instead of waiting until we try to flush the cache. The ** exFlag is ignored if a transaction is already active. */ -int sqlite3pager_begin(void *pData, int exFlag){ - PgHdr *pPg = DATA_TO_PGHDR(pData); +int sqlite3PagerBegin(DbPage *pPg, int exFlag){ Pager *pPager = pPg->pPager; int rc = SQLITE_OK; assert( pPg->nRef>0 ); @@ -3108,11 +3103,11 @@ static void makeClean(PgHdr *pPg){ ** If the journal file could not be written because the disk is full, ** then this routine returns SQLITE_FULL and does an immediate rollback. ** All subsequent write attempts also return SQLITE_FULL until there -** is a call to sqlite3pager_commit() or sqlite3pager_rollback() to +** is a call to sqlite3PagerCommit() or sqlite3PagerRollback() to ** reset. */ -static int pager_write(void *pData){ - PgHdr *pPg = DATA_TO_PGHDR(pData); +static int pager_write(PgHdr *pPg){ + void *pData = PGHDR_TO_DATA(pPg); Pager *pPager = pPg->pPager; int rc = SQLITE_OK; @@ -3145,7 +3140,7 @@ static int pager_write(void *pData){ ** create it if it does not. */ assert( pPager->state!=PAGER_UNLOCK ); - rc = sqlite3pager_begin(pData, 0); + rc = sqlite3PagerBegin(pPg, 0); if( rc!=SQLITE_OK ){ return rc; } @@ -3275,10 +3270,10 @@ static int pager_write(void *pData){ ** fit on a single disk sector. In this case all co-resident pages ** must have been written to the journal file before returning. */ -int sqlite3pager_write(void *pData){ +int sqlite3PagerWrite(DbPage *pDbPage){ int rc = SQLITE_OK; - PgHdr *pPg = DATA_TO_PGHDR(pData); + PgHdr *pPg = pDbPage; Pager *pPager = pPg->pPager; Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize); @@ -3300,7 +3295,7 @@ int sqlite3pager_write(void *pData){ */ pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1; - nPageCount = sqlite3pager_pagecount(pPager); + nPageCount = sqlite3PagerPagecount(pPager); if( pPg->pgno>nPageCount ){ nPage = (pPg->pgno - pg1)+1; }else if( (pg1+nPagePerSector-1)>nPageCount ){ @@ -3318,11 +3313,11 @@ int sqlite3pager_write(void *pData){ pg>pPager->origDbSize || !(pPager->aInJournal[pg/8]&(1<<(pg&7))) ) { if( pg!=PAGER_MJ_PGNO(pPager) ){ - void *pPage; - rc = sqlite3pager_get(pPager, pg, &pPage); + PgHdr *pPage; + rc = sqlite3PagerGet(pPager, pg, &pPage); if( rc==SQLITE_OK ){ rc = pager_write(pPage); - sqlite3pager_unref(pPage); + sqlite3PagerUnref(pPage); } } } @@ -3331,19 +3326,18 @@ int sqlite3pager_write(void *pData){ assert( pPager->doNotSync==1 ); pPager->doNotSync = 0; }else{ - rc = pager_write(pData); + rc = pager_write(pDbPage); } return rc; } /* ** Return TRUE if the page given in the argument was previously passed -** to sqlite3pager_write(). In other words, return TRUE if it is ok +** to sqlite3PagerWrite(). In other words, return TRUE if it is ok ** to change the content of the page. */ #ifndef NDEBUG -int sqlite3pager_iswriteable(void *pData){ - PgHdr *pPg = DATA_TO_PGHDR(pData); +int sqlite3PagerIswriteable(DbPage *pPg){ return pPg->dirty; } #endif @@ -3353,17 +3347,17 @@ int sqlite3pager_iswriteable(void *pData){ ** Replace the content of a single page with the information in the third ** argument. */ -int sqlite3pager_overwrite(Pager *pPager, Pgno pgno, void *pData){ - void *pPage; +int sqlite3PagerOverwrite(Pager *pPager, Pgno pgno, void *pData){ + PgHdr *pPg; int rc; - rc = sqlite3pager_get(pPager, pgno, &pPage); + rc = sqlite3PagerGet(pPager, pgno, &pPg); if( rc==SQLITE_OK ){ - rc = sqlite3pager_write(pPage); + rc = sqlite3PagerWrite(pPg); if( rc==SQLITE_OK ){ - memcpy(pPage, pData, pPager->pageSize); + memcpy(sqlite3PagerGetData(pPg), pData, pPager->pageSize); } - sqlite3pager_unref(pPage); + sqlite3PagerUnref(pPg); } return rc; } @@ -3379,11 +3373,11 @@ int sqlite3pager_overwrite(Pager *pPager, Pgno pgno, void *pData){ ** that it does not get written to disk. ** ** Tests show that this optimization, together with the -** sqlite3pager_dont_rollback() below, more than double the speed +** sqlite3PagerDontRollback() below, more than double the speed ** of large INSERT operations and quadruple the speed of large DELETEs. ** ** When this routine is called, set the alwaysRollback flag to true. -** Subsequent calls to sqlite3pager_dont_rollback() for the same page +** Subsequent calls to sqlite3PagerDontRollback() for the same page ** will thereafter be ignored. This is necessary to avoid a problem ** where a page with data is added to the freelist during one part of ** a transaction then removed from the freelist during a later part @@ -3393,7 +3387,7 @@ int sqlite3pager_overwrite(Pager *pPager, Pgno pgno, void *pData){ ** critical data, we still need to be sure it gets rolled back in spite ** of the dont_rollback() call. */ -void sqlite3pager_dont_write(Pager *pPager, Pgno pgno){ +void sqlite3PagerDontWrite(Pager *pPager, Pgno pgno){ PgHdr *pPg; if( MEMDB ) return; @@ -3429,8 +3423,7 @@ void sqlite3pager_dont_write(Pager *pPager, Pgno pgno){ ** means that the pager does not have to record the given page in the ** rollback journal. */ -void sqlite3pager_dont_rollback(void *pData){ - PgHdr *pPg = DATA_TO_PGHDR(pData); +void sqlite3PagerDontRollback(DbPage *pPg){ Pager *pPager = pPg->pPager; assert( pPager->state>=PAGER_RESERVED ); @@ -3463,7 +3456,7 @@ void sqlite3pager_dont_rollback(void *pData){ ** and an error code is returned. If the commit worked, SQLITE_OK ** is returned. */ -int sqlite3pager_commit(Pager *pPager){ +int sqlite3PagerCommit(Pager *pPager){ int rc; PgHdr *pPg; @@ -3506,7 +3499,7 @@ int sqlite3pager_commit(Pager *pPager){ return rc; } assert( pPager->journalOpen ); - rc = sqlite3pager_sync(pPager, 0, 0); + rc = sqlite3PagerSync(pPager, 0, 0); if( rc==SQLITE_OK ){ rc = pager_unwritelock(pPager); } @@ -3525,7 +3518,7 @@ int sqlite3pager_commit(Pager *pPager){ ** codes are returned for all these occasions. Otherwise, ** SQLITE_OK is returned. */ -int sqlite3pager_rollback(Pager *pPager){ +int sqlite3PagerRollback(Pager *pPager){ int rc; TRACE2("ROLLBACK %d\n", PAGERID(pPager)); if( MEMDB ){ @@ -3552,7 +3545,7 @@ int sqlite3pager_rollback(Pager *pPager){ p->inStmt = 0; p->pPrevStmt = p->pNextStmt = 0; if( pPager->xReiniter ){ - pPager->xReiniter(PGHDR_TO_DATA(p), pPager->pageSize); + pPager->xReiniter(p, pPager->pageSize); } } pPager->pDirty = 0; @@ -3598,14 +3591,14 @@ int sqlite3pager_rollback(Pager *pPager){ ** Return TRUE if the database file is opened read-only. Return FALSE ** if the database is (in theory) writable. */ -int sqlite3pager_isreadonly(Pager *pPager){ +int sqlite3PagerIsreadonly(Pager *pPager){ return pPager->readOnly; } /* ** Return the number of references to the pager. */ -int sqlite3pager_refcount(Pager *pPager){ +int sqlite3PagerRefcount(Pager *pPager){ return pPager->nRef; } @@ -3613,7 +3606,7 @@ int sqlite3pager_refcount(Pager *pPager){ /* ** This routine is used for testing and analysis only. */ -int *sqlite3pager_stats(Pager *pPager){ +int *sqlite3PagerStats(Pager *pPager){ static int a[11]; a[0] = pPager->nRef; a[1] = pPager->nPage; @@ -3637,7 +3630,7 @@ int *sqlite3pager_stats(Pager *pPager){ ** open. A new statement journal is created that can be used to rollback ** changes of a single SQL command within a larger transaction. */ -int sqlite3pager_stmt_begin(Pager *pPager){ +int sqlite3PagerStmtBegin(Pager *pPager){ int rc; assert( !pPager->stmtInUse ); assert( pPager->state>=PAGER_SHARED ); @@ -3668,7 +3661,7 @@ int sqlite3pager_stmt_begin(Pager *pPager){ pPager->stmtHdrOff = 0; pPager->stmtCksum = pPager->cksumInit; if( !pPager->stmtOpen ){ - rc = sqlite3pager_opentemp(&pPager->stfd); + rc = sqlite3PagerOpentemp(&pPager->stfd); if( rc ) goto stmt_begin_failed; pPager->stmtOpen = 1; pPager->stmtNRec = 0; @@ -3687,7 +3680,7 @@ stmt_begin_failed: /* ** Commit a statement. */ -int sqlite3pager_stmt_commit(Pager *pPager){ +int sqlite3PagerStmtCommit(Pager *pPager){ if( pPager->stmtInUse ){ PgHdr *pPg, *pNext; TRACE2("STMT-COMMIT %d\n", PAGERID(pPager)); @@ -3719,7 +3712,7 @@ int sqlite3pager_stmt_commit(Pager *pPager){ /* ** Rollback a statement. */ -int sqlite3pager_stmt_rollback(Pager *pPager){ +int sqlite3PagerStmtRollback(Pager *pPager){ int rc; if( pPager->stmtInUse ){ TRACE2("STMT-ROLLBACK %d\n", PAGERID(pPager)); @@ -3739,7 +3732,7 @@ int sqlite3pager_stmt_rollback(Pager *pPager){ }else{ rc = pager_stmt_playback(pPager); } - sqlite3pager_stmt_commit(pPager); + sqlite3PagerStmtCommit(pPager); }else{ rc = SQLITE_OK; } @@ -3750,21 +3743,21 @@ int sqlite3pager_stmt_rollback(Pager *pPager){ /* ** Return the full pathname of the database file. */ -const char *sqlite3pager_filename(Pager *pPager){ +const char *sqlite3PagerFilename(Pager *pPager){ return pPager->zFilename; } /* ** Return the directory of the database file. */ -const char *sqlite3pager_dirname(Pager *pPager){ +const char *sqlite3PagerDirname(Pager *pPager){ return pPager->zDirectory; } /* ** Return the full pathname of the journal file. */ -const char *sqlite3pager_journalname(Pager *pPager){ +const char *sqlite3PagerJournalname(Pager *pPager){ return pPager->zJournal; } @@ -3772,14 +3765,14 @@ const char *sqlite3pager_journalname(Pager *pPager){ ** Return true if fsync() calls are disabled for this pager. Return FALSE ** if fsync()s are executed normally. */ -int sqlite3pager_nosync(Pager *pPager){ +int sqlite3PagerNosync(Pager *pPager){ return pPager->noSync; } /* ** Set the codec for this pager */ -void sqlite3pager_set_codec( +void sqlite3PagerSetCodec( Pager *pPager, void *(*xCodec)(void*,void*,Pgno,int), void *pCodecArg @@ -3793,19 +3786,17 @@ void sqlite3pager_set_codec( ** stored at byte 24 of the pager file. */ static int pager_incr_changecounter(Pager *pPager){ - void *pPage; PgHdr *pPgHdr; u32 change_counter; int rc; /* Open page 1 of the file for writing. */ - rc = sqlite3pager_get(pPager, 1, &pPage); + rc = sqlite3PagerGet(pPager, 1, &pPgHdr); if( rc!=SQLITE_OK ) return rc; - rc = sqlite3pager_write(pPage); + rc = sqlite3PagerWrite(pPgHdr); if( rc!=SQLITE_OK ) return rc; /* Read the current value at byte 24. */ - pPgHdr = DATA_TO_PGHDR(pPage); change_counter = retrieve32bits(pPgHdr, 24); /* Increment the value just read and write it back to byte 24. */ @@ -3813,7 +3804,7 @@ static int pager_incr_changecounter(Pager *pPager){ put32bits(((char*)PGHDR_TO_DATA(pPgHdr))+24, change_counter); /* Release the page reference. */ - sqlite3pager_unref(pPage); + sqlite3PagerUnref(pPgHdr); return SQLITE_OK; } @@ -3829,12 +3820,12 @@ static int pager_incr_changecounter(Pager *pPager){ ** master journal file if specified). ** ** Note that if zMaster==NULL, this does not overwrite a previous value -** passed to an sqlite3pager_sync() call. +** passed to an sqlite3PagerSync() call. ** ** If parameter nTrunc is non-zero, then the pager file is truncated to ** nTrunc pages (this is used by auto-vacuum databases). */ -int sqlite3pager_sync(Pager *pPager, const char *zMaster, Pgno nTrunc){ +int sqlite3PagerSync(Pager *pPager, const char *zMaster, Pgno nTrunc){ int rc = SQLITE_OK; TRACE4("DATABASE SYNC: File=%s zMaster=%s nTrunc=%d\n", @@ -3863,14 +3854,13 @@ int sqlite3pager_sync(Pager *pPager, const char *zMaster, Pgno nTrunc){ ** file. */ Pgno i; - void *pPage; int iSkip = PAGER_MJ_PGNO(pPager); for( i=nTrunc+1; i<=pPager->origDbSize; i++ ){ if( !(pPager->aInJournal[i/8] & (1<<(i&7))) && i!=iSkip ){ - rc = sqlite3pager_get(pPager, i, &pPage); + rc = sqlite3PagerGet(pPager, i, &pPg); if( rc!=SQLITE_OK ) goto sync_exit; - rc = sqlite3pager_write(pPage); - sqlite3pager_unref(pPage); + rc = sqlite3PagerWrite(pPg); + sqlite3PagerUnref(pPg); if( rc!=SQLITE_OK ) goto sync_exit; } } @@ -3884,7 +3874,7 @@ int sqlite3pager_sync(Pager *pPager, const char *zMaster, Pgno nTrunc){ #ifndef SQLITE_OMIT_AUTOVACUUM if( nTrunc!=0 ){ - rc = sqlite3pager_truncate(pPager, nTrunc); + rc = sqlite3PagerTruncate(pPager, nTrunc); if( rc!=SQLITE_OK ) goto sync_exit; } #endif @@ -3902,7 +3892,7 @@ int sqlite3pager_sync(Pager *pPager, const char *zMaster, Pgno nTrunc){ pPager->state = PAGER_SYNCED; }else if( MEMDB && nTrunc!=0 ){ - rc = sqlite3pager_truncate(pPager, nTrunc); + rc = sqlite3PagerTruncate(pPager, nTrunc); } sync_exit: @@ -3927,8 +3917,7 @@ sync_exit: ** has been removed (CREATE INDEX needs to move a page when a statement ** transaction is active). */ -int sqlite3pager_movepage(Pager *pPager, void *pData, Pgno pgno){ - PgHdr *pPg = DATA_TO_PGHDR(pData); +int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno){ PgHdr *pPgOld; int h; Pgno needSyncPgno = 0; @@ -3989,32 +3978,48 @@ int sqlite3pager_movepage(Pager *pPager, void *pData, Pgno pgno){ ** Pager.aInJournal bit has been set. This needs to be remedied by loading ** the page into the pager-cache and setting the PgHdr.needSync flag. ** - ** The sqlite3pager_get() call may cause the journal to sync. So make + ** The sqlite3PagerGet() call may cause the journal to sync. So make ** sure the Pager.needSync flag is set too. */ int rc; - void *pNeedSync; + PgHdr *pPgHdr; assert( pPager->needSync ); - rc = sqlite3pager_get(pPager, needSyncPgno, &pNeedSync); + rc = sqlite3PagerGet(pPager, needSyncPgno, &pPgHdr); if( rc!=SQLITE_OK ) return rc; pPager->needSync = 1; - DATA_TO_PGHDR(pNeedSync)->needSync = 1; - DATA_TO_PGHDR(pNeedSync)->inJournal = 1; - makeDirty(DATA_TO_PGHDR(pNeedSync)); - sqlite3pager_unref(pNeedSync); + pPgHdr->needSync = 1; + pPgHdr->inJournal = 1; + makeDirty(pPgHdr); + sqlite3PagerUnref(pPgHdr); } return SQLITE_OK; } #endif +/* +** Return a pointer to the data for the specified page. +*/ +void *sqlite3PagerGetData(DbPage *pPg){ + return PGHDR_TO_DATA(pPg); +} + +/* +** Return a pointer to the Pager.nExtra bytes of "extra" space +** allocated along with the specified page. +*/ +void *sqlite3PagerGetExtra(DbPage *pPg){ + Pager *pPager = pPg->pPager; + return (pPager?PGHDR_TO_EXTRA(pPg, pPager):0); +} + #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) /* ** Return the current state of the file lock for the given pager. ** The return value is one of NO_LOCK, SHARED_LOCK, RESERVED_LOCK, ** PENDING_LOCK, or EXCLUSIVE_LOCK. */ -int sqlite3pager_lockstate(Pager *pPager){ +int sqlite3PagerLockstate(Pager *pPager){ return sqlite3OsLockState(pPager->fd); } #endif @@ -4023,7 +4028,7 @@ int sqlite3pager_lockstate(Pager *pPager){ /* ** Print a listing of all referenced pages and their ref count. */ -void sqlite3pager_refdump(Pager *pPager){ +void sqlite3PagerRefdump(Pager *pPager){ PgHdr *pPg; for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ if( pPg->nRef<=0 ) continue; diff --git a/src/pager.h b/src/pager.h index 44825af40..657f1806f 100644 --- a/src/pager.h +++ b/src/pager.h @@ -13,7 +13,7 @@ ** subsystem. The page cache subsystem reads and writes a file a page ** at a time and provides a journal for rollback. ** -** @(#) $Id: pager.h,v 1.53 2007/03/04 13:15:28 drh Exp $ +** @(#) $Id: pager.h,v 1.54 2007/03/19 17:44:27 danielk1977 Exp $ */ #ifndef _PAGER_H_ @@ -57,7 +57,12 @@ typedef unsigned int Pgno; typedef struct Pager Pager; /* -** Allowed values for the flags parameter to sqlite3pager_open(). +** Handle type for pages. +*/ +typedef struct PgHdr DbPage; + +/* +** Allowed values for the flags parameter to sqlite3PagerOpen(). ** ** NOTE: This values must match the corresponding BTREE_ values in btree.h. */ @@ -69,55 +74,58 @@ typedef struct Pager Pager; ** See source code comments for a detailed description of the following ** routines: */ -int sqlite3pager_open(Pager **ppPager, const char *zFilename, +int sqlite3PagerOpen(Pager **ppPager, const char *zFilename, int nExtra, int flags); -void sqlite3pager_set_busyhandler(Pager*, BusyHandler *pBusyHandler); -void sqlite3pager_set_destructor(Pager*, void(*)(void*,int)); -void sqlite3pager_set_reiniter(Pager*, void(*)(void*,int)); -int sqlite3pager_set_pagesize(Pager*, int); -int sqlite3pager_read_fileheader(Pager*, int, unsigned char*); -void sqlite3pager_set_cachesize(Pager*, int); -int sqlite3pager_close(Pager *pPager); -int sqlite3pager_acquire(Pager *pPager, Pgno pgno, void **ppPage, int clrFlag); -#define sqlite3pager_get(A,B,C) sqlite3pager_acquire(A,B,C,0) -void *sqlite3pager_lookup(Pager *pPager, Pgno pgno); -int sqlite3pager_ref(void*); -int sqlite3pager_unref(void*); -Pgno sqlite3pager_pagenumber(void*); -int sqlite3pager_write(void*); -int sqlite3pager_iswriteable(void*); -int sqlite3pager_overwrite(Pager *pPager, Pgno pgno, void*); -int sqlite3pager_pagecount(Pager*); -int sqlite3pager_truncate(Pager*,Pgno); -int sqlite3pager_begin(void*, int exFlag); -int sqlite3pager_commit(Pager*); -int sqlite3pager_sync(Pager*,const char *zMaster, Pgno); -int sqlite3pager_rollback(Pager*); -int sqlite3pager_isreadonly(Pager*); -int sqlite3pager_stmt_begin(Pager*); -int sqlite3pager_stmt_commit(Pager*); -int sqlite3pager_stmt_rollback(Pager*); -void sqlite3pager_dont_rollback(void*); -void sqlite3pager_dont_write(Pager*, Pgno); -int sqlite3pager_refcount(Pager*); -int *sqlite3pager_stats(Pager*); -void sqlite3pager_set_safety_level(Pager*,int,int); -const char *sqlite3pager_filename(Pager*); -const char *sqlite3pager_dirname(Pager*); -const char *sqlite3pager_journalname(Pager*); -int sqlite3pager_nosync(Pager*); -int sqlite3pager_rename(Pager*, const char *zNewName); -void sqlite3pager_set_codec(Pager*,void*(*)(void*,void*,Pgno,int),void*); -int sqlite3pager_movepage(Pager*,void*,Pgno); -int sqlite3pager_reset(Pager*); -int sqlite3pager_release_memory(int); +void sqlite3PagerSetBusyhandler(Pager*, BusyHandler *pBusyHandler); +void sqlite3PagerSetDestructor(Pager*, void(*)(DbPage*,int)); +void sqlite3PagerSetReiniter(Pager*, void(*)(DbPage*,int)); +int sqlite3PagerSetPagesize(Pager*, int); +int sqlite3PagerReadFileheader(Pager*, int, unsigned char*); +void sqlite3PagerSetCachesize(Pager*, int); +int sqlite3PagerClose(Pager *pPager); +int sqlite3PagerAcquire(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag); +#define sqlite3PagerGet(A,B,C) sqlite3PagerAcquire(A,B,C,0) +DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno); +int sqlite3PagerRef(DbPage*); +int sqlite3PagerUnref(DbPage*); +Pgno sqlite3PagerPagenumber(DbPage*); +int sqlite3PagerWrite(DbPage*); +int sqlite3PagerIswriteable(DbPage*); +int sqlite3PagerOverwrite(Pager *pPager, Pgno pgno, void*); +int sqlite3PagerPagecount(Pager*); +int sqlite3PagerTruncate(Pager*,Pgno); +int sqlite3PagerBegin(DbPage*, int exFlag); +int sqlite3PagerCommit(Pager*); +int sqlite3PagerSync(Pager*,const char *zMaster, Pgno); +int sqlite3PagerRollback(Pager*); +int sqlite3PagerIsreadonly(Pager*); +int sqlite3PagerStmtBegin(Pager*); +int sqlite3PagerStmtCommit(Pager*); +int sqlite3PagerStmtRollback(Pager*); +void sqlite3PagerDontRollback(DbPage*); +void sqlite3PagerDontWrite(Pager*, Pgno); +int sqlite3PagerRefcount(Pager*); +int *sqlite3PagerStats(Pager*); +void sqlite3PagerSetSafetyLevel(Pager*,int,int); +const char *sqlite3PagerFilename(Pager*); +const char *sqlite3PagerDirname(Pager*); +const char *sqlite3PagerJournalname(Pager*); +int sqlite3PagerNosync(Pager*); +int sqlite3PagerRename(Pager*, const char *zNewName); +void sqlite3PagerSetCodec(Pager*,void*(*)(void*,void*,Pgno,int),void*); +int sqlite3PagerMovepage(Pager*,DbPage*,Pgno); +int sqlite3PagerReset(Pager*); +int sqlite3PagerReleaseMemory(int); + +void *sqlite3PagerGetData(DbPage *); +void *sqlite3PagerGetExtra(DbPage *); #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) -int sqlite3pager_lockstate(Pager*); +int sqlite3PagerLockstate(Pager*); #endif #ifdef SQLITE_TEST -void sqlite3pager_refdump(Pager*); +void sqlite3PagerRefdump(Pager*); int pager3_refinfo_enable; #endif diff --git a/src/pragma.c b/src/pragma.c index 217709728..c6af3857a 100644 --- a/src/pragma.c +++ b/src/pragma.c @@ -11,7 +11,7 @@ ************************************************************************* ** This file contains code used to implement the PRAGMA command. ** -** $Id: pragma.c,v 1.128 2007/03/14 15:37:04 danielk1977 Exp $ +** $Id: pragma.c,v 1.129 2007/03/19 17:44:28 danielk1977 Exp $ */ #include "sqliteInt.h" #include "os.h" @@ -941,7 +941,7 @@ void sqlite3Pragma( if( pBt==0 || (pPager = sqlite3BtreePager(pBt))==0 ){ sqlite3VdbeOp3(v, OP_String8, 0, 0, "closed", P3_STATIC); }else{ - int j = sqlite3pager_lockstate(pPager); + int j = sqlite3PagerLockstate(pPager); sqlite3VdbeOp3(v, OP_String8, 0, 0, (j>=0 && j<=4) ? azLockName[j] : "unknown", P3_STATIC); } diff --git a/src/test2.c b/src/test2.c index d9acb2b79..828423e4e 100644 --- a/src/test2.c +++ b/src/test2.c @@ -13,7 +13,7 @@ ** is not included in the SQLite library. It is used for automated ** testing of the SQLite library. ** -** $Id: test2.c,v 1.40 2007/03/15 12:17:43 drh Exp $ +** $Id: test2.c,v 1.41 2007/03/19 17:44:28 danielk1977 Exp $ */ #include "sqliteInt.h" #include "os.h" @@ -78,13 +78,13 @@ static int pager_open( return TCL_ERROR; } if( Tcl_GetInt(interp, argv[2], &nPage) ) return TCL_ERROR; - rc = sqlite3pager_open(&pPager, argv[1], 0, 0); + rc = sqlite3PagerOpen(&pPager, argv[1], 0, 0); if( rc!=SQLITE_OK ){ Tcl_AppendResult(interp, errorName(rc), 0); return TCL_ERROR; } - sqlite3pager_set_cachesize(pPager, nPage); - sqlite3pager_set_pagesize(pPager, test_pagesize); + sqlite3PagerSetCachesize(pPager, nPage); + sqlite3PagerSetPagesize(pPager, test_pagesize); sqlite3_snprintf(sizeof(zBuf),zBuf,"%p",pPager); Tcl_AppendResult(interp, zBuf, 0); return TCL_OK; @@ -109,7 +109,7 @@ static int pager_close( return TCL_ERROR; } pPager = sqlite3TextToPtr(argv[1]); - rc = sqlite3pager_close(pPager); + rc = sqlite3PagerClose(pPager); if( rc!=SQLITE_OK ){ Tcl_AppendResult(interp, errorName(rc), 0); return TCL_ERROR; @@ -136,7 +136,7 @@ static int pager_rollback( return TCL_ERROR; } pPager = sqlite3TextToPtr(argv[1]); - rc = sqlite3pager_rollback(pPager); + rc = sqlite3PagerRollback(pPager); if( rc!=SQLITE_OK ){ Tcl_AppendResult(interp, errorName(rc), 0); return TCL_ERROR; @@ -163,7 +163,7 @@ static int pager_commit( return TCL_ERROR; } pPager = sqlite3TextToPtr(argv[1]); - rc = sqlite3pager_commit(pPager); + rc = sqlite3PagerCommit(pPager); if( rc!=SQLITE_OK ){ Tcl_AppendResult(interp, errorName(rc), 0); return TCL_ERROR; @@ -190,7 +190,7 @@ static int pager_stmt_begin( return TCL_ERROR; } pPager = sqlite3TextToPtr(argv[1]); - rc = sqlite3pager_stmt_begin(pPager); + rc = sqlite3PagerStmtBegin(pPager); if( rc!=SQLITE_OK ){ Tcl_AppendResult(interp, errorName(rc), 0); return TCL_ERROR; @@ -217,7 +217,7 @@ static int pager_stmt_rollback( return TCL_ERROR; } pPager = sqlite3TextToPtr(argv[1]); - rc = sqlite3pager_stmt_rollback(pPager); + rc = sqlite3PagerStmtRollback(pPager); if( rc!=SQLITE_OK ){ Tcl_AppendResult(interp, errorName(rc), 0); return TCL_ERROR; @@ -244,7 +244,7 @@ static int pager_stmt_commit( return TCL_ERROR; } pPager = sqlite3TextToPtr(argv[1]); - rc = sqlite3pager_stmt_commit(pPager); + rc = sqlite3PagerStmtCommit(pPager); if( rc!=SQLITE_OK ){ Tcl_AppendResult(interp, errorName(rc), 0); return TCL_ERROR; @@ -271,7 +271,7 @@ static int pager_stats( return TCL_ERROR; } pPager = sqlite3TextToPtr(argv[1]); - a = sqlite3pager_stats(pPager); + a = sqlite3PagerStats(pPager); for(i=0; i<9; i++){ static char *zName[] = { "ref", "page", "max", "size", "state", "err", @@ -304,7 +304,7 @@ static int pager_pagecount( return TCL_ERROR; } pPager = sqlite3TextToPtr(argv[1]); - sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",sqlite3pager_pagecount(pPager)); + sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",sqlite3PagerPagecount(pPager)); Tcl_AppendResult(interp, zBuf, 0); return TCL_OK; } @@ -322,7 +322,7 @@ static int page_get( ){ Pager *pPager; char zBuf[100]; - void *pPage; + DbPage *pPage; int pgno; int rc; if( argc!=3 ){ @@ -332,7 +332,7 @@ static int page_get( } pPager = sqlite3TextToPtr(argv[1]); if( Tcl_GetInt(interp, argv[2], &pgno) ) return TCL_ERROR; - rc = sqlite3pager_get(pPager, pgno, &pPage); + rc = sqlite3PagerGet(pPager, pgno, &pPage); if( rc!=SQLITE_OK ){ Tcl_AppendResult(interp, errorName(rc), 0); return TCL_ERROR; @@ -356,7 +356,7 @@ static int page_lookup( ){ Pager *pPager; char zBuf[100]; - void *pPage; + DbPage *pPage; int pgno; if( argc!=3 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], @@ -365,7 +365,7 @@ static int page_lookup( } pPager = sqlite3TextToPtr(argv[1]); if( Tcl_GetInt(interp, argv[2], &pgno) ) return TCL_ERROR; - pPage = sqlite3pager_lookup(pPager, pgno); + pPage = sqlite3PagerLookup(pPager, pgno); if( pPage ){ sqlite3_snprintf(sizeof(zBuf),zBuf,"%p",pPage); Tcl_AppendResult(interp, zBuf, 0); @@ -392,7 +392,7 @@ static int pager_truncate( } pPager = sqlite3TextToPtr(argv[1]); if( Tcl_GetInt(interp, argv[2], &pgno) ) return TCL_ERROR; - rc = sqlite3pager_truncate(pPager, pgno); + rc = sqlite3PagerTruncate(pPager, pgno); if( rc!=SQLITE_OK ){ Tcl_AppendResult(interp, errorName(rc), 0); return TCL_ERROR; @@ -412,15 +412,15 @@ static int page_unref( int argc, /* Number of arguments */ const char **argv /* Text of each argument */ ){ - void *pPage; + DbPage *pPage; int rc; if( argc!=2 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " PAGE\"", 0); return TCL_ERROR; } - pPage = sqlite3TextToPtr(argv[1]); - rc = sqlite3pager_unref(pPage); + pPage = (DbPage *)sqlite3TextToPtr(argv[1]); + rc = sqlite3PagerUnref(pPage); if( rc!=SQLITE_OK ){ Tcl_AppendResult(interp, errorName(rc), 0); return TCL_ERROR; @@ -440,14 +440,14 @@ static int page_read( const char **argv /* Text of each argument */ ){ char zBuf[100]; - void *pPage; + DbPage *pPage; if( argc!=2 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " PAGE\"", 0); return TCL_ERROR; } pPage = sqlite3TextToPtr(argv[1]); - memcpy(zBuf, pPage, sizeof(zBuf)); + memcpy(zBuf, sqlite3PagerGetData(pPage), sizeof(zBuf)); Tcl_AppendResult(interp, zBuf, 0); return TCL_OK; } @@ -464,14 +464,14 @@ static int page_number( const char **argv /* Text of each argument */ ){ char zBuf[100]; - void *pPage; + DbPage *pPage; if( argc!=2 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " PAGE\"", 0); return TCL_ERROR; } - pPage = sqlite3TextToPtr(argv[1]); - sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", sqlite3pager_pagenumber(pPage)); + pPage = (DbPage *)sqlite3TextToPtr(argv[1]); + sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", sqlite3PagerPagenumber(pPage)); Tcl_AppendResult(interp, zBuf, 0); return TCL_OK; } @@ -487,21 +487,23 @@ static int page_write( int argc, /* Number of arguments */ const char **argv /* Text of each argument */ ){ - void *pPage; + DbPage *pPage; + char *pData; int rc; if( argc!=3 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " PAGE DATA\"", 0); return TCL_ERROR; } - pPage = sqlite3TextToPtr(argv[1]); - rc = sqlite3pager_write(pPage); + pPage = (DbPage *)sqlite3TextToPtr(argv[1]); + rc = sqlite3PagerWrite(pPage); if( rc!=SQLITE_OK ){ Tcl_AppendResult(interp, errorName(rc), 0); return TCL_ERROR; } - strncpy((char*)pPage, argv[2], test_pagesize-1); - ((char*)pPage)[test_pagesize-1] = 0; + pData = sqlite3PagerGetData(pPage); + strncpy(pData, argv[2], test_pagesize-1); + pData[test_pagesize-1] = 0; return TCL_OK; } diff --git a/src/test3.c b/src/test3.c index 99753ab6d..8a2d51531 100644 --- a/src/test3.c +++ b/src/test3.c @@ -13,7 +13,7 @@ ** is not included in the SQLite library. It is used for automated ** testing of the SQLite library. ** -** $Id: test3.c,v 1.70 2007/02/10 19:22:36 drh Exp $ +** $Id: test3.c,v 1.71 2007/03/19 17:44:28 danielk1977 Exp $ */ #include "sqliteInt.h" #include "pager.h" @@ -511,7 +511,7 @@ static int btree_pager_stats( return TCL_ERROR; } pBt = sqlite3TextToPtr(argv[1]); - a = sqlite3pager_stats(sqlite3BtreePager(pBt)); + a = sqlite3PagerStats(sqlite3BtreePager(pBt)); for(i=0; i<11; i++){ static char *zName[] = { "ref", "page", "max", "size", "state", "err", @@ -545,7 +545,7 @@ static int btree_pager_ref_dump( } pBt = sqlite3TextToPtr(argv[1]); #ifdef SQLITE_DEBUG - sqlite3pager_refdump(sqlite3BtreePager(pBt)); + sqlite3PagerRefdump(sqlite3BtreePager(pBt)); #endif return TCL_OK; } @@ -1282,15 +1282,17 @@ static int btree_ovfl_info( n = (n + dataSize - 1)/dataSize; pgno = (u32)aResult[10]; while( pgno && n-- ){ + DbPage *pDbPage; sprintf(zElem, "%d", pgno); Tcl_DStringAppendElement(&str, zElem); - if( sqlite3pager_get(pPager, pgno, &pPage)!=SQLITE_OK ){ + if( sqlite3PagerGet(pPager, pgno, &pDbPage)!=SQLITE_OK ){ Tcl_DStringFree(&str); Tcl_AppendResult(interp, "unable to get page ", zElem, 0); return TCL_ERROR; } + pPage = sqlite3PagerGetData(pDbPage); pgno = get4byte((unsigned char*)pPage); - sqlite3pager_unref(pPage); + sqlite3PagerUnref(pDbPage); } Tcl_DStringResult(interp, &str); return SQLITE_OK; diff --git a/src/util.c b/src/util.c index a160473e1..96d82e7a0 100644 --- a/src/util.c +++ b/src/util.c @@ -14,7 +14,7 @@ ** This file contains functions for allocating memory, comparing ** strings, and stuff like that. ** -** $Id: util.c,v 1.194 2007/03/15 15:33:32 danielk1977 Exp $ +** $Id: util.c,v 1.195 2007/03/19 17:44:28 danielk1977 Exp $ */ #include "sqliteInt.h" #include "os.h" @@ -83,7 +83,7 @@ void sqlite3_soft_heap_limit(int n){ ** Release memory held by SQLite instances created by the current thread. */ int sqlite3_release_memory(int n){ - return sqlite3pager_release_memory(n); + return sqlite3PagerReleaseMemory(n); } #else /* If SQLITE_ENABLE_MEMORY_MANAGEMENT is not defined, then define a version |