sql-cli 1.71.2

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

use crate::app_state_container::AppStateContainer;
use crate::buffer::BufferAPI;
use crate::handlers::YankHandler;
use crate::ui::input::actions::{Action, YankTarget};
// Arc import removed - no longer needed

/// Trait that provides yank operation behavior for TUI components
/// This extracts yank operations from `EnhancedTui` to reduce coupling
pub trait YankBehavior {
    // Required methods - these provide access to TUI internals
    fn buffer(&self) -> &dyn BufferAPI;
    fn buffer_mut(&mut self) -> &mut dyn BufferAPI;
    fn state_container(&self) -> &AppStateContainer;
    fn set_status_message(&mut self, message: String);
    fn set_error_status(&mut self, prefix: &str, error: anyhow::Error);

    // ========== Yank Operation Methods ==========

    /// Yank the currently selected cell
    fn yank_cell(&mut self) {
        let action = Action::Yank(YankTarget::Cell);
        let buffer = self.buffer();
        let result = YankHandler::handle_yank_action(&action, buffer, self.state_container());

        match result {
            Ok(Some(message)) => {
                self.set_status_message(message);
            }
            Ok(None) => {}
            Err(e) => {
                self.set_error_status("Failed to yank cell", e);
            }
        }
    }

    /// Yank the currently selected row
    fn yank_row(&mut self) {
        let action = Action::Yank(YankTarget::Row);
        let buffer = self.buffer();
        let result = YankHandler::handle_yank_action(&action, buffer, self.state_container());

        match result {
            Ok(Some(message)) => {
                self.set_status_message(message);
            }
            Ok(None) => {}
            Err(e) => {
                self.set_error_status("Failed to yank row", e);
            }
        }
    }

    /// Yank the currently selected column
    fn yank_column(&mut self) {
        let action = Action::Yank(YankTarget::Column);
        let buffer = self.buffer();
        let result = YankHandler::handle_yank_action(&action, buffer, self.state_container());

        match result {
            Ok(Some(message)) => {
                self.set_status_message(message);
            }
            Ok(None) => {}
            Err(e) => {
                self.set_error_status("Failed to yank column", e);
            }
        }
    }

    /// Yank all visible data
    fn yank_all(&mut self) {
        let action = Action::Yank(YankTarget::All);
        let buffer = self.buffer();
        let result = YankHandler::handle_yank_action(&action, buffer, self.state_container());

        match result {
            Ok(Some(message)) => {
                self.set_status_message(message);
            }
            Ok(None) => {}
            Err(e) => {
                self.set_error_status("Failed to yank all", e);
            }
        }
    }

    /// Yank the current query
    fn yank_query(&mut self) {
        let action = Action::Yank(YankTarget::Query);
        let buffer = self.buffer();
        let result = YankHandler::handle_yank_action(&action, buffer, self.state_container());

        match result {
            Ok(Some(message)) => {
                self.set_status_message(message);
            }
            Ok(None) => {}
            Err(e) => {
                self.set_error_status("Failed to yank query", e);
            }
        }
    }

    /// Yank current query and results as a complete test case (Ctrl+T in debug mode)
    fn yank_as_test_case(&mut self) {
        let buffer = self.buffer();
        let result = YankHandler::handle_yank_as_test_case(buffer, self.state_container());

        match result {
            Ok(message) => {
                self.set_status_message(message);
            }
            Err(e) => {
                self.set_error_status("Failed to copy test case", e);
            }
        }
    }

    /// Yank debug dump with context for manual test creation (Shift+Y in debug mode)
    fn yank_debug_with_context(&mut self) {
        let buffer = self.buffer();
        let result = YankHandler::handle_yank_debug_context(buffer, self.state_container());

        match result {
            Ok(message) => {
                self.set_status_message(message);
            }
            Err(e) => {
                self.set_error_status("Failed to copy debug context", e);
            }
        }
    }
}