Method extract_text_search_predicate

graphlite/src/plan/optimizer.rs:627–718

ROADMAP v0.6.0 - Full-text search index optimization

(
        &self,
        expr: &Expression,
    )

    /// Returns (variable, query, field, min_score) if this is a text search predicate
    #[allow(dead_code)] // ROADMAP v0.6.0 - Full-text search index optimization
    fn extract_text_search_predicate(
        &self,
        expr: &Expression,
    ) -> Option<(String, String, String, f64)> {
        match expr {
            // Match: TEXT_SEARCH(doc.content, 'query') - standalone boolean predicate (Phase 4)
            Expression::FunctionCall(func)
                if func.name.eq_ignore_ascii_case("text_search") && func.arguments.len() >= 2 =>
            {
                // Extract field from first argument (property access)
                if let (Some((variable, field)), Some(query)) = (
                    self.extract_property_access(&func.arguments[0]),
                    self.extract_string_literal(&func.arguments[1]),
                ) {
                    // Check for optional min_score as 3rd argument
                    let min_score = if func.arguments.len() >= 3 {
                        self.extract_number_literal(&func.arguments[2])
                            .unwrap_or(0.0)
                    } else {
                        0.0 // No minimum score filter
                    };
                    return Some((variable, query, field, min_score));
                }
            }

            // Match: text_search(doc.content, 'query') > 5.0 - with explicit score threshold
            Expression::Binary(binary)
                if matches!(
                    binary.operator,
                    Operator::GreaterThan | Operator::GreaterEqual
                ) =>
            {
                // Check if left side is text_search() function call
                if let Expression::FunctionCall(func) = &*binary.left {
                    if func.name.eq_ignore_ascii_case("text_search") && func.arguments.len() >= 2 {
                        // Extract field from first argument (property access)
                        if let (Some((variable, field)), Some(query), Some(min_score)) = (
                            self.extract_property_access(&func.arguments[0]),
                            self.extract_string_literal(&func.arguments[1]),
                            self.extract_number_literal(&binary.right),
                        ) {
                            return Some((variable, query, field, min_score));
                        }
                    }
                }
            }

            // Match: fuzzy_match(person.name, 'query', 2) > 0.7
            Expression::Binary(binary)
                if matches!(
                    binary.operator,
                    Operator::GreaterThan | Operator::GreaterEqual
                ) =>
            {
                if let Expression::FunctionCall(func) = &*binary.left {
                    if func.name.eq_ignore_ascii_case("fuzzy_match") && func.arguments.len() >= 2 {
                        if let (Some((variable, field)), Some(query), Some(min_score)) = (
                            self.extract_property_access(&func.arguments[0]),