@@ -829,7 +829,7 @@ pub struct ForwardPartialPathStitcher<H> {
     queue: VecDeque<(PartialPath, AppendingCycleDetector<H>, bool)>,
     // tracks the number of initial paths in the queue because we do not want call
     // extend_until on those
-    initial_paths: usize,
+    initial_paths_in_queue: usize,
     // next_iteration is a tuple of queues instead of an queue of tuples so that the path queue
     // can be cheaply exposed through the C API as a continuous memory block
     next_iteration: (
@@ -841,7 +841,8 @@ pub struct ForwardPartialPathStitcher<H> {
     similar_path_detector: Option<SimilarPathDetector<PartialPath>>,
     check_only_join_nodes: bool,
     max_work_per_phase: usize,
-    stats: Stats,
+    initial_paths: usize,
+    stats: Option<Stats>,
     #[cfg(feature = "copious-debugging")]
     phase_number: usize,
 }
@@ -866,13 +867,12 @@ impl<H> ForwardPartialPathStitcher<H> {
                 (p, c, false)
             })
             .multiunzip();
-        let mut stats = Stats::default();
-        stats.initial_paths.record(next_iteration.0.len());
+        let initial_paths = next_iteration.0.len();
         Self {
             candidates: Vec::new(),
             extensions: Vec::new(),
             queue: VecDeque::new(),
-            initial_paths: next_iteration.0.len(),
+            initial_paths_in_queue: initial_paths,
             next_iteration,
             appended_paths,
             // By default, all paths are checked for similarity
@@ -881,7 +881,8 @@ impl<H> ForwardPartialPathStitcher<H> {
             check_only_join_nodes: false,
             // By default, there's no artificial bound on the amount of work done per phase
             max_work_per_phase: usize::MAX,
-            stats,
+            initial_paths,
+            stats: None,
             #[cfg(feature = "copious-debugging")]
             phase_number: 1,
         }
@@ -916,11 +917,24 @@ impl<H> ForwardPartialPathStitcher<H> {
         self.max_work_per_phase = max_work_per_phase;
     }
 
+    /// Sets whether to collect statistics during stitching.
+    pub fn set_collect_stats(&mut self, collect_stats: bool) {
+        if !collect_stats {
+            self.stats = None;
+        } else if self.stats.is_none() {
+            let mut stats = Stats::default();
+            stats.initial_paths.record(self.initial_paths);
+            self.stats = Some(stats);
+        }
+    }
+
     pub fn into_stats(mut self) -> Stats {
-        if let Some(similar_path_detector) = self.similar_path_detector {
-            self.stats.similar_paths_stats = similar_path_detector.stats();
+        if let (Some(stats), Some(similar_path_detector)) =
+            (&mut self.stats, self.similar_path_detector)
+        {
+            stats.similar_paths_stats = similar_path_detector.stats();
         }
-        self.stats
+        self.stats.unwrap_or_default()
     }
 }
 
@@ -1069,22 +1083,21 @@ impl<H: Clone> ForwardPartialPathStitcher<H> {
             self.next_iteration.2.push(new_has_split);
         }
 
-        let (graph, _, _) = candidates.get_graph_partials_and_db();
-        let end_node = &graph[partial_path.end_node];
-        if end_node.is_root() {
-            self.stats.candidates_per_root_path.record(candidate_count);
-            self.stats.extensions_per_root_path.record(extension_count);
-            self.stats.root_visits += 1;
-        } else {
-            self.stats.candidates_per_node_path.record(candidate_count);
-            self.stats.extensions_per_node_path.record(extension_count);
-            self.stats.node_visits.record(end_node.id());
-        }
-
-        if extension_count == 0 {
-            self.stats
-                .terminal_path_lengh
-                .record(partial_path.edges.len());
+        if let Some(stats) = &mut self.stats {
+            let (graph, _, _) = candidates.get_graph_partials_and_db();
+            let end_node = &graph[partial_path.end_node];
+            if end_node.is_root() {
+                stats.candidates_per_root_path.record(candidate_count);
+                stats.extensions_per_root_path.record(extension_count);
+                stats.root_visits += 1;
+            } else {
+                stats.candidates_per_node_path.record(candidate_count);
+                stats.extensions_per_node_path.record(extension_count);
+                stats.node_visits.record(end_node.id());
+            }
+            if extension_count == 0 {
+                stats.terminal_path_lengh.record(partial_path.edges.len());
+            }
         }
         candidate_count
     }
@@ -1119,16 +1132,18 @@ impl<H: Clone> ForwardPartialPathStitcher<H> {
             self.next_iteration.1.drain(..),
             self.next_iteration.2.drain(..),
         ));
-        self.stats.queued_paths_per_phase.record(self.queue.len());
+        if let Some(stats) = &mut self.stats {
+            stats.queued_paths_per_phase.record(self.queue.len());
+        }
         let mut work_performed = 0;
         while let Some((partial_path, cycle_detector, has_split)) = self.queue.pop_front() {
             let (graph, partials, _) = candidates.get_graph_partials_and_db();
             copious_debugging!(
                 "--> Candidate partial path {}",
                 partial_path.display(graph, partials)
             );
-            if self.initial_paths > 0 {
-                self.initial_paths -= 1;
+            if self.initial_paths_in_queue > 0 {
+                self.initial_paths_in_queue -= 1;
             } else if !extend_while(graph, partials, &partial_path) {
                 copious_debugging!(
                     "    Do not extend {}",
@@ -1141,7 +1156,9 @@ impl<H: Clone> ForwardPartialPathStitcher<H> {
                 break;
             }
         }
-        self.stats.processed_paths_per_phase.record(work_performed);
+        if let Some(stats) = &mut self.stats {
+            stats.processed_paths_per_phase.record(work_performed);
+        }
 
         #[cfg(feature = "copious-debugging")]
         {
@@ -1354,6 +1371,8 @@ impl std::ops::AddAssign<&Self> for Stats {
 pub struct StitcherConfig {
     /// Enables similar path detection during path stitching.
     detect_similar_paths: bool,
+    /// Collect statistics about path stitching.
+    collect_stats: bool,
 }
 
 impl StitcherConfig {
@@ -1365,18 +1384,29 @@ impl StitcherConfig {
         self.detect_similar_paths = detect_similar_paths;
         self
     }
+
+    pub fn collect_stats(&self) -> bool {
+        self.collect_stats
+    }
+
+    pub fn with_collect_stats(mut self, collect_stats: bool) -> Self {
+        self.collect_stats = collect_stats;
+        self
+    }
 }
 
 impl StitcherConfig {
     fn apply<H>(&self, stitcher: &mut ForwardPartialPathStitcher<H>) {
         stitcher.set_similar_path_detection(self.detect_similar_paths);
+        stitcher.set_collect_stats(self.collect_stats);
     }
 }
 
 impl Default for StitcherConfig {
     fn default() -> Self {
         Self {
             detect_similar_paths: true,
+            collect_stats: false,
         }
     }
 }
@@ -113,6 +113,7 @@ impl IndexArgs {
         let mut indexer = Indexer::new(&mut db, &mut loader, &reporter);
         indexer.force = self.force;
         indexer.max_file_time = self.max_file_time;
+        indexer.set_collect_stats(self.stats);
 
         let source_paths = self
             .source_paths
@@ -158,7 +159,7 @@ pub struct Indexer<'a> {
     db: &'a mut SQLiteWriter,
     loader: &'a mut Loader,
     reporter: &'a dyn Reporter,
-    stats: IndexingStats,
+    stats: Option<IndexingStats>,
     /// Index files, even if they already exist in the database.
     pub force: bool,
     /// Maximum time per file.
@@ -177,7 +178,15 @@ impl<'a> Indexer<'a> {
             reporter,
             force: false,
             max_file_time: None,
-            stats: IndexingStats::default(),
+            stats: None,
+        }
+    }
+
+    pub fn set_collect_stats(&mut self, collect_stats: bool) {
+        if !collect_stats {
+            self.stats = None;
+        } else if self.stats.is_none() {
+            self.stats = Some(IndexingStats::default());
         }
     }
 
@@ -294,8 +303,9 @@ impl<'a> Indexer<'a> {
             }
             Err(e) => return Err(IndexError::LoadError(e)),
         };
-        let stitcher_config =
-            StitcherConfig::default().with_detect_similar_paths(!lcs.no_similar_paths_in_file());
+        let stitcher_config = StitcherConfig::default()
+            .with_detect_similar_paths(!lcs.no_similar_paths_in_file())
+            .with_collect_stats(self.stats.is_some());
 
         let source = file_reader.get(source_path)?;
         let tag = sha1(source);
@@ -365,21 +375,19 @@ impl<'a> Indexer<'a> {
                 }
             }
         };
-        {
-            self.stats
-                .total_graph_nodes
-                .record(graph.iter_nodes().count());
+        if let Some(stats) = &mut self.stats {
+            stats.total_graph_nodes.record(graph.iter_nodes().count());
             let mut total_edges = 0;
             for n in graph.iter_nodes() {
                 let edge_count = graph.outgoing_edges(n).count();
                 if graph[n].is_root() {
-                    self.stats.root_out_degree = edge_count;
+                    stats.root_out_degree = edge_count;
                 } else {
-                    self.stats.node_out_degrees.record(edge_count);
+                    stats.node_out_degrees.record(edge_count);
                     total_edges += edge_count;
                 }
             }
-            self.stats.total_graph_edges.record(total_edges);
+            stats.total_graph_edges.record(total_edges);
         }
 
         let mut partials = PartialPaths::new();
@@ -395,7 +403,9 @@ impl<'a> Indexer<'a> {
             },
         ) {
             Ok(stitching_stats) => {
-                self.stats.stitching_stats += stitching_stats;
+                if let Some(stats) = &mut self.stats {
+                    stats.stitching_stats += stitching_stats;
+                }
             }
             Err(_) => {
                 file_status.warning("path computation timed out", None);
@@ -475,12 +485,8 @@ impl<'a> Indexer<'a> {
         false
     }
 
-    pub fn stats(&self) -> &IndexingStats {
-        &self.stats
-    }
-
     pub fn into_stats(self) -> IndexingStats {
-        self.stats
+        self.stats.unwrap_or_default()
     }
 }
 
 
@@ -51,7 +51,7 @@ impl QueryArgs {
             wait_for_input()?;
         }
         let mut db = SQLiteReader::open(&db_path)?;
-        let stitching_stats = self.target.run(&mut db)?;
+        let stitching_stats = self.target.run(&mut db, self.stats)?;
         if self.stats {
             println!();
             print_stitching_stats(stitching_stats);
@@ -68,9 +68,10 @@ pub enum Target {
 }
 
 impl Target {
-    pub fn run(self, db: &mut SQLiteReader) -> anyhow::Result<StitchingStats> {
+    fn run(self, db: &mut SQLiteReader, collect_stats: bool) -> anyhow::Result<StitchingStats> {
         let reporter = ConsoleReporter::details();
         let mut querier = Querier::new(db, &reporter);
+        querier.set_collect_stats(collect_stats);
         match self {
             Self::Definition(cmd) => cmd.run(&mut querier)?,
         }
@@ -152,15 +153,23 @@ impl Definition {
 pub struct Querier<'a> {
     db: &'a mut SQLiteReader,
     reporter: &'a dyn Reporter,
-    stats: StitchingStats,
+    stats: Option<StitchingStats>,
 }
 
 impl<'a> Querier<'a> {
     pub fn new(db: &'a mut SQLiteReader, reporter: &'a dyn Reporter) -> Self {
         Self {
             db,
             reporter,
-            stats: StitchingStats::default(),
+            stats: None,
+        }
+    }
+
+    pub fn set_collect_stats(&mut self, collect_stats: bool) {
+        if !collect_stats {
+            self.stats = None;
+        } else if self.stats.is_none() {
+            self.stats = Some(StitchingStats::default());
         }
     }
 
@@ -208,7 +217,8 @@ impl<'a> Querier<'a> {
             let mut reference_paths = Vec::new();
             let stitcher_config = StitcherConfig::default()
                 // always detect similar paths, we don't know the language configurations for the data in the database
-                .with_detect_similar_paths(true);
+                .with_detect_similar_paths(true)
+                .with_collect_stats(self.stats.is_some());
             let ref_result = ForwardPartialPathStitcher::find_all_complete_partial_paths(
                 self.db,
                 std::iter::once(node),
@@ -219,7 +229,11 @@ impl<'a> Querier<'a> {
                 },
             );
             match ref_result {
-                Ok(ref_stats) => self.stats += ref_stats,
+                Ok(ref_stats) => {
+                    if let Some(stats) = &mut self.stats {
+                        *stats += ref_stats
+                    }
+                }
                 Err(err) => {
                     self.reporter.failed(&log_path, "query timed out", None);
                     return Err(err.into());
@@ -276,12 +290,8 @@ impl<'a> Querier<'a> {
         Ok(result)
     }
 
-    pub fn stats(&self) -> &StitchingStats {
-        &self.stats
-    }
-
     pub fn into_stats(self) -> StitchingStats {
-        self.stats
+        self.stats.unwrap_or_default()
     }
 }