sql-cli 1.73.1

SQL query tool for CSV/JSON with both interactive TUI and non-interactive CLI modes - perfect for exploration and automation
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use std::time::{Duration, Instant};

#[derive(Debug, Clone)]
pub struct BenchmarkMetrics {
    pub query_parse_time: Duration,
    pub query_plan_time: Duration,
    pub query_execute_time: Duration,
    pub total_time: Duration,

    pub rows_processed: usize,
    pub rows_returned: usize,
    pub rows_per_second: f64,

    pub peak_memory_bytes: Option<usize>,
    pub allocations_count: Option<usize>,

    pub table_scans: usize,
    pub expressions_evaluated: usize,
    pub functions_called: usize,
}

impl BenchmarkMetrics {
    pub fn new() -> Self {
        BenchmarkMetrics {
            query_parse_time: Duration::ZERO,
            query_plan_time: Duration::ZERO,
            query_execute_time: Duration::ZERO,
            total_time: Duration::ZERO,
            rows_processed: 0,
            rows_returned: 0,
            rows_per_second: 0.0,
            peak_memory_bytes: None,
            allocations_count: None,
            table_scans: 0,
            expressions_evaluated: 0,
            functions_called: 0,
        }
    }

    pub fn calculate_throughput(&mut self) {
        if self.total_time.as_secs_f64() > 0.0 {
            self.rows_per_second = self.rows_processed as f64 / self.total_time.as_secs_f64();
        }
    }

    pub fn to_csv_row(&self) -> String {
        format!(
            "{:.3},{:.3},{:.3},{:.3},{},{},{:.0}",
            self.query_parse_time.as_secs_f64() * 1000.0,
            self.query_plan_time.as_secs_f64() * 1000.0,
            self.query_execute_time.as_secs_f64() * 1000.0,
            self.total_time.as_secs_f64() * 1000.0,
            self.rows_processed,
            self.rows_returned,
            self.rows_per_second
        )
    }
}

#[derive(Debug)]
pub struct BenchmarkResult {
    pub query_name: String,
    pub query_category: String,
    pub table_name: String,
    pub row_count: usize,
    pub metrics: BenchmarkMetrics,
    pub error: Option<String>,
}

impl BenchmarkResult {
    pub fn new(
        query_name: String,
        query_category: String,
        table_name: String,
        row_count: usize,
    ) -> Self {
        BenchmarkResult {
            query_name,
            query_category,
            table_name,
            row_count,
            metrics: BenchmarkMetrics::new(),
            error: None,
        }
    }

    pub fn to_csv_row(&self) -> String {
        format!(
            "{},{},{},{},{}",
            self.query_name,
            self.table_name,
            self.row_count,
            self.metrics.to_csv_row(),
            self.error.as_ref().unwrap_or(&"OK".to_string())
        )
    }
}

pub struct MetricsCollector {
    start: Option<Instant>,
    phase_start: Option<Instant>,
    current_metrics: BenchmarkMetrics,
}

impl MetricsCollector {
    pub fn new() -> Self {
        MetricsCollector {
            start: None,
            phase_start: None,
            current_metrics: BenchmarkMetrics::new(),
        }
    }

    pub fn start_total(&mut self) {
        self.start = Some(Instant::now());
    }

    pub fn start_phase(&mut self) {
        self.phase_start = Some(Instant::now());
    }

    pub fn end_parse_phase(&mut self) {
        if let Some(start) = self.phase_start {
            self.current_metrics.query_parse_time = start.elapsed();
        }
    }

    pub fn end_plan_phase(&mut self) {
        if let Some(start) = self.phase_start {
            self.current_metrics.query_plan_time = start.elapsed();
        }
    }

    pub fn end_execute_phase(&mut self) {
        if let Some(start) = self.phase_start {
            self.current_metrics.query_execute_time = start.elapsed();
        }
    }

    pub fn end_total(&mut self) {
        if let Some(start) = self.start {
            self.current_metrics.total_time = start.elapsed();
        }
    }

    pub fn set_rows(&mut self, processed: usize, returned: usize) {
        self.current_metrics.rows_processed = processed;
        self.current_metrics.rows_returned = returned;
        self.current_metrics.calculate_throughput();
    }

    pub fn get_metrics(&self) -> BenchmarkMetrics {
        self.current_metrics.clone()
    }
}