sqlite_wasm_rs/vfs/
memory.rs

1//! Memory VFS, used as the default VFS
2//!
3//! ```rust
4//! use sqlite_wasm_rs as ffi;
5//!
6//! fn open_db() {
7//!     // open with memory vfs
8//!     let mut db = std::ptr::null_mut();
9//!     let ret = unsafe {
10//!         ffi::sqlite3_open_v2(
11//!             c"mem.db".as_ptr().cast(),
12//!             &mut db as *mut _,
13//!             ffi::SQLITE_OPEN_READWRITE | ffi::SQLITE_OPEN_CREATE,
14//!             std::ptr::null()
15//!         )
16//!     };
17//!     assert_eq!(ffi::SQLITE_OK, ret);
18//! }
19//! ```
20//!
21//! Data is stored in memory, this is the default vfs, and reading
22//! and writing are very fast, after all, in memory.
23//!
24//! Refresh the page and data will be lost, and you also need to
25//! pay attention to the memory size limit of the browser page.
26
27use crate::libsqlite3::*;
28use crate::vfs::utils::{
29    check_import_db, ImportDbError, MemChunksFile, SQLiteIoMethods, SQLiteVfs, SQLiteVfsFile,
30    VfsAppData, VfsError, VfsFile, VfsResult, VfsStore,
31};
32
33use std::cell::RefCell;
34use std::collections::HashMap;
35use std::ffi::CStr;
36
37const VFS_NAME: &CStr = c"memvfs";
38
39type Result<T> = std::result::Result<T, MemVfsError>;
40
41pub(crate) enum MemFile {
42    Main(MemChunksFile),
43    Temp(MemChunksFile),
44}
45
46impl MemFile {
47    fn new(flags: i32) -> Self {
48        if flags & SQLITE_OPEN_MAIN_DB == 0 {
49            Self::Temp(MemChunksFile::default())
50        } else {
51            Self::Main(MemChunksFile::waiting_for_write())
52        }
53    }
54
55    fn file(&self) -> &MemChunksFile {
56        let (MemFile::Main(file) | MemFile::Temp(file)) = self;
57        file
58    }
59
60    fn file_mut(&mut self) -> &mut MemChunksFile {
61        let (MemFile::Main(file) | MemFile::Temp(file)) = self;
62        file
63    }
64}
65
66impl VfsFile for MemFile {
67    fn read(&self, buf: &mut [u8], offset: usize) -> VfsResult<bool> {
68        self.file().read(buf, offset)
69    }
70
71    fn write(&mut self, buf: &[u8], offset: usize) -> VfsResult<()> {
72        self.file_mut().write(buf, offset)
73    }
74
75    fn truncate(&mut self, size: usize) -> VfsResult<()> {
76        self.file_mut().truncate(size)
77    }
78
79    fn flush(&mut self) -> VfsResult<()> {
80        self.file_mut().flush()
81    }
82
83    fn size(&self) -> VfsResult<usize> {
84        self.file().size()
85    }
86}
87
88type MemAppData = RefCell<HashMap<String, MemFile>>;
89
90struct MemStore;
91
92impl VfsStore<MemFile, MemAppData> for MemStore {
93    fn add_file(vfs: *mut sqlite3_vfs, file: &str, flags: i32) -> VfsResult<()> {
94        let app_data = unsafe { Self::app_data(vfs) };
95        app_data
96            .borrow_mut()
97            .insert(file.into(), MemFile::new(flags));
98        Ok(())
99    }
100
101    fn contains_file(vfs: *mut sqlite3_vfs, file: &str) -> VfsResult<bool> {
102        let app_data = unsafe { Self::app_data(vfs) };
103        Ok(app_data.borrow().contains_key(file))
104    }
105
106    fn delete_file(vfs: *mut sqlite3_vfs, file: &str) -> VfsResult<()> {
107        let app_data = unsafe { Self::app_data(vfs) };
108        if app_data.borrow_mut().remove(file).is_none() {
109            return Err(VfsError::new(
110                SQLITE_IOERR_DELETE,
111                format!("{file} not found"),
112            ));
113        }
114        Ok(())
115    }
116
117    fn with_file<F: Fn(&MemFile) -> VfsResult<i32>>(
118        vfs_file: &SQLiteVfsFile,
119        f: F,
120    ) -> VfsResult<i32> {
121        let name = unsafe { vfs_file.name() };
122        let app_data = unsafe { Self::app_data(vfs_file.vfs) };
123        match app_data.borrow().get(name) {
124            Some(file) => f(file),
125            None => Err(VfsError::new(SQLITE_IOERR, format!("{name} not found"))),
126        }
127    }
128
129    fn with_file_mut<F: Fn(&mut MemFile) -> VfsResult<i32>>(
130        vfs_file: &SQLiteVfsFile,
131        f: F,
132    ) -> VfsResult<i32> {
133        let name = unsafe { vfs_file.name() };
134        let app_data = unsafe { Self::app_data(vfs_file.vfs) };
135        match app_data.borrow_mut().get_mut(name) {
136            Some(file) => f(file),
137            None => Err(VfsError::new(SQLITE_IOERR, format!("{name} not found"))),
138        }
139    }
140}
141
142struct MemIoMethods;
143
144impl SQLiteIoMethods for MemIoMethods {
145    type File = MemFile;
146    type AppData = MemAppData;
147    type Store = MemStore;
148
149    const VERSION: ::std::os::raw::c_int = 1;
150}
151
152struct MemVfs;
153
154impl SQLiteVfs<MemIoMethods> for MemVfs {
155    const VERSION: ::std::os::raw::c_int = 1;
156}
157
158#[derive(thiserror::Error, Debug)]
159pub enum MemVfsError {
160    #[error(transparent)]
161    ImportDb(#[from] ImportDbError),
162    #[error("Generic error: {0}")]
163    Generic(String),
164}
165
166/// MemVfs management tool.
167pub struct MemVfsUtil(&'static VfsAppData<MemAppData>);
168
169unsafe impl Send for MemVfsUtil {}
170
171unsafe impl Sync for MemVfsUtil {}
172
173impl Default for MemVfsUtil {
174    fn default() -> Self {
175        MemVfsUtil::new()
176    }
177}
178
179impl MemVfsUtil {
180    /// Get management tool
181    pub fn new() -> Self {
182        MemVfsUtil(unsafe { install() })
183    }
184}
185
186impl MemVfsUtil {
187    fn import_db_unchecked_impl(
188        &self,
189        filename: &str,
190        bytes: &[u8],
191        page_size: usize,
192        clear_wal: bool,
193    ) -> Result<()> {
194        if self.exists(filename) {
195            return Err(MemVfsError::Generic(format!(
196                "{filename} file already exists"
197            )));
198        }
199
200        self.0.borrow_mut().insert(filename.into(), {
201            let mut file = MemFile::Main(MemChunksFile::new(page_size));
202            file.write(bytes, 0).unwrap();
203            if clear_wal {
204                file.write(&[1, 1], 18).unwrap();
205            }
206            file
207        });
208
209        Ok(())
210    }
211
212    /// Import the database.
213    ///
214    /// If the database is imported with WAL mode enabled,
215    /// it will be forced to write back to legacy mode, see
216    /// <https://sqlite.org/forum/forumpost/67882c5b04>
217    ///
218    /// If the imported database is encrypted, use `import_db_unchecked` instead.
219    pub fn import_db(&self, filename: &str, bytes: &[u8]) -> Result<()> {
220        let page_size = check_import_db(bytes)?;
221        self.import_db_unchecked_impl(filename, bytes, page_size, true)
222    }
223
224    /// `import_db` without checking, can be used to import encrypted database.
225    pub fn import_db_unchecked(
226        &self,
227        filename: &str,
228        bytes: &[u8],
229        page_size: usize,
230    ) -> Result<()> {
231        self.import_db_unchecked_impl(filename, bytes, page_size, false)
232    }
233
234    /// Export the database.
235    pub fn export_db(&self, filename: &str) -> Result<Vec<u8>> {
236        let name2file = self.0.borrow();
237
238        if let Some(file) = name2file.get(filename) {
239            let file_size = file.size().unwrap();
240            let mut ret = vec![0; file_size];
241            file.read(&mut ret, 0).unwrap();
242            Ok(ret)
243        } else {
244            Err(MemVfsError::Generic(
245                "The file to be exported does not exist".into(),
246            ))
247        }
248    }
249
250    /// Delete the specified database, make sure that the database is closed.
251    pub fn delete_db(&self, filename: &str) {
252        self.0.borrow_mut().remove(filename);
253    }
254
255    /// Delete all database, make sure that all database is closed.
256    pub fn clear_all(&self) {
257        std::mem::take(&mut *self.0.borrow_mut());
258    }
259
260    /// Does the database exists.
261    pub fn exists(&self, filename: &str) -> bool {
262        self.0.borrow().contains_key(filename)
263    }
264
265    /// List all files.
266    pub fn list(&self) -> Vec<String> {
267        self.0.borrow().keys().cloned().collect()
268    }
269
270    /// Number of files.
271    pub fn count(&self) -> usize {
272        self.0.borrow().len()
273    }
274}
275
276pub(crate) unsafe fn install() -> &'static VfsAppData<MemAppData> {
277    let vfs = sqlite3_vfs_find(VFS_NAME.as_ptr());
278
279    let vfs = if vfs.is_null() {
280        let vfs = Box::leak(Box::new(MemVfs::vfs(
281            VFS_NAME.as_ptr(),
282            VfsAppData::new(MemAppData::default()).leak(),
283        )));
284        assert_eq!(
285            sqlite3_vfs_register(vfs, 1),
286            SQLITE_OK,
287            "failed to register memvfs"
288        );
289        vfs as *mut sqlite3_vfs
290    } else {
291        vfs
292    };
293
294    MemStore::app_data(vfs)
295}
296
297pub(crate) unsafe fn uninstall() {
298    let vfs = sqlite3_vfs_find(VFS_NAME.as_ptr());
299
300    if !vfs.is_null() {
301        assert_eq!(
302            sqlite3_vfs_unregister(vfs),
303            SQLITE_OK,
304            "failed to unregister memvfs"
305        );
306        drop(VfsAppData::<MemAppData>::from_raw(
307            (*vfs).pAppData as *mut _,
308        ));
309        drop(Box::from_raw(vfs));
310    }
311}
312
313#[cfg(test)]
314mod tests {
315    use crate::{
316        mem_vfs::{MemAppData, MemFile, MemStore},
317        utils::{test_suite::test_vfs_store, VfsAppData},
318    };
319    use wasm_bindgen_test::wasm_bindgen_test;
320
321    #[wasm_bindgen_test]
322    fn test_memory_vfs_store() {
323        test_vfs_store::<MemAppData, MemFile, MemStore>(VfsAppData::new(MemAppData::default()))
324            .unwrap();
325    }
326}
sqlite_wasm_rs/vfs/memory.rs

sqlite_wasm_rs/vfs/
memory.rs
