src/third_party/sqlite/src/src/test_demovfs.c

   1 /*
   2 ** 2010 April 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 ** An example of a simple VFS implementation that omits complex features
  14 ** often not required or not possible on embedded platforms. Also includes
  15 ** code to buffer writes to the journal file, which can be a significant
  16 ** performance improvement on some embedded platforms.
  17 **
  18 */
  19
  20 /*
  21 ** OVERVIEW
  22 **
  23 **   The code in this file implements a minimal SQLite VFS that can be
  24 **   used on Linux and other posix-like operating systems. The following
  25 **   system calls are used:
  26 **
  27 **    File-system: access(), unlink(), getcwd()
  28 **    File IO:     open(), read(), write(), fsync(), close(), fstat()
  29 **    Other:       sleep(), usleep(), time()
  30 **
  31 **   The following VFS features are omitted:
  32 **
  33 **     1. File locking. The user must ensure that there is at most one
  34 **        connection to each database when using this VFS. Multiple
  35 **        connections to a single shared-cache count as a single connection
  36 **        for the purposes of the previous statement.
  37 **
  38 **     2. The loading of dynamic extensions (shared libraries).
  39 **
  40 **     3. Temporary files. The user must configure SQLite to use in-memory
  41 **        temp files when using this VFS. The easiest way to do this is to
  42 **        compile with:
  43 **
  44 **          -DSQLITE_TEMP_STORE=3
  45 **
  46 **     4. File truncation. As of version 3.6.24, SQLite may run without
  47 **        a working xTruncate() call, providing the user does not configure
  48 **        SQLite to use "journal_mode=truncate", or use both
  49 **        "journal_mode=persist" and ATTACHed databases.
  50 **
  51 **   It is assumed that the system uses UNIX-like path-names. Specifically,
  52 **   that '/' characters are used to separate path components and that
  53 **   a path-name is a relative path unless it begins with a '/'. And that
  54 **   no UTF-8 encoded paths are greater than 512 bytes in length.
  55 **
  56 ** JOURNAL WRITE-BUFFERING
  57 **
  58 **   To commit a transaction to the database, SQLite first writes rollback
  59 **   information into the journal file. This usually consists of 4 steps:
  60 **
  61 **     1. The rollback information is sequentially written into the journal
  62 **        file, starting at the start of the file.
  63 **     2. The journal file is synced to disk.
  64 **     3. A modification is made to the first few bytes of the journal file.
  65 **     4. The journal file is synced to disk again.
  66 **
  67 **   Most of the data is written in step 1 using a series of calls to the
  68 **   VFS xWrite() method. The buffers passed to the xWrite() calls are of
  69 **   various sizes. For example, as of version 3.6.24, when committing a
  70 **   transaction that modifies 3 pages of a database file that uses 4096
  71 **   byte pages residing on a media with 512 byte sectors, SQLite makes
  72 **   eleven calls to the xWrite() method to create the rollback journal,
  73 **   as follows:
  74 **
  75 **             Write offset | Bytes written
  76 **             ----------------------------
  77 **                        0            512
  78 **                      512              4
  79 **                      516           4096
  80 **                     4612              4
  81 **                     4616              4
  82 **                     4620           4096
  83 **                     8716              4
  84 **                     8720              4
  85 **                     8724           4096
  86 **                    12820              4
  87 **             ++++++++++++SYNC+++++++++++
  88 **                        0             12
  89 **             ++++++++++++SYNC+++++++++++
  90 **
  91 **   On many operating systems, this is an efficient way to write to a file.
  92 **   However, on some embedded systems that do not cache writes in OS
  93 **   buffers it is much more efficient to write data in blocks that are
  94 **   an integer multiple of the sector-size in size and aligned at the
  95 **   start of a sector.
  96 **
  97 **   To work around this, the code in this file allocates a fixed size
  98 **   buffer of SQLITE_DEMOVFS_BUFFERSZ using sqlite3_malloc() whenever a
  99 **   journal file is opened. It uses the buffer to coalesce sequential
 100 **   writes into aligned SQLITE_DEMOVFS_BUFFERSZ blocks. When SQLite
 101 **   invokes the xSync() method to sync the contents of the file to disk,
 102 **   all accumulated data is written out, even if it does not constitute
 103 **   a complete block. This means the actual IO to create the rollback
 104 **   journal for the example transaction above is this:
 105 **
 106 **             Write offset | Bytes written
 107 **             ----------------------------
 108 **                        0           8192
 109 **                     8192           4632
 110 **             ++++++++++++SYNC+++++++++++
 111 **                        0             12
 112 **             ++++++++++++SYNC+++++++++++
 113 **
 114 **   Much more efficient if the underlying OS is not caching write
 115 **   operations.
 116 */
 117
 118 #if !defined(SQLITE_TEST) || SQLITE_OS_UNIX
 119
 120 #include <sqlite3.h>
 121
 122 #include <assert.h>
 123 #include <string.h>
 124 #include <sys/types.h>
 125 #include <sys/stat.h>
 126 #include <sys/file.h>
 127 #include <sys/param.h>
 128 #include <unistd.h>
 129 #include <time.h>
 130 #include <errno.h>
 131
 132 /*
 133 ** Size of the write buffer used by journal files in bytes.
 134 */
 135 #ifndef SQLITE_DEMOVFS_BUFFERSZ
 136 # define SQLITE_DEMOVFS_BUFFERSZ 8192
 137 #endif
 138
 139 /*
 140 ** The maximum pathname length supported by this VFS.
 141 */
 142 #define MAXPATHNAME 512
 143
 144 /*
 145 ** When using this VFS, the sqlite3_file* handles that SQLite uses are
 146 ** actually pointers to instances of type DemoFile.
 147 */
 148 typedef struct DemoFile DemoFile;
 149 struct DemoFile {
 150   sqlite3_file base;              /* Base class. Must be first. */
 151   int fd;                         /* File descriptor */
 152
 153   char *aBuffer;                  /* Pointer to malloc'd buffer */
 154   int nBuffer;                    /* Valid bytes of data in zBuffer */
 155   sqlite3_int64 iBufferOfst;      /* Offset in file of zBuffer[0] */
 156 };
 157
 158 /*
 159 ** Write directly to the file passed as the first argument. Even if the
 160 ** file has a write-buffer (DemoFile.aBuffer), ignore it.
 161 */
 162 static int demoDirectWrite(
 163   DemoFile *p,                    /* File handle */
 164   const void *zBuf,               /* Buffer containing data to write */
 165   int iAmt,                       /* Size of data to write in bytes */
 166   sqlite_int64 iOfst              /* File offset to write to */
 167 ){
 168   off_t ofst;                     /* Return value from lseek() */
 169   size_t nWrite;                  /* Return value from write() */
 170
 171   ofst = lseek(p->fd, iOfst, SEEK_SET);
 172   if( ofst!=iOfst ){
 173     return SQLITE_IOERR_WRITE;
 174   }
 175
 176   nWrite = write(p->fd, zBuf, iAmt);
 177   if( nWrite!=iAmt ){
 178     return SQLITE_IOERR_WRITE;
 179   }
 180
 181   return SQLITE_OK;
 182 }
 183
 184 /*
 185 ** Flush the contents of the DemoFile.aBuffer buffer to disk. This is a
 186 ** no-op if this particular file does not have a buffer (i.e. it is not
 187 ** a journal file) or if the buffer is currently empty.
 188 */
 189 static int demoFlushBuffer(DemoFile *p){
 190   int rc = SQLITE_OK;
 191   if( p->nBuffer ){
 192     rc = demoDirectWrite(p, p->aBuffer, p->nBuffer, p->iBufferOfst);
 193     p->nBuffer = 0;
 194   }
 195   return rc;
 196 }
 197
 198 /*
 199 ** Close a file.
 200 */
 201 static int demoClose(sqlite3_file *pFile){
 202   int rc;
 203   DemoFile *p = (DemoFile*)pFile;
 204   rc = demoFlushBuffer(p);
 205   sqlite3_free(p->aBuffer);
 206   close(p->fd);
 207   return rc;
 208 }
 209
 210 /*
 211 ** Read data from a file.
 212 */
 213 static int demoRead(
 214   sqlite3_file *pFile,
 215   void *zBuf,
 216   int iAmt,
 217   sqlite_int64 iOfst
 218 ){
 219   DemoFile *p = (DemoFile*)pFile;
 220   off_t ofst;                     /* Return value from lseek() */
 221   int nRead;                      /* Return value from read() */
 222   int rc;                         /* Return code from demoFlushBuffer() */
 223
 224   /* Flush any data in the write buffer to disk in case this operation
 225   ** is trying to read data the file-region currently cached in the buffer.
 226   ** It would be possible to detect this case and possibly save an
 227   ** unnecessary write here, but in practice SQLite will rarely read from
 228   ** a journal file when there is data cached in the write-buffer.
 229   */
 230   rc = demoFlushBuffer(p);
 231   if( rc!=SQLITE_OK ){
 232     return rc;
 233   }
 234
 235   ofst = lseek(p->fd, iOfst, SEEK_SET);
 236   if( ofst!=iOfst ){
 237     return SQLITE_IOERR_READ;
 238   }
 239   nRead = read(p->fd, zBuf, iAmt);
 240
 241   if( nRead==iAmt ){
 242     return SQLITE_OK;
 243   }else if( nRead>=0 ){
 244     return SQLITE_IOERR_SHORT_READ;
 245   }
 246
 247   return SQLITE_IOERR_READ;
 248 }
 249
 250 /*
 251 ** Write data to a crash-file.
 252 */
 253 static int demoWrite(
 254   sqlite3_file *pFile,
 255   const void *zBuf,
 256   int iAmt,
 257   sqlite_int64 iOfst
 258 ){
 259   DemoFile *p = (DemoFile*)pFile;
 260
 261   if( p->aBuffer ){
 262     char *z = (char *)zBuf;       /* Pointer to remaining data to write */
 263     int n = iAmt;                 /* Number of bytes at z */
 264     sqlite3_int64 i = iOfst;      /* File offset to write to */
 265
 266     while( n>0 ){
 267       int nCopy;                  /* Number of bytes to copy into buffer */
 268
 269       /* If the buffer is full, or if this data is not being written directly
 270       ** following the data already buffered, flush the buffer. Flushing
 271       ** the buffer is a no-op if it is empty.
 272       */
 273       if( p->nBuffer==SQLITE_DEMOVFS_BUFFERSZ || p->iBufferOfst+p->nBuffer!=i ){
 274         int rc = demoFlushBuffer(p);
 275         if( rc!=SQLITE_OK ){
 276           return rc;
 277         }
 278       }
 279       assert( p->nBuffer==0 || p->iBufferOfst+p->nBuffer==i );
 280       p->iBufferOfst = i - p->nBuffer;
 281
 282       /* Copy as much data as possible into the buffer. */
 283       nCopy = SQLITE_DEMOVFS_BUFFERSZ - p->nBuffer;
 284       if( nCopy>n ){
 285         nCopy = n;
 286       }
 287       memcpy(&p->aBuffer[p->nBuffer], z, nCopy);
 288       p->nBuffer += nCopy;
 289
 290       n -= nCopy;
 291       i += nCopy;
 292       z += nCopy;
 293     }
 294   }else{
 295     return demoDirectWrite(p, zBuf, iAmt, iOfst);
 296   }
 297
 298   return SQLITE_OK;
 299 }
 300
 301 /*
 302 ** Truncate a file. This is a no-op for this VFS (see header comments at
 303 ** the top of the file).
 304 */
 305 static int demoTruncate(sqlite3_file *pFile, sqlite_int64 size){
 306 #if 0
 307   if( ftruncate(((DemoFile *)pFile)->fd, size) ) return SQLITE_IOERR_TRUNCATE;
 308 #endif
 309   return SQLITE_OK;
 310 }
 311
 312 /*
 313 ** Sync the contents of the file to the persistent media.
 314 */
 315 static int demoSync(sqlite3_file *pFile, int flags){
 316   DemoFile *p = (DemoFile*)pFile;
 317   int rc;
 318
 319   rc = demoFlushBuffer(p);
 320   if( rc!=SQLITE_OK ){
 321     return rc;
 322   }
 323
 324   rc = fsync(p->fd);
 325   return (rc==0 ? SQLITE_OK : SQLITE_IOERR_FSYNC);
 326 }
 327
 328 /*
 329 ** Write the size of the file in bytes to *pSize.
 330 */
 331 static int demoFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
 332   DemoFile *p = (DemoFile*)pFile;
 333   int rc;                         /* Return code from fstat() call */
 334   struct stat sStat;              /* Output of fstat() call */
 335
 336   /* Flush the contents of the buffer to disk. As with the flush in the
 337   ** demoRead() method, it would be possible to avoid this and save a write
 338   ** here and there. But in practice this comes up so infrequently it is
 339   ** not worth the trouble.
 340   */
 341   rc = demoFlushBuffer(p);
 342   if( rc!=SQLITE_OK ){
 343     return rc;
 344   }
 345
 346   rc = fstat(p->fd, &sStat);
 347   if( rc!=0 ) return SQLITE_IOERR_FSTAT;
 348   *pSize = sStat.st_size;
 349   return SQLITE_OK;
 350 }
 351
 352 /*
 353 ** Locking functions. The xLock() and xUnlock() methods are both no-ops.
 354 ** The xCheckReservedLock() always indicates that no other process holds
 355 ** a reserved lock on the database file. This ensures that if a hot-journal
 356 ** file is found in the file-system it is rolled back.
 357 */
 358 static int demoLock(sqlite3_file *pFile, int eLock){
 359   return SQLITE_OK;
 360 }
 361 static int demoUnlock(sqlite3_file *pFile, int eLock){
 362   return SQLITE_OK;
 363 }
 364 static int demoCheckReservedLock(sqlite3_file *pFile, int *pResOut){
 365   *pResOut = 0;
 366   return SQLITE_OK;
 367 }
 368
 369 /*
 370 ** No xFileControl() verbs are implemented by this VFS.
 371 */
 372 static int demoFileControl(sqlite3_file *pFile, int op, void *pArg){
 373   return SQLITE_OK;
 374 }
 375
 376 /*
 377 ** The xSectorSize() and xDeviceCharacteristics() methods. These two
 378 ** may return special values allowing SQLite to optimize file-system
 379 ** access to some extent. But it is also safe to simply return 0.
 380 */
 381 static int demoSectorSize(sqlite3_file *pFile){
 382   return 0;
 383 }
 384 static int demoDeviceCharacteristics(sqlite3_file *pFile){
 385   return 0;
 386 }
 387
 388 /*
 389 ** Open a file handle.
 390 */
 391 static int demoOpen(
 392   sqlite3_vfs *pVfs,              /* VFS */
 393   const char *zName,              /* File to open, or 0 for a temp file */
 394   sqlite3_file *pFile,            /* Pointer to DemoFile struct to populate */
 395   int flags,                      /* Input SQLITE_OPEN_XXX flags */
 396   int *pOutFlags                  /* Output SQLITE_OPEN_XXX flags (or NULL) */
 397 ){
 398   static const sqlite3_io_methods demoio = {
 399     1,                            /* iVersion */
 400     demoClose,                    /* xClose */
 401     demoRead,                     /* xRead */
 402     demoWrite,                    /* xWrite */
 403     demoTruncate,                 /* xTruncate */
 404     demoSync,                     /* xSync */
 405     demoFileSize,                 /* xFileSize */
 406     demoLock,                     /* xLock */
 407     demoUnlock,                   /* xUnlock */
 408     demoCheckReservedLock,        /* xCheckReservedLock */
 409     demoFileControl,              /* xFileControl */
 410     demoSectorSize,               /* xSectorSize */
 411     demoDeviceCharacteristics     /* xDeviceCharacteristics */
 412   };
 413
 414   DemoFile *p = (DemoFile*)pFile; /* Populate this structure */
 415   int oflags = 0;                 /* flags to pass to open() call */
 416   char *aBuf = 0;
 417
 418   if( zName==0 ){
 419     return SQLITE_IOERR;
 420   }
 421
 422   if( flags&SQLITE_OPEN_MAIN_JOURNAL ){
 423     aBuf = (char *)sqlite3_malloc(SQLITE_DEMOVFS_BUFFERSZ);
 424     if( !aBuf ){
 425       return SQLITE_NOMEM;
 426     }
 427   }
 428
 429   if( flags&SQLITE_OPEN_EXCLUSIVE ) oflags |= O_EXCL;
 430   if( flags&SQLITE_OPEN_CREATE )    oflags |= O_CREAT;
 431   if( flags&SQLITE_OPEN_READONLY )  oflags |= O_RDONLY;
 432   if( flags&SQLITE_OPEN_READWRITE ) oflags |= O_RDWR;
 433
 434   memset(p, 0, sizeof(DemoFile));
 435   p->fd = open(zName, oflags, 0600);
 436   if( p->fd<0 ){
 437     sqlite3_free(aBuf);
 438     return SQLITE_CANTOPEN;
 439   }
 440   p->aBuffer = aBuf;
 441
 442   if( pOutFlags ){
 443     *pOutFlags = flags;
 444   }
 445   p->base.pMethods = &demoio;
 446   return SQLITE_OK;
 447 }
 448
 449 /*
 450 ** Delete the file identified by argument zPath. If the dirSync parameter
 451 ** is non-zero, then ensure the file-system modification to delete the
 452 ** file has been synced to disk before returning.
 453 */
 454 static int demoDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
 455   int rc;                         /* Return code */
 456
 457   rc = unlink(zPath);
 458   if( rc!=0 && errno==ENOENT ) return SQLITE_OK;
 459
 460   if( rc==0 && dirSync ){
 461     int dfd;                      /* File descriptor open on directory */
 462     int i;                        /* Iterator variable */
 463     char zDir[MAXPATHNAME+1];     /* Name of directory containing file zPath */
 464
 465     /* Figure out the directory name from the path of the file deleted. */
 466     sqlite3_snprintf(MAXPATHNAME, zDir, "%s", zPath);
 467     zDir[MAXPATHNAME] = '\0';
 468     for(i=strlen(zDir); i>1 && zDir[i]!='/'; i++);
 469     zDir[i] = '\0';
 470
 471     /* Open a file-descriptor on the directory. Sync. Close. */
 472     dfd = open(zDir, O_RDONLY, 0);
 473     if( dfd<0 ){
 474       rc = -1;
 475     }else{
 476       rc = fsync(dfd);
 477       close(dfd);
 478     }
 479   }
 480   return (rc==0 ? SQLITE_OK : SQLITE_IOERR_DELETE);
 481 }
 482
 483 #ifndef F_OK
 484 # define F_OK 0
 485 #endif
 486 #ifndef R_OK
 487 # define R_OK 4
 488 #endif
 489 #ifndef W_OK
 490 # define W_OK 2
 491 #endif
 492
 493 /*
 494 ** Query the file-system to see if the named file exists, is readable or
 495 ** is both readable and writable.
 496 */
 497 static int demoAccess(
 498   sqlite3_vfs *pVfs,
 499   const char *zPath,
 500   int flags,
 501   int *pResOut
 502 ){
 503   int rc;                         /* access() return code */
 504   int eAccess = F_OK;             /* Second argument to access() */
 505
 506   assert( flags==SQLITE_ACCESS_EXISTS       /* access(zPath, F_OK) */
 507        || flags==SQLITE_ACCESS_READ         /* access(zPath, R_OK) */
 508        || flags==SQLITE_ACCESS_READWRITE    /* access(zPath, R_OK|W_OK) */
 509   );
 510
 511   if( flags==SQLITE_ACCESS_READWRITE ) eAccess = R_OK|W_OK;
 512   if( flags==SQLITE_ACCESS_READ )      eAccess = R_OK;
 513
 514   rc = access(zPath, eAccess);
 515   *pResOut = (rc==0);
 516   return SQLITE_OK;
 517 }
 518
 519 /*
 520 ** Argument zPath points to a nul-terminated string containing a file path.
 521 ** If zPath is an absolute path, then it is copied as is into the output
 522 ** buffer. Otherwise, if it is a relative path, then the equivalent full
 523 ** path is written to the output buffer.
 524 **
 525 ** This function assumes that paths are UNIX style. Specifically, that:
 526 **
 527 **   1. Path components are separated by a '/'. and
 528 **   2. Full paths begin with a '/' character.
 529 */
 530 static int demoFullPathname(
 531   sqlite3_vfs *pVfs,              /* VFS */
 532   const char *zPath,              /* Input path (possibly a relative path) */
 533   int nPathOut,                   /* Size of output buffer in bytes */
 534   char *zPathOut                  /* Pointer to output buffer */
 535 ){
 536   char zDir[MAXPATHNAME+1];
 537   if( zPath[0]=='/' ){
 538     zDir[0] = '\0';
 539   }else{
 540     getcwd(zDir, sizeof(zDir));
 541   }
 542   zDir[MAXPATHNAME] = '\0';
 543
 544   sqlite3_snprintf(nPathOut, zPathOut, "%s/%s", zDir, zPath);
 545   zPathOut[nPathOut-1] = '\0';
 546
 547   return SQLITE_OK;
 548 }
 549
 550 /*
 551 ** The following four VFS methods:
 552 **
 553 **   xDlOpen
 554 **   xDlError
 555 **   xDlSym
 556 **   xDlClose
 557 **
 558 ** are supposed to implement the functionality needed by SQLite to load
 559 ** extensions compiled as shared objects. This simple VFS does not support
 560 ** this functionality, so the following functions are no-ops.
 561 */
 562 static void *demoDlOpen(sqlite3_vfs *pVfs, const char *zPath){
 563   return 0;
 564 }
 565 static void demoDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
 566   sqlite3_snprintf(nByte, zErrMsg, "Loadable extensions are not supported");
 567   zErrMsg[nByte-1] = '\0';
 568 }
 569 static void (*demoDlSym(sqlite3_vfs *pVfs, void *pH, const char *z))(void){
 570   return 0;
 571 }
 572 static void demoDlClose(sqlite3_vfs *pVfs, void *pHandle){
 573   return;
 574 }
 575
 576 /*
 577 ** Parameter zByte points to a buffer nByte bytes in size. Populate this
 578 ** buffer with pseudo-random data.
 579 */
 580 static int demoRandomness(sqlite3_vfs *pVfs, int nByte, char *zByte){
 581   return SQLITE_OK;
 582 }
 583
 584 /*
 585 ** Sleep for at least nMicro microseconds. Return the (approximate) number
 586 ** of microseconds slept for.
 587 */
 588 static int demoSleep(sqlite3_vfs *pVfs, int nMicro){
 589   sleep(nMicro / 1000000);
 590   usleep(nMicro % 1000000);
 591   return nMicro;
 592 }
 593
 594 /*
 595 ** Set *pTime to the current UTC time expressed as a Julian day. Return
 596 ** SQLITE_OK if successful, or an error code otherwise.
 597 **
 598 **   http://en.wikipedia.org/wiki/Julian_day
 599 **
 600 ** This implementation is not very good. The current time is rounded to
 601 ** an integer number of seconds. Also, assuming time_t is a signed 32-bit
 602 ** value, it will stop working some time in the year 2038 AD (the so-called
 603 ** "year 2038" problem that afflicts systems that store time this way).
 604 */
 605 static int demoCurrentTime(sqlite3_vfs *pVfs, double *pTime){
 606   time_t t = time(0);
 607   *pTime = t/86400.0 + 2440587.5;
 608   return SQLITE_OK;
 609 }
 610
 611 /*
 612 ** This function returns a pointer to the VFS implemented in this file.
 613 ** To make the VFS available to SQLite:
 614 **
 615 **   sqlite3_vfs_register(sqlite3_demovfs(), 0);
 616 */
 617 sqlite3_vfs *sqlite3_demovfs(void){
 618   static sqlite3_vfs demovfs = {
 619     1,                            /* iVersion */
 620     sizeof(DemoFile),             /* szOsFile */
 621     MAXPATHNAME,                  /* mxPathname */
 622     0,                            /* pNext */
 623     "demo",                       /* zName */
 624     0,                            /* pAppData */
 625     demoOpen,                     /* xOpen */
 626     demoDelete,                   /* xDelete */
 627     demoAccess,                   /* xAccess */
 628     demoFullPathname,             /* xFullPathname */
 629     demoDlOpen,                   /* xDlOpen */
 630     demoDlError,                  /* xDlError */
 631     demoDlSym,                    /* xDlSym */
 632     demoDlClose,                  /* xDlClose */
 633     demoRandomness,               /* xRandomness */
 634     demoSleep,                    /* xSleep */
 635     demoCurrentTime,              /* xCurrentTime */
 636   };
 637   return &demovfs;
 638 }
 639
 640 #endif /* !defined(SQLITE_TEST) || SQLITE_OS_UNIX */
 641
 642
 643 #ifdef SQLITE_TEST
 644
 645 #include <tcl.h>
 646
 647 #if SQLITE_OS_UNIX
 648 static int register_demovfs(
 649   ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
 650   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
 651   int objc,              /* Number of arguments */
 652   Tcl_Obj *CONST objv[]  /* Command arguments */
 653 ){
 654   sqlite3_vfs_register(sqlite3_demovfs(), 1);
 655   return TCL_OK;
 656 }
 657 static int unregister_demovfs(
 658   ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
 659   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
 660   int objc,              /* Number of arguments */
 661   Tcl_Obj *CONST objv[]  /* Command arguments */
 662 ){
 663   sqlite3_vfs_unregister(sqlite3_demovfs());
 664   return TCL_OK;
 665 }
 666
 667 /*
 668 ** Register commands with the TCL interpreter.
 669 */
 670 int Sqlitetest_demovfs_Init(Tcl_Interp *interp){
 671   Tcl_CreateObjCommand(interp, "register_demovfs", register_demovfs, 0, 0);
 672   Tcl_CreateObjCommand(interp, "unregister_demovfs", unregister_demovfs, 0, 0);
 673   return TCL_OK;
 674 }
 675
 676 #else
 677 int Sqlitetest_demovfs_Init(Tcl_Interp *interp){ return TCL_OK; }
 678 #endif
 679
 680 #endif /* SQLITE_TEST */