v1.0.0: Functions in WHERE, performance optimization

- LOWER(), UPPER(), TRIM(), SPLIT(), REPLACE() now work in WHERE conditions
- 4x faster file traversal (use DirEntry::file_type instead of stat)
- Skip file open when query only needs metadata (no binary check overhead)
- Race condition fix: skip vanished files gracefully

Author: Fabian2000

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "fquery"
-version = "0.1.0"
+version = "1.0.0"
 edition = "2024"
 
 [profile.release]

Cargo.toml

@@ -621,6 +621,27 @@ fn matches_condition(
             let len = val_str.chars().count();
             Ok(cmp_op_eval(op, &len, val))
         }
+        Condition::ExprEquals(expr, val, negated) => {
+            let v = resolve_column_in_where(expr, line, lineno, file_info) == *val;
+            Ok(if *negated { !v } else { v })
+        }
+        Condition::ExprContains(expr, val, negated) => {
+            let v = resolve_column_in_where(expr, line, lineno, file_info).contains(val.as_str());
+            Ok(if *negated { !v } else { v })
+        }
+        Condition::ExprMatches(expr, pat, negated) => {
+            let re = compiled_regexes.get(pat)
+                .ok_or_else(|| FQueryError::Parse(format!("regex not compiled: {pat}")))?;
+            let v = re.is_match(&resolve_column_in_where(expr, line, lineno, file_info));
+            Ok(if *negated { !v } else { v })
+        }
+        Condition::ExprLike(expr, pat, negated) => {
+            let re_pat = like_to_regex(pat);
+            let re = compiled_regexes.get(&re_pat)
+                .ok_or_else(|| FQueryError::Parse(format!("like regex not compiled: {pat}")))?;
+            let v = re.is_match(&resolve_column_in_where(expr, line, lineno, file_info));
+            Ok(if *negated { !v } else { v })
+        }
         Condition::FileSizeBetween(low, high) => {
             Ok(file_info.size >= *low && file_info.size <= *high)
         }
@@ -692,12 +713,17 @@ fn collect_patterns(clause: &WhereClause, patterns: &mut Vec<String>) {
                     patterns.push(p.clone());
                 }
             }
-            Condition::LineLike(p, _) | Condition::FileFieldLike(_, p, _) => {
+            Condition::LineLike(p, _) | Condition::FileFieldLike(_, p, _) | Condition::ExprLike(_, p, _) => {
                 let re_pat = like_to_regex(p);
                 if !patterns.contains(&re_pat) {
                     patterns.push(re_pat);
                 }
             }
+            Condition::ExprMatches(_, p, _) => {
+                if !patterns.contains(p) {
+                    patterns.push(p.clone());
+                }
+            }
             _ => {}
         },
         WhereClause::And(parts) | WhereClause::Or(parts) => {
@@ -734,6 +760,10 @@ fn is_file_condition(c: &Condition) -> bool {
         | Condition::ModifiedCmp(..)
         | Condition::CreatedCmp(..) => true,
         Condition::LenCmp(col, _, _) => !is_line_level_column(&col.col),
+        Condition::ExprEquals(col, _, _)
+        | Condition::ExprContains(col, _, _)
+        | Condition::ExprMatches(col, _, _)
+        | Condition::ExprLike(col, _, _) => !is_line_level_column(&col.col),
         _ => false,
     }
 }

src/engine.rs

@@ -129,6 +129,12 @@ pub enum Condition {
     FileFieldMatches(FileField, String, bool),
     /// FILENAME|FILEPATH|FILEDIR|FILEEXT LIKE "pattern"
     FileFieldLike(FileField, String, bool),
+    // --- Generic column expression conditions (for functions in WHERE) ---
+    /// LOWER(col) = "value", TRIM(col) CONTAINS "x", etc.
+    ExprEquals(ColumnExpr, String, bool),
+    ExprContains(ColumnExpr, String, bool),
+    ExprMatches(ColumnExpr, String, bool),
+    ExprLike(ColumnExpr, String, bool),
     // --- LEN() function ---
     /// LEN(col) <op> N
     LenCmp(ColumnExpr, CmpOp, usize),
@@ -893,7 +899,65 @@ impl Parser {
         Ok(WhereClause::Single(cond))
     }
 
+    fn parse_expr_condition(&mut self, expr: ColumnExpr) -> Result<Condition> {
+        let op = self.advance()?.clone();
+        match &op {
+            Token::Eq => {
+                let val = self.expect_string()?;
+                Ok(Condition::ExprEquals(expr, val, false))
+            }
+            Token::Neq => {
+                let val = self.expect_string()?;
+                Ok(Condition::ExprEquals(expr, val, true))
+            }
+            Token::Keyword(k) if k.eq_ignore_ascii_case("CONTAINS") => {
+                let val = self.expect_string()?;
+                Ok(Condition::ExprContains(expr, val, false))
+            }
+            Token::Keyword(k) if k.eq_ignore_ascii_case("MATCHES") => {
+                let val = self.expect_string()?;
+                Ok(Condition::ExprMatches(expr, val, false))
+            }
+            Token::Keyword(k) if k.eq_ignore_ascii_case("LIKE") => {
+                let val = self.expect_string()?;
+                Ok(Condition::ExprLike(expr, val, false))
+            }
+            Token::Keyword(k) if k.eq_ignore_ascii_case("NOT") => {
+                let next = self.advance()?.clone();
+                match &next {
+                    Token::Keyword(kk) if kk.eq_ignore_ascii_case("CONTAINS") => {
+                        let val = self.expect_string()?;
+                        Ok(Condition::ExprContains(expr, val, true))
+                    }
+                    Token::Keyword(kk) if kk.eq_ignore_ascii_case("MATCHES") => {
+                        let val = self.expect_string()?;
+                        Ok(Condition::ExprMatches(expr, val, true))
+                    }
+                    Token::Keyword(kk) if kk.eq_ignore_ascii_case("LIKE") => {
+                        let val = self.expect_string()?;
+                        Ok(Condition::ExprLike(expr, val, true))
+                    }
+                    other => Err(FQueryError::Parse(format!(
+                        "expected CONTAINS, MATCHES, or LIKE after NOT, got {other:?}"
+                    ))),
+                }
+            }
+            other => Err(FQueryError::Parse(format!(
+                "expected operator after expression, got {other:?}"
+            ))),
+        }
+    }
+
     fn parse_condition(&mut self) -> Result<Condition> {
+        // Check for function-wrapped columns: LOWER(col), UPPER(col), TRIM(col), etc.
+        if let Some(Token::Keyword(k)) = self.peek() {
+            let upper = k.to_ascii_uppercase();
+            if matches!(upper.as_str(), "LOWER" | "UPPER" | "TRIM" | "TRIMSTART" | "TRIMEND" | "SPLIT" | "REPLACE") {
+                let expr = self.parse_single_column()?;
+                return self.parse_expr_condition(expr);
+            }
+        }
+
         let field = self.advance()?.clone();
         match &field {
             Token::Keyword(k) if k.eq_ignore_ascii_case("LINE") => {