| Index: third_party/sqlite/src/src/test_demovfs.c
|
| diff --git a/third_party/sqlite/src/src/test_demovfs.c b/third_party/sqlite/src/src/test_demovfs.c
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..e56e8065cfbcd3cb73cfbf5d3535265b130998e8
|
| --- /dev/null
|
| +++ b/third_party/sqlite/src/src/test_demovfs.c
|
| @@ -0,0 +1,680 @@
|
| +/*
|
| +** 2010 April 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.
|
| +**
|
| +*************************************************************************
|
| +**
|
| +** An example of a simple VFS implementation that omits complex features
|
| +** often not required or not possible on embedded platforms. Also includes
|
| +** code to buffer writes to the journal file, which can be a significant
|
| +** performance improvement on some embedded platforms.
|
| +**
|
| +*/
|
| +
|
| +/*
|
| +** OVERVIEW
|
| +**
|
| +** The code in this file implements a minimal SQLite VFS that can be
|
| +** used on Linux and other posix-like operating systems. The following
|
| +** system calls are used:
|
| +**
|
| +** File-system: access(), unlink(), getcwd()
|
| +** File IO: open(), read(), write(), fsync(), close(), fstat()
|
| +** Other: sleep(), usleep(), time()
|
| +**
|
| +** The following VFS features are omitted:
|
| +**
|
| +** 1. File locking. The user must ensure that there is at most one
|
| +** connection to each database when using this VFS. Multiple
|
| +** connections to a single shared-cache count as a single connection
|
| +** for the purposes of the previous statement.
|
| +**
|
| +** 2. The loading of dynamic extensions (shared libraries).
|
| +**
|
| +** 3. Temporary files. The user must configure SQLite to use in-memory
|
| +** temp files when using this VFS. The easiest way to do this is to
|
| +** compile with:
|
| +**
|
| +** -DSQLITE_TEMP_STORE=3
|
| +**
|
| +** 4. File truncation. As of version 3.6.24, SQLite may run without
|
| +** a working xTruncate() call, providing the user does not configure
|
| +** SQLite to use "journal_mode=truncate", or use both
|
| +** "journal_mode=persist" and ATTACHed databases.
|
| +**
|
| +** It is assumed that the system uses UNIX-like path-names. Specifically,
|
| +** that '/' characters are used to separate path components and that
|
| +** a path-name is a relative path unless it begins with a '/'. And that
|
| +** no UTF-8 encoded paths are greater than 512 bytes in length.
|
| +**
|
| +** JOURNAL WRITE-BUFFERING
|
| +**
|
| +** To commit a transaction to the database, SQLite first writes rollback
|
| +** information into the journal file. This usually consists of 4 steps:
|
| +**
|
| +** 1. The rollback information is sequentially written into the journal
|
| +** file, starting at the start of the file.
|
| +** 2. The journal file is synced to disk.
|
| +** 3. A modification is made to the first few bytes of the journal file.
|
| +** 4. The journal file is synced to disk again.
|
| +**
|
| +** Most of the data is written in step 1 using a series of calls to the
|
| +** VFS xWrite() method. The buffers passed to the xWrite() calls are of
|
| +** various sizes. For example, as of version 3.6.24, when committing a
|
| +** transaction that modifies 3 pages of a database file that uses 4096
|
| +** byte pages residing on a media with 512 byte sectors, SQLite makes
|
| +** eleven calls to the xWrite() method to create the rollback journal,
|
| +** as follows:
|
| +**
|
| +** Write offset | Bytes written
|
| +** ----------------------------
|
| +** 0 512
|
| +** 512 4
|
| +** 516 4096
|
| +** 4612 4
|
| +** 4616 4
|
| +** 4620 4096
|
| +** 8716 4
|
| +** 8720 4
|
| +** 8724 4096
|
| +** 12820 4
|
| +** ++++++++++++SYNC+++++++++++
|
| +** 0 12
|
| +** ++++++++++++SYNC+++++++++++
|
| +**
|
| +** On many operating systems, this is an efficient way to write to a file.
|
| +** However, on some embedded systems that do not cache writes in OS
|
| +** buffers it is much more efficient to write data in blocks that are
|
| +** an integer multiple of the sector-size in size and aligned at the
|
| +** start of a sector.
|
| +**
|
| +** To work around this, the code in this file allocates a fixed size
|
| +** buffer of SQLITE_DEMOVFS_BUFFERSZ using sqlite3_malloc() whenever a
|
| +** journal file is opened. It uses the buffer to coalesce sequential
|
| +** writes into aligned SQLITE_DEMOVFS_BUFFERSZ blocks. When SQLite
|
| +** invokes the xSync() method to sync the contents of the file to disk,
|
| +** all accumulated data is written out, even if it does not constitute
|
| +** a complete block. This means the actual IO to create the rollback
|
| +** journal for the example transaction above is this:
|
| +**
|
| +** Write offset | Bytes written
|
| +** ----------------------------
|
| +** 0 8192
|
| +** 8192 4632
|
| +** ++++++++++++SYNC+++++++++++
|
| +** 0 12
|
| +** ++++++++++++SYNC+++++++++++
|
| +**
|
| +** Much more efficient if the underlying OS is not caching write
|
| +** operations.
|
| +*/
|
| +
|
| +#if !defined(SQLITE_TEST) || SQLITE_OS_UNIX
|
| +
|
| +#include <sqlite3.h>
|
| +
|
| +#include <assert.h>
|
| +#include <string.h>
|
| +#include <sys/types.h>
|
| +#include <sys/stat.h>
|
| +#include <sys/file.h>
|
| +#include <sys/param.h>
|
| +#include <unistd.h>
|
| +#include <time.h>
|
| +#include <errno.h>
|
| +
|
| +/*
|
| +** Size of the write buffer used by journal files in bytes.
|
| +*/
|
| +#ifndef SQLITE_DEMOVFS_BUFFERSZ
|
| +# define SQLITE_DEMOVFS_BUFFERSZ 8192
|
| +#endif
|
| +
|
| +/*
|
| +** The maximum pathname length supported by this VFS.
|
| +*/
|
| +#define MAXPATHNAME 512
|
| +
|
| +/*
|
| +** When using this VFS, the sqlite3_file* handles that SQLite uses are
|
| +** actually pointers to instances of type DemoFile.
|
| +*/
|
| +typedef struct DemoFile DemoFile;
|
| +struct DemoFile {
|
| + sqlite3_file base; /* Base class. Must be first. */
|
| + int fd; /* File descriptor */
|
| +
|
| + char *aBuffer; /* Pointer to malloc'd buffer */
|
| + int nBuffer; /* Valid bytes of data in zBuffer */
|
| + sqlite3_int64 iBufferOfst; /* Offset in file of zBuffer[0] */
|
| +};
|
| +
|
| +/*
|
| +** Write directly to the file passed as the first argument. Even if the
|
| +** file has a write-buffer (DemoFile.aBuffer), ignore it.
|
| +*/
|
| +static int demoDirectWrite(
|
| + DemoFile *p, /* File handle */
|
| + const void *zBuf, /* Buffer containing data to write */
|
| + int iAmt, /* Size of data to write in bytes */
|
| + sqlite_int64 iOfst /* File offset to write to */
|
| +){
|
| + off_t ofst; /* Return value from lseek() */
|
| + size_t nWrite; /* Return value from write() */
|
| +
|
| + ofst = lseek(p->fd, iOfst, SEEK_SET);
|
| + if( ofst!=iOfst ){
|
| + return SQLITE_IOERR_WRITE;
|
| + }
|
| +
|
| + nWrite = write(p->fd, zBuf, iAmt);
|
| + if( nWrite!=iAmt ){
|
| + return SQLITE_IOERR_WRITE;
|
| + }
|
| +
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Flush the contents of the DemoFile.aBuffer buffer to disk. This is a
|
| +** no-op if this particular file does not have a buffer (i.e. it is not
|
| +** a journal file) or if the buffer is currently empty.
|
| +*/
|
| +static int demoFlushBuffer(DemoFile *p){
|
| + int rc = SQLITE_OK;
|
| + if( p->nBuffer ){
|
| + rc = demoDirectWrite(p, p->aBuffer, p->nBuffer, p->iBufferOfst);
|
| + p->nBuffer = 0;
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Close a file.
|
| +*/
|
| +static int demoClose(sqlite3_file *pFile){
|
| + int rc;
|
| + DemoFile *p = (DemoFile*)pFile;
|
| + rc = demoFlushBuffer(p);
|
| + sqlite3_free(p->aBuffer);
|
| + close(p->fd);
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Read data from a file.
|
| +*/
|
| +static int demoRead(
|
| + sqlite3_file *pFile,
|
| + void *zBuf,
|
| + int iAmt,
|
| + sqlite_int64 iOfst
|
| +){
|
| + DemoFile *p = (DemoFile*)pFile;
|
| + off_t ofst; /* Return value from lseek() */
|
| + int nRead; /* Return value from read() */
|
| + int rc; /* Return code from demoFlushBuffer() */
|
| +
|
| + /* Flush any data in the write buffer to disk in case this operation
|
| + ** is trying to read data the file-region currently cached in the buffer.
|
| + ** It would be possible to detect this case and possibly save an
|
| + ** unnecessary write here, but in practice SQLite will rarely read from
|
| + ** a journal file when there is data cached in the write-buffer.
|
| + */
|
| + rc = demoFlushBuffer(p);
|
| + if( rc!=SQLITE_OK ){
|
| + return rc;
|
| + }
|
| +
|
| + ofst = lseek(p->fd, iOfst, SEEK_SET);
|
| + if( ofst!=iOfst ){
|
| + return SQLITE_IOERR_READ;
|
| + }
|
| + nRead = read(p->fd, zBuf, iAmt);
|
| +
|
| + if( nRead==iAmt ){
|
| + return SQLITE_OK;
|
| + }else if( nRead>=0 ){
|
| + return SQLITE_IOERR_SHORT_READ;
|
| + }
|
| +
|
| + return SQLITE_IOERR_READ;
|
| +}
|
| +
|
| +/*
|
| +** Write data to a crash-file.
|
| +*/
|
| +static int demoWrite(
|
| + sqlite3_file *pFile,
|
| + const void *zBuf,
|
| + int iAmt,
|
| + sqlite_int64 iOfst
|
| +){
|
| + DemoFile *p = (DemoFile*)pFile;
|
| +
|
| + if( p->aBuffer ){
|
| + char *z = (char *)zBuf; /* Pointer to remaining data to write */
|
| + int n = iAmt; /* Number of bytes at z */
|
| + sqlite3_int64 i = iOfst; /* File offset to write to */
|
| +
|
| + while( n>0 ){
|
| + int nCopy; /* Number of bytes to copy into buffer */
|
| +
|
| + /* If the buffer is full, or if this data is not being written directly
|
| + ** following the data already buffered, flush the buffer. Flushing
|
| + ** the buffer is a no-op if it is empty.
|
| + */
|
| + if( p->nBuffer==SQLITE_DEMOVFS_BUFFERSZ || p->iBufferOfst+p->nBuffer!=i ){
|
| + int rc = demoFlushBuffer(p);
|
| + if( rc!=SQLITE_OK ){
|
| + return rc;
|
| + }
|
| + }
|
| + assert( p->nBuffer==0 || p->iBufferOfst+p->nBuffer==i );
|
| + p->iBufferOfst = i - p->nBuffer;
|
| +
|
| + /* Copy as much data as possible into the buffer. */
|
| + nCopy = SQLITE_DEMOVFS_BUFFERSZ - p->nBuffer;
|
| + if( nCopy>n ){
|
| + nCopy = n;
|
| + }
|
| + memcpy(&p->aBuffer[p->nBuffer], z, nCopy);
|
| + p->nBuffer += nCopy;
|
| +
|
| + n -= nCopy;
|
| + i += nCopy;
|
| + z += nCopy;
|
| + }
|
| + }else{
|
| + return demoDirectWrite(p, zBuf, iAmt, iOfst);
|
| + }
|
| +
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Truncate a file. This is a no-op for this VFS (see header comments at
|
| +** the top of the file).
|
| +*/
|
| +static int demoTruncate(sqlite3_file *pFile, sqlite_int64 size){
|
| +#if 0
|
| + if( ftruncate(((DemoFile *)pFile)->fd, size) ) return SQLITE_IOERR_TRUNCATE;
|
| +#endif
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Sync the contents of the file to the persistent media.
|
| +*/
|
| +static int demoSync(sqlite3_file *pFile, int flags){
|
| + DemoFile *p = (DemoFile*)pFile;
|
| + int rc;
|
| +
|
| + rc = demoFlushBuffer(p);
|
| + if( rc!=SQLITE_OK ){
|
| + return rc;
|
| + }
|
| +
|
| + rc = fsync(p->fd);
|
| + return (rc==0 ? SQLITE_OK : SQLITE_IOERR_FSYNC);
|
| +}
|
| +
|
| +/*
|
| +** Write the size of the file in bytes to *pSize.
|
| +*/
|
| +static int demoFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
|
| + DemoFile *p = (DemoFile*)pFile;
|
| + int rc; /* Return code from fstat() call */
|
| + struct stat sStat; /* Output of fstat() call */
|
| +
|
| + /* Flush the contents of the buffer to disk. As with the flush in the
|
| + ** demoRead() method, it would be possible to avoid this and save a write
|
| + ** here and there. But in practice this comes up so infrequently it is
|
| + ** not worth the trouble.
|
| + */
|
| + rc = demoFlushBuffer(p);
|
| + if( rc!=SQLITE_OK ){
|
| + return rc;
|
| + }
|
| +
|
| + rc = fstat(p->fd, &sStat);
|
| + if( rc!=0 ) return SQLITE_IOERR_FSTAT;
|
| + *pSize = sStat.st_size;
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Locking functions. The xLock() and xUnlock() methods are both no-ops.
|
| +** The xCheckReservedLock() always indicates that no other process holds
|
| +** a reserved lock on the database file. This ensures that if a hot-journal
|
| +** file is found in the file-system it is rolled back.
|
| +*/
|
| +static int demoLock(sqlite3_file *pFile, int eLock){
|
| + return SQLITE_OK;
|
| +}
|
| +static int demoUnlock(sqlite3_file *pFile, int eLock){
|
| + return SQLITE_OK;
|
| +}
|
| +static int demoCheckReservedLock(sqlite3_file *pFile, int *pResOut){
|
| + *pResOut = 0;
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** No xFileControl() verbs are implemented by this VFS.
|
| +*/
|
| +static int demoFileControl(sqlite3_file *pFile, int op, void *pArg){
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** The xSectorSize() and xDeviceCharacteristics() methods. These two
|
| +** may return special values allowing SQLite to optimize file-system
|
| +** access to some extent. But it is also safe to simply return 0.
|
| +*/
|
| +static int demoSectorSize(sqlite3_file *pFile){
|
| + return 0;
|
| +}
|
| +static int demoDeviceCharacteristics(sqlite3_file *pFile){
|
| + return 0;
|
| +}
|
| +
|
| +/*
|
| +** Open a file handle.
|
| +*/
|
| +static int demoOpen(
|
| + sqlite3_vfs *pVfs, /* VFS */
|
| + const char *zName, /* File to open, or 0 for a temp file */
|
| + sqlite3_file *pFile, /* Pointer to DemoFile struct to populate */
|
| + int flags, /* Input SQLITE_OPEN_XXX flags */
|
| + int *pOutFlags /* Output SQLITE_OPEN_XXX flags (or NULL) */
|
| +){
|
| + static const sqlite3_io_methods demoio = {
|
| + 1, /* iVersion */
|
| + demoClose, /* xClose */
|
| + demoRead, /* xRead */
|
| + demoWrite, /* xWrite */
|
| + demoTruncate, /* xTruncate */
|
| + demoSync, /* xSync */
|
| + demoFileSize, /* xFileSize */
|
| + demoLock, /* xLock */
|
| + demoUnlock, /* xUnlock */
|
| + demoCheckReservedLock, /* xCheckReservedLock */
|
| + demoFileControl, /* xFileControl */
|
| + demoSectorSize, /* xSectorSize */
|
| + demoDeviceCharacteristics /* xDeviceCharacteristics */
|
| + };
|
| +
|
| + DemoFile *p = (DemoFile*)pFile; /* Populate this structure */
|
| + int oflags = 0; /* flags to pass to open() call */
|
| + char *aBuf = 0;
|
| +
|
| + if( zName==0 ){
|
| + return SQLITE_IOERR;
|
| + }
|
| +
|
| + if( flags&SQLITE_OPEN_MAIN_JOURNAL ){
|
| + aBuf = (char *)sqlite3_malloc(SQLITE_DEMOVFS_BUFFERSZ);
|
| + if( !aBuf ){
|
| + return SQLITE_NOMEM;
|
| + }
|
| + }
|
| +
|
| + if( flags&SQLITE_OPEN_EXCLUSIVE ) oflags |= O_EXCL;
|
| + if( flags&SQLITE_OPEN_CREATE ) oflags |= O_CREAT;
|
| + if( flags&SQLITE_OPEN_READONLY ) oflags |= O_RDONLY;
|
| + if( flags&SQLITE_OPEN_READWRITE ) oflags |= O_RDWR;
|
| +
|
| + memset(p, 0, sizeof(DemoFile));
|
| + p->fd = open(zName, oflags, 0600);
|
| + if( p->fd<0 ){
|
| + sqlite3_free(aBuf);
|
| + return SQLITE_CANTOPEN;
|
| + }
|
| + p->aBuffer = aBuf;
|
| +
|
| + if( pOutFlags ){
|
| + *pOutFlags = flags;
|
| + }
|
| + p->base.pMethods = &demoio;
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Delete the file identified by argument zPath. If the dirSync parameter
|
| +** is non-zero, then ensure the file-system modification to delete the
|
| +** file has been synced to disk before returning.
|
| +*/
|
| +static int demoDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
|
| + int rc; /* Return code */
|
| +
|
| + rc = unlink(zPath);
|
| + if( rc!=0 && errno==ENOENT ) return SQLITE_OK;
|
| +
|
| + if( rc==0 && dirSync ){
|
| + int dfd; /* File descriptor open on directory */
|
| + int i; /* Iterator variable */
|
| + char zDir[MAXPATHNAME+1]; /* Name of directory containing file zPath */
|
| +
|
| + /* Figure out the directory name from the path of the file deleted. */
|
| + sqlite3_snprintf(MAXPATHNAME, zDir, "%s", zPath);
|
| + zDir[MAXPATHNAME] = '\0';
|
| + for(i=strlen(zDir); i>1 && zDir[i]!='/'; i++);
|
| + zDir[i] = '\0';
|
| +
|
| + /* Open a file-descriptor on the directory. Sync. Close. */
|
| + dfd = open(zDir, O_RDONLY, 0);
|
| + if( dfd<0 ){
|
| + rc = -1;
|
| + }else{
|
| + rc = fsync(dfd);
|
| + close(dfd);
|
| + }
|
| + }
|
| + return (rc==0 ? SQLITE_OK : SQLITE_IOERR_DELETE);
|
| +}
|
| +
|
| +#ifndef F_OK
|
| +# define F_OK 0
|
| +#endif
|
| +#ifndef R_OK
|
| +# define R_OK 4
|
| +#endif
|
| +#ifndef W_OK
|
| +# define W_OK 2
|
| +#endif
|
| +
|
| +/*
|
| +** Query the file-system to see if the named file exists, is readable or
|
| +** is both readable and writable.
|
| +*/
|
| +static int demoAccess(
|
| + sqlite3_vfs *pVfs,
|
| + const char *zPath,
|
| + int flags,
|
| + int *pResOut
|
| +){
|
| + int rc; /* access() return code */
|
| + int eAccess = F_OK; /* Second argument to access() */
|
| +
|
| + assert( flags==SQLITE_ACCESS_EXISTS /* access(zPath, F_OK) */
|
| + || flags==SQLITE_ACCESS_READ /* access(zPath, R_OK) */
|
| + || flags==SQLITE_ACCESS_READWRITE /* access(zPath, R_OK|W_OK) */
|
| + );
|
| +
|
| + if( flags==SQLITE_ACCESS_READWRITE ) eAccess = R_OK|W_OK;
|
| + if( flags==SQLITE_ACCESS_READ ) eAccess = R_OK;
|
| +
|
| + rc = access(zPath, eAccess);
|
| + *pResOut = (rc==0);
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Argument zPath points to a nul-terminated string containing a file path.
|
| +** If zPath is an absolute path, then it is copied as is into the output
|
| +** buffer. Otherwise, if it is a relative path, then the equivalent full
|
| +** path is written to the output buffer.
|
| +**
|
| +** This function assumes that paths are UNIX style. Specifically, that:
|
| +**
|
| +** 1. Path components are separated by a '/'. and
|
| +** 2. Full paths begin with a '/' character.
|
| +*/
|
| +static int demoFullPathname(
|
| + sqlite3_vfs *pVfs, /* VFS */
|
| + const char *zPath, /* Input path (possibly a relative path) */
|
| + int nPathOut, /* Size of output buffer in bytes */
|
| + char *zPathOut /* Pointer to output buffer */
|
| +){
|
| + char zDir[MAXPATHNAME+1];
|
| + if( zPath[0]=='/' ){
|
| + zDir[0] = '\0';
|
| + }else{
|
| + getcwd(zDir, sizeof(zDir));
|
| + }
|
| + zDir[MAXPATHNAME] = '\0';
|
| +
|
| + sqlite3_snprintf(nPathOut, zPathOut, "%s/%s", zDir, zPath);
|
| + zPathOut[nPathOut-1] = '\0';
|
| +
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** The following four VFS methods:
|
| +**
|
| +** xDlOpen
|
| +** xDlError
|
| +** xDlSym
|
| +** xDlClose
|
| +**
|
| +** are supposed to implement the functionality needed by SQLite to load
|
| +** extensions compiled as shared objects. This simple VFS does not support
|
| +** this functionality, so the following functions are no-ops.
|
| +*/
|
| +static void *demoDlOpen(sqlite3_vfs *pVfs, const char *zPath){
|
| + return 0;
|
| +}
|
| +static void demoDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
|
| + sqlite3_snprintf(nByte, zErrMsg, "Loadable extensions are not supported");
|
| + zErrMsg[nByte-1] = '\0';
|
| +}
|
| +static void (*demoDlSym(sqlite3_vfs *pVfs, void *pH, const char *z))(void){
|
| + return 0;
|
| +}
|
| +static void demoDlClose(sqlite3_vfs *pVfs, void *pHandle){
|
| + return;
|
| +}
|
| +
|
| +/*
|
| +** Parameter zByte points to a buffer nByte bytes in size. Populate this
|
| +** buffer with pseudo-random data.
|
| +*/
|
| +static int demoRandomness(sqlite3_vfs *pVfs, int nByte, char *zByte){
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Sleep for at least nMicro microseconds. Return the (approximate) number
|
| +** of microseconds slept for.
|
| +*/
|
| +static int demoSleep(sqlite3_vfs *pVfs, int nMicro){
|
| + sleep(nMicro / 1000000);
|
| + usleep(nMicro % 1000000);
|
| + return nMicro;
|
| +}
|
| +
|
| +/*
|
| +** Set *pTime to the current UTC time expressed as a Julian day. Return
|
| +** SQLITE_OK if successful, or an error code otherwise.
|
| +**
|
| +** http://en.wikipedia.org/wiki/Julian_day
|
| +**
|
| +** This implementation is not very good. The current time is rounded to
|
| +** an integer number of seconds. Also, assuming time_t is a signed 32-bit
|
| +** value, it will stop working some time in the year 2038 AD (the so-called
|
| +** "year 2038" problem that afflicts systems that store time this way).
|
| +*/
|
| +static int demoCurrentTime(sqlite3_vfs *pVfs, double *pTime){
|
| + time_t t = time(0);
|
| + *pTime = t/86400.0 + 2440587.5;
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** This function returns a pointer to the VFS implemented in this file.
|
| +** To make the VFS available to SQLite:
|
| +**
|
| +** sqlite3_vfs_register(sqlite3_demovfs(), 0);
|
| +*/
|
| +sqlite3_vfs *sqlite3_demovfs(void){
|
| + static sqlite3_vfs demovfs = {
|
| + 1, /* iVersion */
|
| + sizeof(DemoFile), /* szOsFile */
|
| + MAXPATHNAME, /* mxPathname */
|
| + 0, /* pNext */
|
| + "demo", /* zName */
|
| + 0, /* pAppData */
|
| + demoOpen, /* xOpen */
|
| + demoDelete, /* xDelete */
|
| + demoAccess, /* xAccess */
|
| + demoFullPathname, /* xFullPathname */
|
| + demoDlOpen, /* xDlOpen */
|
| + demoDlError, /* xDlError */
|
| + demoDlSym, /* xDlSym */
|
| + demoDlClose, /* xDlClose */
|
| + demoRandomness, /* xRandomness */
|
| + demoSleep, /* xSleep */
|
| + demoCurrentTime, /* xCurrentTime */
|
| + };
|
| + return &demovfs;
|
| +}
|
| +
|
| +#endif /* !defined(SQLITE_TEST) || SQLITE_OS_UNIX */
|
| +
|
| +
|
| +#ifdef SQLITE_TEST
|
| +
|
| +#include <tcl.h>
|
| +
|
| +#if SQLITE_OS_UNIX
|
| +static int register_demovfs(
|
| + ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
|
| + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
|
| + int objc, /* Number of arguments */
|
| + Tcl_Obj *CONST objv[] /* Command arguments */
|
| +){
|
| + sqlite3_vfs_register(sqlite3_demovfs(), 1);
|
| + return TCL_OK;
|
| +}
|
| +static int unregister_demovfs(
|
| + ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
|
| + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
|
| + int objc, /* Number of arguments */
|
| + Tcl_Obj *CONST objv[] /* Command arguments */
|
| +){
|
| + sqlite3_vfs_unregister(sqlite3_demovfs());
|
| + return TCL_OK;
|
| +}
|
| +
|
| +/*
|
| +** Register commands with the TCL interpreter.
|
| +*/
|
| +int Sqlitetest_demovfs_Init(Tcl_Interp *interp){
|
| + Tcl_CreateObjCommand(interp, "register_demovfs", register_demovfs, 0, 0);
|
| + Tcl_CreateObjCommand(interp, "unregister_demovfs", unregister_demovfs, 0, 0);
|
| + return TCL_OK;
|
| +}
|
| +
|
| +#else
|
| +int Sqlitetest_demovfs_Init(Tcl_Interp *interp){ return TCL_OK; }
|
| +#endif
|
| +
|
| +#endif /* SQLITE_TEST */
|
|
|
Chromium Code Reviews
