Annotation of embedaddon/sqlite3/src/memjournal.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2008 October 7
! 3: **
! 4: ** The author disclaims copyright to this source code. In place of
! 5: ** a legal notice, here is a blessing:
! 6: **
! 7: ** May you do good and not evil.
! 8: ** May you find forgiveness for yourself and forgive others.
! 9: ** May you share freely, never taking more than you give.
! 10: **
! 11: *************************************************************************
! 12: **
! 13: ** This file contains code use to implement an in-memory rollback journal.
! 14: ** The in-memory rollback journal is used to journal transactions for
! 15: ** ":memory:" databases and when the journal_mode=MEMORY pragma is used.
! 16: */
! 17: #include "sqliteInt.h"
! 18:
! 19: /* Forward references to internal structures */
! 20: typedef struct MemJournal MemJournal;
! 21: typedef struct FilePoint FilePoint;
! 22: typedef struct FileChunk FileChunk;
! 23:
! 24: /* Space to hold the rollback journal is allocated in increments of
! 25: ** this many bytes.
! 26: **
! 27: ** The size chosen is a little less than a power of two. That way,
! 28: ** the FileChunk object will have a size that almost exactly fills
! 29: ** a power-of-two allocation. This mimimizes wasted space in power-of-two
! 30: ** memory allocators.
! 31: */
! 32: #define JOURNAL_CHUNKSIZE ((int)(1024-sizeof(FileChunk*)))
! 33:
! 34: /* Macro to find the minimum of two numeric values.
! 35: */
! 36: #ifndef MIN
! 37: # define MIN(x,y) ((x)<(y)?(x):(y))
! 38: #endif
! 39:
! 40: /*
! 41: ** The rollback journal is composed of a linked list of these structures.
! 42: */
! 43: struct FileChunk {
! 44: FileChunk *pNext; /* Next chunk in the journal */
! 45: u8 zChunk[JOURNAL_CHUNKSIZE]; /* Content of this chunk */
! 46: };
! 47:
! 48: /*
! 49: ** An instance of this object serves as a cursor into the rollback journal.
! 50: ** The cursor can be either for reading or writing.
! 51: */
! 52: struct FilePoint {
! 53: sqlite3_int64 iOffset; /* Offset from the beginning of the file */
! 54: FileChunk *pChunk; /* Specific chunk into which cursor points */
! 55: };
! 56:
! 57: /*
! 58: ** This subclass is a subclass of sqlite3_file. Each open memory-journal
! 59: ** is an instance of this class.
! 60: */
! 61: struct MemJournal {
! 62: sqlite3_io_methods *pMethod; /* Parent class. MUST BE FIRST */
! 63: FileChunk *pFirst; /* Head of in-memory chunk-list */
! 64: FilePoint endpoint; /* Pointer to the end of the file */
! 65: FilePoint readpoint; /* Pointer to the end of the last xRead() */
! 66: };
! 67:
! 68: /*
! 69: ** Read data from the in-memory journal file. This is the implementation
! 70: ** of the sqlite3_vfs.xRead method.
! 71: */
! 72: static int memjrnlRead(
! 73: sqlite3_file *pJfd, /* The journal file from which to read */
! 74: void *zBuf, /* Put the results here */
! 75: int iAmt, /* Number of bytes to read */
! 76: sqlite_int64 iOfst /* Begin reading at this offset */
! 77: ){
! 78: MemJournal *p = (MemJournal *)pJfd;
! 79: u8 *zOut = zBuf;
! 80: int nRead = iAmt;
! 81: int iChunkOffset;
! 82: FileChunk *pChunk;
! 83:
! 84: /* SQLite never tries to read past the end of a rollback journal file */
! 85: assert( iOfst+iAmt<=p->endpoint.iOffset );
! 86:
! 87: if( p->readpoint.iOffset!=iOfst || iOfst==0 ){
! 88: sqlite3_int64 iOff = 0;
! 89: for(pChunk=p->pFirst;
! 90: ALWAYS(pChunk) && (iOff+JOURNAL_CHUNKSIZE)<=iOfst;
! 91: pChunk=pChunk->pNext
! 92: ){
! 93: iOff += JOURNAL_CHUNKSIZE;
! 94: }
! 95: }else{
! 96: pChunk = p->readpoint.pChunk;
! 97: }
! 98:
! 99: iChunkOffset = (int)(iOfst%JOURNAL_CHUNKSIZE);
! 100: do {
! 101: int iSpace = JOURNAL_CHUNKSIZE - iChunkOffset;
! 102: int nCopy = MIN(nRead, (JOURNAL_CHUNKSIZE - iChunkOffset));
! 103: memcpy(zOut, &pChunk->zChunk[iChunkOffset], nCopy);
! 104: zOut += nCopy;
! 105: nRead -= iSpace;
! 106: iChunkOffset = 0;
! 107: } while( nRead>=0 && (pChunk=pChunk->pNext)!=0 && nRead>0 );
! 108: p->readpoint.iOffset = iOfst+iAmt;
! 109: p->readpoint.pChunk = pChunk;
! 110:
! 111: return SQLITE_OK;
! 112: }
! 113:
! 114: /*
! 115: ** Write data to the file.
! 116: */
! 117: static int memjrnlWrite(
! 118: sqlite3_file *pJfd, /* The journal file into which to write */
! 119: const void *zBuf, /* Take data to be written from here */
! 120: int iAmt, /* Number of bytes to write */
! 121: sqlite_int64 iOfst /* Begin writing at this offset into the file */
! 122: ){
! 123: MemJournal *p = (MemJournal *)pJfd;
! 124: int nWrite = iAmt;
! 125: u8 *zWrite = (u8 *)zBuf;
! 126:
! 127: /* An in-memory journal file should only ever be appended to. Random
! 128: ** access writes are not required by sqlite.
! 129: */
! 130: assert( iOfst==p->endpoint.iOffset );
! 131: UNUSED_PARAMETER(iOfst);
! 132:
! 133: while( nWrite>0 ){
! 134: FileChunk *pChunk = p->endpoint.pChunk;
! 135: int iChunkOffset = (int)(p->endpoint.iOffset%JOURNAL_CHUNKSIZE);
! 136: int iSpace = MIN(nWrite, JOURNAL_CHUNKSIZE - iChunkOffset);
! 137:
! 138: if( iChunkOffset==0 ){
! 139: /* New chunk is required to extend the file. */
! 140: FileChunk *pNew = sqlite3_malloc(sizeof(FileChunk));
! 141: if( !pNew ){
! 142: return SQLITE_IOERR_NOMEM;
! 143: }
! 144: pNew->pNext = 0;
! 145: if( pChunk ){
! 146: assert( p->pFirst );
! 147: pChunk->pNext = pNew;
! 148: }else{
! 149: assert( !p->pFirst );
! 150: p->pFirst = pNew;
! 151: }
! 152: p->endpoint.pChunk = pNew;
! 153: }
! 154:
! 155: memcpy(&p->endpoint.pChunk->zChunk[iChunkOffset], zWrite, iSpace);
! 156: zWrite += iSpace;
! 157: nWrite -= iSpace;
! 158: p->endpoint.iOffset += iSpace;
! 159: }
! 160:
! 161: return SQLITE_OK;
! 162: }
! 163:
! 164: /*
! 165: ** Truncate the file.
! 166: */
! 167: static int memjrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){
! 168: MemJournal *p = (MemJournal *)pJfd;
! 169: FileChunk *pChunk;
! 170: assert(size==0);
! 171: UNUSED_PARAMETER(size);
! 172: pChunk = p->pFirst;
! 173: while( pChunk ){
! 174: FileChunk *pTmp = pChunk;
! 175: pChunk = pChunk->pNext;
! 176: sqlite3_free(pTmp);
! 177: }
! 178: sqlite3MemJournalOpen(pJfd);
! 179: return SQLITE_OK;
! 180: }
! 181:
! 182: /*
! 183: ** Close the file.
! 184: */
! 185: static int memjrnlClose(sqlite3_file *pJfd){
! 186: memjrnlTruncate(pJfd, 0);
! 187: return SQLITE_OK;
! 188: }
! 189:
! 190:
! 191: /*
! 192: ** Sync the file.
! 193: **
! 194: ** Syncing an in-memory journal is a no-op. And, in fact, this routine
! 195: ** is never called in a working implementation. This implementation
! 196: ** exists purely as a contingency, in case some malfunction in some other
! 197: ** part of SQLite causes Sync to be called by mistake.
! 198: */
! 199: static int memjrnlSync(sqlite3_file *NotUsed, int NotUsed2){
! 200: UNUSED_PARAMETER2(NotUsed, NotUsed2);
! 201: return SQLITE_OK;
! 202: }
! 203:
! 204: /*
! 205: ** Query the size of the file in bytes.
! 206: */
! 207: static int memjrnlFileSize(sqlite3_file *pJfd, sqlite_int64 *pSize){
! 208: MemJournal *p = (MemJournal *)pJfd;
! 209: *pSize = (sqlite_int64) p->endpoint.iOffset;
! 210: return SQLITE_OK;
! 211: }
! 212:
! 213: /*
! 214: ** Table of methods for MemJournal sqlite3_file object.
! 215: */
! 216: static const struct sqlite3_io_methods MemJournalMethods = {
! 217: 1, /* iVersion */
! 218: memjrnlClose, /* xClose */
! 219: memjrnlRead, /* xRead */
! 220: memjrnlWrite, /* xWrite */
! 221: memjrnlTruncate, /* xTruncate */
! 222: memjrnlSync, /* xSync */
! 223: memjrnlFileSize, /* xFileSize */
! 224: 0, /* xLock */
! 225: 0, /* xUnlock */
! 226: 0, /* xCheckReservedLock */
! 227: 0, /* xFileControl */
! 228: 0, /* xSectorSize */
! 229: 0, /* xDeviceCharacteristics */
! 230: 0, /* xShmMap */
! 231: 0, /* xShmLock */
! 232: 0, /* xShmBarrier */
! 233: 0 /* xShmUnlock */
! 234: };
! 235:
! 236: /*
! 237: ** Open a journal file.
! 238: */
! 239: void sqlite3MemJournalOpen(sqlite3_file *pJfd){
! 240: MemJournal *p = (MemJournal *)pJfd;
! 241: assert( EIGHT_BYTE_ALIGNMENT(p) );
! 242: memset(p, 0, sqlite3MemJournalSize());
! 243: p->pMethod = (sqlite3_io_methods*)&MemJournalMethods;
! 244: }
! 245:
! 246: /*
! 247: ** Return true if the file-handle passed as an argument is
! 248: ** an in-memory journal
! 249: */
! 250: int sqlite3IsMemJournal(sqlite3_file *pJfd){
! 251: return pJfd->pMethods==&MemJournalMethods;
! 252: }
! 253:
! 254: /*
! 255: ** Return the number of bytes required to store a MemJournal file descriptor.
! 256: */
! 257: int sqlite3MemJournalSize(void){
! 258: return sizeof(MemJournal);
! 259: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to memjournal.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src