sql-cli 1.71.3

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

use std::fmt;

/// A section of debug information with a title and content
#[derive(Debug, Clone)]
pub struct DebugSection {
    /// The title of this debug section (e.g., "VIEWPORT STATE", "DATAVIEW STATE")
    pub title: String,
    /// The content of this debug section
    pub content: String,
    /// Priority for ordering (lower values appear first)
    pub priority: u32,
}

impl DebugSection {
    /// Create a new debug section
    pub fn new(title: impl Into<String>, content: impl Into<String>, priority: u32) -> Self {
        Self {
            title: title.into(),
            content: content.into(),
            priority,
        }
    }

    /// Create a section with a formatted title
    pub fn with_header(
        title: impl Into<String>,
        content: impl Into<String>,
        priority: u32,
    ) -> Self {
        let title_str = title.into();
        let header = format!("\n========== {title_str} ==========\n");
        Self {
            title: title_str,
            content: format!("{}{}", header, content.into()),
            priority,
        }
    }
}

impl fmt::Display for DebugSection {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.content)
    }
}

/// Trait for components that can provide debug information
pub trait DebugTrace: Send + Sync {
    /// Get the name of this debug provider
    fn name(&self) -> &str;

    /// Generate debug sections for the current state
    /// Returns a vector of debug sections that can be displayed
    fn debug_sections(&self) -> Vec<DebugSection>;

    /// Optional method to get a quick summary (one-liner)
    fn debug_summary(&self) -> Option<String> {
        None
    }

    /// Check if this provider is currently active/relevant
    fn is_active(&self) -> bool {
        true
    }
}

/// Priority constants for standard sections
pub mod Priority {
    pub const PARSER: u32 = 100;
    pub const BUFFER: u32 = 200;
    pub const RESULTS: u32 = 300;
    pub const DATATABLE: u32 = 400;
    pub const DATAVIEW: u32 = 500;
    pub const VIEWPORT: u32 = 600;
    pub const MEMORY: u32 = 700;
    pub const NAVIGATION: u32 = 800;
    pub const RENDER: u32 = 900;
    pub const TRACE: u32 = 1000;
    pub const STATE_LOGS: u32 = 1100;
}

/// Helper builder for creating debug sections
pub struct DebugSectionBuilder {
    sections: Vec<DebugSection>,
}

impl DebugSectionBuilder {
    #[must_use]
    pub fn new() -> Self {
        Self {
            sections: Vec::new(),
        }
    }

    pub fn add_section(
        &mut self,
        title: impl Into<String>,
        content: impl Into<String>,
        priority: u32,
    ) -> &mut Self {
        self.sections
            .push(DebugSection::with_header(title, content, priority));
        self
    }

    pub fn add_raw(&mut self, section: DebugSection) -> &mut Self {
        self.sections.push(section);
        self
    }

    pub fn add_field(&mut self, name: &str, value: impl fmt::Display) -> &mut Self {
        if let Some(last) = self.sections.last_mut() {
            last.content.push_str(&format!("{name}: {value}\n"));
        }
        self
    }

    pub fn add_line(&mut self, line: impl Into<String>) -> &mut Self {
        if let Some(last) = self.sections.last_mut() {
            last.content.push_str(&format!("{}\n", line.into()));
        }
        self
    }

    #[must_use]
    pub fn build(self) -> Vec<DebugSection> {
        self.sections
    }
}

impl Default for DebugSectionBuilder {
    fn default() -> Self {
        Self::new()
    }
}