Merge Chromium + Blink git repositories
[chromium-blink-merge.git] / third_party / sqlite / sqlite-src-3080704 / src / journal.c
blobfed27be3e38055d2204395cde6ffc94589fbf5e8
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.
11 *************************************************************************
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.
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:
23 ** 1) The in-memory representation grows too large for the allocated
24 ** buffer, or
25 ** 2) The sqlite3JournalCreate() function is called.
27 #ifdef SQLITE_ENABLE_ATOMIC_WRITE
28 #include "sqliteInt.h"
32 ** A JournalFile object is a subclass of sqlite3_file used by
33 ** as an open file handle for journal files.
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 */
45 typedef struct JournalFile JournalFile;
48 ** If it does not already exists, create and populate the on-disk file
49 ** for JournalFile p.
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);
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;
72 return rc;
76 ** Close the file.
78 static int jrnlClose(sqlite3_file *pJfd){
79 JournalFile *p = (JournalFile *)pJfd;
80 if( p->pReal ){
81 sqlite3OsClose(p->pReal);
83 sqlite3_free(p->zBuf);
84 return SQLITE_OK;
88 ** Read data from the file.
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 */
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);
105 return rc;
109 ** Write data to the file.
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 */
117 int rc = SQLITE_OK;
118 JournalFile *p = (JournalFile *)pJfd;
119 if( !p->pReal && (iOfst+iAmt)>p->nBuf ){
120 rc = createFile(p);
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);
132 return rc;
136 ** Truncate the file.
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;
146 return rc;
150 ** Sync the file.
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;
160 return rc;
164 ** Query the size of the file in bytes.
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;
174 return rc;
178 ** Table of methods for JournalFile sqlite3_file object.
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 */
201 ** Open a journal file.
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 */
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;
217 }else{
218 return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0);
220 p->pMethod = &JournalFileMethods;
221 p->nBuf = nBuf;
222 p->flags = flags;
223 p->zJournal = zName;
224 p->pVfs = pVfs;
225 return SQLITE_OK;
229 ** If the argument p points to a JournalFile structure, and the underlying
230 ** file has not yet been created, create it now.
232 int sqlite3JournalCreate(sqlite3_file *p){
233 if( p->pMethods!=&JournalFileMethods ){
234 return SQLITE_OK;
236 return createFile((JournalFile *)p);
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.
245 int sqlite3JournalExists(sqlite3_file *p){
246 return (p->pMethods!=&JournalFileMethods || ((JournalFile *)p)->pReal!=0);
250 ** Return the number of bytes required to store a JournalFile that uses vfs
251 ** pVfs to create the underlying on-disk files.
253 int sqlite3JournalSize(sqlite3_vfs *pVfs){
254 return (pVfs->szOsFile+sizeof(JournalFile));
256 #endif