asimov-dataset-cli 25.0.0-dev.6

ASIMOV Dataset Command-Line Interface (CLI)
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

// This is free and unencumbered software released into the public domain.

use std::{collections::VecDeque, path::PathBuf};

/// Prepare contains the UI state of preparation progress.
#[derive(Debug, Default)]
pub struct PrepareState {
    pub current_file: Option<PathBuf>,
    pub current_file_size: usize,
    pub current_read_bytes: usize,

    pub queued_files: VecDeque<(PathBuf, usize)>,
    pub total_bytes: usize,

    pub read_bytes: usize,
    pub read_files: Vec<PathBuf>,
    pub read_statements: usize,

    pub prepared_bytes: usize,
    pub prepared_files: Vec<PathBuf>,
    pub prepared_statements: usize,
    pub skipped_statemets: usize,
}

impl PrepareState {
    pub fn update_reader_state(&mut self, progress: ReaderProgress) {
        match self.current_file {
            Some(ref curr) if *curr == progress.filename => {
                self.current_read_bytes += progress.bytes;
            }
            _ => {
                let size = self
                    .queued_files
                    .iter()
                    .find(|(name, _size)| *name == progress.filename)
                    .unwrap()
                    .1;
                self.current_file = Some(progress.filename.clone());
                self.current_file_size = size;
                self.current_read_bytes = progress.bytes;
            }
        }

        self.read_bytes += progress.bytes;
        self.read_statements += progress.statement_count;

        if progress.finished {
            self.queued_files
                .retain(|(name, _size)| *name != progress.filename);
            self.read_files.push(progress.filename);
            self.current_file = None;
        }
    }

    pub fn update_prepare_state(&mut self, progress: PrepareProgress) {
        self.prepared_bytes += progress.bytes;
        self.prepared_statements += progress.statement_count;
        self.skipped_statemets += progress.skipped_statements;
        self.prepared_files.push(progress.filename);
    }
}

#[derive(Debug, Default)]
pub struct ReaderProgress {
    pub filename: PathBuf,
    pub bytes: usize,
    pub statement_count: usize,
    pub finished: bool,
}

#[derive(Debug, Default)]
pub struct PrepareProgress {
    pub filename: PathBuf,
    pub bytes: usize,
    pub statement_count: usize,
    pub skipped_statements: usize,
}