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

// Simplified BufferAdapter - just delegates to DataView
// This is a temporary migration adapter until we remove DataProvider completely

use crate::buffer::BufferAPI;
use crate::data::data_provider::DataProvider;
use std::fmt::Debug;

/// Minimal adapter that just uses `DataView` for everything
pub struct BufferAdapter<'a> {
    buffer: &'a (dyn BufferAPI + Send + Sync),
}

impl<'a> BufferAdapter<'a> {
    pub fn new(buffer: &'a (dyn BufferAPI + Send + Sync)) -> Self {
        Self { buffer }
    }
}

impl Debug for BufferAdapter<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("BufferAdapter").finish()
    }
}

impl DataProvider for BufferAdapter<'_> {
    fn get_row(&self, index: usize) -> Option<Vec<String>> {
        // Use DataView if available
        if let Some(dataview) = self.buffer.get_dataview() {
            if let Some(row) = dataview.get_row(index) {
                return Some(
                    row.values
                        .iter()
                        .map(std::string::ToString::to_string)
                        .collect(),
                );
            }
        }

        // Fallback to DataTable if no DataView
        if let Some(datatable) = self.buffer.get_datatable() {
            if let Some(row) = datatable.get_row_as_strings(index) {
                return Some(row);
            }
        }

        None
    }

    fn get_column_names(&self) -> Vec<String> {
        // Use DataView if available (respects hidden columns)
        if let Some(dataview) = self.buffer.get_dataview() {
            return dataview.column_names();
        }

        // Fallback to DataTable
        if let Some(datatable) = self.buffer.get_datatable() {
            return datatable.column_names();
        }

        Vec::new()
    }

    fn get_row_count(&self) -> usize {
        // Use DataView if available (respects filtering)
        if let Some(dataview) = self.buffer.get_dataview() {
            return dataview.row_count();
        }

        // Fallback to DataTable
        if let Some(datatable) = self.buffer.get_datatable() {
            return datatable.row_count();
        }

        0
    }

    fn get_column_count(&self) -> usize {
        // Use DataView if available (respects hidden columns)
        if let Some(dataview) = self.buffer.get_dataview() {
            return dataview.column_count();
        }

        // Fallback to DataTable
        if let Some(datatable) = self.buffer.get_datatable() {
            return datatable.column_count();
        }

        0
    }
}