#ifndef SQLITE_OMIT_DISKIO

#include "sqliteInt.h"

#include "wal.h"

#if 0

int sqlite3PagerTrace=1; /* True to enable tracing */

#define sqlite3DebugPrintf printf

#define PAGERTRACE(X) if( sqlite3PagerTrace ){ sqlite3DebugPrintf X; }

#define PAGERTRACE(X)

#define PAGERID(p) (SQLITE_PTR_TO_INT(p->fd))

#define FILEHANDLEID(fd) (SQLITE_PTR_TO_INT(fd))

#define PAGER_OPEN 0

#define PAGER_READER 1

#define PAGER_WRITER_LOCKED 2

#define PAGER_WRITER_CACHEMOD 3

#define PAGER_WRITER_DBMOD 4

#define PAGER_WRITER_FINISHED 5

#define PAGER_ERROR 6

#define UNKNOWN_LOCK (EXCLUSIVE_LOCK+1)

#define MAX_SECTOR_SIZE 0x10000

typedef struct PagerSavepoint PagerSavepoint;

struct PagerSavepoint {

};

#define SPILLFLAG_OFF 0x01 /* Never spill cache. Set via pragma */

#define SPILLFLAG_ROLLBACK 0x02 /* Current rolling back, so do not spill */

#define SPILLFLAG_NOSYNC 0x04 /* Spill is ok, but do not sync */

struct Pager {

};

#define PAGER_STAT_HIT 0

#define PAGER_STAT_MISS 1

#define PAGER_STAT_WRITE 2

#define PAGER_STAT_SPILL 3

#ifdef SQLITE_TEST

int sqlite3_pager_readdb_count = 0; /* Number of full pages read from DB */

int sqlite3_pager_writedb_count = 0; /* Number of full pages written to DB */

int sqlite3_pager_writej_count = 0; /* Number of pages written to journal */

# define PAGER_INCR(v) v++

# define PAGER_INCR(v)

static const unsigned char aJournalMagic[] = {

0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7,

};

#define JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8)

#define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize)

#ifdef SQLITE_OMIT_MEMORYDB

# define MEMDB 0

# define MEMDB pPager->memDb

#if SQLITE_MAX_MMAP_SIZE>0

# define USEFETCH(x) ((x)->bUseFetch)

# define USEFETCH(x) 0

#define isOpen(pFd) ((pFd)->pMethods!=0)

#ifdef SQLITE_DIRECT_OVERFLOW_READ

int sqlite3PagerDirectReadOk(Pager *pPager, Pgno pgno){

if( pPager->fd->pMethods==0 ) return 0;

if( sqlite3PCacheIsDirty(pPager->pPCache) ) return 0;

#ifndef SQLITE_OMIT_WAL

if( pPager->pWal ){

u32 iRead = 0;

int rc;

rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iRead);

return (rc==SQLITE_OK && iRead==0);

}

return 1;

}

#ifndef SQLITE_OMIT_WAL

# define pagerUseWal(x) ((x)->pWal!=0)

# define pagerUseWal(x) 0

# define pagerRollbackWal(x) 0

# define pagerWalFrames(v,w,x,y) 0

# define pagerOpenWalIfPresent(z) SQLITE_OK

# define pagerBeginReadTransaction(z) SQLITE_OK

#ifndef NDEBUG

static int assert_pager_state(Pager *p){

Pager *pPager = p;

/* State must be valid. */

assert( p->eState==PAGER_OPEN

|| p->eState==PAGER_READER

|| p->eState==PAGER_WRITER_LOCKED

|| p->eState==PAGER_WRITER_CACHEMOD

|| p->eState==PAGER_WRITER_DBMOD

|| p->eState==PAGER_WRITER_FINISHED

|| p->eState==PAGER_ERROR

);

/* Regardless of the current state, a temp-file connection always behaves

assert( p->tempFile==0 || p->eLock==EXCLUSIVE_LOCK );

assert( p->tempFile==0 || pPager->changeCountDone );

/* If the useJournal flag is clear, the journal-mode must be "OFF".

assert( p->journalMode==PAGER_JOURNALMODE_OFF || p->useJournal );

assert( p->journalMode!=PAGER_JOURNALMODE_OFF || !isOpen(p->jfd) );

/* Check that MEMDB implies noSync. And an in-memory journal. Since

if( MEMDB ){

assert( !isOpen(p->fd) );

assert( p->noSync );

assert( p->journalMode==PAGER_JOURNALMODE_OFF

|| p->journalMode==PAGER_JOURNALMODE_MEMORY

);

assert( p->eState!=PAGER_ERROR && p->eState!=PAGER_OPEN );

assert( pagerUseWal(p)==0 );

}

/* If changeCountDone is set, a RESERVED lock or greater must be held

assert( pPager->changeCountDone==0 || pPager->eLock>=RESERVED_LOCK );

assert( p->eLock!=PENDING_LOCK );

switch( p->eState ){

case PAGER_OPEN:

assert( !MEMDB );

assert( pPager->errCode==SQLITE_OK );

assert( sqlite3PcacheRefCount(pPager->pPCache)==0 || pPager->tempFile );

break;

case PAGER_READER:

assert( pPager->errCode==SQLITE_OK );

assert( p->eLock!=UNKNOWN_LOCK );

assert( p->eLock>=SHARED_LOCK );

break;

case PAGER_WRITER_LOCKED:

assert( p->eLock!=UNKNOWN_LOCK );

assert( pPager->errCode==SQLITE_OK );

if( !pagerUseWal(pPager) ){

assert( p->eLock>=RESERVED_LOCK );

}

assert( pPager->dbSize==pPager->dbOrigSize );

assert( pPager->dbOrigSize==pPager->dbFileSize );

assert( pPager->dbOrigSize==pPager->dbHintSize );

assert( pPager->setSuper==0 );

break;

case PAGER_WRITER_CACHEMOD:

assert( p->eLock!=UNKNOWN_LOCK );

assert( pPager->errCode==SQLITE_OK );

if( !pagerUseWal(pPager) ){

/* It is possible that if journal_mode=wal here that neither the

assert( p->eLock>=RESERVED_LOCK );

assert( isOpen(p->jfd)

|| p->journalMode==PAGER_JOURNALMODE_OFF

|| p->journalMode==PAGER_JOURNALMODE_WAL

);

}

assert( pPager->dbOrigSize==pPager->dbFileSize );

assert( pPager->dbOrigSize==pPager->dbHintSize );

break;

case PAGER_WRITER_DBMOD:

assert( p->eLock==EXCLUSIVE_LOCK );

assert( pPager->errCode==SQLITE_OK );

assert( !pagerUseWal(pPager) );

assert( p->eLock>=EXCLUSIVE_LOCK );

assert( isOpen(p->jfd)

|| p->journalMode==PAGER_JOURNALMODE_OFF

|| p->journalMode==PAGER_JOURNALMODE_WAL

|| (sqlite3OsDeviceCharacteristics(p->fd)&SQLITE_IOCAP_BATCH_ATOMIC)

);

assert( pPager->dbOrigSize<=pPager->dbHintSize );

break;

case PAGER_WRITER_FINISHED:

assert( p->eLock==EXCLUSIVE_LOCK );

assert( pPager->errCode==SQLITE_OK );

assert( !pagerUseWal(pPager) );

assert( isOpen(p->jfd)

|| p->journalMode==PAGER_JOURNALMODE_OFF

|| p->journalMode==PAGER_JOURNALMODE_WAL

|| (sqlite3OsDeviceCharacteristics(p->fd)&SQLITE_IOCAP_BATCH_ATOMIC)

);

break;

case PAGER_ERROR:

/* There must be at least one outstanding reference to the pager if

assert( pPager->errCode!=SQLITE_OK );

assert( sqlite3PcacheRefCount(pPager->pPCache)>0 || pPager->tempFile );

break;

}

return 1;

}

#endif /* ifndef NDEBUG */

#ifdef SQLITE_DEBUG

char *print_pager_state(Pager *p){

static char zRet[1024];

sqlite3_snprintf(1024, zRet,

"Filename: %s\n"

"State: %s errCode=%d\n"

"Lock: %s\n"