Annotation of embedaddon/sqlite3/src/test_onefile.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2007 September 14
! 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: ** OVERVIEW:
! 14: **
! 15: ** This file contains some example code demonstrating how the SQLite
! 16: ** vfs feature can be used to have SQLite operate directly on an
! 17: ** embedded media, without using an intermediate file system.
! 18: **
! 19: ** Because this is only a demo designed to run on a workstation, the
! 20: ** underlying media is simulated using a regular file-system file. The
! 21: ** size of the file is fixed when it is first created (default size 10 MB).
! 22: ** From SQLite's point of view, this space is used to store a single
! 23: ** database file and the journal file.
! 24: **
! 25: ** Any statement journal created is stored in volatile memory obtained
! 26: ** from sqlite3_malloc(). Any attempt to create a temporary database file
! 27: ** will fail (SQLITE_IOERR). To prevent SQLite from attempting this,
! 28: ** it should be configured to store all temporary database files in
! 29: ** main memory (see pragma "temp_store" or the SQLITE_TEMP_STORE compile
! 30: ** time option).
! 31: **
! 32: ** ASSUMPTIONS:
! 33: **
! 34: ** After it has been created, the blob file is accessed using the
! 35: ** following three functions only:
! 36: **
! 37: ** mediaRead(); - Read a 512 byte block from the file.
! 38: ** mediaWrite(); - Write a 512 byte block to the file.
! 39: ** mediaSync(); - Tell the media hardware to sync.
! 40: **
! 41: ** It is assumed that these can be easily implemented by any "real"
! 42: ** media vfs driver adapting this code.
! 43: **
! 44: ** FILE FORMAT:
! 45: **
! 46: ** The basic principle is that the "database file" is stored at the
! 47: ** beginning of the 10 MB blob and grows in a forward direction. The
! 48: ** "journal file" is stored at the end of the 10MB blob and grows
! 49: ** in the reverse direction. If, during a transaction, insufficient
! 50: ** space is available to expand either the journal or database file,
! 51: ** an SQLITE_FULL error is returned. The database file is never allowed
! 52: ** to consume more than 90% of the blob space. If SQLite tries to
! 53: ** create a file larger than this, SQLITE_FULL is returned.
! 54: **
! 55: ** No allowance is made for "wear-leveling", as is required by.
! 56: ** embedded devices in the absence of equivalent hardware features.
! 57: **
! 58: ** The first 512 block byte of the file is reserved for storing the
! 59: ** size of the "database file". It is updated as part of the sync()
! 60: ** operation. On startup, it can only be trusted if no journal file
! 61: ** exists. If a journal-file does exist, then it stores the real size
! 62: ** of the database region. The second and subsequent blocks store the
! 63: ** actual database content.
! 64: **
! 65: ** The size of the "journal file" is not stored persistently in the
! 66: ** file. When the system is running, the size of the journal file is
! 67: ** stored in volatile memory. When recovering from a crash, this vfs
! 68: ** reports a very large size for the journal file. The normal journal
! 69: ** header and checksum mechanisms serve to prevent SQLite from
! 70: ** processing any data that lies past the logical end of the journal.
! 71: **
! 72: ** When SQLite calls OsDelete() to delete the journal file, the final
! 73: ** 512 bytes of the blob (the area containing the first journal header)
! 74: ** are zeroed.
! 75: **
! 76: ** LOCKING:
! 77: **
! 78: ** File locking is a no-op. Only one connection may be open at any one
! 79: ** time using this demo vfs.
! 80: */
! 81:
! 82: #include "sqlite3.h"
! 83: #include <assert.h>
! 84: #include <string.h>
! 85:
! 86: /*
! 87: ** Maximum pathname length supported by the fs backend.
! 88: */
! 89: #define BLOCKSIZE 512
! 90: #define BLOBSIZE 10485760
! 91:
! 92: /*
! 93: ** Name used to identify this VFS.
! 94: */
! 95: #define FS_VFS_NAME "fs"
! 96:
! 97: typedef struct fs_real_file fs_real_file;
! 98: struct fs_real_file {
! 99: sqlite3_file *pFile;
! 100: const char *zName;
! 101: int nDatabase; /* Current size of database region */
! 102: int nJournal; /* Current size of journal region */
! 103: int nBlob; /* Total size of allocated blob */
! 104: int nRef; /* Number of pointers to this structure */
! 105: fs_real_file *pNext;
! 106: fs_real_file **ppThis;
! 107: };
! 108:
! 109: typedef struct fs_file fs_file;
! 110: struct fs_file {
! 111: sqlite3_file base;
! 112: int eType;
! 113: fs_real_file *pReal;
! 114: };
! 115:
! 116: typedef struct tmp_file tmp_file;
! 117: struct tmp_file {
! 118: sqlite3_file base;
! 119: int nSize;
! 120: int nAlloc;
! 121: char *zAlloc;
! 122: };
! 123:
! 124: /* Values for fs_file.eType. */
! 125: #define DATABASE_FILE 1
! 126: #define JOURNAL_FILE 2
! 127:
! 128: /*
! 129: ** Method declarations for fs_file.
! 130: */
! 131: static int fsClose(sqlite3_file*);
! 132: static int fsRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
! 133: static int fsWrite(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst);
! 134: static int fsTruncate(sqlite3_file*, sqlite3_int64 size);
! 135: static int fsSync(sqlite3_file*, int flags);
! 136: static int fsFileSize(sqlite3_file*, sqlite3_int64 *pSize);
! 137: static int fsLock(sqlite3_file*, int);
! 138: static int fsUnlock(sqlite3_file*, int);
! 139: static int fsCheckReservedLock(sqlite3_file*, int *pResOut);
! 140: static int fsFileControl(sqlite3_file*, int op, void *pArg);
! 141: static int fsSectorSize(sqlite3_file*);
! 142: static int fsDeviceCharacteristics(sqlite3_file*);
! 143:
! 144: /*
! 145: ** Method declarations for tmp_file.
! 146: */
! 147: static int tmpClose(sqlite3_file*);
! 148: static int tmpRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
! 149: static int tmpWrite(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst);
! 150: static int tmpTruncate(sqlite3_file*, sqlite3_int64 size);
! 151: static int tmpSync(sqlite3_file*, int flags);
! 152: static int tmpFileSize(sqlite3_file*, sqlite3_int64 *pSize);
! 153: static int tmpLock(sqlite3_file*, int);
! 154: static int tmpUnlock(sqlite3_file*, int);
! 155: static int tmpCheckReservedLock(sqlite3_file*, int *pResOut);
! 156: static int tmpFileControl(sqlite3_file*, int op, void *pArg);
! 157: static int tmpSectorSize(sqlite3_file*);
! 158: static int tmpDeviceCharacteristics(sqlite3_file*);
! 159:
! 160: /*
! 161: ** Method declarations for fs_vfs.
! 162: */
! 163: static int fsOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *);
! 164: static int fsDelete(sqlite3_vfs*, const char *zName, int syncDir);
! 165: static int fsAccess(sqlite3_vfs*, const char *zName, int flags, int *);
! 166: static int fsFullPathname(sqlite3_vfs*, const char *zName, int nOut,char *zOut);
! 167: static void *fsDlOpen(sqlite3_vfs*, const char *zFilename);
! 168: static void fsDlError(sqlite3_vfs*, int nByte, char *zErrMsg);
! 169: static void (*fsDlSym(sqlite3_vfs*,void*, const char *zSymbol))(void);
! 170: static void fsDlClose(sqlite3_vfs*, void*);
! 171: static int fsRandomness(sqlite3_vfs*, int nByte, char *zOut);
! 172: static int fsSleep(sqlite3_vfs*, int microseconds);
! 173: static int fsCurrentTime(sqlite3_vfs*, double*);
! 174:
! 175:
! 176: typedef struct fs_vfs_t fs_vfs_t;
! 177: struct fs_vfs_t {
! 178: sqlite3_vfs base;
! 179: fs_real_file *pFileList;
! 180: sqlite3_vfs *pParent;
! 181: };
! 182:
! 183: static fs_vfs_t fs_vfs = {
! 184: {
! 185: 1, /* iVersion */
! 186: 0, /* szOsFile */
! 187: 0, /* mxPathname */
! 188: 0, /* pNext */
! 189: FS_VFS_NAME, /* zName */
! 190: 0, /* pAppData */
! 191: fsOpen, /* xOpen */
! 192: fsDelete, /* xDelete */
! 193: fsAccess, /* xAccess */
! 194: fsFullPathname, /* xFullPathname */
! 195: fsDlOpen, /* xDlOpen */
! 196: fsDlError, /* xDlError */
! 197: fsDlSym, /* xDlSym */
! 198: fsDlClose, /* xDlClose */
! 199: fsRandomness, /* xRandomness */
! 200: fsSleep, /* xSleep */
! 201: fsCurrentTime, /* xCurrentTime */
! 202: 0 /* xCurrentTimeInt64 */
! 203: },
! 204: 0, /* pFileList */
! 205: 0 /* pParent */
! 206: };
! 207:
! 208: static sqlite3_io_methods fs_io_methods = {
! 209: 1, /* iVersion */
! 210: fsClose, /* xClose */
! 211: fsRead, /* xRead */
! 212: fsWrite, /* xWrite */
! 213: fsTruncate, /* xTruncate */
! 214: fsSync, /* xSync */
! 215: fsFileSize, /* xFileSize */
! 216: fsLock, /* xLock */
! 217: fsUnlock, /* xUnlock */
! 218: fsCheckReservedLock, /* xCheckReservedLock */
! 219: fsFileControl, /* xFileControl */
! 220: fsSectorSize, /* xSectorSize */
! 221: fsDeviceCharacteristics, /* xDeviceCharacteristics */
! 222: 0, /* xShmMap */
! 223: 0, /* xShmLock */
! 224: 0, /* xShmBarrier */
! 225: 0 /* xShmUnmap */
! 226: };
! 227:
! 228:
! 229: static sqlite3_io_methods tmp_io_methods = {
! 230: 1, /* iVersion */
! 231: tmpClose, /* xClose */
! 232: tmpRead, /* xRead */
! 233: tmpWrite, /* xWrite */
! 234: tmpTruncate, /* xTruncate */
! 235: tmpSync, /* xSync */
! 236: tmpFileSize, /* xFileSize */
! 237: tmpLock, /* xLock */
! 238: tmpUnlock, /* xUnlock */
! 239: tmpCheckReservedLock, /* xCheckReservedLock */
! 240: tmpFileControl, /* xFileControl */
! 241: tmpSectorSize, /* xSectorSize */
! 242: tmpDeviceCharacteristics, /* xDeviceCharacteristics */
! 243: 0, /* xShmMap */
! 244: 0, /* xShmLock */
! 245: 0, /* xShmBarrier */
! 246: 0 /* xShmUnmap */
! 247: };
! 248:
! 249: /* Useful macros used in several places */
! 250: #define MIN(x,y) ((x)<(y)?(x):(y))
! 251: #define MAX(x,y) ((x)>(y)?(x):(y))
! 252:
! 253:
! 254: /*
! 255: ** Close a tmp-file.
! 256: */
! 257: static int tmpClose(sqlite3_file *pFile){
! 258: tmp_file *pTmp = (tmp_file *)pFile;
! 259: sqlite3_free(pTmp->zAlloc);
! 260: return SQLITE_OK;
! 261: }
! 262:
! 263: /*
! 264: ** Read data from a tmp-file.
! 265: */
! 266: static int tmpRead(
! 267: sqlite3_file *pFile,
! 268: void *zBuf,
! 269: int iAmt,
! 270: sqlite_int64 iOfst
! 271: ){
! 272: tmp_file *pTmp = (tmp_file *)pFile;
! 273: if( (iAmt+iOfst)>pTmp->nSize ){
! 274: return SQLITE_IOERR_SHORT_READ;
! 275: }
! 276: memcpy(zBuf, &pTmp->zAlloc[iOfst], iAmt);
! 277: return SQLITE_OK;
! 278: }
! 279:
! 280: /*
! 281: ** Write data to a tmp-file.
! 282: */
! 283: static int tmpWrite(
! 284: sqlite3_file *pFile,
! 285: const void *zBuf,
! 286: int iAmt,
! 287: sqlite_int64 iOfst
! 288: ){
! 289: tmp_file *pTmp = (tmp_file *)pFile;
! 290: if( (iAmt+iOfst)>pTmp->nAlloc ){
! 291: int nNew = 2*(iAmt+iOfst+pTmp->nAlloc);
! 292: char *zNew = sqlite3_realloc(pTmp->zAlloc, nNew);
! 293: if( !zNew ){
! 294: return SQLITE_NOMEM;
! 295: }
! 296: pTmp->zAlloc = zNew;
! 297: pTmp->nAlloc = nNew;
! 298: }
! 299: memcpy(&pTmp->zAlloc[iOfst], zBuf, iAmt);
! 300: pTmp->nSize = MAX(pTmp->nSize, iOfst+iAmt);
! 301: return SQLITE_OK;
! 302: }
! 303:
! 304: /*
! 305: ** Truncate a tmp-file.
! 306: */
! 307: static int tmpTruncate(sqlite3_file *pFile, sqlite_int64 size){
! 308: tmp_file *pTmp = (tmp_file *)pFile;
! 309: pTmp->nSize = MIN(pTmp->nSize, size);
! 310: return SQLITE_OK;
! 311: }
! 312:
! 313: /*
! 314: ** Sync a tmp-file.
! 315: */
! 316: static int tmpSync(sqlite3_file *pFile, int flags){
! 317: return SQLITE_OK;
! 318: }
! 319:
! 320: /*
! 321: ** Return the current file-size of a tmp-file.
! 322: */
! 323: static int tmpFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
! 324: tmp_file *pTmp = (tmp_file *)pFile;
! 325: *pSize = pTmp->nSize;
! 326: return SQLITE_OK;
! 327: }
! 328:
! 329: /*
! 330: ** Lock a tmp-file.
! 331: */
! 332: static int tmpLock(sqlite3_file *pFile, int eLock){
! 333: return SQLITE_OK;
! 334: }
! 335:
! 336: /*
! 337: ** Unlock a tmp-file.
! 338: */
! 339: static int tmpUnlock(sqlite3_file *pFile, int eLock){
! 340: return SQLITE_OK;
! 341: }
! 342:
! 343: /*
! 344: ** Check if another file-handle holds a RESERVED lock on a tmp-file.
! 345: */
! 346: static int tmpCheckReservedLock(sqlite3_file *pFile, int *pResOut){
! 347: *pResOut = 0;
! 348: return SQLITE_OK;
! 349: }
! 350:
! 351: /*
! 352: ** File control method. For custom operations on a tmp-file.
! 353: */
! 354: static int tmpFileControl(sqlite3_file *pFile, int op, void *pArg){
! 355: return SQLITE_OK;
! 356: }
! 357:
! 358: /*
! 359: ** Return the sector-size in bytes for a tmp-file.
! 360: */
! 361: static int tmpSectorSize(sqlite3_file *pFile){
! 362: return 0;
! 363: }
! 364:
! 365: /*
! 366: ** Return the device characteristic flags supported by a tmp-file.
! 367: */
! 368: static int tmpDeviceCharacteristics(sqlite3_file *pFile){
! 369: return 0;
! 370: }
! 371:
! 372: /*
! 373: ** Close an fs-file.
! 374: */
! 375: static int fsClose(sqlite3_file *pFile){
! 376: int rc = SQLITE_OK;
! 377: fs_file *p = (fs_file *)pFile;
! 378: fs_real_file *pReal = p->pReal;
! 379:
! 380: /* Decrement the real_file ref-count. */
! 381: pReal->nRef--;
! 382: assert(pReal->nRef>=0);
! 383:
! 384: /* When the ref-count reaches 0, destroy the structure */
! 385: if( pReal->nRef==0 ){
! 386: *pReal->ppThis = pReal->pNext;
! 387: if( pReal->pNext ){
! 388: pReal->pNext->ppThis = pReal->ppThis;
! 389: }
! 390: rc = pReal->pFile->pMethods->xClose(pReal->pFile);
! 391: sqlite3_free(pReal);
! 392: }
! 393:
! 394: return rc;
! 395: }
! 396:
! 397: /*
! 398: ** Read data from an fs-file.
! 399: */
! 400: static int fsRead(
! 401: sqlite3_file *pFile,
! 402: void *zBuf,
! 403: int iAmt,
! 404: sqlite_int64 iOfst
! 405: ){
! 406: int rc = SQLITE_OK;
! 407: fs_file *p = (fs_file *)pFile;
! 408: fs_real_file *pReal = p->pReal;
! 409: sqlite3_file *pF = pReal->pFile;
! 410:
! 411: if( (p->eType==DATABASE_FILE && (iAmt+iOfst)>pReal->nDatabase)
! 412: || (p->eType==JOURNAL_FILE && (iAmt+iOfst)>pReal->nJournal)
! 413: ){
! 414: rc = SQLITE_IOERR_SHORT_READ;
! 415: }else if( p->eType==DATABASE_FILE ){
! 416: rc = pF->pMethods->xRead(pF, zBuf, iAmt, iOfst+BLOCKSIZE);
! 417: }else{
! 418: /* Journal file. */
! 419: int iRem = iAmt;
! 420: int iBuf = 0;
! 421: int ii = iOfst;
! 422: while( iRem>0 && rc==SQLITE_OK ){
! 423: int iRealOff = pReal->nBlob - BLOCKSIZE*((ii/BLOCKSIZE)+1) + ii%BLOCKSIZE;
! 424: int iRealAmt = MIN(iRem, BLOCKSIZE - (iRealOff%BLOCKSIZE));
! 425:
! 426: rc = pF->pMethods->xRead(pF, &((char *)zBuf)[iBuf], iRealAmt, iRealOff);
! 427: ii += iRealAmt;
! 428: iBuf += iRealAmt;
! 429: iRem -= iRealAmt;
! 430: }
! 431: }
! 432:
! 433: return rc;
! 434: }
! 435:
! 436: /*
! 437: ** Write data to an fs-file.
! 438: */
! 439: static int fsWrite(
! 440: sqlite3_file *pFile,
! 441: const void *zBuf,
! 442: int iAmt,
! 443: sqlite_int64 iOfst
! 444: ){
! 445: int rc = SQLITE_OK;
! 446: fs_file *p = (fs_file *)pFile;
! 447: fs_real_file *pReal = p->pReal;
! 448: sqlite3_file *pF = pReal->pFile;
! 449:
! 450: if( p->eType==DATABASE_FILE ){
! 451: if( (iAmt+iOfst+BLOCKSIZE)>(pReal->nBlob-pReal->nJournal) ){
! 452: rc = SQLITE_FULL;
! 453: }else{
! 454: rc = pF->pMethods->xWrite(pF, zBuf, iAmt, iOfst+BLOCKSIZE);
! 455: if( rc==SQLITE_OK ){
! 456: pReal->nDatabase = MAX(pReal->nDatabase, iAmt+iOfst);
! 457: }
! 458: }
! 459: }else{
! 460: /* Journal file. */
! 461: int iRem = iAmt;
! 462: int iBuf = 0;
! 463: int ii = iOfst;
! 464: while( iRem>0 && rc==SQLITE_OK ){
! 465: int iRealOff = pReal->nBlob - BLOCKSIZE*((ii/BLOCKSIZE)+1) + ii%BLOCKSIZE;
! 466: int iRealAmt = MIN(iRem, BLOCKSIZE - (iRealOff%BLOCKSIZE));
! 467:
! 468: if( iRealOff<(pReal->nDatabase+BLOCKSIZE) ){
! 469: rc = SQLITE_FULL;
! 470: }else{
! 471: rc = pF->pMethods->xWrite(pF, &((char *)zBuf)[iBuf], iRealAmt,iRealOff);
! 472: ii += iRealAmt;
! 473: iBuf += iRealAmt;
! 474: iRem -= iRealAmt;
! 475: }
! 476: }
! 477: if( rc==SQLITE_OK ){
! 478: pReal->nJournal = MAX(pReal->nJournal, iAmt+iOfst);
! 479: }
! 480: }
! 481:
! 482: return rc;
! 483: }
! 484:
! 485: /*
! 486: ** Truncate an fs-file.
! 487: */
! 488: static int fsTruncate(sqlite3_file *pFile, sqlite_int64 size){
! 489: fs_file *p = (fs_file *)pFile;
! 490: fs_real_file *pReal = p->pReal;
! 491: if( p->eType==DATABASE_FILE ){
! 492: pReal->nDatabase = MIN(pReal->nDatabase, size);
! 493: }else{
! 494: pReal->nJournal = MIN(pReal->nJournal, size);
! 495: }
! 496: return SQLITE_OK;
! 497: }
! 498:
! 499: /*
! 500: ** Sync an fs-file.
! 501: */
! 502: static int fsSync(sqlite3_file *pFile, int flags){
! 503: fs_file *p = (fs_file *)pFile;
! 504: fs_real_file *pReal = p->pReal;
! 505: sqlite3_file *pRealFile = pReal->pFile;
! 506: int rc = SQLITE_OK;
! 507:
! 508: if( p->eType==DATABASE_FILE ){
! 509: unsigned char zSize[4];
! 510: zSize[0] = (pReal->nDatabase&0xFF000000)>>24;
! 511: zSize[1] = (pReal->nDatabase&0x00FF0000)>>16;
! 512: zSize[2] = (pReal->nDatabase&0x0000FF00)>>8;
! 513: zSize[3] = (pReal->nDatabase&0x000000FF);
! 514: rc = pRealFile->pMethods->xWrite(pRealFile, zSize, 4, 0);
! 515: }
! 516: if( rc==SQLITE_OK ){
! 517: rc = pRealFile->pMethods->xSync(pRealFile, flags&(~SQLITE_SYNC_DATAONLY));
! 518: }
! 519:
! 520: return rc;
! 521: }
! 522:
! 523: /*
! 524: ** Return the current file-size of an fs-file.
! 525: */
! 526: static int fsFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
! 527: fs_file *p = (fs_file *)pFile;
! 528: fs_real_file *pReal = p->pReal;
! 529: if( p->eType==DATABASE_FILE ){
! 530: *pSize = pReal->nDatabase;
! 531: }else{
! 532: *pSize = pReal->nJournal;
! 533: }
! 534: return SQLITE_OK;
! 535: }
! 536:
! 537: /*
! 538: ** Lock an fs-file.
! 539: */
! 540: static int fsLock(sqlite3_file *pFile, int eLock){
! 541: return SQLITE_OK;
! 542: }
! 543:
! 544: /*
! 545: ** Unlock an fs-file.
! 546: */
! 547: static int fsUnlock(sqlite3_file *pFile, int eLock){
! 548: return SQLITE_OK;
! 549: }
! 550:
! 551: /*
! 552: ** Check if another file-handle holds a RESERVED lock on an fs-file.
! 553: */
! 554: static int fsCheckReservedLock(sqlite3_file *pFile, int *pResOut){
! 555: *pResOut = 0;
! 556: return SQLITE_OK;
! 557: }
! 558:
! 559: /*
! 560: ** File control method. For custom operations on an fs-file.
! 561: */
! 562: static int fsFileControl(sqlite3_file *pFile, int op, void *pArg){
! 563: return SQLITE_OK;
! 564: }
! 565:
! 566: /*
! 567: ** Return the sector-size in bytes for an fs-file.
! 568: */
! 569: static int fsSectorSize(sqlite3_file *pFile){
! 570: return BLOCKSIZE;
! 571: }
! 572:
! 573: /*
! 574: ** Return the device characteristic flags supported by an fs-file.
! 575: */
! 576: static int fsDeviceCharacteristics(sqlite3_file *pFile){
! 577: return 0;
! 578: }
! 579:
! 580: /*
! 581: ** Open an fs file handle.
! 582: */
! 583: static int fsOpen(
! 584: sqlite3_vfs *pVfs,
! 585: const char *zName,
! 586: sqlite3_file *pFile,
! 587: int flags,
! 588: int *pOutFlags
! 589: ){
! 590: fs_vfs_t *pFsVfs = (fs_vfs_t *)pVfs;
! 591: fs_file *p = (fs_file *)pFile;
! 592: fs_real_file *pReal = 0;
! 593: int eType;
! 594: int nName;
! 595: int rc = SQLITE_OK;
! 596:
! 597: if( 0==(flags&(SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_MAIN_JOURNAL)) ){
! 598: tmp_file *p = (tmp_file *)pFile;
! 599: memset(p, 0, sizeof(*p));
! 600: p->base.pMethods = &tmp_io_methods;
! 601: return SQLITE_OK;
! 602: }
! 603:
! 604: eType = ((flags&(SQLITE_OPEN_MAIN_DB))?DATABASE_FILE:JOURNAL_FILE);
! 605: p->base.pMethods = &fs_io_methods;
! 606: p->eType = eType;
! 607:
! 608: assert(strlen("-journal")==8);
! 609: nName = strlen(zName)-((eType==JOURNAL_FILE)?8:0);
! 610: pReal=pFsVfs->pFileList;
! 611: for(; pReal && strncmp(pReal->zName, zName, nName); pReal=pReal->pNext);
! 612:
! 613: if( !pReal ){
! 614: int real_flags = (flags&~(SQLITE_OPEN_MAIN_DB))|SQLITE_OPEN_TEMP_DB;
! 615: sqlite3_int64 size;
! 616: sqlite3_file *pRealFile;
! 617: sqlite3_vfs *pParent = pFsVfs->pParent;
! 618: assert(eType==DATABASE_FILE);
! 619:
! 620: pReal = (fs_real_file *)sqlite3_malloc(sizeof(*pReal)+pParent->szOsFile);
! 621: if( !pReal ){
! 622: rc = SQLITE_NOMEM;
! 623: goto open_out;
! 624: }
! 625: memset(pReal, 0, sizeof(*pReal)+pParent->szOsFile);
! 626: pReal->zName = zName;
! 627: pReal->pFile = (sqlite3_file *)(&pReal[1]);
! 628:
! 629: rc = pParent->xOpen(pParent, zName, pReal->pFile, real_flags, pOutFlags);
! 630: if( rc!=SQLITE_OK ){
! 631: goto open_out;
! 632: }
! 633: pRealFile = pReal->pFile;
! 634:
! 635: rc = pRealFile->pMethods->xFileSize(pRealFile, &size);
! 636: if( rc!=SQLITE_OK ){
! 637: goto open_out;
! 638: }
! 639: if( size==0 ){
! 640: rc = pRealFile->pMethods->xWrite(pRealFile, "\0", 1, BLOBSIZE-1);
! 641: pReal->nBlob = BLOBSIZE;
! 642: }else{
! 643: unsigned char zS[4];
! 644: pReal->nBlob = size;
! 645: rc = pRealFile->pMethods->xRead(pRealFile, zS, 4, 0);
! 646: pReal->nDatabase = (zS[0]<<24)+(zS[1]<<16)+(zS[2]<<8)+zS[3];
! 647: if( rc==SQLITE_OK ){
! 648: rc = pRealFile->pMethods->xRead(pRealFile, zS, 4, pReal->nBlob-4);
! 649: if( zS[0] || zS[1] || zS[2] || zS[3] ){
! 650: pReal->nJournal = pReal->nBlob;
! 651: }
! 652: }
! 653: }
! 654:
! 655: if( rc==SQLITE_OK ){
! 656: pReal->pNext = pFsVfs->pFileList;
! 657: if( pReal->pNext ){
! 658: pReal->pNext->ppThis = &pReal->pNext;
! 659: }
! 660: pReal->ppThis = &pFsVfs->pFileList;
! 661: pFsVfs->pFileList = pReal;
! 662: }
! 663: }
! 664:
! 665: open_out:
! 666: if( pReal ){
! 667: if( rc==SQLITE_OK ){
! 668: p->pReal = pReal;
! 669: pReal->nRef++;
! 670: }else{
! 671: if( pReal->pFile->pMethods ){
! 672: pReal->pFile->pMethods->xClose(pReal->pFile);
! 673: }
! 674: sqlite3_free(pReal);
! 675: }
! 676: }
! 677: return rc;
! 678: }
! 679:
! 680: /*
! 681: ** Delete the file located at zPath. If the dirSync argument is true,
! 682: ** ensure the file-system modifications are synced to disk before
! 683: ** returning.
! 684: */
! 685: static int fsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
! 686: int rc = SQLITE_OK;
! 687: fs_vfs_t *pFsVfs = (fs_vfs_t *)pVfs;
! 688: fs_real_file *pReal;
! 689: sqlite3_file *pF;
! 690: int nName = strlen(zPath) - 8;
! 691:
! 692: assert(strlen("-journal")==8);
! 693: assert(strcmp("-journal", &zPath[nName])==0);
! 694:
! 695: pReal = pFsVfs->pFileList;
! 696: for(; pReal && strncmp(pReal->zName, zPath, nName); pReal=pReal->pNext);
! 697: if( pReal ){
! 698: pF = pReal->pFile;
! 699: rc = pF->pMethods->xWrite(pF, "\0\0\0\0", 4, pReal->nBlob-BLOCKSIZE);
! 700: if( rc==SQLITE_OK ){
! 701: pReal->nJournal = 0;
! 702: }
! 703: }
! 704: return rc;
! 705: }
! 706:
! 707: /*
! 708: ** Test for access permissions. Return true if the requested permission
! 709: ** is available, or false otherwise.
! 710: */
! 711: static int fsAccess(
! 712: sqlite3_vfs *pVfs,
! 713: const char *zPath,
! 714: int flags,
! 715: int *pResOut
! 716: ){
! 717: fs_vfs_t *pFsVfs = (fs_vfs_t *)pVfs;
! 718: fs_real_file *pReal;
! 719: int isJournal = 0;
! 720: int nName = strlen(zPath);
! 721:
! 722: if( flags!=SQLITE_ACCESS_EXISTS ){
! 723: sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
! 724: return pParent->xAccess(pParent, zPath, flags, pResOut);
! 725: }
! 726:
! 727: assert(strlen("-journal")==8);
! 728: if( nName>8 && strcmp("-journal", &zPath[nName-8])==0 ){
! 729: nName -= 8;
! 730: isJournal = 1;
! 731: }
! 732:
! 733: pReal = pFsVfs->pFileList;
! 734: for(; pReal && strncmp(pReal->zName, zPath, nName); pReal=pReal->pNext);
! 735:
! 736: *pResOut = (pReal && (!isJournal || pReal->nJournal>0));
! 737: return SQLITE_OK;
! 738: }
! 739:
! 740: /*
! 741: ** Populate buffer zOut with the full canonical pathname corresponding
! 742: ** to the pathname in zPath. zOut is guaranteed to point to a buffer
! 743: ** of at least (FS_MAX_PATHNAME+1) bytes.
! 744: */
! 745: static int fsFullPathname(
! 746: sqlite3_vfs *pVfs, /* Pointer to vfs object */
! 747: const char *zPath, /* Possibly relative input path */
! 748: int nOut, /* Size of output buffer in bytes */
! 749: char *zOut /* Output buffer */
! 750: ){
! 751: sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
! 752: return pParent->xFullPathname(pParent, zPath, nOut, zOut);
! 753: }
! 754:
! 755: /*
! 756: ** Open the dynamic library located at zPath and return a handle.
! 757: */
! 758: static void *fsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
! 759: sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
! 760: return pParent->xDlOpen(pParent, zPath);
! 761: }
! 762:
! 763: /*
! 764: ** Populate the buffer zErrMsg (size nByte bytes) with a human readable
! 765: ** utf-8 string describing the most recent error encountered associated
! 766: ** with dynamic libraries.
! 767: */
! 768: static void fsDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
! 769: sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
! 770: pParent->xDlError(pParent, nByte, zErrMsg);
! 771: }
! 772:
! 773: /*
! 774: ** Return a pointer to the symbol zSymbol in the dynamic library pHandle.
! 775: */
! 776: static void (*fsDlSym(sqlite3_vfs *pVfs, void *pH, const char *zSym))(void){
! 777: sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
! 778: return pParent->xDlSym(pParent, pH, zSym);
! 779: }
! 780:
! 781: /*
! 782: ** Close the dynamic library handle pHandle.
! 783: */
! 784: static void fsDlClose(sqlite3_vfs *pVfs, void *pHandle){
! 785: sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
! 786: pParent->xDlClose(pParent, pHandle);
! 787: }
! 788:
! 789: /*
! 790: ** Populate the buffer pointed to by zBufOut with nByte bytes of
! 791: ** random data.
! 792: */
! 793: static int fsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
! 794: sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
! 795: return pParent->xRandomness(pParent, nByte, zBufOut);
! 796: }
! 797:
! 798: /*
! 799: ** Sleep for nMicro microseconds. Return the number of microseconds
! 800: ** actually slept.
! 801: */
! 802: static int fsSleep(sqlite3_vfs *pVfs, int nMicro){
! 803: sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
! 804: return pParent->xSleep(pParent, nMicro);
! 805: }
! 806:
! 807: /*
! 808: ** Return the current time as a Julian Day number in *pTimeOut.
! 809: */
! 810: static int fsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
! 811: sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;
! 812: return pParent->xCurrentTime(pParent, pTimeOut);
! 813: }
! 814:
! 815: /*
! 816: ** This procedure registers the fs vfs with SQLite. If the argument is
! 817: ** true, the fs vfs becomes the new default vfs. It is the only publicly
! 818: ** available function in this file.
! 819: */
! 820: int fs_register(void){
! 821: if( fs_vfs.pParent ) return SQLITE_OK;
! 822: fs_vfs.pParent = sqlite3_vfs_find(0);
! 823: fs_vfs.base.mxPathname = fs_vfs.pParent->mxPathname;
! 824: fs_vfs.base.szOsFile = MAX(sizeof(tmp_file), sizeof(fs_file));
! 825: return sqlite3_vfs_register(&fs_vfs.base, 0);
! 826: }
! 827:
! 828: #ifdef SQLITE_TEST
! 829: int SqlitetestOnefile_Init() {return fs_register();}
! 830: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_onefile.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src