Skip to main content

zero_client/ivm/
data.rs

1//! Value comparison for rows (`packages/zql/src/ivm/data.ts`); the value
2//! orders themselves are in [`crate::compare`].
3
4use super::Row;
5use crate::ast::{Direction, OrderPart};
6use crate::compare;
7use crate::json::Value;
8use std::cmp::Ordering;
9use std::rc::Rc;
10
11/// Orders rows (`Comparator` in `data.ts`).
12pub type Comparator = Rc<dyn Fn(&Row, &Row) -> Ordering>;
13
14static NULL: Value = Value::Null;
15
16/// A row's value for `column`; a missing column reads as `null`.
17pub fn value<'a>(row: &'a Row, column: &str) -> &'a Value {
18    row.get(column).unwrap_or(&NULL)
19}
20
21/// `compareValues` on possibly missing values: `undefined` reads as `null`.
22pub fn compare_values(a: Option<&Value>, b: Option<&Value>) -> Ordering {
23    compare::compare(a.unwrap_or(&NULL), b.unwrap_or(&NULL))
24}
25
26/// `valuesEqual` on possibly missing values: `undefined` and `null` equal
27/// nothing.
28pub fn values_equal(a: Option<&Value>, b: Option<&Value>) -> bool {
29    match (a, b) {
30        (Some(a), Some(b)) => compare::equal(a, b),
31        _ => false,
32    }
33}
34
35/// JS `===` on possibly missing values. Arrays and objects are never
36/// identical, since rows are decoded fresh.
37pub fn identical(a: Option<&Value>, b: Option<&Value>) -> bool {
38    match (a, b) {
39        (None, None) => true,
40        (Some(Value::Null), Some(Value::Null)) => true,
41        (Some(Value::String(x)), Some(Value::String(y))) => x == y,
42        (Some(Value::Number(x)), Some(Value::Number(y))) => x == y,
43        (Some(Value::Bool(x)), Some(Value::Bool(y))) => x == y,
44        _ => false,
45    }
46}
47
48/// `makeComparator(order, reverse)`.
49pub fn make_comparator(order: &[OrderPart], reverse: bool) -> Comparator {
50    let parts: Vec<(String, bool)> = order
51        .iter()
52        .map(|p| (p.field.clone(), p.direction == Direction::Asc))
53        .collect();
54    Rc::new(move |a: &Row, b: &Row| {
55        for (field, asc) in &parts {
56            let c = compare_values(a.get(field), b.get(field));
57            if c != Ordering::Equal {
58                let c = if *asc { c } else { c.reverse() };
59                return if reverse { c.reverse() } else { c };
60            }
61        }
62        Ordering::Equal
63    })
64}