aboutsummaryrefslogtreecommitdiff
path: root/src/pager.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/pager.c')
-rw-r--r--src/pager.c265
1 files changed, 135 insertions, 130 deletions
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;
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-22 14:22:12 +0000