| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 ** 2007 August 22 | |
| 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 implements a special kind of sqlite3_file object used | |
| 14 ** by SQLite to create journal files if the atomic-write optimization | |
| 15 ** is enabled. | |
| 16 ** | |
| 17 ** The distinctive characteristic of this sqlite3_file is that the | |
| 18 ** actual on disk file is created lazily. When the file is created, | |
| 19 ** the caller specifies a buffer size for an in-memory buffer to | |
| 20 ** be used to service read() and write() requests. The actual file | |
| 21 ** on disk is not created or populated until either: | |
| 22 ** | |
| 23 ** 1) The in-memory representation grows too large for the allocated | |
| 24 ** buffer, or | |
| 25 ** 2) The sqlite3JournalCreate() function is called. | |
| 26 */ | |
| 27 #ifdef SQLITE_ENABLE_ATOMIC_WRITE | |
| 28 #include "sqliteInt.h" | |
| 29 | |
| 30 | |
| 31 /* | |
| 32 ** A JournalFile object is a subclass of sqlite3_file used by | |
| 33 ** as an open file handle for journal files. | |
| 34 */ | |
| 35 struct JournalFile { | |
| 36 sqlite3_io_methods *pMethod; /* I/O methods on journal files */ | |
| 37 int nBuf; /* Size of zBuf[] in bytes */ | |
| 38 char *zBuf; /* Space to buffer journal writes */ | |
| 39 int iSize; /* Amount of zBuf[] currently used */ | |
| 40 int flags; /* xOpen flags */ | |
| 41 sqlite3_vfs *pVfs; /* The "real" underlying VFS */ | |
| 42 sqlite3_file *pReal; /* The "real" underlying file descriptor */ | |
| 43 const char *zJournal; /* Name of the journal file */ | |
| 44 }; | |
| 45 typedef struct JournalFile JournalFile; | |
| 46 | |
| 47 /* | |
| 48 ** If it does not already exists, create and populate the on-disk file | |
| 49 ** for JournalFile p. | |
| 50 */ | |
| 51 static int createFile(JournalFile *p){ | |
| 52 int rc = SQLITE_OK; | |
| 53 if( !p->pReal ){ | |
| 54 sqlite3_file *pReal = (sqlite3_file *)&p[1]; | |
| 55 rc = sqlite3OsOpen(p->pVfs, p->zJournal, pReal, p->flags, 0); | |
| 56 if( rc==SQLITE_OK ){ | |
| 57 p->pReal = pReal; | |
| 58 if( p->iSize>0 ){ | |
| 59 assert(p->iSize<=p->nBuf); | |
| 60 rc = sqlite3OsWrite(p->pReal, p->zBuf, p->iSize, 0); | |
| 61 } | |
| 62 if( rc!=SQLITE_OK ){ | |
| 63 /* If an error occurred while writing to the file, close it before | |
| 64 ** returning. This way, SQLite uses the in-memory journal data to | |
| 65 ** roll back changes made to the internal page-cache before this | |
| 66 ** function was called. */ | |
| 67 sqlite3OsClose(pReal); | |
| 68 p->pReal = 0; | |
| 69 } | |
| 70 } | |
| 71 } | |
| 72 return rc; | |
| 73 } | |
| 74 | |
| 75 /* | |
| 76 ** Close the file. | |
| 77 */ | |
| 78 static int jrnlClose(sqlite3_file *pJfd){ | |
| 79 JournalFile *p = (JournalFile *)pJfd; | |
| 80 if( p->pReal ){ | |
| 81 sqlite3OsClose(p->pReal); | |
| 82 } | |
| 83 sqlite3_free(p->zBuf); | |
| 84 return SQLITE_OK; | |
| 85 } | |
| 86 | |
| 87 /* | |
| 88 ** Read data from the file. | |
| 89 */ | |
| 90 static int jrnlRead( | |
| 91 sqlite3_file *pJfd, /* The journal file from which to read */ | |
| 92 void *zBuf, /* Put the results here */ | |
| 93 int iAmt, /* Number of bytes to read */ | |
| 94 sqlite_int64 iOfst /* Begin reading at this offset */ | |
| 95 ){ | |
| 96 int rc = SQLITE_OK; | |
| 97 JournalFile *p = (JournalFile *)pJfd; | |
| 98 if( p->pReal ){ | |
| 99 rc = sqlite3OsRead(p->pReal, zBuf, iAmt, iOfst); | |
| 100 }else if( (iAmt+iOfst)>p->iSize ){ | |
| 101 rc = SQLITE_IOERR_SHORT_READ; | |
| 102 }else{ | |
| 103 memcpy(zBuf, &p->zBuf[iOfst], iAmt); | |
| 104 } | |
| 105 return rc; | |
| 106 } | |
| 107 | |
| 108 /* | |
| 109 ** Write data to the file. | |
| 110 */ | |
| 111 static int jrnlWrite( | |
| 112 sqlite3_file *pJfd, /* The journal file into which to write */ | |
| 113 const void *zBuf, /* Take data to be written from here */ | |
| 114 int iAmt, /* Number of bytes to write */ | |
| 115 sqlite_int64 iOfst /* Begin writing at this offset into the file */ | |
| 116 ){ | |
| 117 int rc = SQLITE_OK; | |
| 118 JournalFile *p = (JournalFile *)pJfd; | |
| 119 if( !p->pReal && (iOfst+iAmt)>p->nBuf ){ | |
| 120 rc = createFile(p); | |
| 121 } | |
| 122 if( rc==SQLITE_OK ){ | |
| 123 if( p->pReal ){ | |
| 124 rc = sqlite3OsWrite(p->pReal, zBuf, iAmt, iOfst); | |
| 125 }else{ | |
| 126 memcpy(&p->zBuf[iOfst], zBuf, iAmt); | |
| 127 if( p->iSize<(iOfst+iAmt) ){ | |
| 128 p->iSize = (iOfst+iAmt); | |
| 129 } | |
| 130 } | |
| 131 } | |
| 132 return rc; | |
| 133 } | |
| 134 | |
| 135 /* | |
| 136 ** Truncate the file. | |
| 137 */ | |
| 138 static int jrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){ | |
| 139 int rc = SQLITE_OK; | |
| 140 JournalFile *p = (JournalFile *)pJfd; | |
| 141 if( p->pReal ){ | |
| 142 rc = sqlite3OsTruncate(p->pReal, size); | |
| 143 }else if( size<p->iSize ){ | |
| 144 p->iSize = size; | |
| 145 } | |
| 146 return rc; | |
| 147 } | |
| 148 | |
| 149 /* | |
| 150 ** Sync the file. | |
| 151 */ | |
| 152 static int jrnlSync(sqlite3_file *pJfd, int flags){ | |
| 153 int rc; | |
| 154 JournalFile *p = (JournalFile *)pJfd; | |
| 155 if( p->pReal ){ | |
| 156 rc = sqlite3OsSync(p->pReal, flags); | |
| 157 }else{ | |
| 158 rc = SQLITE_OK; | |
| 159 } | |
| 160 return rc; | |
| 161 } | |
| 162 | |
| 163 /* | |
| 164 ** Query the size of the file in bytes. | |
| 165 */ | |
| 166 static int jrnlFileSize(sqlite3_file *pJfd, sqlite_int64 *pSize){ | |
| 167 int rc = SQLITE_OK; | |
| 168 JournalFile *p = (JournalFile *)pJfd; | |
| 169 if( p->pReal ){ | |
| 170 rc = sqlite3OsFileSize(p->pReal, pSize); | |
| 171 }else{ | |
| 172 *pSize = (sqlite_int64) p->iSize; | |
| 173 } | |
| 174 return rc; | |
| 175 } | |
| 176 | |
| 177 /* | |
| 178 ** Table of methods for JournalFile sqlite3_file object. | |
| 179 */ | |
| 180 static struct sqlite3_io_methods JournalFileMethods = { | |
| 181 1, /* iVersion */ | |
| 182 jrnlClose, /* xClose */ | |
| 183 jrnlRead, /* xRead */ | |
| 184 jrnlWrite, /* xWrite */ | |
| 185 jrnlTruncate, /* xTruncate */ | |
| 186 jrnlSync, /* xSync */ | |
| 187 jrnlFileSize, /* xFileSize */ | |
| 188 0, /* xLock */ | |
| 189 0, /* xUnlock */ | |
| 190 0, /* xCheckReservedLock */ | |
| 191 0, /* xFileControl */ | |
| 192 0, /* xSectorSize */ | |
| 193 0, /* xDeviceCharacteristics */ | |
| 194 0, /* xShmMap */ | |
| 195 0, /* xShmLock */ | |
| 196 0, /* xShmBarrier */ | |
| 197 0 /* xShmUnmap */ | |
| 198 }; | |
| 199 | |
| 200 /* | |
| 201 ** Open a journal file. | |
| 202 */ | |
| 203 int sqlite3JournalOpen( | |
| 204 sqlite3_vfs *pVfs, /* The VFS to use for actual file I/O */ | |
| 205 const char *zName, /* Name of the journal file */ | |
| 206 sqlite3_file *pJfd, /* Preallocated, blank file handle */ | |
| 207 int flags, /* Opening flags */ | |
| 208 int nBuf /* Bytes buffered before opening the file */ | |
| 209 ){ | |
| 210 JournalFile *p = (JournalFile *)pJfd; | |
| 211 memset(p, 0, sqlite3JournalSize(pVfs)); | |
| 212 if( nBuf>0 ){ | |
| 213 p->zBuf = sqlite3MallocZero(nBuf); | |
| 214 if( !p->zBuf ){ | |
| 215 return SQLITE_NOMEM; | |
| 216 } | |
| 217 }else{ | |
| 218 return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0); | |
| 219 } | |
| 220 p->pMethod = &JournalFileMethods; | |
| 221 p->nBuf = nBuf; | |
| 222 p->flags = flags; | |
| 223 p->zJournal = zName; | |
| 224 p->pVfs = pVfs; | |
| 225 return SQLITE_OK; | |
| 226 } | |
| 227 | |
| 228 /* | |
| 229 ** If the argument p points to a JournalFile structure, and the underlying | |
| 230 ** file has not yet been created, create it now. | |
| 231 */ | |
| 232 int sqlite3JournalCreate(sqlite3_file *p){ | |
| 233 if( p->pMethods!=&JournalFileMethods ){ | |
| 234 return SQLITE_OK; | |
| 235 } | |
| 236 return createFile((JournalFile *)p); | |
| 237 } | |
| 238 | |
| 239 /* | |
| 240 ** The file-handle passed as the only argument is guaranteed to be an open | |
| 241 ** file. It may or may not be of class JournalFile. If the file is a | |
| 242 ** JournalFile, and the underlying file on disk has not yet been opened, | |
| 243 ** return 0. Otherwise, return 1. | |
| 244 */ | |
| 245 int sqlite3JournalExists(sqlite3_file *p){ | |
| 246 return (p->pMethods!=&JournalFileMethods || ((JournalFile *)p)->pReal!=0); | |
| 247 } | |
| 248 | |
| 249 /* | |
| 250 ** Return the number of bytes required to store a JournalFile that uses vfs | |
| 251 ** pVfs to create the underlying on-disk files. | |
| 252 */ | |
| 253 int sqlite3JournalSize(sqlite3_vfs *pVfs){ | |
| 254 return (pVfs->szOsFile+sizeof(JournalFile)); | |
| 255 } | |
| 256 #endif | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2363173002:
[sqlite] Remove obsolete reference version 3.8.7.4. (Closed)
