core_query/
value_ops.rs

1use core_storage::Value;
2use std::cmp::Ordering;
3
4pub fn values_equal(a: &Value, b: &Value) -> bool {
5    match (a, b) {
6        (Value::Int(x), Value::Int(y)) => x == y,
7        (Value::Float(x), Value::Float(y)) => x == y,
8        (Value::Int(x), Value::Float(y)) => *x as f64 == *y,
9        (Value::Float(x), Value::Int(y)) => *x == *y as f64,
10        (Value::Str(x), Value::Str(y)) => x == y,
11        (Value::Bool(x), Value::Bool(y)) => x == y,
12        (Value::List(x), Value::List(y)) => {
13            x.len() == y.len() && x.iter().zip(y.iter()).all(|(l, r)| values_equal(l, r))
14        }
15        (Value::Map(x), Value::Map(y)) => {
16            x.len() == y.len()
17                && x.iter()
18                    .zip(y.iter())
19                    .all(|((k1, v1), (k2, v2))| k1 == k2 && values_equal(v1, v2))
20        }
21        _ => false,
22    }
23}
24
25fn class_rank(v: &Value) -> u8 {
26    match v {
27        Value::Int(_) | Value::Float(_) => 0,
28        Value::Str(_) => 1,
29        Value::Bool(_) => 2,
30        Value::List(_) => 3,
31        // Map sorts after all other types.
32        Value::Map(_) => 4,
33    }
34}
35
36fn as_f64(v: &Value) -> f64 {
37    match v {
38        Value::Int(i) => *i as f64,
39        Value::Float(f) => *f,
40        _ => unreachable!("as_f64 only for numeric class"),
41    }
42}
43
44pub fn cmp_values(a: &Value, b: &Value) -> Ordering {
45    let ra = class_rank(a);
46    let rb = class_rank(b);
47    if ra != rb {
48        return ra.cmp(&rb);
49    }
50    match (a, b) {
51        (Value::Int(_) | Value::Float(_), Value::Int(_) | Value::Float(_)) => {
52            as_f64(a).total_cmp(&as_f64(b))
53        }
54        (Value::Str(x), Value::Str(y)) => x.cmp(y),
55        (Value::Bool(x), Value::Bool(y)) => x.cmp(y),
56        (Value::List(x), Value::List(y)) => {
57            for (l, r) in x.iter().zip(y.iter()) {
58                let c = cmp_values(l, r);
59                if c != Ordering::Equal {
60                    return c;
61                }
62            }
63            x.len().cmp(&y.len())
64        }
65        (Value::Map(x), Value::Map(y)) => {
66            // BTreeMap iterates in key-sorted order; compare key then value.
67            for ((k1, v1), (k2, v2)) in x.iter().zip(y.iter()) {
68                let ck = k1.cmp(k2);
69                if ck != Ordering::Equal {
70                    return ck;
71                }
72                let cv = cmp_values(v1, v2);
73                if cv != Ordering::Equal {
74                    return cv;
75                }
76            }
77            x.len().cmp(&y.len())
78        }
79        _ => unreachable!("same class rank implies matching variants"),
80    }
81}
82
83pub fn cmp_optional(a: Option<&Value>, b: Option<&Value>, descending: bool) -> Ordering {
84    match (a, b) {
85        (None, None) => Ordering::Equal,
86        // None sorts LAST regardless of ascending/descending.
87        (None, Some(_)) => Ordering::Greater,
88        (Some(_), None) => Ordering::Less,
89        (Some(x), Some(y)) => {
90            let c = cmp_values(x, y);
91            if descending {
92                c.reverse()
93            } else {
94                c
95            }
96        }
97    }
98}
99
100#[cfg(test)]
101mod tests {
102    use super::{cmp_optional, cmp_values, values_equal};
103    use core_storage::Value;
104    use std::cmp::Ordering::*;
105
106    #[test]
107    fn int_equals_float_numerically() {
108        assert!(values_equal(&Value::Int(2), &Value::Float(2.0)));
109        assert!(values_equal(&Value::Float(2.0), &Value::Int(2)));
110        assert!(!values_equal(&Value::Int(2), &Value::Float(2.1)));
111    }
112
113    #[test]
114    fn same_variant_equality() {
115        assert!(values_equal(&Value::Int(1), &Value::Int(1)));
116        assert!(!values_equal(&Value::Int(1), &Value::Int(2)));
117        assert!(values_equal(
118            &Value::Str("a".into()),
119            &Value::Str("a".into())
120        ));
121        assert!(!values_equal(
122            &Value::Str("a".into()),
123            &Value::Str("b".into())
124        ));
125        assert!(values_equal(&Value::Bool(true), &Value::Bool(true)));
126        assert!(!values_equal(&Value::Bool(true), &Value::Bool(false)));
127        assert!(values_equal(&Value::Float(1.5), &Value::Float(1.5)));
128        assert!(values_equal(
129            &Value::List(vec![Value::Int(1), Value::Float(2.0)]),
130            &Value::List(vec![Value::Float(1.0), Value::Int(2)]),
131        ));
132        assert!(!values_equal(
133            &Value::List(vec![Value::Int(1)]),
134            &Value::List(vec![Value::Int(1), Value::Int(2)]),
135        ));
136    }
137
138    #[test]
139    fn cross_variant_not_equal_except_int_float() {
140        assert!(!values_equal(&Value::Str("2".into()), &Value::Int(2)));
141        assert!(!values_equal(&Value::Bool(true), &Value::Int(1)));
142        assert!(!values_equal(&Value::List(vec![]), &Value::Str("".into())));
143        assert!(!values_equal(&Value::Bool(false), &Value::Float(0.0)));
144    }
145
146    #[test]
147    fn cmp_values_class_ranks() {
148        // numeric < Str < Bool < List
149        assert_eq!(cmp_values(&Value::Int(99), &Value::Str("a".into())), Less);
150        assert_eq!(cmp_values(&Value::Float(1.0), &Value::Bool(false)), Less);
151        assert_eq!(
152            cmp_values(&Value::Str("z".into()), &Value::Bool(false)),
153            Less
154        );
155        assert_eq!(cmp_values(&Value::Bool(true), &Value::List(vec![])), Less);
156        assert_eq!(cmp_values(&Value::List(vec![]), &Value::Int(0)), Greater);
157
158        // numerics via f64::total_cmp
159        assert_eq!(cmp_values(&Value::Int(1), &Value::Float(1.5)), Less);
160        assert_eq!(cmp_values(&Value::Int(2), &Value::Float(2.0)), Equal);
161        // f64::total_cmp: -0.0 < +0.0 (unlike IEEE ==).
162        assert_eq!(cmp_values(&Value::Float(-0.0), &Value::Float(0.0)), Less);
163
164        // str lexicographic
165        assert_eq!(
166            cmp_values(&Value::Str("a".into()), &Value::Str("b".into())),
167            Less
168        );
169
170        // bool false < true
171        assert_eq!(cmp_values(&Value::Bool(false), &Value::Bool(true)), Less);
172
173        // list elementwise, then length
174        assert_eq!(
175            cmp_values(
176                &Value::List(vec![Value::Int(1), Value::Int(2)]),
177                &Value::List(vec![Value::Int(1), Value::Int(3)]),
178            ),
179            Less
180        );
181        assert_eq!(
182            cmp_values(
183                &Value::List(vec![Value::Int(1)]),
184                &Value::List(vec![Value::Int(1), Value::Int(2)]),
185            ),
186            Less
187        );
188        // list elements use class ranks
189        assert_eq!(
190            cmp_values(
191                &Value::List(vec![Value::Int(1)]),
192                &Value::List(vec![Value::Str("a".into())]),
193            ),
194            Less
195        );
196    }
197
198    #[test]
199    fn cmp_optional_none_last_both_directions() {
200        let a = Value::Int(1);
201        let b = Value::Int(2);
202        assert_eq!(cmp_optional(None, Some(&a), false), Greater);
203        assert_eq!(cmp_optional(Some(&a), None, false), Less);
204        assert_eq!(cmp_optional(None, Some(&a), true), Greater);
205        assert_eq!(cmp_optional(Some(&a), None, true), Less);
206        assert_eq!(cmp_optional(None, None, false), Equal);
207        assert_eq!(cmp_optional(None, None, true), Equal);
208        assert_eq!(cmp_optional(Some(&a), Some(&b), false), Less);
209        assert_eq!(cmp_optional(Some(&a), Some(&b), true), Greater);
210        assert_eq!(cmp_optional(Some(&a), Some(&a), false), Equal);
211        assert_eq!(cmp_optional(Some(&a), Some(&a), true), Equal);
212    }
213}
core_query/value_ops.rs

core_query/
value_ops.rs
