Method match_like_pattern

graphlite/src/exec/executor.rs:5461–5504

Match a string against a LIKE pattern with SQL-style wildcards

(&self, text: &str, pattern: &str)

    /// Match a string against a LIKE pattern with SQL-style wildcards
    fn match_like_pattern(&self, text: &str, pattern: &str) -> Result<Value, ExecutionError> {
        // Convert SQL LIKE pattern to regex
        // % matches any sequence of characters (including empty)
        // _ matches exactly one character
        let mut regex_pattern = String::new();
        regex_pattern.push('^'); // Anchor to start

        let mut chars = pattern.chars().peekable();
        while let Some(ch) = chars.next() {
            match ch {
                '%' => regex_pattern.push_str(".*"),
                '_' => regex_pattern.push('.'),
                '\\' => {
                    // Handle escape sequences
                    if let Some(next_ch) = chars.next() {
                        match next_ch {
                            '%' => regex_pattern.push('%'),
                            '_' => regex_pattern.push('_'),
                            '\\' => regex_pattern.push_str("\\\\"),
                            _ => {
                                regex_pattern.push('\\');
                                regex_pattern.push(next_ch);
                            }
                        }
                    } else {
                        regex_pattern.push('\\');
                    }
                }
                // Escape regex special characters
                '.' | '+' | '*' | '?' | '^' | '$' | '(' | ')' | '[' | ']' | '{' | '}' | '|' => {
                    regex_pattern.push('\\');
                    regex_pattern.push(ch);
                }
                _ => regex_pattern.push(ch),
            }
        }

        regex_pattern.push('$'); // Anchor to end

        // For now, implement a simple pattern matching without regex dependency
        // This is a basic implementation that handles % and _ wildcards
        let matches = self.simple_like_match(text, pattern);
        Ok(Value::Boolean(matches))
    }

    /// Simple LIKE pattern matching without regex dependency
    fn simple_like_match(&self, text: &str, pattern: &str) -> bool {