absurder_sql/storage/
sync_operations.rs1#[cfg(target_arch = "wasm32")]
6macro_rules! lock_mutex {
7 ($mutex:expr) => {
8 $mutex
9 .try_borrow_mut()
10 .expect("RefCell borrow failed - reentrancy detected in sync_operations.rs")
11 };
12}
13
14#[cfg(not(target_arch = "wasm32"))]
15macro_rules! lock_mutex {
16 ($mutex:expr) => {
17 $mutex.lock()
18 };
19}
20
21#[allow(unused_macros)]
22#[cfg(target_arch = "wasm32")]
23macro_rules! try_lock_mutex {
24 ($mutex:expr) => {
25 $mutex
26 };
27}
28
29#[allow(unused_macros)]
30#[cfg(not(target_arch = "wasm32"))]
31macro_rules! try_lock_mutex {
32 ($mutex:expr) => {
33 $mutex.lock()
34 };
35}
36
37use super::block_storage::BlockStorage;
38use crate::types::DatabaseError;
39
40#[cfg(all(not(target_arch = "wasm32"), not(feature = "fs_persist")))]
41use std::collections::HashMap;
42#[cfg(all(not(target_arch = "wasm32"), not(feature = "fs_persist")))]
43use std::sync::atomic::Ordering;
44
45#[cfg(any(
46 target_arch = "wasm32",
47 all(not(target_arch = "wasm32"), not(feature = "fs_persist"))
48))]
49use super::metadata::BlockMetadataPersist;
50#[cfg(any(
51 target_arch = "wasm32",
52 all(not(target_arch = "wasm32"), not(feature = "fs_persist"))
53))]
54use super::vfs_sync;
55
56#[cfg(target_arch = "wasm32")]
57use std::collections::HashMap;
58
59#[cfg(all(not(target_arch = "wasm32"), not(feature = "fs_persist")))]
60use super::block_storage::GLOBAL_METADATA_TEST;
61
62pub fn sync_implementation_impl(storage: &mut BlockStorage) -> Result<(), DatabaseError> {
64 #[cfg(all(not(target_arch = "wasm32"), not(feature = "fs_persist")))]
65 let start = std::time::Instant::now();
66
67 let dirty_count = lock_mutex!(storage.dirty_blocks).len();
68 let dirty_bytes = dirty_count * super::block_storage::BLOCK_SIZE;
69 storage
70 .observability
71 .record_sync_start(dirty_count, dirty_bytes);
72
73 #[cfg(not(target_arch = "wasm32"))]
74 if let Some(ref callback) = storage.observability.sync_start_callback {
75 callback(dirty_count, dirty_bytes);
76 }
77
78 #[cfg(all(not(target_arch = "wasm32"), feature = "fs_persist"))]
79 {
80 storage.fs_persist_sync()
81 }
82
83 #[cfg(all(not(target_arch = "wasm32"), not(feature = "fs_persist")))]
84 {
85 let current_dirty = lock_mutex!(storage.dirty_blocks).len();
86 log::info!(
87 "Syncing {} dirty blocks (native non-fs_persist)",
88 current_dirty
89 );
90
91 let to_persist: Vec<(u64, Vec<u8>)> = {
92 let dirty = lock_mutex!(storage.dirty_blocks);
93 dirty.iter().map(|(k, v)| (*k, v.clone())).collect()
94 };
95 let ids: Vec<u64> = to_persist.iter().map(|(k, _)| *k).collect();
96 let blocks_synced = ids.len();
97
98 let next_commit: u64 = vfs_sync::with_global_commit_marker(|cm| {
99 let cm = cm.borrow();
100 let current = cm.get(&storage.db_name).copied().unwrap_or(0);
101 current + 1
102 });
103
104 vfs_sync::with_global_storage(|gs| {
105 let mut storage_map = gs.borrow_mut();
106 let db_storage = storage_map
107 .entry(storage.db_name.clone())
108 .or_insert_with(HashMap::new);
109 for (block_id, data) in to_persist {
110 db_storage.insert(block_id, data);
111 }
112 });
113
114 GLOBAL_METADATA_TEST.with(|meta| {
115 let mut meta_map = meta.lock();
116 let db_meta = meta_map
117 .entry(storage.db_name.clone())
118 .or_insert_with(HashMap::new);
119 for block_id in ids {
120 if let Some(checksum) = storage.checksum_manager.get_checksum(block_id) {
121 db_meta.insert(
122 block_id,
123 BlockMetadataPersist {
124 checksum,
125 last_modified_ms: std::time::SystemTime::now()
126 .duration_since(std::time::UNIX_EPOCH)
127 .unwrap_or_default()
128 .as_millis() as u64,
129 version: next_commit as u32,
130 algo: storage.checksum_manager.get_algorithm(block_id),
131 },
132 );
133 }
134 }
135 });
136
137 vfs_sync::with_global_commit_marker(|cm| {
138 let mut cm_map = cm.borrow_mut();
139 cm_map.insert(storage.db_name.clone(), next_commit);
140 });
141
142 lock_mutex!(storage.dirty_blocks).clear();
143
144 storage.sync_count.fetch_add(1, Ordering::SeqCst);
145 let ms = (start.elapsed().as_millis() as u64).max(1);
146 storage.last_sync_duration_ms.store(ms, Ordering::SeqCst);
147 storage.observability.record_sync_success(ms, blocks_synced);
148
149 if let Some(ref callback) = storage.observability.sync_success_callback {
150 callback(ms, blocks_synced);
151 }
152
153 storage.evict_if_needed();
154 return Ok(());
155 }
156
157 #[cfg(target_arch = "wasm32")]
158 {
159 let current_dirty = lock_mutex!(storage.dirty_blocks).len();
160 log::info!("Syncing {} dirty blocks (WASM)", current_dirty);
161
162 let to_persist: Vec<(u64, Vec<u8>)> = {
163 let dirty = lock_mutex!(storage.dirty_blocks);
164 dirty.iter().map(|(k, v)| (*k, v.clone())).collect()
165 };
166 let ids: Vec<u64> = to_persist.iter().map(|(k, _)| *k).collect();
167 let next_commit: u64 = vfs_sync::with_global_commit_marker(|cm| {
168 let current = cm.borrow().get(&storage.db_name).copied().unwrap_or(0);
169 current + 1
170 });
171 let metadata_to_persist: Vec<(u64, BlockMetadataPersist)> = ids
172 .iter()
173 .filter_map(|block_id| {
174 storage
175 .checksum_manager
176 .get_checksum(*block_id)
177 .map(|checksum| {
178 (
179 *block_id,
180 BlockMetadataPersist {
181 checksum,
182 last_modified_ms: BlockStorage::now_millis(),
183 version: next_commit as u32,
184 algo: storage.checksum_manager.get_algorithm(*block_id),
185 },
186 )
187 })
188 })
189 .collect();
190
191 vfs_sync::with_global_storage(|gs| {
192 let mut storage_map = gs.borrow_mut();
193 let db_storage = storage_map
194 .entry(storage.db_name.clone())
195 .or_insert_with(HashMap::new);
196 for (block_id, data) in &to_persist {
197 let should_update = if let Some(existing) = db_storage.get(block_id) {
198 if existing != data {
199 !vfs_sync::with_global_metadata(|meta| {
200 meta.borrow()
201 .get(&storage.db_name)
202 .and_then(|db_meta| db_meta.get(block_id))
203 .is_some_and(|metadata| metadata.version > 0)
204 })
205 } else {
206 true
207 }
208 } else {
209 true
210 };
211
212 if should_update {
213 db_storage.insert(*block_id, data.clone());
214 }
215 }
216 });
217
218 vfs_sync::with_global_metadata(|meta| {
219 let mut meta_guard = meta.borrow_mut();
220 let db_meta = meta_guard
221 .entry(storage.db_name.clone())
222 .or_insert_with(HashMap::new);
223 for (block_id, metadata) in &metadata_to_persist {
224 db_meta.insert(*block_id, metadata.clone());
225 }
226 });
227 vfs_sync::with_global_commit_marker(|cm| {
228 cm.borrow_mut().insert(storage.db_name.clone(), next_commit);
229 });
230
231 if !to_persist.is_empty() {
232 let db_name = storage.db_name.clone();
233 let backend = storage.storage_backend();
234 wasm_bindgen_futures::spawn_local(async move {
235 let persist_result = match backend {
236 super::block_storage::StorageBackend::IndexedDb => {
237 super::wasm_indexeddb::persist_to_indexeddb_event_based(
238 &db_name,
239 to_persist,
240 metadata_to_persist,
241 next_commit,
242 #[cfg(feature = "telemetry")]
243 None,
244 #[cfg(feature = "telemetry")]
245 None,
246 )
247 .await
248 }
249 super::block_storage::StorageBackend::Opfs
250 | super::block_storage::StorageBackend::Hybrid => {
251 super::hybrid_store::hybrid_persist(
252 &db_name,
253 to_persist,
254 metadata_to_persist,
255 next_commit,
256 #[cfg(feature = "telemetry")]
257 None,
258 #[cfg(feature = "telemetry")]
259 None,
260 )
261 .await
262 }
263 };
264
265 if let Err(error) = persist_result {
266 log::error!(
267 "Failed to persist {} using backend {}: {}",
268 db_name,
269 backend.as_str(),
270 error
271 );
272 }
273 });
274 }
275
276 lock_mutex!(storage.dirty_blocks).clear();
277 storage.observability.record_sync_success(1, current_dirty);
278
279 if let Some(ref callback) = storage.observability.wasm_sync_success_callback {
280 callback(1, current_dirty);
281 }
282
283 storage.evict_if_needed();
284 Ok(())
285 }
286}