sql-cli 1.69.4

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

use anyhow::{anyhow, Result};
use std::collections::HashMap;
use std::sync::Arc;

use crate::data::datatable::{DataColumn, DataRow, DataTable, DataType, DataValue};

pub struct VirtualTableGenerator;

impl VirtualTableGenerator {
    pub fn generate_range(
        start: i64,
        end: i64,
        step: Option<i64>,
        column_name: Option<String>,
    ) -> Result<Arc<DataTable>> {
        let step = step.unwrap_or(1);
        let column_name = column_name.unwrap_or_else(|| "value".to_string());

        if step == 0 {
            return Err(anyhow!("RANGE step cannot be zero"));
        }

        if (step > 0 && start > end) || (step < 0 && start < end) {
            return Err(anyhow!(
                "RANGE parameters invalid: start={}, end={}, step={}",
                start,
                end,
                step
            ));
        }

        let mut table = DataTable::new("range_table");

        let column = DataColumn {
            name: column_name,
            data_type: DataType::Integer,
            nullable: false,
            unique_values: Some(0),
            null_count: 0,
            metadata: HashMap::new(),
            qualified_name: None,
            source_table: None,
        };
        table.add_column(column);

        let mut current = start;
        while (step > 0 && current <= end) || (step < 0 && current >= end) {
            let row = DataRow {
                values: vec![DataValue::Integer(current)],
            };
            table.add_row(row);
            current += step;
        }

        Ok(Arc::new(table))
    }

    pub fn generate_series(count: i64, start: Option<i64>) -> Result<Arc<DataTable>> {
        let start = start.unwrap_or(1);
        Self::generate_range(start, start + count - 1, Some(1), Some("index".to_string()))
    }

    /// Generate a virtual table from a split string
    pub fn generate_split(
        text: &str,
        delimiter: Option<&str>,
        column_name: Option<String>,
    ) -> Result<Arc<DataTable>> {
        let delimiter = delimiter.unwrap_or(" ");
        let column_name = column_name.unwrap_or_else(|| "value".to_string());

        let mut table = DataTable::new("split_table");

        let column = DataColumn {
            name: column_name,
            data_type: DataType::String,
            nullable: false,
            unique_values: Some(0),
            null_count: 0,
            metadata: HashMap::new(),
            qualified_name: None,
            source_table: None,
        };
        table.add_column(column);

        // Add index column for position tracking
        let index_column = DataColumn {
            name: "index".to_string(),
            data_type: DataType::Integer,
            nullable: false,
            unique_values: Some(0),
            null_count: 0,
            metadata: HashMap::new(),
            qualified_name: None,
            source_table: None,
        };
        table.add_column(index_column);

        // Split the string and create rows
        let parts: Vec<String> = if delimiter.is_empty() {
            // If delimiter is empty, split into individual characters
            text.chars().map(|c| c.to_string()).collect()
        } else {
            text.split(delimiter).map(|s| s.to_string()).collect()
        };

        for (i, part) in parts.iter().enumerate() {
            // Skip empty parts unless they're meaningful
            if part.is_empty() && delimiter != "" {
                continue;
            }

            let row = DataRow {
                values: vec![
                    DataValue::String(part.clone()),
                    DataValue::Integer((i + 1) as i64),
                ],
            };
            table.add_row(row);
        }

        Ok(Arc::new(table))
    }
}