src/memdb.c

   1 /*
   2 ** 2016-09-07
   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 in-memory VFS. A database is held as a contiguous
  14 ** block of memory.
  15 **
  16 ** This file also implements interface sqlite3_serialize() and
  17 ** sqlite3_deserialize().
  18 */
  19 #include "sqliteInt.h"
  20 #ifndef SQLITE_OMIT_DESERIALIZE
  21
  22 /*
  23 ** Forward declaration of objects used by this utility
  24 */
  25 typedef struct sqlite3_vfs MemVfs;
  26 typedef struct MemFile MemFile;
  27 typedef struct MemStore MemStore;
  28
  29 /* Access to a lower-level VFS that (might) implement dynamic loading,
  30 ** access to randomness, etc.
  31 */
  32 #define ORIGVFS(p) ((sqlite3_vfs*)((p)->pAppData))
  33
  34 /* Storage for a memdb file.
  35 **
  36 ** An memdb object can be shared or separate.  Shared memdb objects can be
  37 ** used by more than one database connection.  Mutexes are used by shared
  38 ** memdb objects to coordinate access.  Separate memdb objects are only
  39 ** connected to a single database connection and do not require additional
  40 ** mutexes.
  41 **
  42 ** Shared memdb objects have .zFName!=0 and .pMutex!=0.  They are created
  43 ** using "file:/name?vfs=memdb".  The first character of the name must be
  44 ** "/" or else the object will be a separate memdb object.  All shared
  45 ** memdb objects are stored in memdb_g.apMemStore[] in an arbitrary order.
  46 **
  47 ** Separate memdb objects are created using a name that does not begin
  48 ** with "/" or using sqlite3_deserialize().
  49 **
  50 ** Access rules for shared MemStore objects:
  51 **
  52 **   *  .zFName is initialized when the object is created and afterwards
  53 **      is unchanged until the object is destroyed.  So it can be accessed
  54 **      at any time as long as we know the object is not being destroyed,
  55 **      which means while either the SQLITE_MUTEX_STATIC_VFS1 or
  56 **      .pMutex is held or the object is not part of memdb_g.apMemStore[].
  57 **
  58 **   *  Can .pMutex can only be changed while holding the
  59 **      SQLITE_MUTEX_STATIC_VFS1 mutex or while the object is not part
  60 **      of memdb_g.apMemStore[].
  61 **
  62 **   *  Other fields can only be changed while holding the .pMutex mutex
  63 **      or when the .nRef is less than zero and the object is not part of
  64 **      memdb_g.apMemStore[].
  65 **
  66 **   *  The .aData pointer has the added requirement that it can can only
  67 **      be changed (for resizing) when nMmap is zero.
  68 **
  69 */
  70 struct MemStore {
  71   sqlite3_int64 sz;               /* Size of the file */
  72   sqlite3_int64 szAlloc;          /* Space allocated to aData */
  73   sqlite3_int64 szMax;            /* Maximum allowed size of the file */
  74   unsigned char *aData;           /* content of the file */
  75   sqlite3_mutex *pMutex;          /* Used by shared stores only */
  76   int nMmap;                      /* Number of memory mapped pages */
  77   unsigned mFlags;                /* Flags */
  78   int nRdLock;                    /* Number of readers */
  79   int nWrLock;                    /* Number of writers.  (Always 0 or 1) */
  80   int nRef;                       /* Number of users of this MemStore */
  81   char *zFName;                   /* The filename for shared stores */
  82 };
  83
  84 /* An open file */
  85 struct MemFile {
  86   sqlite3_file base;              /* IO methods */
  87   MemStore *pStore;               /* The storage */
  88   int eLock;                      /* Most recent lock against this file */
  89 };
  90
  91 /*
  92 ** File-scope variables for holding the memdb files that are accessible
  93 ** to multiple database connections in separate threads.
  94 **
  95 ** Must hold SQLITE_MUTEX_STATIC_VFS1 to access any part of this object.
  96 */
  97 static struct MemFS {
  98   int nMemStore;                  /* Number of shared MemStore objects */
  99   MemStore **apMemStore;          /* Array of all shared MemStore objects */
 100 } memdb_g;
 101
 102 /*
 103 ** Methods for MemFile
 104 */
 105 static int memdbClose(sqlite3_file*);
 106 static int memdbRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
 107 static int memdbWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst);
 108 static int memdbTruncate(sqlite3_file*, sqlite3_int64 size);
 109 static int memdbSync(sqlite3_file*, int flags);
 110 static int memdbFileSize(sqlite3_file*, sqlite3_int64 *pSize);
 111 static int memdbLock(sqlite3_file*, int);
 112 static int memdbUnlock(sqlite3_file*, int);
 113 /* static int memdbCheckReservedLock(sqlite3_file*, int *pResOut);// not used */
 114 static int memdbFileControl(sqlite3_file*, int op, void *pArg);
 115 /* static int memdbSectorSize(sqlite3_file*); // not used */
 116 static int memdbDeviceCharacteristics(sqlite3_file*);
 117 static int memdbFetch(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp);
 118 static int memdbUnfetch(sqlite3_file*, sqlite3_int64 iOfst, void *p);
 119
 120 /*
 121 ** Methods for MemVfs
 122 */
 123 static int memdbOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *);
 124 /* static int memdbDelete(sqlite3_vfs*, const char *zName, int syncDir); */
 125 static int memdbAccess(sqlite3_vfs*, const char *zName, int flags, int *);
 126 static int memdbFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
 127 static void *memdbDlOpen(sqlite3_vfs*, const char *zFilename);
 128 static void memdbDlError(sqlite3_vfs*, int nByte, char *zErrMsg);
 129 static void (*memdbDlSym(sqlite3_vfs *pVfs, void *p, const char*zSym))(void);
 130 static void memdbDlClose(sqlite3_vfs*, void*);
 131 static int memdbRandomness(sqlite3_vfs*, int nByte, char *zOut);
 132 static int memdbSleep(sqlite3_vfs*, int microseconds);
 133 /* static int memdbCurrentTime(sqlite3_vfs*, double*); */
 134 static int memdbGetLastError(sqlite3_vfs*, int, char *);
 135 static int memdbCurrentTimeInt64(sqlite3_vfs*, sqlite3_int64*);
 136
 137 static sqlite3_vfs memdb_vfs = {
 138   2,                           /* iVersion */
 139   0,                           /* szOsFile (set when registered) */
 140   1024,                        /* mxPathname */
 141   0,                           /* pNext */
 142   "memdb",                     /* zName */
 143   0,                           /* pAppData (set when registered) */
 144   memdbOpen,                   /* xOpen */
 145   0, /* memdbDelete, */        /* xDelete */
 146   memdbAccess,                 /* xAccess */
 147   memdbFullPathname,           /* xFullPathname */
 148   memdbDlOpen,                 /* xDlOpen */
 149   memdbDlError,                /* xDlError */
 150   memdbDlSym,                  /* xDlSym */
 151   memdbDlClose,                /* xDlClose */
 152   memdbRandomness,             /* xRandomness */
 153   memdbSleep,                  /* xSleep */
 154   0, /* memdbCurrentTime, */   /* xCurrentTime */
 155   memdbGetLastError,           /* xGetLastError */
 156   memdbCurrentTimeInt64,       /* xCurrentTimeInt64 */
 157   0,                           /* xSetSystemCall */
 158   0,                           /* xGetSystemCall */
 159   0,                           /* xNextSystemCall */
 160 };
 161
 162 static const sqlite3_io_methods memdb_io_methods = {
 163   3,                              /* iVersion */
 164   memdbClose,                      /* xClose */
 165   memdbRead,                       /* xRead */
 166   memdbWrite,                      /* xWrite */
 167   memdbTruncate,                   /* xTruncate */
 168   memdbSync,                       /* xSync */
 169   memdbFileSize,                   /* xFileSize */
 170   memdbLock,                       /* xLock */
 171   memdbUnlock,                     /* xUnlock */
 172   0, /* memdbCheckReservedLock, */ /* xCheckReservedLock */
 173   memdbFileControl,                /* xFileControl */
 174   0, /* memdbSectorSize,*/         /* xSectorSize */
 175   memdbDeviceCharacteristics,      /* xDeviceCharacteristics */
 176   0,                               /* xShmMap */
 177   0,                               /* xShmLock */
 178   0,                               /* xShmBarrier */
 179   0,                               /* xShmUnmap */
 180   memdbFetch,                      /* xFetch */
 181   memdbUnfetch                     /* xUnfetch */
 182 };
 183
 184 /*
 185 ** Enter/leave the mutex on a MemStore
 186 */
 187 #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE==0
 188 static void memdbEnter(MemStore *p){
 189   UNUSED_PARAMETER(p);
 190 }
 191 static void memdbLeave(MemStore *p){
 192   UNUSED_PARAMETER(p);
 193 }
 194 #else
 195 static void memdbEnter(MemStore *p){
 196   sqlite3_mutex_enter(p->pMutex);
 197 }
 198 static void memdbLeave(MemStore *p){
 199   sqlite3_mutex_leave(p->pMutex);
 200 }
 201 #endif
 202
 203
 204
 205 /*
 206 ** Close an memdb-file.
 207 ** Free the underlying MemStore object when its refcount drops to zero
 208 ** or less.
 209 */
 210 static int memdbClose(sqlite3_file *pFile){
 211   MemStore *p = ((MemFile*)pFile)->pStore;
 212   if( p->zFName ){
 213     int i;
 214 #ifndef SQLITE_MUTEX_OMIT
 215     sqlite3_mutex *pVfsMutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1);
 216 #endif
 217     sqlite3_mutex_enter(pVfsMutex);
 218     for(i=0; ALWAYS(i<memdb_g.nMemStore); i++){
 219       if( memdb_g.apMemStore[i]==p ){
 220         memdbEnter(p);
 221         if( p->nRef==1 ){
 222           memdb_g.apMemStore[i] = memdb_g.apMemStore[--memdb_g.nMemStore];
 223           if( memdb_g.nMemStore==0 ){
 224             sqlite3_free(memdb_g.apMemStore);
 225             memdb_g.apMemStore = 0;
 226           }
 227         }
 228         break;
 229       }
 230     }
 231     sqlite3_mutex_leave(pVfsMutex);
 232   }else{
 233     memdbEnter(p);
 234   }
 235   p->nRef--;
 236   if( p->nRef<=0 ){
 237     if( p->mFlags & SQLITE_DESERIALIZE_FREEONCLOSE ){
 238       sqlite3_free(p->aData);
 239     }
 240     memdbLeave(p);
 241     sqlite3_mutex_free(p->pMutex);
 242     sqlite3_free(p);
 243   }else{
 244     memdbLeave(p);
 245   }
 246   return SQLITE_OK;
 247 }
 248
 249 /*
 250 ** Read data from an memdb-file.
 251 */
 252 static int memdbRead(
 253   sqlite3_file *pFile,
 254   void *zBuf,
 255   int iAmt,
 256   sqlite_int64 iOfst
 257 ){
 258   MemStore *p = ((MemFile*)pFile)->pStore;
 259   memdbEnter(p);
 260   if( iOfst+iAmt>p->sz ){
 261     memset(zBuf, 0, iAmt);
 262     if( iOfst<p->sz ) memcpy(zBuf, p->aData+iOfst, p->sz - iOfst);
 263     memdbLeave(p);
 264     return SQLITE_IOERR_SHORT_READ;
 265   }
 266   memcpy(zBuf, p->aData+iOfst, iAmt);
 267   memdbLeave(p);
 268   return SQLITE_OK;
 269 }
 270
 271 /*
 272 ** Try to enlarge the memory allocation to hold at least sz bytes
 273 */
 274 static int memdbEnlarge(MemStore *p, sqlite3_int64 newSz){
 275   unsigned char *pNew;
 276   if( (p->mFlags & SQLITE_DESERIALIZE_RESIZEABLE)==0 || NEVER(p->nMmap>0) ){
 277     return SQLITE_FULL;
 278   }
 279   if( newSz>p->szMax ){
 280     return SQLITE_FULL;
 281   }
 282   newSz *= 2;
 283   if( newSz>p->szMax ) newSz = p->szMax;
 284   pNew = sqlite3Realloc(p->aData, newSz);
 285   if( pNew==0 ) return SQLITE_IOERR_NOMEM;
 286   p->aData = pNew;
 287   p->szAlloc = newSz;
 288   return SQLITE_OK;
 289 }
 290
 291 /*
 292 ** Write data to an memdb-file.
 293 */
 294 static int memdbWrite(
 295   sqlite3_file *pFile,
 296   const void *z,
 297   int iAmt,
 298   sqlite_int64 iOfst
 299 ){
 300   MemStore *p = ((MemFile*)pFile)->pStore;
 301   memdbEnter(p);
 302   if( NEVER(p->mFlags & SQLITE_DESERIALIZE_READONLY) ){
 303     /* Can't happen: memdbLock() will return SQLITE_READONLY before
 304     ** reaching this point */
 305     memdbLeave(p);
 306     return SQLITE_IOERR_WRITE;
 307   }
 308   if( iOfst+iAmt>p->sz ){
 309     int rc;
 310     if( iOfst+iAmt>p->szAlloc
 311      && (rc = memdbEnlarge(p, iOfst+iAmt))!=SQLITE_OK
 312     ){
 313       memdbLeave(p);
 314       return rc;
 315     }
 316     if( iOfst>p->sz ) memset(p->aData+p->sz, 0, iOfst-p->sz);
 317     p->sz = iOfst+iAmt;
 318   }
 319   memcpy(p->aData+iOfst, z, iAmt);
 320   memdbLeave(p);
 321   return SQLITE_OK;
 322 }
 323
 324 /*
 325 ** Truncate an memdb-file.
 326 **
 327 ** In rollback mode (which is always the case for memdb, as it does not
 328 ** support WAL mode) the truncate() method is only used to reduce
 329 ** the size of a file, never to increase the size.
 330 */
 331 static int memdbTruncate(sqlite3_file *pFile, sqlite_int64 size){
 332   MemStore *p = ((MemFile*)pFile)->pStore;
 333   int rc = SQLITE_OK;
 334   memdbEnter(p);
 335   if( size>p->sz ){
 336     /* This can only happen with a corrupt wal mode db */
 337     rc = SQLITE_CORRUPT;
 338   }else{
 339     p->sz = size;
 340   }
 341   memdbLeave(p);
 342   return rc;
 343 }
 344
 345 /*
 346 ** Sync an memdb-file.
 347 */
 348 static int memdbSync(sqlite3_file *pFile, int flags){
 349   UNUSED_PARAMETER(pFile);
 350   UNUSED_PARAMETER(flags);
 351   return SQLITE_OK;
 352 }
 353
 354 /*
 355 ** Return the current file-size of an memdb-file.
 356 */
 357 static int memdbFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
 358   MemStore *p = ((MemFile*)pFile)->pStore;
 359   memdbEnter(p);
 360   *pSize = p->sz;
 361   memdbLeave(p);
 362   return SQLITE_OK;
 363 }
 364
 365 /*
 366 ** Lock an memdb-file.
 367 */
 368 static int memdbLock(sqlite3_file *pFile, int eLock){
 369   MemFile *pThis = (MemFile*)pFile;
 370   MemStore *p = pThis->pStore;
 371   int rc = SQLITE_OK;
 372   if( eLock<=pThis->eLock ) return SQLITE_OK;
 373   memdbEnter(p);
 374
 375   assert( p->nWrLock==0 || p->nWrLock==1 );
 376   assert( pThis->eLock<=SQLITE_LOCK_SHARED || p->nWrLock==1 );
 377   assert( pThis->eLock==SQLITE_LOCK_NONE || p->nRdLock>=1 );
 378
 379   if( eLock>SQLITE_LOCK_SHARED && (p->mFlags & SQLITE_DESERIALIZE_READONLY) ){
 380     rc = SQLITE_READONLY;
 381   }else{
 382     switch( eLock ){
 383       case SQLITE_LOCK_SHARED: {
 384         assert( pThis->eLock==SQLITE_LOCK_NONE );
 385         if( p->nWrLock>0 ){
 386           rc = SQLITE_BUSY;
 387         }else{
 388           p->nRdLock++;
 389         }
 390         break;
 391       };
 392
 393       case SQLITE_LOCK_RESERVED:
 394       case SQLITE_LOCK_PENDING: {
 395         assert( pThis->eLock>=SQLITE_LOCK_SHARED );
 396         if( ALWAYS(pThis->eLock==SQLITE_LOCK_SHARED) ){
 397           if( p->nWrLock>0 ){
 398             rc = SQLITE_BUSY;
 399           }else{
 400             p->nWrLock = 1;
 401           }
 402         }
 403         break;
 404       }
 405
 406       default: {
 407         assert(  eLock==SQLITE_LOCK_EXCLUSIVE );
 408         assert( pThis->eLock>=SQLITE_LOCK_SHARED );
 409         if( p->nRdLock>1 ){
 410           rc = SQLITE_BUSY;
 411         }else if( pThis->eLock==SQLITE_LOCK_SHARED ){
 412           p->nWrLock = 1;
 413         }
 414         break;
 415       }
 416     }
 417   }
 418   if( rc==SQLITE_OK ) pThis->eLock = eLock;
 419   memdbLeave(p);
 420   return rc;
 421 }
 422
 423 /*
 424 ** Unlock an memdb-file.
 425 */
 426 static int memdbUnlock(sqlite3_file *pFile, int eLock){
 427   MemFile *pThis = (MemFile*)pFile;
 428   MemStore *p = pThis->pStore;
 429   if( eLock>=pThis->eLock ) return SQLITE_OK;
 430   memdbEnter(p);
 431
 432   assert( eLock==SQLITE_LOCK_SHARED || eLock==SQLITE_LOCK_NONE );
 433   if( eLock==SQLITE_LOCK_SHARED ){
 434     if( ALWAYS(pThis->eLock>SQLITE_LOCK_SHARED) ){
 435       p->nWrLock--;
 436     }
 437   }else{
 438     if( pThis->eLock>SQLITE_LOCK_SHARED ){
 439       p->nWrLock--;
 440     }
 441     p->nRdLock--;
 442   }
 443
 444   pThis->eLock = eLock;
 445   memdbLeave(p);
 446   return SQLITE_OK;
 447 }
 448
 449 #if 0
 450 /*
 451 ** This interface is only used for crash recovery, which does not
 452 ** occur on an in-memory database.
 453 */
 454 static int memdbCheckReservedLock(sqlite3_file *pFile, int *pResOut){
 455   *pResOut = 0;
 456   return SQLITE_OK;
 457 }
 458 #endif
 459
 460
 461 /*
 462 ** File control method. For custom operations on an memdb-file.
 463 */
 464 static int memdbFileControl(sqlite3_file *pFile, int op, void *pArg){
 465   MemStore *p = ((MemFile*)pFile)->pStore;
 466   int rc = SQLITE_NOTFOUND;
 467   memdbEnter(p);
 468   if( op==SQLITE_FCNTL_VFSNAME ){
 469     *(char**)pArg = sqlite3_mprintf("memdb(%p,%lld)", p->aData, p->sz);
 470     rc = SQLITE_OK;
 471   }
 472   if( op==SQLITE_FCNTL_SIZE_LIMIT ){
 473     sqlite3_int64 iLimit = *(sqlite3_int64*)pArg;
 474     if( iLimit<p->sz ){
 475       if( iLimit<0 ){
 476         iLimit = p->szMax;
 477       }else{
 478         iLimit = p->sz;
 479       }
 480     }
 481     p->szMax = iLimit;
 482     *(sqlite3_int64*)pArg = iLimit;
 483     rc = SQLITE_OK;
 484   }
 485   memdbLeave(p);
 486   return rc;
 487 }
 488
 489 #if 0  /* Not used because of SQLITE_IOCAP_POWERSAFE_OVERWRITE */
 490 /*
 491 ** Return the sector-size in bytes for an memdb-file.
 492 */
 493 static int memdbSectorSize(sqlite3_file *pFile){
 494   return 1024;
 495 }
 496 #endif
 497
 498 /*
 499 ** Return the device characteristic flags supported by an memdb-file.
 500 */
 501 static int memdbDeviceCharacteristics(sqlite3_file *pFile){
 502   UNUSED_PARAMETER(pFile);
 503   return SQLITE_IOCAP_ATOMIC |
 504          SQLITE_IOCAP_POWERSAFE_OVERWRITE |
 505          SQLITE_IOCAP_SAFE_APPEND |
 506          SQLITE_IOCAP_SEQUENTIAL;
 507 }
 508
 509 /* Fetch a page of a memory-mapped file */
 510 static int memdbFetch(
 511   sqlite3_file *pFile,
 512   sqlite3_int64 iOfst,
 513   int iAmt,
 514   void **pp
 515 ){
 516   MemStore *p = ((MemFile*)pFile)->pStore;
 517   memdbEnter(p);
 518   if( iOfst+iAmt>p->sz || (p->mFlags & SQLITE_DESERIALIZE_RESIZEABLE)!=0 ){
 519     *pp = 0;
 520   }else{
 521     p->nMmap++;
 522     *pp = (void*)(p->aData + iOfst);
 523   }
 524   memdbLeave(p);
 525   return SQLITE_OK;
 526 }
 527
 528 /* Release a memory-mapped page */
 529 static int memdbUnfetch(sqlite3_file *pFile, sqlite3_int64 iOfst, void *pPage){
 530   MemStore *p = ((MemFile*)pFile)->pStore;
 531   UNUSED_PARAMETER(iOfst);
 532   UNUSED_PARAMETER(pPage);
 533   memdbEnter(p);
 534   p->nMmap--;
 535   memdbLeave(p);
 536   return SQLITE_OK;
 537 }
 538
 539 /*
 540 ** Open an mem file handle.
 541 */
 542 static int memdbOpen(
 543   sqlite3_vfs *pVfs,
 544   const char *zName,
 545   sqlite3_file *pFd,
 546   int flags,
 547   int *pOutFlags
 548 ){
 549   MemFile *pFile = (MemFile*)pFd;
 550   MemStore *p = 0;
 551   int szName;
 552   UNUSED_PARAMETER(pVfs);
 553
 554   memset(pFile, 0, sizeof(*pFile));
 555   szName = sqlite3Strlen30(zName);
 556   if( szName>1 && (zName[0]=='/' || zName[0]=='\\') ){
 557     int i;
 558 #ifndef SQLITE_MUTEX_OMIT
 559     sqlite3_mutex *pVfsMutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1);
 560 #endif
 561     sqlite3_mutex_enter(pVfsMutex);
 562     for(i=0; i<memdb_g.nMemStore; i++){
 563       if( strcmp(memdb_g.apMemStore[i]->zFName,zName)==0 ){
 564         p = memdb_g.apMemStore[i];
 565         break;
 566       }
 567     }
 568     if( p==0 ){
 569       MemStore **apNew;
 570       p = sqlite3Malloc( sizeof(*p) + szName + 3 );
 571       if( p==0 ){
 572         sqlite3_mutex_leave(pVfsMutex);
 573         return SQLITE_NOMEM;
 574       }
 575       apNew = sqlite3Realloc(memdb_g.apMemStore,
 576                              sizeof(apNew[0])*(memdb_g.nMemStore+1) );
 577       if( apNew==0 ){
 578         sqlite3_free(p);
 579         sqlite3_mutex_leave(pVfsMutex);
 580         return SQLITE_NOMEM;
 581       }
 582       apNew[memdb_g.nMemStore++] = p;
 583       memdb_g.apMemStore = apNew;
 584       memset(p, 0, sizeof(*p));
 585       p->mFlags = SQLITE_DESERIALIZE_RESIZEABLE|SQLITE_DESERIALIZE_FREEONCLOSE;
 586       p->szMax = sqlite3GlobalConfig.mxMemdbSize;
 587       p->zFName = (char*)&p[1];
 588       memcpy(p->zFName, zName, szName+1);
 589       p->pMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
 590       if( p->pMutex==0 ){
 591         memdb_g.nMemStore--;
 592         sqlite3_free(p);
 593         sqlite3_mutex_leave(pVfsMutex);
 594         return SQLITE_NOMEM;
 595       }
 596       p->nRef = 1;
 597       memdbEnter(p);
 598     }else{
 599       memdbEnter(p);
 600       p->nRef++;
 601     }
 602     sqlite3_mutex_leave(pVfsMutex);
 603   }else{
 604     p = sqlite3Malloc( sizeof(*p) );
 605     if( p==0 ){
 606       return SQLITE_NOMEM;
 607     }
 608     memset(p, 0, sizeof(*p));
 609     p->mFlags = SQLITE_DESERIALIZE_RESIZEABLE | SQLITE_DESERIALIZE_FREEONCLOSE;
 610     p->szMax = sqlite3GlobalConfig.mxMemdbSize;
 611   }
 612   pFile->pStore = p;
 613   if( pOutFlags!=0 ){
 614     *pOutFlags = flags | SQLITE_OPEN_MEMORY;
 615   }
 616   pFd->pMethods = &memdb_io_methods;
 617   memdbLeave(p);
 618   return SQLITE_OK;
 619 }
 620
 621 #if 0 /* Only used to delete rollback journals, super-journals, and WAL
 622       ** files, none of which exist in memdb.  So this routine is never used */
 623 /*
 624 ** Delete the file located at zPath. If the dirSync argument is true,
 625 ** ensure the file-system modifications are synced to disk before
 626 ** returning.
 627 */
 628 static int memdbDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
 629   return SQLITE_IOERR_DELETE;
 630 }
 631 #endif
 632
 633 /*
 634 ** Test for access permissions. Return true if the requested permission
 635 ** is available, or false otherwise.
 636 **
 637 ** With memdb, no files ever exist on disk.  So always return false.
 638 */
 639 static int memdbAccess(
 640   sqlite3_vfs *pVfs,
 641   const char *zPath,
 642   int flags,
 643   int *pResOut
 644 ){
 645   UNUSED_PARAMETER(pVfs);
 646   UNUSED_PARAMETER(zPath);
 647   UNUSED_PARAMETER(flags);
 648   *pResOut = 0;
 649   return SQLITE_OK;
 650 }
 651
 652 /*
 653 ** Populate buffer zOut with the full canonical pathname corresponding
 654 ** to the pathname in zPath. zOut is guaranteed to point to a buffer
 655 ** of at least (INST_MAX_PATHNAME+1) bytes.
 656 */
 657 static int memdbFullPathname(
 658   sqlite3_vfs *pVfs,
 659   const char *zPath,
 660   int nOut,
 661   char *zOut
 662 ){
 663   UNUSED_PARAMETER(pVfs);
 664   sqlite3_snprintf(nOut, zOut, "%s", zPath);
 665   return SQLITE_OK;
 666 }
 667
 668 /*
 669 ** Open the dynamic library located at zPath and return a handle.
 670 */
 671 static void *memdbDlOpen(sqlite3_vfs *pVfs, const char *zPath){
 672   return ORIGVFS(pVfs)->xDlOpen(ORIGVFS(pVfs), zPath);
 673 }
 674
 675 /*
 676 ** Populate the buffer zErrMsg (size nByte bytes) with a human readable
 677 ** utf-8 string describing the most recent error encountered associated
 678 ** with dynamic libraries.
 679 */
 680 static void memdbDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
 681   ORIGVFS(pVfs)->xDlError(ORIGVFS(pVfs), nByte, zErrMsg);
 682 }
 683
 684 /*
 685 ** Return a pointer to the symbol zSymbol in the dynamic library pHandle.
 686 */
 687 static void (*memdbDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){
 688   return ORIGVFS(pVfs)->xDlSym(ORIGVFS(pVfs), p, zSym);
 689 }
 690
 691 /*
 692 ** Close the dynamic library handle pHandle.
 693 */
 694 static void memdbDlClose(sqlite3_vfs *pVfs, void *pHandle){
 695   ORIGVFS(pVfs)->xDlClose(ORIGVFS(pVfs), pHandle);
 696 }
 697
 698 /*
 699 ** Populate the buffer pointed to by zBufOut with nByte bytes of
 700 ** random data.
 701 */
 702 static int memdbRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
 703   return ORIGVFS(pVfs)->xRandomness(ORIGVFS(pVfs), nByte, zBufOut);
 704 }
 705
 706 /*
 707 ** Sleep for nMicro microseconds. Return the number of microseconds
 708 ** actually slept.
 709 */
 710 static int memdbSleep(sqlite3_vfs *pVfs, int nMicro){
 711   return ORIGVFS(pVfs)->xSleep(ORIGVFS(pVfs), nMicro);
 712 }
 713
 714 #if 0  /* Never used.  Modern cores only call xCurrentTimeInt64() */
 715 /*
 716 ** Return the current time as a Julian Day number in *pTimeOut.
 717 */
 718 static int memdbCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
 719   return ORIGVFS(pVfs)->xCurrentTime(ORIGVFS(pVfs), pTimeOut);
 720 }
 721 #endif
 722
 723 static int memdbGetLastError(sqlite3_vfs *pVfs, int a, char *b){
 724   return ORIGVFS(pVfs)->xGetLastError(ORIGVFS(pVfs), a, b);
 725 }
 726 static int memdbCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *p){
 727   return ORIGVFS(pVfs)->xCurrentTimeInt64(ORIGVFS(pVfs), p);
 728 }
 729
 730 /*
 731 ** Translate a database connection pointer and schema name into a
 732 ** MemFile pointer.
 733 */
 734 static MemFile *memdbFromDbSchema(sqlite3 *db, const char *zSchema){
 735   MemFile *p = 0;
 736   MemStore *pStore;
 737   int rc = sqlite3_file_control(db, zSchema, SQLITE_FCNTL_FILE_POINTER, &p);
 738   if( rc ) return 0;
 739   if( p->base.pMethods!=&memdb_io_methods ) return 0;
 740   pStore = p->pStore;
 741   memdbEnter(pStore);
 742   if( pStore->zFName!=0 ) p = 0;
 743   memdbLeave(pStore);
 744   return p;
 745 }
 746
 747 /*
 748 ** Return the serialization of a database
 749 */
 750 unsigned char *sqlite3_serialize(
 751   sqlite3 *db,              /* The database connection */
 752   const char *zSchema,      /* Which database within the connection */
 753   sqlite3_int64 *piSize,    /* Write size here, if not NULL */
 754   unsigned int mFlags       /* Maybe SQLITE_SERIALIZE_NOCOPY */
 755 ){
 756   MemFile *p;
 757   int iDb;
 758   Btree *pBt;
 759   sqlite3_int64 sz;
 760   int szPage = 0;
 761   sqlite3_stmt *pStmt = 0;
 762   unsigned char *pOut;
 763   char *zSql;
 764   int rc;
 765
 766 #ifdef SQLITE_ENABLE_API_ARMOR
 767   if( !sqlite3SafetyCheckOk(db) ){
 768     (void)SQLITE_MISUSE_BKPT;
 769     return 0;
 770   }
 771 #endif
 772
 773   if( zSchema==0 ) zSchema = db->aDb[0].zDbSName;
 774   p = memdbFromDbSchema(db, zSchema);
 775   iDb = sqlite3FindDbName(db, zSchema);
 776   if( piSize ) *piSize = -1;
 777   if( iDb<0 ) return 0;
 778   if( p ){
 779     MemStore *pStore = p->pStore;
 780     assert( pStore->pMutex==0 );
 781     if( piSize ) *piSize = pStore->sz;
 782     if( mFlags & SQLITE_SERIALIZE_NOCOPY ){
 783       pOut = pStore->aData;
 784     }else{
 785       pOut = sqlite3_malloc64( pStore->sz );
 786       if( pOut ) memcpy(pOut, pStore->aData, pStore->sz);
 787     }
 788     return pOut;
 789   }
 790   pBt = db->aDb[iDb].pBt;
 791   if( pBt==0 ) return 0;
 792   szPage = sqlite3BtreeGetPageSize(pBt);
 793   zSql = sqlite3_mprintf("PRAGMA \"%w\".page_count", zSchema);
 794   rc = zSql ? sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0) : SQLITE_NOMEM;
 795   sqlite3_free(zSql);
 796   if( rc ) return 0;
 797   rc = sqlite3_step(pStmt);
 798   if( rc!=SQLITE_ROW ){
 799     pOut = 0;
 800   }else{
 801     sz = sqlite3_column_int64(pStmt, 0)*szPage;
 802     if( sz==0 ){
 803       sqlite3_reset(pStmt);
 804       sqlite3_exec(db, "BEGIN IMMEDIATE; COMMIT;", 0, 0, 0);
 805       rc = sqlite3_step(pStmt);
 806       if( rc==SQLITE_ROW ){
 807         sz = sqlite3_column_int64(pStmt, 0)*szPage;
 808       }
 809     }
 810     if( piSize ) *piSize = sz;
 811     if( mFlags & SQLITE_SERIALIZE_NOCOPY ){
 812       pOut = 0;
 813     }else{
 814       pOut = sqlite3_malloc64( sz );
 815       if( pOut ){
 816         int nPage = sqlite3_column_int(pStmt, 0);
 817         Pager *pPager = sqlite3BtreePager(pBt);
 818         int pgno;
 819         for(pgno=1; pgno<=nPage; pgno++){
 820           DbPage *pPage = 0;
 821           unsigned char *pTo = pOut + szPage*(sqlite3_int64)(pgno-1);
 822           rc = sqlite3PagerGet(pPager, pgno, (DbPage**)&pPage, 0);
 823           if( rc==SQLITE_OK ){
 824             memcpy(pTo, sqlite3PagerGetData(pPage), szPage);
 825           }else{
 826             memset(pTo, 0, szPage);
 827           }
 828           sqlite3PagerUnref(pPage);
 829         }
 830       }
 831     }
 832   }
 833   sqlite3_finalize(pStmt);
 834   return pOut;
 835 }
 836
 837 /* Convert zSchema to a MemDB and initialize its content.
 838 */
 839 int sqlite3_deserialize(
 840   sqlite3 *db,            /* The database connection */
 841   const char *zSchema,    /* Which DB to reopen with the deserialization */
 842   unsigned char *pData,   /* The serialized database content */
 843   sqlite3_int64 szDb,     /* Number bytes in the deserialization */
 844   sqlite3_int64 szBuf,    /* Total size of buffer pData[] */
 845   unsigned mFlags         /* Zero or more SQLITE_DESERIALIZE_* flags */
 846 ){
 847   MemFile *p;
 848   char *zSql;
 849   sqlite3_stmt *pStmt = 0;
 850   int rc;
 851   int iDb;
 852
 853 #ifdef SQLITE_ENABLE_API_ARMOR
 854   if( !sqlite3SafetyCheckOk(db) ){
 855     return SQLITE_MISUSE_BKPT;
 856   }
 857   if( szDb<0 ) return SQLITE_MISUSE_BKPT;
 858   if( szBuf<0 ) return SQLITE_MISUSE_BKPT;
 859 #endif
 860
 861   sqlite3_mutex_enter(db->mutex);
 862   if( zSchema==0 ) zSchema = db->aDb[0].zDbSName;
 863   iDb = sqlite3FindDbName(db, zSchema);
 864   testcase( iDb==1 );
 865   if( iDb<2 && iDb!=0 ){
 866     rc = SQLITE_ERROR;
 867     goto end_deserialize;
 868   }
 869   zSql = sqlite3_mprintf("ATTACH x AS %Q", zSchema);
 870   if( zSql==0 ){
 871     rc = SQLITE_NOMEM;
 872   }else{
 873     rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
 874     sqlite3_free(zSql);
 875   }
 876   if( rc ) goto end_deserialize;
 877   db->init.iDb = (u8)iDb;
 878   db->init.reopenMemdb = 1;
 879   rc = sqlite3_step(pStmt);
 880   db->init.reopenMemdb = 0;
 881   if( rc!=SQLITE_DONE ){
 882     rc = SQLITE_ERROR;
 883     goto end_deserialize;
 884   }
 885   p = memdbFromDbSchema(db, zSchema);
 886   if( p==0 ){
 887     rc = SQLITE_ERROR;
 888   }else{
 889     MemStore *pStore = p->pStore;
 890     pStore->aData = pData;
 891     pData = 0;
 892     pStore->sz = szDb;
 893     pStore->szAlloc = szBuf;
 894     pStore->szMax = szBuf;
 895     if( pStore->szMax<sqlite3GlobalConfig.mxMemdbSize ){
 896       pStore->szMax = sqlite3GlobalConfig.mxMemdbSize;
 897     }
 898     pStore->mFlags = mFlags;
 899     rc = SQLITE_OK;
 900   }
 901
 902 end_deserialize:
 903   sqlite3_finalize(pStmt);
 904   if( pData && (mFlags & SQLITE_DESERIALIZE_FREEONCLOSE)!=0 ){
 905     sqlite3_free(pData);
 906   }
 907   sqlite3_mutex_leave(db->mutex);
 908   return rc;
 909 }
 910
 911 /*
 912 ** Return true if the VFS is the memvfs.
 913 */
 914 int sqlite3IsMemdb(const sqlite3_vfs *pVfs){
 915   return pVfs==&memdb_vfs;
 916 }
 917
 918 /*
 919 ** This routine is called when the extension is loaded.
 920 ** Register the new VFS.
 921 */
 922 int sqlite3MemdbInit(void){
 923   sqlite3_vfs *pLower = sqlite3_vfs_find(0);
 924   unsigned int sz;
 925   if( NEVER(pLower==0) ) return SQLITE_ERROR;
 926   sz = pLower->szOsFile;
 927   memdb_vfs.pAppData = pLower;
 928   /* The following conditional can only be true when compiled for
 929   ** Windows x86 and SQLITE_MAX_MMAP_SIZE=0.  We always leave
 930   ** it in, to be safe, but it is marked as NO_TEST since there
 931   ** is no way to reach it under most builds. */
 932   if( sz<sizeof(MemFile) ) sz = sizeof(MemFile); /*NO_TEST*/
 933   memdb_vfs.szOsFile = sz;
 934   return sqlite3_vfs_register(&memdb_vfs, 0);
 935 }
 936 #endif /* SQLITE_OMIT_DESERIALIZE */