e1e2e9acd6
comments to the NGQP and adjust costs slightly. FossilOrigin-Name: 3a72af2a95b04b8e195ef17cb3e9d9021a4f0915
256 lines
7.3 KiB
C
256 lines
7.3 KiB
C
/*
|
|
** 2008 October 7
|
|
**
|
|
** The author disclaims copyright to this source code. In place of
|
|
** a legal notice, here is a blessing:
|
|
**
|
|
** May you do good and not evil.
|
|
** May you find forgiveness for yourself and forgive others.
|
|
** May you share freely, never taking more than you give.
|
|
**
|
|
*************************************************************************
|
|
**
|
|
** This file contains code use to implement an in-memory rollback journal.
|
|
** The in-memory rollback journal is used to journal transactions for
|
|
** ":memory:" databases and when the journal_mode=MEMORY pragma is used.
|
|
*/
|
|
#include "sqliteInt.h"
|
|
|
|
/* Forward references to internal structures */
|
|
typedef struct MemJournal MemJournal;
|
|
typedef struct FilePoint FilePoint;
|
|
typedef struct FileChunk FileChunk;
|
|
|
|
/* Space to hold the rollback journal is allocated in increments of
|
|
** this many bytes.
|
|
**
|
|
** The size chosen is a little less than a power of two. That way,
|
|
** the FileChunk object will have a size that almost exactly fills
|
|
** a power-of-two allocation. This mimimizes wasted space in power-of-two
|
|
** memory allocators.
|
|
*/
|
|
#define JOURNAL_CHUNKSIZE ((int)(1024-sizeof(FileChunk*)))
|
|
|
|
/*
|
|
** The rollback journal is composed of a linked list of these structures.
|
|
*/
|
|
struct FileChunk {
|
|
FileChunk *pNext; /* Next chunk in the journal */
|
|
u8 zChunk[JOURNAL_CHUNKSIZE]; /* Content of this chunk */
|
|
};
|
|
|
|
/*
|
|
** An instance of this object serves as a cursor into the rollback journal.
|
|
** The cursor can be either for reading or writing.
|
|
*/
|
|
struct FilePoint {
|
|
sqlite3_int64 iOffset; /* Offset from the beginning of the file */
|
|
FileChunk *pChunk; /* Specific chunk into which cursor points */
|
|
};
|
|
|
|
/*
|
|
** This subclass is a subclass of sqlite3_file. Each open memory-journal
|
|
** is an instance of this class.
|
|
*/
|
|
struct MemJournal {
|
|
sqlite3_io_methods *pMethod; /* Parent class. MUST BE FIRST */
|
|
FileChunk *pFirst; /* Head of in-memory chunk-list */
|
|
FilePoint endpoint; /* Pointer to the end of the file */
|
|
FilePoint readpoint; /* Pointer to the end of the last xRead() */
|
|
};
|
|
|
|
/*
|
|
** Read data from the in-memory journal file. This is the implementation
|
|
** of the sqlite3_vfs.xRead method.
|
|
*/
|
|
static int memjrnlRead(
|
|
sqlite3_file *pJfd, /* The journal file from which to read */
|
|
void *zBuf, /* Put the results here */
|
|
int iAmt, /* Number of bytes to read */
|
|
sqlite_int64 iOfst /* Begin reading at this offset */
|
|
){
|
|
MemJournal *p = (MemJournal *)pJfd;
|
|
u8 *zOut = zBuf;
|
|
int nRead = iAmt;
|
|
int iChunkOffset;
|
|
FileChunk *pChunk;
|
|
|
|
/* SQLite never tries to read past the end of a rollback journal file */
|
|
assert( iOfst+iAmt<=p->endpoint.iOffset );
|
|
|
|
if( p->readpoint.iOffset!=iOfst || iOfst==0 ){
|
|
sqlite3_int64 iOff = 0;
|
|
for(pChunk=p->pFirst;
|
|
ALWAYS(pChunk) && (iOff+JOURNAL_CHUNKSIZE)<=iOfst;
|
|
pChunk=pChunk->pNext
|
|
){
|
|
iOff += JOURNAL_CHUNKSIZE;
|
|
}
|
|
}else{
|
|
pChunk = p->readpoint.pChunk;
|
|
}
|
|
|
|
iChunkOffset = (int)(iOfst%JOURNAL_CHUNKSIZE);
|
|
do {
|
|
int iSpace = JOURNAL_CHUNKSIZE - iChunkOffset;
|
|
int nCopy = MIN(nRead, (JOURNAL_CHUNKSIZE - iChunkOffset));
|
|
memcpy(zOut, &pChunk->zChunk[iChunkOffset], nCopy);
|
|
zOut += nCopy;
|
|
nRead -= iSpace;
|
|
iChunkOffset = 0;
|
|
} while( nRead>=0 && (pChunk=pChunk->pNext)!=0 && nRead>0 );
|
|
p->readpoint.iOffset = iOfst+iAmt;
|
|
p->readpoint.pChunk = pChunk;
|
|
|
|
return SQLITE_OK;
|
|
}
|
|
|
|
/*
|
|
** Write data to the file.
|
|
*/
|
|
static int memjrnlWrite(
|
|
sqlite3_file *pJfd, /* The journal file into which to write */
|
|
const void *zBuf, /* Take data to be written from here */
|
|
int iAmt, /* Number of bytes to write */
|
|
sqlite_int64 iOfst /* Begin writing at this offset into the file */
|
|
){
|
|
MemJournal *p = (MemJournal *)pJfd;
|
|
int nWrite = iAmt;
|
|
u8 *zWrite = (u8 *)zBuf;
|
|
|
|
/* An in-memory journal file should only ever be appended to. Random
|
|
** access writes are not required by sqlite.
|
|
*/
|
|
assert( iOfst==p->endpoint.iOffset );
|
|
UNUSED_PARAMETER(iOfst);
|
|
|
|
while( nWrite>0 ){
|
|
FileChunk *pChunk = p->endpoint.pChunk;
|
|
int iChunkOffset = (int)(p->endpoint.iOffset%JOURNAL_CHUNKSIZE);
|
|
int iSpace = MIN(nWrite, JOURNAL_CHUNKSIZE - iChunkOffset);
|
|
|
|
if( iChunkOffset==0 ){
|
|
/* New chunk is required to extend the file. */
|
|
FileChunk *pNew = sqlite3_malloc(sizeof(FileChunk));
|
|
if( !pNew ){
|
|
return SQLITE_IOERR_NOMEM;
|
|
}
|
|
pNew->pNext = 0;
|
|
if( pChunk ){
|
|
assert( p->pFirst );
|
|
pChunk->pNext = pNew;
|
|
}else{
|
|
assert( !p->pFirst );
|
|
p->pFirst = pNew;
|
|
}
|
|
p->endpoint.pChunk = pNew;
|
|
}
|
|
|
|
memcpy(&p->endpoint.pChunk->zChunk[iChunkOffset], zWrite, iSpace);
|
|
zWrite += iSpace;
|
|
nWrite -= iSpace;
|
|
p->endpoint.iOffset += iSpace;
|
|
}
|
|
|
|
return SQLITE_OK;
|
|
}
|
|
|
|
/*
|
|
** Truncate the file.
|
|
*/
|
|
static int memjrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){
|
|
MemJournal *p = (MemJournal *)pJfd;
|
|
FileChunk *pChunk;
|
|
assert(size==0);
|
|
UNUSED_PARAMETER(size);
|
|
pChunk = p->pFirst;
|
|
while( pChunk ){
|
|
FileChunk *pTmp = pChunk;
|
|
pChunk = pChunk->pNext;
|
|
sqlite3_free(pTmp);
|
|
}
|
|
sqlite3MemJournalOpen(pJfd);
|
|
return SQLITE_OK;
|
|
}
|
|
|
|
/*
|
|
** Close the file.
|
|
*/
|
|
static int memjrnlClose(sqlite3_file *pJfd){
|
|
memjrnlTruncate(pJfd, 0);
|
|
return SQLITE_OK;
|
|
}
|
|
|
|
|
|
/*
|
|
** Sync the file.
|
|
**
|
|
** Syncing an in-memory journal is a no-op. And, in fact, this routine
|
|
** is never called in a working implementation. This implementation
|
|
** exists purely as a contingency, in case some malfunction in some other
|
|
** part of SQLite causes Sync to be called by mistake.
|
|
*/
|
|
static int memjrnlSync(sqlite3_file *NotUsed, int NotUsed2){
|
|
UNUSED_PARAMETER2(NotUsed, NotUsed2);
|
|
return SQLITE_OK;
|
|
}
|
|
|
|
/*
|
|
** Query the size of the file in bytes.
|
|
*/
|
|
static int memjrnlFileSize(sqlite3_file *pJfd, sqlite_int64 *pSize){
|
|
MemJournal *p = (MemJournal *)pJfd;
|
|
*pSize = (sqlite_int64) p->endpoint.iOffset;
|
|
return SQLITE_OK;
|
|
}
|
|
|
|
/*
|
|
** Table of methods for MemJournal sqlite3_file object.
|
|
*/
|
|
static const struct sqlite3_io_methods MemJournalMethods = {
|
|
1, /* iVersion */
|
|
memjrnlClose, /* xClose */
|
|
memjrnlRead, /* xRead */
|
|
memjrnlWrite, /* xWrite */
|
|
memjrnlTruncate, /* xTruncate */
|
|
memjrnlSync, /* xSync */
|
|
memjrnlFileSize, /* xFileSize */
|
|
0, /* xLock */
|
|
0, /* xUnlock */
|
|
0, /* xCheckReservedLock */
|
|
0, /* xFileControl */
|
|
0, /* xSectorSize */
|
|
0, /* xDeviceCharacteristics */
|
|
0, /* xShmMap */
|
|
0, /* xShmLock */
|
|
0, /* xShmBarrier */
|
|
0, /* xShmUnmap */
|
|
0, /* xFetch */
|
|
0 /* xUnfetch */
|
|
};
|
|
|
|
/*
|
|
** Open a journal file.
|
|
*/
|
|
void sqlite3MemJournalOpen(sqlite3_file *pJfd){
|
|
MemJournal *p = (MemJournal *)pJfd;
|
|
assert( EIGHT_BYTE_ALIGNMENT(p) );
|
|
memset(p, 0, sqlite3MemJournalSize());
|
|
p->pMethod = (sqlite3_io_methods*)&MemJournalMethods;
|
|
}
|
|
|
|
/*
|
|
** Return true if the file-handle passed as an argument is
|
|
** an in-memory journal
|
|
*/
|
|
int sqlite3IsMemJournal(sqlite3_file *pJfd){
|
|
return pJfd->pMethods==&MemJournalMethods;
|
|
}
|
|
|
|
/*
|
|
** Return the number of bytes required to store a MemJournal file descriptor.
|
|
*/
|
|
int sqlite3MemJournalSize(void){
|
|
return sizeof(MemJournal);
|
|
}
|