diff options
| author | Onur Gündüz <ogunduz@gmail.com> | 2026-09-29 14:34:42 +0200 |
|---|---|---|
| committer | Onur Gündüz <ogunduz@gmail.com> | 2026-09-29 14:34:42 +0200 |
| commit | 0ebdd46766744d649c93f4023d7f20cbfde51c1e (patch) | |
| tree | c1ce87732fa766b591e380e1fb0b0a3f86d77807 /src/compiled.rs | |
| parent | 66e86c9693a7184944cdd2a0dbf1514e9d0125dc (diff) | |
| download | ele-0ebdd46766744d649c93f4023d7f20cbfde51c1e.tar.gz ele-0ebdd46766744d649c93f4023d7f20cbfde51c1e.zip | |
Implement map-key presence and repeated has traversal
Diffstat (limited to 'src/compiled.rs')
| -rw-r--r-- | src/compiled.rs | 90 |
1 files changed, 81 insertions, 9 deletions
diff --git a/src/compiled.rs b/src/compiled.rs index c9f5ab8..2981f78 100644 --- a/src/compiled.rs +++ b/src/compiled.rs @@ -28,7 +28,11 @@ enum Node<'a> { field: Option<Source<'a>>, boolean_only: bool, }, - Comparison(Source<'a>, Predicate<'a>), + Comparison { + source: Source<'a>, + predicate: Predicate<'a>, + op: CompareOp, + }, } #[derive(Debug)] @@ -75,10 +79,11 @@ impl<'a> Node<'a> { Expr::Unary { expr, .. } => Self::Not(Box::new(Self::compile(expr, regex_budget)?)), Expr::Comparison { op, left, right, .. - } => Self::Comparison( - Source::compile(left)?, - Predicate::compile(*op, right, regex_budget)?, - ), + } => Self::Comparison { + source: Source::compile(left)?, + predicate: Predicate::compile(*op, right, regex_budget)?, + op: *op, + }, Expr::Name { name, is_string, .. } => Self::Global { @@ -121,7 +126,14 @@ impl<'a> Node<'a> { } record.matches_global(text) } - Self::Comparison(source, predicate) => source + Self::Comparison { + source, + predicate, + op: CompareOp::Has, + } => source.evaluate_has(record, predicate), + Self::Comparison { + source, predicate, .. + } => source .resolve(record) .is_some_and(|value| predicate.evaluate(&value)), } @@ -145,6 +157,30 @@ impl<'a> Source<'a> { } } + fn evaluate_has<T: Filterable>(&self, record: &T, predicate: &Predicate<'_>) -> bool { + if let Self::Field(path) = self { + for length in 1..path.len() { + let value = if length == 1 { + record + .field(path[0]) + .or_else(|| record.field_path(&path[..length])) + } else { + record.field_path(&path[..length]) + }; + if let Some(value) = value + && matches!( + value, + Value::Map(_) | Value::JsonObject(_) | Value::List(_) | Value::JsonArray(_) + ) + { + return has_path(value, &path[length..], predicate, false); + } + } + } + self.resolve(record) + .is_some_and(|value| predicate.evaluate(&value)) + } + fn resolve<'s, T: Filterable>(&'s self, record: &'s T) -> Option<Value<'s>> { let path = match self { Self::String(text) => return Some(Value::String(text)), @@ -216,14 +252,21 @@ impl<'a> Predicate<'a> { } fn evaluate(&self, value: &Value<'_>) -> bool { + self.evaluate_with_presence(value, false) + } + + fn evaluate_with_presence(&self, value: &Value<'_>, map_entry: bool) -> bool { match self { Self::Binary(BinaryOp::And, left, right) => { - left.evaluate(value) && right.evaluate(value) + left.evaluate_with_presence(value, map_entry) + && right.evaluate_with_presence(value, map_entry) } Self::Binary(BinaryOp::Or, left, right) => { - left.evaluate(value) || right.evaluate(value) + left.evaluate_with_presence(value, map_entry) + || right.evaluate_with_presence(value, map_entry) } - Self::Not(expr) => !expr.evaluate(value), + Self::Not(expr) => !expr.evaluate_with_presence(value, map_entry), + Self::Literal(CompareOp::Has, literal) if map_entry && literal.is_presence() => true, Self::Literal(op, literal) => eval_literal(*op, value, literal), Self::Regex { regex, negated } => value .as_str() @@ -232,6 +275,35 @@ impl<'a> Predicate<'a> { } } +// Map-key presence is independent of its value; only `:` traverses repeated values. +fn has_path(value: Value<'_>, path: &[&str], predicate: &Predicate<'_>, map_entry: bool) -> bool { + let Some((segment, rest)) = path.split_first() else { + return predicate.evaluate_with_presence(&value, map_entry); + }; + match value { + Value::Map(entries) => entries + .into_iter() + .find(|(key, _)| key.eq_ignore_ascii_case(segment)) + .is_some_and(|(_, value)| has_path(value, rest, predicate, true)), + Value::JsonObject(entries) => entries + .get(*segment) + .or_else(|| { + entries + .iter() + .find(|(key, _)| key.eq_ignore_ascii_case(segment)) + .map(|(_, value)| value) + }) + .is_some_and(|value| has_path(Value::from(value), rest, predicate, true)), + Value::List(items) => items + .into_iter() + .any(|value| has_path(value, path, predicate, false)), + Value::JsonArray(items) => items + .iter() + .any(|value| has_path(Value::from(value), path, predicate, false)), + _ => false, + } +} + fn field_path(expr: &Expr) -> Result<Vec<&str>, String> { let mut path = Vec::new(); let mut current = expr; |
