drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 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 | ** |
drh | 840fda4 | 2018-03-28 15:06:39 +0000 | [diff] [blame] | 13 | ** This file implements an in-memory VFS. A database is held as a contiguous |
drh | 99abe5c | 2018-01-03 22:48:38 +0000 | [diff] [blame] | 14 | ** block of memory. |
| 15 | ** |
| 16 | ** This file also implements interface sqlite3_serialize() and |
| 17 | ** sqlite3_deserialize(). |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 18 | */ |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 19 | #include "sqliteInt.h" |
mistachkin | ed008ec | 2018-09-12 01:05:26 +0000 | [diff] [blame] | 20 | #ifdef SQLITE_ENABLE_DESERIALIZE |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 21 | |
| 22 | /* |
| 23 | ** Forward declaration of objects used by this utility |
| 24 | */ |
| 25 | typedef struct sqlite3_vfs MemVfs; |
| 26 | typedef struct MemFile MemFile; |
| 27 | |
| 28 | /* Access to a lower-level VFS that (might) implement dynamic loading, |
| 29 | ** access to randomness, etc. |
| 30 | */ |
| 31 | #define ORIGVFS(p) ((sqlite3_vfs*)((p)->pAppData)) |
| 32 | |
| 33 | /* An open file */ |
| 34 | struct MemFile { |
| 35 | sqlite3_file base; /* IO methods */ |
| 36 | sqlite3_int64 sz; /* Size of the file */ |
drh | 6ca6448 | 2019-01-22 16:06:20 +0000 | [diff] [blame] | 37 | sqlite3_int64 szAlloc; /* Space allocated to aData */ |
| 38 | sqlite3_int64 szMax; /* Maximum allowed size of the file */ |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 39 | unsigned char *aData; /* content of the file */ |
| 40 | int nMmap; /* Number of memory mapped pages */ |
| 41 | unsigned mFlags; /* Flags */ |
| 42 | int eLock; /* Most recent lock against this file */ |
| 43 | }; |
| 44 | |
| 45 | /* |
| 46 | ** Methods for MemFile |
| 47 | */ |
| 48 | static int memdbClose(sqlite3_file*); |
| 49 | static int memdbRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); |
| 50 | static int memdbWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst); |
| 51 | static int memdbTruncate(sqlite3_file*, sqlite3_int64 size); |
| 52 | static int memdbSync(sqlite3_file*, int flags); |
| 53 | static int memdbFileSize(sqlite3_file*, sqlite3_int64 *pSize); |
| 54 | static int memdbLock(sqlite3_file*, int); |
drh | 1471416 | 2018-03-06 19:14:32 +0000 | [diff] [blame] | 55 | /* static int memdbCheckReservedLock(sqlite3_file*, int *pResOut);// not used */ |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 56 | static int memdbFileControl(sqlite3_file*, int op, void *pArg); |
drh | 5f9d192 | 2018-03-06 04:01:08 +0000 | [diff] [blame] | 57 | /* static int memdbSectorSize(sqlite3_file*); // not used */ |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 58 | static int memdbDeviceCharacteristics(sqlite3_file*); |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 59 | static int memdbFetch(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp); |
| 60 | static int memdbUnfetch(sqlite3_file*, sqlite3_int64 iOfst, void *p); |
| 61 | |
| 62 | /* |
| 63 | ** Methods for MemVfs |
| 64 | */ |
| 65 | static int memdbOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *); |
drh | 1471416 | 2018-03-06 19:14:32 +0000 | [diff] [blame] | 66 | /* static int memdbDelete(sqlite3_vfs*, const char *zName, int syncDir); */ |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 67 | static int memdbAccess(sqlite3_vfs*, const char *zName, int flags, int *); |
| 68 | static int memdbFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut); |
| 69 | static void *memdbDlOpen(sqlite3_vfs*, const char *zFilename); |
| 70 | static void memdbDlError(sqlite3_vfs*, int nByte, char *zErrMsg); |
| 71 | static void (*memdbDlSym(sqlite3_vfs *pVfs, void *p, const char*zSym))(void); |
| 72 | static void memdbDlClose(sqlite3_vfs*, void*); |
| 73 | static int memdbRandomness(sqlite3_vfs*, int nByte, char *zOut); |
| 74 | static int memdbSleep(sqlite3_vfs*, int microseconds); |
drh | 1471416 | 2018-03-06 19:14:32 +0000 | [diff] [blame] | 75 | /* static int memdbCurrentTime(sqlite3_vfs*, double*); */ |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 76 | static int memdbGetLastError(sqlite3_vfs*, int, char *); |
| 77 | static int memdbCurrentTimeInt64(sqlite3_vfs*, sqlite3_int64*); |
| 78 | |
| 79 | static sqlite3_vfs memdb_vfs = { |
| 80 | 2, /* iVersion */ |
| 81 | 0, /* szOsFile (set when registered) */ |
| 82 | 1024, /* mxPathname */ |
| 83 | 0, /* pNext */ |
| 84 | "memdb", /* zName */ |
| 85 | 0, /* pAppData (set when registered) */ |
| 86 | memdbOpen, /* xOpen */ |
drh | 1471416 | 2018-03-06 19:14:32 +0000 | [diff] [blame] | 87 | 0, /* memdbDelete, */ /* xDelete */ |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 88 | memdbAccess, /* xAccess */ |
| 89 | memdbFullPathname, /* xFullPathname */ |
| 90 | memdbDlOpen, /* xDlOpen */ |
| 91 | memdbDlError, /* xDlError */ |
| 92 | memdbDlSym, /* xDlSym */ |
| 93 | memdbDlClose, /* xDlClose */ |
| 94 | memdbRandomness, /* xRandomness */ |
| 95 | memdbSleep, /* xSleep */ |
drh | 1471416 | 2018-03-06 19:14:32 +0000 | [diff] [blame] | 96 | 0, /* memdbCurrentTime, */ /* xCurrentTime */ |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 97 | memdbGetLastError, /* xGetLastError */ |
| 98 | memdbCurrentTimeInt64 /* xCurrentTimeInt64 */ |
| 99 | }; |
| 100 | |
| 101 | static const sqlite3_io_methods memdb_io_methods = { |
| 102 | 3, /* iVersion */ |
| 103 | memdbClose, /* xClose */ |
| 104 | memdbRead, /* xRead */ |
| 105 | memdbWrite, /* xWrite */ |
| 106 | memdbTruncate, /* xTruncate */ |
| 107 | memdbSync, /* xSync */ |
| 108 | memdbFileSize, /* xFileSize */ |
| 109 | memdbLock, /* xLock */ |
| 110 | memdbLock, /* xUnlock - same as xLock in this case */ |
drh | 1471416 | 2018-03-06 19:14:32 +0000 | [diff] [blame] | 111 | 0, /* memdbCheckReservedLock, */ /* xCheckReservedLock */ |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 112 | memdbFileControl, /* xFileControl */ |
drh | 5f9d192 | 2018-03-06 04:01:08 +0000 | [diff] [blame] | 113 | 0, /* memdbSectorSize,*/ /* xSectorSize */ |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 114 | memdbDeviceCharacteristics, /* xDeviceCharacteristics */ |
drh | 99abe5c | 2018-01-03 22:48:38 +0000 | [diff] [blame] | 115 | 0, /* xShmMap */ |
| 116 | 0, /* xShmLock */ |
| 117 | 0, /* xShmBarrier */ |
| 118 | 0, /* xShmUnmap */ |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 119 | memdbFetch, /* xFetch */ |
| 120 | memdbUnfetch /* xUnfetch */ |
| 121 | }; |
| 122 | |
| 123 | |
| 124 | |
| 125 | /* |
| 126 | ** Close an memdb-file. |
| 127 | ** |
| 128 | ** The pData pointer is owned by the application, so there is nothing |
| 129 | ** to free. |
| 130 | */ |
| 131 | static int memdbClose(sqlite3_file *pFile){ |
| 132 | MemFile *p = (MemFile *)pFile; |
drh | 3ec8665 | 2018-01-03 19:03:31 +0000 | [diff] [blame] | 133 | if( p->mFlags & SQLITE_DESERIALIZE_FREEONCLOSE ) sqlite3_free(p->aData); |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 134 | return SQLITE_OK; |
| 135 | } |
| 136 | |
| 137 | /* |
| 138 | ** Read data from an memdb-file. |
| 139 | */ |
| 140 | static int memdbRead( |
| 141 | sqlite3_file *pFile, |
| 142 | void *zBuf, |
| 143 | int iAmt, |
| 144 | sqlite_int64 iOfst |
| 145 | ){ |
| 146 | MemFile *p = (MemFile *)pFile; |
| 147 | if( iOfst+iAmt>p->sz ){ |
| 148 | memset(zBuf, 0, iAmt); |
drh | cb7d541 | 2018-01-03 16:49:52 +0000 | [diff] [blame] | 149 | if( iOfst<p->sz ) memcpy(zBuf, p->aData+iOfst, p->sz - iOfst); |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 150 | return SQLITE_IOERR_SHORT_READ; |
| 151 | } |
| 152 | memcpy(zBuf, p->aData+iOfst, iAmt); |
| 153 | return SQLITE_OK; |
| 154 | } |
| 155 | |
| 156 | /* |
| 157 | ** Try to enlarge the memory allocation to hold at least sz bytes |
| 158 | */ |
| 159 | static int memdbEnlarge(MemFile *p, sqlite3_int64 newSz){ |
| 160 | unsigned char *pNew; |
drh | 5f9d192 | 2018-03-06 04:01:08 +0000 | [diff] [blame] | 161 | if( (p->mFlags & SQLITE_DESERIALIZE_RESIZEABLE)==0 || p->nMmap>0 ){ |
| 162 | return SQLITE_FULL; |
| 163 | } |
drh | 6ca6448 | 2019-01-22 16:06:20 +0000 | [diff] [blame] | 164 | if( newSz>p->szMax ){ |
| 165 | return SQLITE_FULL; |
| 166 | } |
| 167 | newSz *= 2; |
| 168 | if( newSz>p->szMax ) newSz = p->szMax; |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 169 | pNew = sqlite3_realloc64(p->aData, newSz); |
drh | 5f9d192 | 2018-03-06 04:01:08 +0000 | [diff] [blame] | 170 | if( pNew==0 ) return SQLITE_NOMEM; |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 171 | p->aData = pNew; |
drh | 6ca6448 | 2019-01-22 16:06:20 +0000 | [diff] [blame] | 172 | p->szAlloc = newSz; |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 173 | return SQLITE_OK; |
| 174 | } |
| 175 | |
| 176 | /* |
| 177 | ** Write data to an memdb-file. |
| 178 | */ |
| 179 | static int memdbWrite( |
| 180 | sqlite3_file *pFile, |
| 181 | const void *z, |
| 182 | int iAmt, |
| 183 | sqlite_int64 iOfst |
| 184 | ){ |
| 185 | MemFile *p = (MemFile *)pFile; |
drh | f186f0b | 2019-01-22 16:43:47 +0000 | [diff] [blame] | 186 | if( NEVER(p->mFlags & SQLITE_DESERIALIZE_READONLY) ) return SQLITE_READONLY; |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 187 | if( iOfst+iAmt>p->sz ){ |
drh | 5f9d192 | 2018-03-06 04:01:08 +0000 | [diff] [blame] | 188 | int rc; |
drh | 6ca6448 | 2019-01-22 16:06:20 +0000 | [diff] [blame] | 189 | if( iOfst+iAmt>p->szAlloc |
| 190 | && (rc = memdbEnlarge(p, iOfst+iAmt))!=SQLITE_OK |
drh | 5f9d192 | 2018-03-06 04:01:08 +0000 | [diff] [blame] | 191 | ){ |
| 192 | return rc; |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 193 | } |
| 194 | if( iOfst>p->sz ) memset(p->aData+p->sz, 0, iOfst-p->sz); |
| 195 | p->sz = iOfst+iAmt; |
| 196 | } |
| 197 | memcpy(p->aData+iOfst, z, iAmt); |
| 198 | return SQLITE_OK; |
| 199 | } |
| 200 | |
| 201 | /* |
| 202 | ** Truncate an memdb-file. |
drh | 1471416 | 2018-03-06 19:14:32 +0000 | [diff] [blame] | 203 | ** |
| 204 | ** In rollback mode (which is always the case for memdb, as it does not |
| 205 | ** support WAL mode) the truncate() method is only used to reduce |
| 206 | ** the size of a file, never to increase the size. |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 207 | */ |
| 208 | static int memdbTruncate(sqlite3_file *pFile, sqlite_int64 size){ |
| 209 | MemFile *p = (MemFile *)pFile; |
drh | 1471416 | 2018-03-06 19:14:32 +0000 | [diff] [blame] | 210 | if( NEVER(size>p->sz) ) return SQLITE_FULL; |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 211 | p->sz = size; |
| 212 | return SQLITE_OK; |
| 213 | } |
| 214 | |
| 215 | /* |
| 216 | ** Sync an memdb-file. |
| 217 | */ |
| 218 | static int memdbSync(sqlite3_file *pFile, int flags){ |
| 219 | return SQLITE_OK; |
| 220 | } |
| 221 | |
| 222 | /* |
| 223 | ** Return the current file-size of an memdb-file. |
| 224 | */ |
| 225 | static int memdbFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){ |
| 226 | MemFile *p = (MemFile *)pFile; |
| 227 | *pSize = p->sz; |
| 228 | return SQLITE_OK; |
| 229 | } |
| 230 | |
| 231 | /* |
| 232 | ** Lock an memdb-file. |
| 233 | */ |
| 234 | static int memdbLock(sqlite3_file *pFile, int eLock){ |
| 235 | MemFile *p = (MemFile *)pFile; |
drh | f186f0b | 2019-01-22 16:43:47 +0000 | [diff] [blame] | 236 | if( eLock>SQLITE_LOCK_SHARED |
| 237 | && (p->mFlags & SQLITE_DESERIALIZE_READONLY)!=0 |
| 238 | ){ |
| 239 | return SQLITE_READONLY; |
| 240 | } |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 241 | p->eLock = eLock; |
| 242 | return SQLITE_OK; |
| 243 | } |
| 244 | |
drh | 1471416 | 2018-03-06 19:14:32 +0000 | [diff] [blame] | 245 | #if 0 /* Never used because memdbAccess() always returns false */ |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 246 | /* |
| 247 | ** Check if another file-handle holds a RESERVED lock on an memdb-file. |
| 248 | */ |
| 249 | static int memdbCheckReservedLock(sqlite3_file *pFile, int *pResOut){ |
| 250 | *pResOut = 0; |
| 251 | return SQLITE_OK; |
| 252 | } |
drh | 1471416 | 2018-03-06 19:14:32 +0000 | [diff] [blame] | 253 | #endif |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 254 | |
| 255 | /* |
| 256 | ** File control method. For custom operations on an memdb-file. |
| 257 | */ |
| 258 | static int memdbFileControl(sqlite3_file *pFile, int op, void *pArg){ |
| 259 | MemFile *p = (MemFile *)pFile; |
| 260 | int rc = SQLITE_NOTFOUND; |
| 261 | if( op==SQLITE_FCNTL_VFSNAME ){ |
| 262 | *(char**)pArg = sqlite3_mprintf("memdb(%p,%lld)", p->aData, p->sz); |
| 263 | rc = SQLITE_OK; |
| 264 | } |
drh | 6ca6448 | 2019-01-22 16:06:20 +0000 | [diff] [blame] | 265 | if( op==SQLITE_FCNTL_SIZE_LIMIT ){ |
| 266 | sqlite3_int64 iLimit = *(sqlite3_int64*)pArg; |
| 267 | if( iLimit<p->sz ){ |
| 268 | if( iLimit<0 ){ |
| 269 | iLimit = p->szMax; |
| 270 | }else{ |
| 271 | iLimit = p->sz; |
| 272 | } |
| 273 | } |
| 274 | p->szMax = iLimit; |
| 275 | *(sqlite3_int64*)pArg = iLimit; |
| 276 | rc = SQLITE_OK; |
| 277 | } |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 278 | return rc; |
| 279 | } |
| 280 | |
drh | 5f9d192 | 2018-03-06 04:01:08 +0000 | [diff] [blame] | 281 | #if 0 /* Not used because of SQLITE_IOCAP_POWERSAFE_OVERWRITE */ |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 282 | /* |
| 283 | ** Return the sector-size in bytes for an memdb-file. |
| 284 | */ |
| 285 | static int memdbSectorSize(sqlite3_file *pFile){ |
| 286 | return 1024; |
| 287 | } |
drh | 5f9d192 | 2018-03-06 04:01:08 +0000 | [diff] [blame] | 288 | #endif |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 289 | |
| 290 | /* |
| 291 | ** Return the device characteristic flags supported by an memdb-file. |
| 292 | */ |
| 293 | static int memdbDeviceCharacteristics(sqlite3_file *pFile){ |
| 294 | return SQLITE_IOCAP_ATOMIC | |
| 295 | SQLITE_IOCAP_POWERSAFE_OVERWRITE | |
| 296 | SQLITE_IOCAP_SAFE_APPEND | |
| 297 | SQLITE_IOCAP_SEQUENTIAL; |
| 298 | } |
| 299 | |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 300 | /* Fetch a page of a memory-mapped file */ |
| 301 | static int memdbFetch( |
| 302 | sqlite3_file *pFile, |
| 303 | sqlite3_int64 iOfst, |
| 304 | int iAmt, |
| 305 | void **pp |
| 306 | ){ |
| 307 | MemFile *p = (MemFile *)pFile; |
drh | 94f0a83 | 2019-01-25 14:16:01 +0000 | [diff] [blame] | 308 | if( iOfst+iAmt>p->sz ){ |
drh | 94f0a83 | 2019-01-25 14:16:01 +0000 | [diff] [blame] | 309 | *pp = 0; |
| 310 | }else{ |
| 311 | p->nMmap++; |
| 312 | *pp = (void*)(p->aData + iOfst); |
| 313 | } |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 314 | return SQLITE_OK; |
| 315 | } |
| 316 | |
| 317 | /* Release a memory-mapped page */ |
| 318 | static int memdbUnfetch(sqlite3_file *pFile, sqlite3_int64 iOfst, void *pPage){ |
| 319 | MemFile *p = (MemFile *)pFile; |
| 320 | p->nMmap--; |
| 321 | return SQLITE_OK; |
| 322 | } |
| 323 | |
| 324 | /* |
| 325 | ** Open an mem file handle. |
| 326 | */ |
| 327 | static int memdbOpen( |
| 328 | sqlite3_vfs *pVfs, |
| 329 | const char *zName, |
| 330 | sqlite3_file *pFile, |
| 331 | int flags, |
| 332 | int *pOutFlags |
| 333 | ){ |
| 334 | MemFile *p = (MemFile*)pFile; |
drh | 5f9d192 | 2018-03-06 04:01:08 +0000 | [diff] [blame] | 335 | if( (flags & SQLITE_OPEN_MAIN_DB)==0 ){ |
| 336 | return ORIGVFS(pVfs)->xOpen(ORIGVFS(pVfs), zName, pFile, flags, pOutFlags); |
| 337 | } |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 338 | memset(p, 0, sizeof(*p)); |
drh | 3ec8665 | 2018-01-03 19:03:31 +0000 | [diff] [blame] | 339 | p->mFlags = SQLITE_DESERIALIZE_RESIZEABLE | SQLITE_DESERIALIZE_FREEONCLOSE; |
drh | 1471416 | 2018-03-06 19:14:32 +0000 | [diff] [blame] | 340 | assert( pOutFlags!=0 ); /* True because flags==SQLITE_OPEN_MAIN_DB */ |
| 341 | *pOutFlags = flags | SQLITE_OPEN_MEMORY; |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 342 | p->base.pMethods = &memdb_io_methods; |
drh | 23a8859 | 2019-01-31 15:38:53 +0000 | [diff] [blame] | 343 | p->szMax = sqlite3GlobalConfig.mxMemdbSize; |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 344 | return SQLITE_OK; |
| 345 | } |
| 346 | |
drh | 1471416 | 2018-03-06 19:14:32 +0000 | [diff] [blame] | 347 | #if 0 /* Only used to delete rollback journals, master journals, and WAL |
| 348 | ** files, none of which exist in memdb. So this routine is never used */ |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 349 | /* |
| 350 | ** Delete the file located at zPath. If the dirSync argument is true, |
| 351 | ** ensure the file-system modifications are synced to disk before |
| 352 | ** returning. |
| 353 | */ |
| 354 | static int memdbDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){ |
| 355 | return SQLITE_IOERR_DELETE; |
| 356 | } |
drh | 1471416 | 2018-03-06 19:14:32 +0000 | [diff] [blame] | 357 | #endif |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 358 | |
| 359 | /* |
| 360 | ** Test for access permissions. Return true if the requested permission |
| 361 | ** is available, or false otherwise. |
drh | 1471416 | 2018-03-06 19:14:32 +0000 | [diff] [blame] | 362 | ** |
| 363 | ** With memdb, no files ever exist on disk. So always return false. |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 364 | */ |
| 365 | static int memdbAccess( |
| 366 | sqlite3_vfs *pVfs, |
| 367 | const char *zPath, |
| 368 | int flags, |
| 369 | int *pResOut |
| 370 | ){ |
| 371 | *pResOut = 0; |
| 372 | return SQLITE_OK; |
| 373 | } |
| 374 | |
| 375 | /* |
| 376 | ** Populate buffer zOut with the full canonical pathname corresponding |
| 377 | ** to the pathname in zPath. zOut is guaranteed to point to a buffer |
| 378 | ** of at least (INST_MAX_PATHNAME+1) bytes. |
| 379 | */ |
| 380 | static int memdbFullPathname( |
| 381 | sqlite3_vfs *pVfs, |
| 382 | const char *zPath, |
| 383 | int nOut, |
| 384 | char *zOut |
| 385 | ){ |
| 386 | sqlite3_snprintf(nOut, zOut, "%s", zPath); |
| 387 | return SQLITE_OK; |
| 388 | } |
| 389 | |
| 390 | /* |
| 391 | ** Open the dynamic library located at zPath and return a handle. |
| 392 | */ |
| 393 | static void *memdbDlOpen(sqlite3_vfs *pVfs, const char *zPath){ |
| 394 | return ORIGVFS(pVfs)->xDlOpen(ORIGVFS(pVfs), zPath); |
| 395 | } |
| 396 | |
| 397 | /* |
| 398 | ** Populate the buffer zErrMsg (size nByte bytes) with a human readable |
| 399 | ** utf-8 string describing the most recent error encountered associated |
| 400 | ** with dynamic libraries. |
| 401 | */ |
| 402 | static void memdbDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){ |
| 403 | ORIGVFS(pVfs)->xDlError(ORIGVFS(pVfs), nByte, zErrMsg); |
| 404 | } |
| 405 | |
| 406 | /* |
| 407 | ** Return a pointer to the symbol zSymbol in the dynamic library pHandle. |
| 408 | */ |
| 409 | static void (*memdbDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){ |
| 410 | return ORIGVFS(pVfs)->xDlSym(ORIGVFS(pVfs), p, zSym); |
| 411 | } |
| 412 | |
| 413 | /* |
| 414 | ** Close the dynamic library handle pHandle. |
| 415 | */ |
| 416 | static void memdbDlClose(sqlite3_vfs *pVfs, void *pHandle){ |
| 417 | ORIGVFS(pVfs)->xDlClose(ORIGVFS(pVfs), pHandle); |
| 418 | } |
| 419 | |
| 420 | /* |
| 421 | ** Populate the buffer pointed to by zBufOut with nByte bytes of |
| 422 | ** random data. |
| 423 | */ |
| 424 | static int memdbRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ |
| 425 | return ORIGVFS(pVfs)->xRandomness(ORIGVFS(pVfs), nByte, zBufOut); |
| 426 | } |
| 427 | |
| 428 | /* |
| 429 | ** Sleep for nMicro microseconds. Return the number of microseconds |
| 430 | ** actually slept. |
| 431 | */ |
| 432 | static int memdbSleep(sqlite3_vfs *pVfs, int nMicro){ |
| 433 | return ORIGVFS(pVfs)->xSleep(ORIGVFS(pVfs), nMicro); |
| 434 | } |
| 435 | |
drh | 1471416 | 2018-03-06 19:14:32 +0000 | [diff] [blame] | 436 | #if 0 /* Never used. Modern cores only call xCurrentTimeInt64() */ |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 437 | /* |
| 438 | ** Return the current time as a Julian Day number in *pTimeOut. |
| 439 | */ |
| 440 | static int memdbCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){ |
| 441 | return ORIGVFS(pVfs)->xCurrentTime(ORIGVFS(pVfs), pTimeOut); |
| 442 | } |
drh | 1471416 | 2018-03-06 19:14:32 +0000 | [diff] [blame] | 443 | #endif |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 444 | |
| 445 | static int memdbGetLastError(sqlite3_vfs *pVfs, int a, char *b){ |
| 446 | return ORIGVFS(pVfs)->xGetLastError(ORIGVFS(pVfs), a, b); |
| 447 | } |
| 448 | static int memdbCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *p){ |
| 449 | return ORIGVFS(pVfs)->xCurrentTimeInt64(ORIGVFS(pVfs), p); |
| 450 | } |
| 451 | |
| 452 | /* |
| 453 | ** Translate a database connection pointer and schema name into a |
| 454 | ** MemFile pointer. |
| 455 | */ |
| 456 | static MemFile *memdbFromDbSchema(sqlite3 *db, const char *zSchema){ |
| 457 | MemFile *p = 0; |
| 458 | int rc = sqlite3_file_control(db, zSchema, SQLITE_FCNTL_FILE_POINTER, &p); |
| 459 | if( rc ) return 0; |
| 460 | if( p->base.pMethods!=&memdb_io_methods ) return 0; |
| 461 | return p; |
| 462 | } |
| 463 | |
| 464 | /* |
drh | cb7d541 | 2018-01-03 16:49:52 +0000 | [diff] [blame] | 465 | ** Return the serialization of a database |
| 466 | */ |
| 467 | unsigned char *sqlite3_serialize( |
| 468 | sqlite3 *db, /* The database connection */ |
| 469 | const char *zSchema, /* Which database within the connection */ |
| 470 | sqlite3_int64 *piSize, /* Write size here, if not NULL */ |
| 471 | unsigned int mFlags /* Maybe SQLITE_SERIALIZE_NOCOPY */ |
| 472 | ){ |
drh | b2194ce | 2018-03-01 22:18:26 +0000 | [diff] [blame] | 473 | MemFile *p; |
| 474 | int iDb; |
drh | cb7d541 | 2018-01-03 16:49:52 +0000 | [diff] [blame] | 475 | Btree *pBt; |
| 476 | sqlite3_int64 sz; |
| 477 | int szPage = 0; |
| 478 | sqlite3_stmt *pStmt = 0; |
| 479 | unsigned char *pOut; |
| 480 | char *zSql; |
| 481 | int rc; |
| 482 | |
mistachkin | 6630f94 | 2018-03-08 19:56:52 +0000 | [diff] [blame] | 483 | #ifdef SQLITE_ENABLE_API_ARMOR |
| 484 | if( !sqlite3SafetyCheckOk(db) ){ |
| 485 | (void)SQLITE_MISUSE_BKPT; |
| 486 | return 0; |
| 487 | } |
| 488 | #endif |
| 489 | |
drh | b2194ce | 2018-03-01 22:18:26 +0000 | [diff] [blame] | 490 | if( zSchema==0 ) zSchema = db->aDb[0].zDbSName; |
| 491 | p = memdbFromDbSchema(db, zSchema); |
| 492 | iDb = sqlite3FindDbName(db, zSchema); |
drh | cb7d541 | 2018-01-03 16:49:52 +0000 | [diff] [blame] | 493 | if( piSize ) *piSize = -1; |
| 494 | if( iDb<0 ) return 0; |
| 495 | if( p ){ |
| 496 | if( piSize ) *piSize = p->sz; |
| 497 | if( mFlags & SQLITE_SERIALIZE_NOCOPY ){ |
| 498 | pOut = p->aData; |
| 499 | }else{ |
| 500 | pOut = sqlite3_malloc64( p->sz ); |
| 501 | if( pOut ) memcpy(pOut, p->aData, p->sz); |
| 502 | } |
| 503 | return pOut; |
| 504 | } |
| 505 | pBt = db->aDb[iDb].pBt; |
| 506 | if( pBt==0 ) return 0; |
| 507 | szPage = sqlite3BtreeGetPageSize(pBt); |
| 508 | zSql = sqlite3_mprintf("PRAGMA \"%w\".page_count", zSchema); |
| 509 | rc = zSql ? sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0) : SQLITE_NOMEM; |
| 510 | sqlite3_free(zSql); |
| 511 | if( rc ) return 0; |
drh | 8784efa | 2018-03-06 20:54:27 +0000 | [diff] [blame] | 512 | rc = sqlite3_step(pStmt); |
| 513 | if( rc!=SQLITE_ROW ){ |
drh | cb7d541 | 2018-01-03 16:49:52 +0000 | [diff] [blame] | 514 | pOut = 0; |
| 515 | }else{ |
drh | 8784efa | 2018-03-06 20:54:27 +0000 | [diff] [blame] | 516 | sz = sqlite3_column_int64(pStmt, 0)*szPage; |
| 517 | if( piSize ) *piSize = sz; |
| 518 | if( mFlags & SQLITE_SERIALIZE_NOCOPY ){ |
| 519 | pOut = 0; |
| 520 | }else{ |
| 521 | pOut = sqlite3_malloc64( sz ); |
| 522 | if( pOut ){ |
| 523 | int nPage = sqlite3_column_int(pStmt, 0); |
| 524 | Pager *pPager = sqlite3BtreePager(pBt); |
| 525 | int pgno; |
| 526 | for(pgno=1; pgno<=nPage; pgno++){ |
| 527 | DbPage *pPage = 0; |
| 528 | unsigned char *pTo = pOut + szPage*(sqlite3_int64)(pgno-1); |
| 529 | rc = sqlite3PagerGet(pPager, pgno, (DbPage**)&pPage, 0); |
| 530 | if( rc==SQLITE_OK ){ |
| 531 | memcpy(pTo, sqlite3PagerGetData(pPage), szPage); |
| 532 | }else{ |
| 533 | memset(pTo, 0, szPage); |
| 534 | } |
| 535 | sqlite3PagerUnref(pPage); |
drh | cb7d541 | 2018-01-03 16:49:52 +0000 | [diff] [blame] | 536 | } |
drh | cb7d541 | 2018-01-03 16:49:52 +0000 | [diff] [blame] | 537 | } |
| 538 | } |
| 539 | } |
| 540 | sqlite3_finalize(pStmt); |
| 541 | return pOut; |
| 542 | } |
| 543 | |
drh | 3ec8665 | 2018-01-03 19:03:31 +0000 | [diff] [blame] | 544 | /* Convert zSchema to a MemDB and initialize its content. |
| 545 | */ |
| 546 | int sqlite3_deserialize( |
| 547 | sqlite3 *db, /* The database connection */ |
| 548 | const char *zSchema, /* Which DB to reopen with the deserialization */ |
| 549 | unsigned char *pData, /* The serialized database content */ |
| 550 | sqlite3_int64 szDb, /* Number bytes in the deserialization */ |
| 551 | sqlite3_int64 szBuf, /* Total size of buffer pData[] */ |
| 552 | unsigned mFlags /* Zero or more SQLITE_DESERIALIZE_* flags */ |
| 553 | ){ |
| 554 | MemFile *p; |
| 555 | char *zSql; |
| 556 | sqlite3_stmt *pStmt = 0; |
| 557 | int rc; |
| 558 | int iDb; |
| 559 | |
mistachkin | 6630f94 | 2018-03-08 19:56:52 +0000 | [diff] [blame] | 560 | #ifdef SQLITE_ENABLE_API_ARMOR |
| 561 | if( !sqlite3SafetyCheckOk(db) ){ |
| 562 | return SQLITE_MISUSE_BKPT; |
| 563 | } |
| 564 | if( szDb<0 ) return SQLITE_MISUSE_BKPT; |
| 565 | if( szBuf<0 ) return SQLITE_MISUSE_BKPT; |
| 566 | #endif |
| 567 | |
drh | 3ec8665 | 2018-01-03 19:03:31 +0000 | [diff] [blame] | 568 | sqlite3_mutex_enter(db->mutex); |
| 569 | if( zSchema==0 ) zSchema = db->aDb[0].zDbSName; |
| 570 | iDb = sqlite3FindDbName(db, zSchema); |
| 571 | if( iDb<0 ){ |
| 572 | rc = SQLITE_ERROR; |
| 573 | goto end_deserialize; |
| 574 | } |
| 575 | zSql = sqlite3_mprintf("ATTACH x AS %Q", zSchema); |
| 576 | rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); |
| 577 | sqlite3_free(zSql); |
| 578 | if( rc ) goto end_deserialize; |
| 579 | db->init.iDb = (u8)iDb; |
| 580 | db->init.reopenMemdb = 1; |
| 581 | rc = sqlite3_step(pStmt); |
| 582 | db->init.reopenMemdb = 0; |
| 583 | if( rc!=SQLITE_DONE ){ |
| 584 | rc = SQLITE_ERROR; |
| 585 | goto end_deserialize; |
| 586 | } |
| 587 | p = memdbFromDbSchema(db, zSchema); |
drh | 8784efa | 2018-03-06 20:54:27 +0000 | [diff] [blame] | 588 | if( p==0 ){ |
| 589 | rc = SQLITE_ERROR; |
| 590 | }else{ |
| 591 | p->aData = pData; |
| 592 | p->sz = szDb; |
drh | 6ca6448 | 2019-01-22 16:06:20 +0000 | [diff] [blame] | 593 | p->szAlloc = szBuf; |
drh | 8784efa | 2018-03-06 20:54:27 +0000 | [diff] [blame] | 594 | p->szMax = szBuf; |
drh | 23a8859 | 2019-01-31 15:38:53 +0000 | [diff] [blame] | 595 | if( p->szMax<sqlite3GlobalConfig.mxMemdbSize ){ |
| 596 | p->szMax = sqlite3GlobalConfig.mxMemdbSize; |
drh | 6ca6448 | 2019-01-22 16:06:20 +0000 | [diff] [blame] | 597 | } |
drh | 8784efa | 2018-03-06 20:54:27 +0000 | [diff] [blame] | 598 | p->mFlags = mFlags; |
| 599 | rc = SQLITE_OK; |
| 600 | } |
| 601 | |
drh | 3ec8665 | 2018-01-03 19:03:31 +0000 | [diff] [blame] | 602 | end_deserialize: |
| 603 | sqlite3_finalize(pStmt); |
| 604 | sqlite3_mutex_leave(db->mutex); |
| 605 | return rc; |
| 606 | } |
| 607 | |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 608 | /* |
| 609 | ** This routine is called when the extension is loaded. |
| 610 | ** Register the new VFS. |
| 611 | */ |
| 612 | int sqlite3MemdbInit(void){ |
drh | 5f9d192 | 2018-03-06 04:01:08 +0000 | [diff] [blame] | 613 | sqlite3_vfs *pLower = sqlite3_vfs_find(0); |
| 614 | int sz = pLower->szOsFile; |
| 615 | memdb_vfs.pAppData = pLower; |
drh | 4811a71 | 2018-03-07 01:37:05 +0000 | [diff] [blame] | 616 | /* In all known configurations of SQLite, the size of a default |
| 617 | ** sqlite3_file is greater than the size of a memdb sqlite3_file. |
| 618 | ** Should that ever change, remove the following NEVER() */ |
| 619 | if( NEVER(sz<sizeof(MemFile)) ) sz = sizeof(MemFile); |
drh | 5f9d192 | 2018-03-06 04:01:08 +0000 | [diff] [blame] | 620 | memdb_vfs.szOsFile = sz; |
drh | ac442f4 | 2018-01-03 01:28:46 +0000 | [diff] [blame] | 621 | return sqlite3_vfs_register(&memdb_vfs, 0); |
| 622 | } |
drh | 9c6396e | 2018-03-06 21:43:19 +0000 | [diff] [blame] | 623 | #endif /* SQLITE_ENABLE_DESERIALIZE */ |