sql-cli 1.68.0

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

/// Scroll and cursor position utilities extracted from `enhanced_tui`
/// Calculate horizontal scroll offset for input field
#[must_use]
pub fn calculate_horizontal_scroll(cursor_pos: usize, terminal_width: u16) -> u16 {
    let inner_width = terminal_width.saturating_sub(3) as usize; // Account for borders + padding

    if cursor_pos >= inner_width {
        // Cursor is beyond visible area, scroll to show it
        (cursor_pos + 1).saturating_sub(inner_width) as u16
    } else {
        0
    }
}

/// Update scroll offset based on cursor position
#[must_use]
pub fn update_scroll_offset(cursor_pos: usize, current_offset: u16, visible_width: usize) -> u16 {
    // If cursor is before the scroll window, scroll left
    if cursor_pos < current_offset as usize {
        cursor_pos as u16
    }
    // If cursor is after the scroll window, scroll right
    else if cursor_pos >= current_offset as usize + visible_width {
        (cursor_pos + 1).saturating_sub(visible_width) as u16
    }
    // Otherwise keep current offset
    else {
        current_offset
    }
}

/// Calculate visible range for viewport
#[must_use]
pub fn calculate_visible_range(
    total_items: usize,
    viewport_start: usize,
    viewport_size: usize,
) -> (usize, usize) {
    let start = viewport_start.min(total_items);
    let end = (viewport_start + viewport_size).min(total_items);
    (start, end)
}

/// Calculate page jump offset
#[must_use]
pub fn calculate_page_jump(
    current_pos: usize,
    page_size: usize,
    total_items: usize,
    direction_up: bool,
) -> usize {
    if direction_up {
        current_pos.saturating_sub(page_size)
    } else {
        (current_pos + page_size).min(total_items.saturating_sub(1))
    }
}

/// Calculate centered viewport position
/// Centers the given position in the viewport if possible
#[must_use]
pub fn calculate_centered_viewport(
    target_pos: usize,
    viewport_size: usize,
    total_items: usize,
) -> usize {
    if total_items <= viewport_size {
        // Everything fits, start at 0
        0
    } else if target_pos < viewport_size / 2 {
        // Target is near the beginning
        0
    } else if target_pos > total_items.saturating_sub(viewport_size / 2) {
        // Target is near the end
        total_items.saturating_sub(viewport_size)
    } else {
        // Center the target
        target_pos.saturating_sub(viewport_size / 2)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_horizontal_scroll() {
        // No scroll needed
        assert_eq!(calculate_horizontal_scroll(5, 80), 0);

        // Scroll needed
        assert_eq!(calculate_horizontal_scroll(100, 80), 24); // 100 + 1 - 77
    }

    #[test]
    fn test_update_scroll_offset() {
        // Cursor before window - scroll left
        assert_eq!(update_scroll_offset(5, 10, 20), 5);

        // Cursor in window - no change
        assert_eq!(update_scroll_offset(15, 10, 20), 10);

        // Cursor after window - scroll right
        assert_eq!(update_scroll_offset(35, 10, 20), 16); // 35 + 1 - 20
    }

    #[test]
    fn test_visible_range() {
        assert_eq!(calculate_visible_range(100, 10, 20), (10, 30));
        assert_eq!(calculate_visible_range(100, 90, 20), (90, 100));
        assert_eq!(calculate_visible_range(5, 0, 10), (0, 5));
    }

    #[test]
    fn test_page_jump() {
        // Jump up
        assert_eq!(calculate_page_jump(50, 10, 100, true), 40);
        assert_eq!(calculate_page_jump(5, 10, 100, true), 0);

        // Jump down
        assert_eq!(calculate_page_jump(50, 10, 100, false), 60);
        assert_eq!(calculate_page_jump(95, 10, 100, false), 99);
    }

    #[test]
    fn test_centered_viewport() {
        // Everything fits
        assert_eq!(calculate_centered_viewport(5, 20, 10), 0);

        // Near beginning
        assert_eq!(calculate_centered_viewport(5, 20, 100), 0);

        // Near end
        assert_eq!(calculate_centered_viewport(95, 20, 100), 80);

        // Middle - centered
        assert_eq!(calculate_centered_viewport(50, 20, 100), 40);
    }
}