Indexing: Speed up full scan bulk inserts

- Drop `idx_parent_name` before bulk inserts, recreate after
- Eliminates ~110M `platform_case` collation calls from incremental B-tree maintenance during `INSERT OR REPLACE`
- Index is rebuilt in a single sort pass after all entries are inserted
- `RecreateNameIndex` sent unconditionally (even on cancellation) so live-mode writes always have the index

Author: vdavid

apps/desktop/src-tauri/src/indexing/CLAUDE.md

@@ -117,6 +117,8 @@ Key test files are alongside each module (test functions within `#[cfg(test)]` b
 
 **MustScanSubDirs uses reconciliation, not delete-then-reinsert**: `reconcile_subtree()` diffs the filesystem against the DB directory-by-directory, only inserting/deleting/updating entries that changed. This is safe to interrupt at any point (no bulk delete phase that could leave the DB empty). For brand-new directories discovered during reconciliation, a `flush_blocking()` + re-resolve cycle ensures their IDs are available before recursing into them. `scanner::scan_subtree` (which uses destructive `DeleteDescendantsById`) is still used by micro-scans but no longer by MustScanSubDirs.
 
+**Bulk insert drops `idx_parent_name`, recreates after**: During a full scan the table is truncated first, so the unique index serves no purpose during inserts — IDs are pre-assigned by `ScanContext` and there can't be conflicts. Dropping the index before bulk inserts eliminates ~110M `platform_case` collation calls (NFD + case fold on macOS) from incremental B-tree maintenance. The index is rebuilt in a single pass after all entries are inserted. `RecreateNameIndex` is sent unconditionally (even on cancellation) to ensure live-mode writes always have the index available. Enrichment queries during the scan may be slower (no `parent_id` prefix index), but the table starts empty and the UI shows "Scanning..." during this window.
+
 **In-memory accumulation eliminates aggregation SQL queries**: During a full scan, the writer thread accumulates two HashMaps in `AccumulatorMaps` as `InsertEntriesV2` batches arrive: `direct_stats` (parent_id -> file size/count/dir count) and `child_dirs` (parent_id -> child dir IDs). When `ComputeAllAggregates` fires, these maps are passed to `compute_all_aggregates_with_maps()`, skipping the two expensive full-table-scan SQL queries (`bulk_get_children_stats_by_id` and `bulk_get_child_dir_ids`) that previously dominated aggregation time (~70%). Maps are cleared on `TruncateData` and after aggregation completes. Falls back to SQL queries if maps are empty.
 
 **Subtree aggregation uses scoped queries**: `scoped_get_children_stats_by_id` and `scoped_get_child_dir_ids` in `aggregator.rs` use recursive CTEs scoped to the target subtree, not full-table scans. This keeps subtree aggregation O(subtree_size) regardless of total DB size.

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

@@ -402,6 +402,13 @@ impl IndexManager {
             log::warn!("Failed to flush after TruncateData: {e}");
         }
 
+        // Drop the unique name index before bulk inserts. Without it, each INSERT
+        // only touches the integer PK B-tree. The index is recreated by the scanner
+        // thread after all entries are inserted (or after cancellation).
+        if let Err(e) = self.writer.send(WriteMessage::DropNameIndex) {
+            log::warn!("Failed to send DropNameIndex: {e}");
+        }
+
         // Step 1: Start the FSEvents watcher BEFORE the scan so we don't miss events
         let (event_tx, event_rx) = tokio::sync::mpsc::channel(WATCHER_CHANNEL_CAPACITY);
         let scan_start_event_id = watcher::current_event_id();

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

@@ -201,6 +201,12 @@ pub fn scan_volume(
                 true, // volume scan: root always maps to ROOT_ID
             );
 
+            // Always recreate the name index after bulk inserts, whether the
+            // scan completed or was cancelled. Live-mode writes need it.
+            if let Err(e) = writer.send(WriteMessage::RecreateNameIndex) {
+                log::warn!("Scanner: failed to send RecreateNameIndex: {e}");
+            }
+
             // Trigger full aggregation if scan completed without cancellation
             if let Ok(ref s) = summary
                 && !s.was_cancelled

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

@@ -92,6 +92,14 @@ pub enum WriteMessage {
     /// Used before a full rescan on a stale DB to avoid slow `INSERT OR REPLACE`
     /// on a populated table with the expensive `platform_case` collation.
     TruncateData,
+    /// Drop `idx_parent_name` before a full scan's bulk inserts.
+    /// Eliminates expensive `platform_case` collation during B-tree maintenance.
+    /// The scanner sends `RecreateNameIndex` after all entries are inserted.
+    DropNameIndex,
+    /// Recreate `idx_parent_name` after bulk inserts complete (or scan cancellation).
+    /// Must be sent before live-mode writes resume, since `UpsertEntryV2` and
+    /// `resolve_component` depend on this index.
+    RecreateNameIndex,
     /// Begin an explicit SQLite transaction.
     /// All subsequent writes are batched until `CommitTransaction`.
     /// Dramatically reduces fsync overhead for bulk operations (replay).
@@ -572,6 +580,27 @@ fn process_message(
                 Err(e) => log::warn!("Writer: truncate failed: {e}"),
             }
         }
+        WriteMessage::DropNameIndex => {
+            let t = Instant::now();
+            if let Err(e) = conn.execute_batch("DROP INDEX IF EXISTS idx_parent_name") {
+                log::warn!("Writer: DROP INDEX idx_parent_name failed: {e}");
+            } else {
+                log::info!("Writer: dropped idx_parent_name ({}ms)", t.elapsed().as_millis());
+            }
+        }
+        WriteMessage::RecreateNameIndex => {
+            let t = Instant::now();
+            if let Err(e) = conn.execute_batch(
+                "CREATE UNIQUE INDEX IF NOT EXISTS idx_parent_name ON entries (parent_id, name)",
+            ) {
+                log::warn!("Writer: CREATE INDEX idx_parent_name failed: {e}");
+            } else {
+                log::info!(
+                    "Writer: recreated idx_parent_name ({}ms)",
+                    t.elapsed().as_millis(),
+                );
+            }
+        }
         WriteMessage::ComputeAllAggregates => {
             let t = Instant::now();
             let use_maps = !accumulator.direct_stats.is_empty();