featherdb_query/expr/

helpers.rs

//! Helper functions for expression evaluation

use std::collections::HashSet;

/// Match text against a SQL LIKE pattern
///
/// Supports:
/// - `%` matches zero or more characters
/// - `_` matches exactly one character
pub fn like_match(text: &str, pattern: &str) -> bool {
    let text_chars: Vec<char> = text.chars().collect();
    let pattern_chars: Vec<char> = pattern.chars().collect();

    like_match_recursive(&text_chars, &pattern_chars, 0, 0)
}

fn like_match_recursive(
    text: &[char],
    pattern: &[char],
    text_idx: usize,
    pattern_idx: usize,
) -> bool {
    // Base cases
    if pattern_idx == pattern.len() {
        return text_idx == text.len();
    }

    // Handle wildcard %
    if pattern[pattern_idx] == '%' {
        // Try matching zero characters
        if like_match_recursive(text, pattern, text_idx, pattern_idx + 1) {
            return true;
        }
        // Try matching one or more characters
        if text_idx < text.len() {
            return like_match_recursive(text, pattern, text_idx + 1, pattern_idx);
        }
        return false;
    }

    // Check if we've consumed all text but pattern remains
    if text_idx >= text.len() {
        return false;
    }

    // Handle single character wildcard _
    if pattern[pattern_idx] == '_' {
        return like_match_recursive(text, pattern, text_idx + 1, pattern_idx + 1);
    }

    // Match literal character
    if text[text_idx] == pattern[pattern_idx] {
        return like_match_recursive(text, pattern, text_idx + 1, pattern_idx + 1);
    }

    false
}

/// Collect all column references from an expression tree
pub fn collect_column_refs(expr: &super::Expr, columns: &mut HashSet<String>) {
    match expr {
        super::Expr::Column { name, .. } => {
            columns.insert(name.clone());
        }
        super::Expr::BinaryOp { left, right, .. } => {
            collect_column_refs(left, columns);
            collect_column_refs(right, columns);
        }
        super::Expr::UnaryOp { expr, .. } => {
            collect_column_refs(expr, columns);
        }
        super::Expr::Function { args, .. } => {
            for arg in args {
                collect_column_refs(arg, columns);
            }
        }
        super::Expr::Aggregate { arg, .. } => {
            if let Some(e) = arg {
                collect_column_refs(e, columns);
            }
        }
        super::Expr::Case {
            when_clauses,
            else_result,
            ..
        } => {
            for (cond, res) in when_clauses {
                collect_column_refs(cond, columns);
                collect_column_refs(res, columns);
            }
            if let Some(else_expr) = else_result {
                collect_column_refs(else_expr, columns);
            }
        }
        super::Expr::InList { expr, list, .. } => {
            collect_column_refs(expr, columns);
            for item in list {
                collect_column_refs(item, columns);
            }
        }
        super::Expr::Between {
            expr, low, high, ..
        } => {
            collect_column_refs(expr, columns);
            collect_column_refs(low, columns);
            collect_column_refs(high, columns);
        }
        super::Expr::Window { .. } => {
            // Window functions handle their own column references
        }
        super::Expr::ScalarSubquery { .. }
        | super::Expr::Exists { .. }
        | super::Expr::InSubquery { .. }
        | super::Expr::AnySubquery { .. }
        | super::Expr::AllSubquery { .. } => {
            // Subqueries handle their own column references
        }
        super::Expr::Literal(_)
        | super::Expr::Parameter { .. }
        | super::Expr::Wildcard
        | super::Expr::QualifiedWildcard(_)
        | super::Expr::Like { .. } => {
            // No column references
        }
    }
}

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

    #[test]
    fn test_like_match_exact() {
        assert!(like_match("hello", "hello"));
        assert!(!like_match("hello", "world"));
    }

    #[test]
    fn test_like_match_percent() {
        assert!(like_match("hello", "h%"));
        assert!(like_match("hello", "%lo"));
        assert!(like_match("hello", "h%o"));
        assert!(like_match("hello", "%"));
        assert!(!like_match("hello", "w%"));
    }

    #[test]
    fn test_like_match_underscore() {
        assert!(like_match("hello", "h_llo"));
        assert!(like_match("hello", "_ello"));
        assert!(like_match("hello", "hell_"));
        assert!(!like_match("hello", "h_lo"));
    }

    #[test]
    fn test_like_match_combined() {
        assert!(like_match("hello world", "h%d"));
        assert!(like_match("hello world", "h_llo%"));
        assert!(like_match("hello world", "%o w%"));
        assert!(!like_match("hello world", "h%x"));
    }

    #[test]
    fn test_like_match_edge_cases() {
        assert!(like_match("", ""));
        assert!(like_match("", "%"));
        assert!(!like_match("", "_"));
        assert!(like_match("a", "_"));
        assert!(!like_match("ab", "_"));
    }

    #[test]
    fn test_collect_column_refs_literal() {
        use super::super::Expr;
        use featherdb_core::Value;

        let expr = Expr::Literal(Value::Integer(42));
        let mut columns = HashSet::new();
        collect_column_refs(&expr, &mut columns);
        assert!(columns.is_empty());
    }

    #[test]
    fn test_collect_column_refs_column() {
        use super::super::Expr;

        let expr = Expr::Column {
            table: None,
            name: "age".to_string(),
            index: None,
        };
        let mut columns = HashSet::new();
        collect_column_refs(&expr, &mut columns);
        assert_eq!(columns.len(), 1);
        assert!(columns.contains("age"));
    }

    #[test]
    fn test_collect_column_refs_binary_op() {
        use super::super::{BinaryOp, Expr};

        let expr = Expr::BinaryOp {
            left: Box::new(Expr::Column {
                table: None,
                name: "age".to_string(),
                index: None,
            }),
            op: BinaryOp::Gt,
            right: Box::new(Expr::Column {
                table: None,
                name: "salary".to_string(),
                index: None,
            }),
        };
        let mut columns = HashSet::new();
        collect_column_refs(&expr, &mut columns);
        assert_eq!(columns.len(), 2);
        assert!(columns.contains("age"));
        assert!(columns.contains("salary"));
    }

    #[test]
    fn test_collect_column_refs_qualified_column() {
        use super::super::Expr;

        let expr = Expr::Column {
            table: Some("users".to_string()),
            name: "name".to_string(),
            index: None,
        };
        let mut columns = HashSet::new();
        collect_column_refs(&expr, &mut columns);
        assert_eq!(columns.len(), 1);
        assert!(columns.contains("name"));
    }
}