mongosh 0.9.0

A high-performance MongoDB Shell implementation in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

//! Progress tracking for export operations
//!
//! This module provides progress bar and statistics tracking for long-running
//! export operations, giving users real-time feedback on export progress.

use std::sync::atomic::{AtomicU64, Ordering};
use std::time::Instant;

use indicatif::{ProgressBar, ProgressStyle};

/// Progress tracker for export operations
///
/// Tracks document processing progress and displays a progress bar
/// with statistics like speed and ETA.
pub struct ProgressTracker {
    /// Number of documents processed so far
    processed: AtomicU64,
    /// Start time of the operation
    start_time: Instant,
    /// Progress bar (optional, can be disabled)
    bar: Option<ProgressBar>,
}

impl ProgressTracker {
    /// Create a new progress tracker
    ///
    /// # Arguments
    /// * `total` - Total number of documents if known (None for unknown)
    /// * `enable_bar` - Whether to display a progress bar
    ///
    /// # Returns
    /// * `Self` - New progress tracker instance
    pub fn new(total: Option<u64>, enable_bar: bool) -> Self {
        let bar = if enable_bar {
            let pb = match total {
                Some(n) => {
                    let bar = ProgressBar::new(n);
                    bar.set_style(
                        ProgressStyle::default_bar()
                            .template(
                                "{spinner:.green} [{bar:40.cyan/blue}] {pos}/{len} {msg}"
                            )
                            .unwrap()
                            .progress_chars("#>-")
                    );
                    bar
                }
                None => {
                    let bar = ProgressBar::new_spinner();
                    bar.set_style(
                        ProgressStyle::default_spinner()
                            .template(
                                "{spinner:.green} {pos} documents {msg}"
                            )
                            .unwrap()
                    );
                    bar
                }
            };
            Some(pb)
        } else {
            None
        };

        Self {
            processed: AtomicU64::new(0),
            start_time: Instant::now(),
            bar,
        }
    }

    /// Update progress with new count
    ///
    /// # Arguments
    /// * `count` - Total number of documents processed so far
    pub fn update(&self, count: u64) {
        self.processed.store(count, Ordering::Relaxed);

        if let Some(ref bar) = self.bar {
            bar.set_position(count);

            // Calculate and display speed
            let elapsed = self.start_time.elapsed().as_secs_f64();
            if elapsed > 0.0 {
                let speed = count as f64 / elapsed;
                bar.set_message(format!("({:.0} docs/sec)", speed));
            }
        }
    }

    /// Finish and clear the progress bar
    pub fn finish(&self) {
        if let Some(ref bar) = self.bar {
            bar.finish_and_clear();
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_progress_tracker_with_total() {
        let tracker = ProgressTracker::new(Some(1000), false);
        tracker.update(500);
        // Progress updated successfully (no panic means success)
    }

    #[test]
    fn test_progress_tracker_without_total() {
        let tracker = ProgressTracker::new(None, false);
        tracker.update(500);
        // Progress updated successfully (no panic means success)
    }
}