mnemo_engine/store/
snapshots.rs1use super::*;
4
5impl Mnemo {
6 pub fn session(&mut self, agent_id: impl Into<String>) -> crate::session::Session<'_> {
11 crate::session::Session::new(self, agent_id.into())
12 }
13
14 pub fn snapshots(&self) -> Vec<SnapshotInfo> {
25 let mut v: Vec<SnapshotInfo> = self
26 .manifest
27 .iter()
28 .map(|s| SnapshotInfo {
29 txn_id: s.txn_id,
30 created_at: s.created_at,
31 memory_count: s.memory_count,
32 })
33 .collect();
34 v.sort_by_key(|s| s.txn_id);
35 v
36 }
37
38 pub(super) fn restore_points(&self) -> RestorePoints {
44 let oldest = self.manifest.iter().min_by_key(|s| s.txn_id);
45 RestorePoints {
46 retained: self.manifest.len(),
47 oldest_at: oldest.map(|s| s.created_at),
48 pinned_bytes: match oldest {
49 Some(o) if self.is_v9() => self.free.pinned_pages(o.txn_id) * PAGE_SIZE as u64,
50 _ => 0,
51 },
52 }
53 }
54
55 pub(super) fn apply_snapshot(&mut self, snap: &Snapshot) -> Result<()> {
57 let catalog = load_catalog(
58 &mut self.pager,
59 snap.catalog_start,
60 snap.catalog_pages,
61 snap.catalog_len,
62 snap.catalog_gen(),
63 )?;
64 let (catalog, _, _) = apply_delta_chain(&mut self.pager, catalog, snap.delta_head())?;
65 self.catalog_rewrite = true;
67 let ann = load_index(
68 &mut self.pager,
69 snap.index_start,
70 snap.index_pages,
71 snap.index_len,
72 snap.index_gen(),
73 self.dimensions,
74 )?;
75 let mut ann = ann;
76 if self.is_v9() {
77 self.reclaim_for_restore(&catalog);
78 if let Some(a) = ann.as_mut() {
79 apply_index_chain(&mut self.pager, a, snap.index_delta_head())?;
80 a.enable_log();
81 }
82 self.index_rebase = true;
83 let bptr = snap.gens.map_or(RunPtr::default(), |g| tuple_ptr(g.bm25));
86 let manifest = load_bm25_manifest(&mut self.pager, bptr)?;
87 let runs = |ptr: RunPtr, m: &Bm25Manifest| {
90 let mut v: Vec<(u64, u64)> = m.segments.iter().map(|t| (t.0, t.1)).collect();
91 if !ptr.is_empty() {
92 v.push((ptr.start, ptr.pages));
93 }
94 v
95 };
96 let then = runs(bptr, &manifest);
97 let now = runs(self.header.bm25, &self.bm25.manifest);
98 self.pending_free.retain(|r| !then.contains(r));
99 for &(p, c) in &then {
100 self.free.unfree(p, c);
101 }
102 for r in now {
103 if !then.contains(&r) {
104 self.release_pages(r.0, r.1);
105 }
106 }
107 self.header.bm25 = bptr;
108 self.free_dirty = true;
109 self.bm25 = Bm25State {
110 manifest,
111 ..Bm25State::default()
112 };
113 }
114 self.index = build_id_index(&catalog);
115 self.catalog = catalog;
116 self.col = VecColumn::from_catalog(&self.catalog);
119 self.recs = RecPages::from_catalog(&self.catalog);
120 self.ann = ann;
121 self.ann_unloaded = false;
122 self.index_repair = false;
124 self.key_index = None;
126 self.superseded = None;
127 self.layers = None;
128 self.agent_set = None;
129 let snap_index_gen = snap.index_gen().max(snap.index_delta_head().gen);
132 self.reconcile_ann_with_catalog(snap.index_start, snap_index_gen)?;
133 self.dirty_catalog = true;
136 self.dirty_index = true;
137 self.index_persist.forced = true;
138 self.flush()
139 }
140
141 pub(super) fn apply_retention(&self, manifest: &mut Vec<Snapshot>, extra: u64) {
155 if self.snapshot_cap_explicit {
156 if self.max_snapshots > 0 {
157 while manifest.len() > self.max_snapshots {
158 manifest.remove(0);
159 }
160 }
161 return;
162 }
163 let now = memory::now_secs();
164 if self.max_snapshots > 0 {
165 while manifest.len() > self.max_snapshots
166 && now - manifest[0].created_at > V9_SNAPSHOT_KEEP_SECS
167 {
168 manifest.remove(0);
169 }
170 }
171 let live_pages = self.header.next_page.saturating_sub(self.free.pages());
172 let cap = (live_pages / 4).max(V9_PIN_FLOOR_PAGES);
173 while manifest.len() > 1 {
174 let pinned = self.free.pinned_pages(manifest[0].txn_id) + extra;
175 if pinned <= cap {
176 break;
177 }
178 manifest.remove(0);
179 }
180 }
181
182 pub(super) fn reclaim_for_restore(&mut self, restored: &[CatalogEntry]) {
189 let runs = |cat: &[CatalogEntry]| -> std::collections::BTreeMap<u64, u64> {
192 cat.iter()
193 .filter(|e| !e.deleted && e.start_page != 0)
194 .map(|e| (e.start_page, e.page_count as u64))
195 .collect()
196 };
197 let live_then = runs(restored);
198 let live_now = runs(&self.catalog);
199 let overlaps = |p: u64, c: u64| {
200 live_then
201 .range(..p + c)
202 .next_back()
203 .is_some_and(|(&q, &n)| q + n > p)
204 };
205 let dying: Vec<(u64, u64)> = live_now
206 .iter()
207 .filter(|(p, _)| !live_then.contains_key(p))
208 .map(|(&p, &c)| (p, c))
209 .collect();
210 let vec_then: std::collections::BTreeSet<u64> = restored
213 .iter()
214 .filter(|e| !e.deleted)
215 .filter_map(|e| e.v9.map(|r| r.vec_page))
216 .filter(|&p| p != 0)
217 .collect();
218 let vec_dying: Vec<u64> = self
219 .col
220 .page_rows
221 .keys()
222 .copied()
223 .filter(|p| !vec_then.contains(p))
224 .collect();
225 self.pending_free
226 .retain(|&(p, c)| !(overlaps(p, c) || (c == 1 && vec_then.contains(&p))));
227 for (&p, &c) in &live_then {
228 self.free.unfree(p, c);
229 }
230 for &p in &vec_then {
231 self.free.unfree(p, 1);
232 }
233 for (p, c) in dying {
234 self.release_pages(p, c);
235 }
236 for p in vec_dying {
237 self.release_pages(p, 1);
238 }
239 self.free_dirty = true;
240 }
241
242 pub fn restore_to(&mut self, txn_id: u64) -> Result<SnapshotInfo> {
248 if self.read_only {
249 return Err(MnemoError::ReadOnly);
250 }
251 let snap = self
252 .manifest
253 .iter()
254 .find(|s| s.txn_id == txn_id)
255 .cloned()
256 .ok_or_else(|| {
257 let oldest = self.manifest.iter().map(|s| s.txn_id).min();
258 match oldest {
259 Some(o) if self.is_v9() && txn_id < o => MnemoError::NotFound(format!(
260 "snapshot for transaction {txn_id}: older than the retention window \
261 (the newest {} snapshots and any from the last 24 hours, with at \
262 most a quarter of the file pinned); the oldest kept is {o}",
263 self.max_snapshots
264 )),
265 _ => MnemoError::NotFound(format!("snapshot for transaction {txn_id}")),
266 }
267 })?;
268 self.apply_snapshot(&snap)?;
269 Ok(SnapshotInfo {
270 txn_id: snap.txn_id,
271 created_at: snap.created_at,
272 memory_count: snap.memory_count,
273 })
274 }
275
276 pub fn restore_to_time(&mut self, unix_secs: i64) -> Result<SnapshotInfo> {
280 if self.read_only {
281 return Err(MnemoError::ReadOnly);
282 }
283 let snap = self
284 .manifest
285 .iter()
286 .filter(|s| s.created_at <= unix_secs)
287 .max_by_key(|s| s.txn_id)
288 .cloned()
289 .ok_or_else(|| {
290 MnemoError::NotFound(format!("no snapshot at or before time {unix_secs}"))
291 })?;
292 self.apply_snapshot(&snap)?;
293 Ok(SnapshotInfo {
294 txn_id: snap.txn_id,
295 created_at: snap.created_at,
296 memory_count: snap.memory_count,
297 })
298 }
299}