Indexing: Periodically vacuum DB

So that the DB doesn't grow too big.

Author: vdavid

apps/desktop/src-tauri/src/indexing/mod.rs

@@ -2114,6 +2114,10 @@ pub fn start_indexing(app: &AppHandle) -> Result<(), String> {
 
     let scan_result = manager.resume_or_scan();
 
+    // Clone the writer before moving manager into the state machine, so we
+    // can hand it to the vacuum timer if startup succeeds.
+    let writer_for_vacuum = manager.writer.clone();
+
     // Re-lock and check: if someone called stop_indexing() while we were
     // inside resume_or_scan(), the phase is now Disabled. Respect that —
     // shut down the manager instead of overwriting with Running.
@@ -2122,6 +2126,17 @@ pub fn start_indexing(app: &AppHandle) -> Result<(), String> {
         (IndexPhase::Initializing { .. }, Ok(())) => {
             *guard = IndexPhase::Running(Box::new(manager));
             log::info!("start_indexing: done — IndexManager is Running");
+
+            // Periodic incremental vacuum: reclaim free pages from deletes/rescans
+            // every 30s. Stops automatically when the writer channel closes.
+            tauri::async_runtime::spawn(async move {
+                loop {
+                    tokio::time::sleep(Duration::from_secs(30)).await;
+                    if writer_for_vacuum.send(WriteMessage::IncrementalVacuum).is_err() {
+                        break;
+                    }
+                }
+            });
         }
         (IndexPhase::Initializing { .. }, Err(e)) => {
             *guard = IndexPhase::Disabled;

apps/desktop/src-tauri/src/indexing/writer.rs

@@ -98,6 +98,9 @@ pub enum WriteMessage {
     BeginTransaction,
     /// Commit the current explicit transaction.
     CommitTransaction,
+    /// Periodic housekeeping: reclaim free pages from deletes/rescans.
+    /// Sent by a background timer, not counted in WriterStats.
+    IncrementalVacuum,
     /// Shut down the writer thread.
     Shutdown,
 }
@@ -381,7 +384,9 @@ fn writer_loop(
     let mut accumulator = AccumulatorMaps::new();
 
     for msg in &receiver {
-        stats.record(&msg);
+        if !matches!(msg, WriteMessage::IncrementalVacuum) {
+            stats.record(&msg);
+        }
         if process_message(
             &conn,
             msg,
@@ -628,6 +633,19 @@ fn process_message(
             }
             log::debug!("Writer: COMMIT transaction ({}ms)", t.elapsed().as_millis());
         }
+        WriteMessage::IncrementalVacuum => {
+            match conn.pragma_query_value(None, "freelist_count", |row| row.get::<_, i64>(0)) {
+                Ok(free) if free > 0 => {
+                    if let Err(e) = conn.execute_batch("PRAGMA incremental_vacuum(2000)") {
+                        log::warn!("Writer: incremental_vacuum failed: {e}");
+                    } else {
+                        log::debug!("Writer: incremental_vacuum reclaimed up to 2000 of {free} free pages");
+                    }
+                }
+                Ok(_) => {} // No free pages, nothing to do
+                Err(e) => log::warn!("Writer: freelist_count query failed: {e}"),
+            }
+        }
         WriteMessage::Shutdown => return true,
     }
     false