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