sql-cli 1.69.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
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
140
141
142
143
144

// Logical expression parsing
// Handles logical operators (AND, OR) and NOT operator
// These operators are used for combining boolean expressions

use crate::sql::parser::ast::SqlExpression;
use crate::sql::parser::lexer::Token;
use tracing::debug;

use super::{log_parse_decision, trace_parse_entry, trace_parse_exit};

/// Parse a logical OR expression
/// OR has the lowest precedence of the logical operators
pub fn parse_logical_or<P>(parser: &mut P) -> Result<SqlExpression, String>
where
    P: ParseLogical + ?Sized,
{
    trace_parse_entry("parse_logical_or", parser.current_token());

    let mut left = parser.parse_logical_and()?;

    while matches!(parser.current_token(), Token::Or) {
        log_parse_decision(
            "parse_logical_or",
            parser.current_token(),
            "OR operator found, parsing right operand",
        );

        debug!("Processing logical OR operator");
        parser.advance();
        let right = parser.parse_logical_and()?;

        // Use BinaryOp to represent OR operations
        left = SqlExpression::BinaryOp {
            left: Box::new(left),
            op: "OR".to_string(),
            right: Box::new(right),
        };

        debug!("Created OR expression");
    }

    let result = Ok(left);
    trace_parse_exit("parse_logical_or", &result);
    result
}

/// Parse a logical AND expression
/// AND has higher precedence than OR but lower than comparison operators
pub fn parse_logical_and<P>(parser: &mut P) -> Result<SqlExpression, String>
where
    P: ParseLogical + ?Sized,
{
    trace_parse_entry("parse_logical_and", parser.current_token());

    // Parse the base expression (comparison or lower)
    let mut left = parser.parse_base_logical_expression()?;

    while matches!(parser.current_token(), Token::And) {
        log_parse_decision(
            "parse_logical_and",
            parser.current_token(),
            "AND operator found, parsing right operand",
        );

        debug!("Processing logical AND operator");
        parser.advance();
        let right = parser.parse_base_logical_expression()?;

        // Use BinaryOp to represent AND operations
        left = SqlExpression::BinaryOp {
            left: Box::new(left),
            op: "AND".to_string(),
            right: Box::new(right),
        };

        debug!("Created AND expression");
    }

    let result = Ok(left);
    trace_parse_exit("parse_logical_and", &result);
    result
}

/// Parse a NOT expression (unary logical operator)
/// This is handled as part of primary expression parsing
pub fn parse_not_expression<P>(parser: &mut P) -> Result<SqlExpression, String>
where
    P: ParseLogical + ?Sized,
{
    trace_parse_entry("parse_not_expression", parser.current_token());

    if !matches!(parser.current_token(), Token::Not) {
        return Err("Expected NOT token".to_string());
    }

    log_parse_decision(
        "parse_not_expression",
        parser.current_token(),
        "NOT operator found, parsing operand",
    );

    debug!("Processing NOT operator");
    parser.advance(); // consume NOT

    // Check if this is a NOT IN expression
    let inner_expr = parser.parse_comparison()?;

    // After parsing the inner expression, check if we're followed by IN
    if matches!(parser.current_token(), Token::In) {
        debug!("NOT IN expression detected");
        parser.advance(); // consume IN
        parser.consume(Token::LeftParen)?;
        let values = parser.parse_expression_list()?;
        parser.consume(Token::RightParen)?;

        let result = Ok(SqlExpression::NotInList {
            expr: Box::new(inner_expr),
            values,
        });
        trace_parse_exit("parse_not_expression", &result);
        result
    } else {
        // Regular NOT expression
        debug!("Creating NOT expression");
        let result = Ok(SqlExpression::Not {
            expr: Box::new(inner_expr),
        });
        trace_parse_exit("parse_not_expression", &result);
        result
    }
}

/// Trait that parsers must implement to use logical expression parsing
pub trait ParseLogical {
    fn current_token(&self) -> &Token;
    fn advance(&mut self);
    fn consume(&mut self, expected: Token) -> Result<(), String>;

    // These methods are called from logical parsing
    fn parse_logical_and(&mut self) -> Result<SqlExpression, String>;
    fn parse_base_logical_expression(&mut self) -> Result<SqlExpression, String>;
    fn parse_comparison(&mut self) -> Result<SqlExpression, String>;
    fn parse_expression_list(&mut self) -> Result<Vec<SqlExpression>, String>;
}