partiql_value/
lib.rs

1#![deny(rust_2018_idioms)]
2#![deny(clippy::all)]
3
4mod bag;
5mod bindings;
6pub mod boxed_variant;
7pub mod comparison;
8mod datetime;
9pub mod datum;
10mod graph;
11mod list;
12mod pretty;
13mod sort;
14mod tuple;
15mod util;
16mod value;
17mod variant;
18
19pub use bag::*;
20pub use bindings::*;
21pub use comparison::*;
22pub use datetime::*;
23pub use graph::*;
24pub use list::*;
25pub use sort::*;
26pub use tuple::*;
27pub use value::*;
28pub use variant::*;
29
30#[cfg(test)]
31mod tests {
32    use super::*;
33    use crate::comparison::{EqualityValue, NullableEq, NullableOrd};
34    use crate::sort::NullSortedValue;
35    use ordered_float::OrderedFloat;
36    use rust_decimal::Decimal as RustDecimal;
37    use rust_decimal_macros::dec;
38    use std::borrow::Cow;
39    use std::cell::RefCell;
40    use std::cmp::Ordering;
41    use std::collections::HashSet;
42    use std::mem;
43    use std::rc::Rc;
44
45    #[test]
46    fn value_size() {
47        println!("bool size: {}", mem::size_of::<bool>());
48        println!("i64 size: {}", mem::size_of::<i64>());
49        println!(
50            "OrderedFloat<f64> size: {}",
51            mem::size_of::<OrderedFloat<f64>>()
52        );
53        println!("Decimal size: {}", mem::size_of::<RustDecimal>());
54        println!("String size: {}", mem::size_of::<String>());
55        println!("Bag size: {}", mem::size_of::<Bag>());
56        println!("List size: {}", mem::size_of::<List>());
57        println!("Tuple size: {}", mem::size_of::<Tuple>());
58        println!("Box<Tuple> size: {}", mem::size_of::<Box<Tuple>>());
59        println!("Rc<Tuple> size: {}", mem::size_of::<Rc<Tuple>>());
60        println!(
61            "Rc<RefCell<Tuple>> size: {}",
62            mem::size_of::<Rc<RefCell<Tuple>>>()
63        );
64        println!("Cow<&Tuple> size: {}", mem::size_of::<Cow<'_, &Tuple>>());
65        println!("Value size: {}", mem::size_of::<Value>());
66        println!("Option<Value> size: {}", mem::size_of::<Option<Value>>());
67        println!(
68            "Option<Option<Value>> size: {}",
69            mem::size_of::<Option<Option<Value>>>()
70        );
71        println!("Cow<'_, Value> size: {}", mem::size_of::<Cow<'_, Value>>());
72        println!("Cow<&Value> size: {}", mem::size_of::<Cow<'_, &Value>>());
73
74        assert_eq!(mem::size_of::<Value>(), 16);
75        assert_eq!(mem::size_of::<Option<Option<Value>>>(), 16);
76    }
77
78    #[test]
79    fn macro_rules_tests() {
80        println!("partiql_list:{:?}", list!());
81        println!("partiql_list:{:?}", list![10, 10]);
82        println!("partiql_list:{:?}", list!(5; 3));
83        println!("partiql_bag:{:?}", bag!());
84        println!("partiql_bag:{:?}", bag![10, 10]);
85        println!("partiql_bag:{:?}", bag!(5; 3));
86        println!("partiql_tuple:{:?}", tuple![]);
87        println!("partiql_tuple:{:?}", tuple![("a", 1), ("b", 2)]);
88    }
89
90    #[test]
91    fn iterators() {
92        let bag: Bag = [1, 10, 3, 4].into_iter().collect();
93        assert_eq!(bag.len(), 4);
94        let max = bag
95            .iter()
96            .fold(Value::Integer(0), |x, y| if y > &x { y.clone() } else { x });
97        assert_eq!(max, Value::Integer(10));
98        let _bref = Value::from(bag).as_bag_ref();
99
100        let list: List = [1, 2, 3, -4].into_iter().collect();
101        assert_eq!(list.len(), 4);
102        let max = list
103            .iter()
104            .fold(Value::Integer(0), |x, y| if y > &x { y.clone() } else { x });
105        assert_eq!(max, Value::Integer(3));
106        let _lref = Value::from(list).as_bag_ref();
107
108        let bag: Bag = [Value::from(5), "text".into(), true.into()]
109            .iter()
110            .map(Clone::clone)
111            .collect();
112        assert_eq!(bag.len(), 3);
113        let max = bag
114            .iter()
115            .fold(Value::Integer(0), |x, y| if y > &x { y.clone() } else { x });
116        assert_eq!(max, Value::String(Box::new("text".to_string())));
117
118        let list: List = [Value::from(5), Value::from(bag.clone()), true.into()]
119            .iter()
120            .map(Clone::clone)
121            .collect();
122        assert_eq!(list.len(), 3);
123        let max = list
124            .iter()
125            .fold(Value::Integer(0), |x, y| if y > &x { y.clone() } else { x });
126        assert_eq!(max, Value::from(bag.clone()));
127
128        let tuple: Tuple = [
129            ("list", Value::from(list.clone())),
130            ("bag", Value::from(bag.clone())),
131        ]
132        .iter()
133        .cloned()
134        .collect();
135
136        let mut pairs = tuple.pairs();
137        let list_val = Value::from(list);
138        assert_eq!(pairs.next(), Some((&"list".to_string(), &list_val)));
139        let bag_val = Value::from(bag);
140        assert_eq!(pairs.next(), Some((&"bag".to_string(), &bag_val)));
141        assert_eq!(pairs.next(), None);
142    }
143
144    #[test]
145    fn partiql_value_ordering() {
146        // TODO: some additional checking can be included in the ordering testing
147        //  - add timestamp, date, time once added to `Value`
148        //  - equality checking between equivalent ordered values (e.g. missing and null, same numeric values)
149        let mut vals = vec![
150            Value::Missing,
151            Value::from(false),
152            Value::from(true),
153            Value::from(f64::NAN),
154            Value::from(f64::NEG_INFINITY),
155            Value::from(-123.456),
156            Value::Decimal(Box::new(dec!(1.23456))),
157            Value::from(138u8),
158            Value::from(1348u16),
159            Value::from(13849u32),
160            Value::from(123_456),
161            Value::from(1_384_449_u64),
162            Value::from(138_444_339_u128),
163            Value::from(f64::INFINITY),
164            Value::from(""),
165            Value::from("abc"),
166            Value::Blob(Box::default()),
167            Value::Blob(Box::new(vec![1, 2, 3])),
168            Value::from(list!()),
169            Value::from(list!(1, 2, 3)),
170            Value::from(list!(1, 2, 3, 4, 5)),
171            Value::from(tuple!()),
172            Value::from(tuple![("a", 1), ("b", 2)]),
173            Value::from(tuple![("a", 1), ("b", 3)]),
174            Value::from(tuple![("a", 1), ("c", 2)]),
175            Value::from(bag!()),
176            Value::from(bag!(1, 2, 3)),
177            Value::from(bag!(3, 3, 3)),
178        ];
179        let expected_vals = vals.clone();
180        vals.reverse();
181        vals.sort();
182        assert_eq!(expected_vals, vals);
183    }
184
185    #[test]
186    fn partiql_value_arithmetic() {
187        // Unary plus
188        assert_eq!(&Value::Missing, &Value::Missing.positive());
189        assert_eq!(&Value::Null, &Value::Null.positive());
190        assert_eq!(&Value::Integer(123), &Value::Integer(123).positive());
191        assert_eq!(
192            &Value::Decimal(Box::new(dec!(3))),
193            &Value::Decimal(Box::new(dec!(3))).positive()
194        );
195        assert_eq!(&Value::from(4.0), &Value::from(4.0).positive());
196        assert_eq!(&Value::Missing, &Value::from("foo").positive());
197
198        // Negation
199        assert_eq!(Value::Missing, -&Value::Missing);
200        assert_eq!(Value::Null, -&Value::Null);
201        assert_eq!(Value::Integer(-123), -&Value::Integer(123));
202        assert_eq!(
203            Value::Decimal(Box::new(dec!(-3))),
204            -&Value::Decimal(Box::new(dec!(3)))
205        );
206        assert_eq!(Value::from(-4.0), -&Value::from(4.0));
207        assert_eq!(Value::Missing, -&Value::from("foo"));
208
209        // Add
210        assert_eq!(Value::Missing, &Value::Missing + &Value::Missing);
211        assert_eq!(Value::Missing, &Value::Missing + &Value::Null);
212        assert_eq!(Value::Missing, &Value::Null + &Value::Missing);
213        assert_eq!(Value::Null, &Value::Null + &Value::Null);
214        assert_eq!(Value::Missing, &Value::Integer(1) + &Value::from("a"));
215        assert_eq!(Value::Integer(3), &Value::Integer(1) + &Value::Integer(2));
216        assert_eq!(Value::from(4.0), &Value::from(1.5) + &Value::from(2.5));
217        assert_eq!(
218            Value::Decimal(Box::new(dec!(3))),
219            &Value::Decimal(Box::new(dec!(1))) + &Value::Decimal(Box::new(dec!(2)))
220        );
221        assert_eq!(Value::from(3.5), &Value::Integer(1) + &Value::from(2.5));
222        assert_eq!(Value::from(3.), &Value::from(1.) + &Value::from(2.));
223        assert_eq!(
224            Value::Decimal(Box::new(dec!(3))),
225            &Value::Integer(1) + &Value::Decimal(Box::new(dec!(2)))
226        );
227        assert_eq!(
228            Value::Decimal(Box::new(dec!(3))),
229            &Value::Decimal(Box::new(dec!(1))) + &Value::Integer(2)
230        );
231        assert_eq!(
232            Value::Decimal(Box::new(dec!(3))),
233            &Value::from(1.) + &Value::Decimal(Box::new(dec!(2)))
234        );
235        assert_eq!(
236            Value::Decimal(Box::new(dec!(3))),
237            &Value::Decimal(Box::new(dec!(1))) + &Value::from(2.)
238        );
239
240        // Sub
241        assert_eq!(Value::Missing, &Value::Missing - &Value::Missing);
242        assert_eq!(Value::Missing, &Value::Missing - &Value::Null);
243        assert_eq!(Value::Missing, &Value::Null - &Value::Missing);
244        assert_eq!(Value::Null, &Value::Null - &Value::Null);
245        assert_eq!(Value::Missing, &Value::Integer(1) - &Value::from("a"));
246        assert_eq!(Value::Integer(-1), &Value::Integer(1) - &Value::Integer(2));
247        assert_eq!(Value::from(-1.0), &Value::from(1.5) - &Value::from(2.5));
248        assert_eq!(
249            Value::Decimal(Box::new(dec!(-1))),
250            &Value::Decimal(Box::new(dec!(1))) - &Value::Decimal(Box::new(dec!(2)))
251        );
252        assert_eq!(Value::from(-1.5), &Value::Integer(1) - &Value::from(2.5));
253        assert_eq!(Value::from(-1.), &Value::from(1.) - &Value::from(2.));
254        assert_eq!(
255            Value::Decimal(Box::new(dec!(-1))),
256            &Value::Integer(1) - &Value::Decimal(Box::new(dec!(2)))
257        );
258        assert_eq!(
259            Value::Decimal(Box::new(dec!(-1))),
260            &Value::Decimal(Box::new(dec!(1))) - &Value::Integer(2)
261        );
262        assert_eq!(
263            Value::Decimal(Box::new(dec!(-1))),
264            &Value::from(1.) - &Value::Decimal(Box::new(dec!(2)))
265        );
266        assert_eq!(
267            Value::Decimal(Box::new(dec!(-1))),
268            &Value::Decimal(Box::new(dec!(1))) - &Value::from(2.)
269        );
270
271        // Mul
272        assert_eq!(Value::Missing, &Value::Missing * &Value::Missing);
273        assert_eq!(Value::Missing, &Value::Missing * &Value::Null);
274        assert_eq!(Value::Missing, &Value::Null * &Value::Missing);
275        assert_eq!(Value::Null, &Value::Null * &Value::Null);
276        assert_eq!(Value::Missing, &Value::Integer(1) * &Value::from("a"));
277        assert_eq!(Value::Integer(2), &Value::Integer(1) * &Value::Integer(2));
278        assert_eq!(Value::from(3.75), &Value::from(1.5) * &Value::from(2.5));
279        assert_eq!(
280            Value::from(RustDecimal::new(2, 0)),
281            &Value::Decimal(Box::new(dec!(1))) * &Value::from(dec!(2))
282        );
283        assert_eq!(Value::from(2.5), &Value::Integer(1) * &Value::from(2.5));
284        assert_eq!(Value::from(2.), &Value::from(1.) * &Value::from(2.));
285        assert_eq!(
286            Value::from(RustDecimal::new(2, 0)),
287            &Value::Integer(1) * &Value::Decimal(Box::new(dec!(2)))
288        );
289        assert_eq!(
290            Value::from(RustDecimal::new(2, 0)),
291            &Value::Decimal(Box::new(dec!(1))) * &Value::Integer(2)
292        );
293        assert_eq!(
294            Value::from(RustDecimal::new(2, 0)),
295            &Value::from(1.) * &Value::Decimal(Box::new(dec!(2)))
296        );
297        assert_eq!(
298            Value::from(RustDecimal::new(2, 0)),
299            &Value::Decimal(Box::new(dec!(1))) * &Value::from(2.)
300        );
301
302        // Div
303        assert_eq!(Value::Missing, &Value::Missing / &Value::Missing);
304        assert_eq!(Value::Missing, &Value::Missing / &Value::Null);
305        assert_eq!(Value::Missing, &Value::Null / &Value::Missing);
306        assert_eq!(Value::Null, &Value::Null / &Value::Null);
307        assert_eq!(Value::Missing, &Value::Integer(1) / &Value::from("a"));
308        assert_eq!(Value::Integer(0), &Value::Integer(1) / &Value::Integer(2));
309        assert_eq!(Value::from(0.6), &Value::from(1.5) / &Value::from(2.5));
310        assert_eq!(
311            Value::Decimal(Box::new(dec!(0.5))),
312            &Value::Decimal(Box::new(dec!(1))) / &Value::from(dec!(2))
313        );
314        assert_eq!(Value::from(0.4), &Value::Integer(1) / &Value::from(2.5));
315        assert_eq!(Value::from(0.5), &Value::from(1.) / &Value::from(2.));
316        assert_eq!(
317            Value::Decimal(Box::new(dec!(0.5))),
318            &Value::Integer(1) / &Value::Decimal(Box::new(dec!(2)))
319        );
320        assert_eq!(
321            Value::Decimal(Box::new(dec!(0.5))),
322            &Value::Decimal(Box::new(dec!(1))) / &Value::Integer(2)
323        );
324        assert_eq!(
325            Value::Decimal(Box::new(dec!(0.5))),
326            &Value::from(1.) / &Value::Decimal(Box::new(dec!(2)))
327        );
328        assert_eq!(
329            Value::Decimal(Box::new(dec!(0.5))),
330            &Value::Decimal(Box::new(dec!(1))) / &Value::from(2.)
331        );
332
333        // Mod
334        assert_eq!(Value::Missing, &Value::Missing % &Value::Missing);
335        assert_eq!(Value::Missing, &Value::Missing % &Value::Null);
336        assert_eq!(Value::Missing, &Value::Null % &Value::Missing);
337        assert_eq!(Value::Null, &Value::Null % &Value::Null);
338        assert_eq!(Value::Missing, &Value::Integer(1) % &Value::from("a"));
339        assert_eq!(Value::Integer(1), &Value::Integer(1) % &Value::Integer(2));
340        assert_eq!(Value::from(1.5), &Value::from(1.5) % &Value::from(2.5));
341        assert_eq!(
342            Value::Decimal(Box::new(dec!(1))),
343            &Value::Decimal(Box::new(dec!(1))) % &Value::from(dec!(2))
344        );
345        assert_eq!(Value::from(1.), &Value::Integer(1) % &Value::from(2.5));
346        assert_eq!(Value::from(1.), &Value::from(1.) % &Value::from(2.));
347        assert_eq!(
348            Value::Decimal(Box::new(dec!(1))),
349            &Value::Integer(1) % &Value::Decimal(Box::new(dec!(2)))
350        );
351        assert_eq!(
352            Value::Decimal(Box::new(dec!(1))),
353            &Value::Decimal(Box::new(dec!(1))) % &Value::Integer(2)
354        );
355        assert_eq!(
356            Value::Decimal(Box::new(dec!(1))),
357            &Value::from(1.) % &Value::Decimal(Box::new(dec!(2)))
358        );
359        assert_eq!(
360            Value::Decimal(Box::new(dec!(1))),
361            &Value::Decimal(Box::new(dec!(1))) % &Value::from(2.)
362        );
363    }
364
365    #[test]
366    fn partiql_value_logical() {
367        // Unary NOT
368        assert_eq!(Value::Null, !&Value::Missing);
369        assert_eq!(Value::Null, !&Value::Null);
370        assert_eq!(Value::from(true), !&Value::from(false));
371        assert_eq!(Value::from(false), !&Value::from(true));
372        assert_eq!(Value::Missing, !&Value::from("foo"));
373
374        // AND
375        assert_eq!(
376            Value::from(false),
377            Value::from(false).and(&Value::from(true))
378        );
379        assert_eq!(
380            Value::from(false),
381            Value::from(true).and(&Value::from(false))
382        );
383        assert_eq!(Value::from(true), Value::from(true).and(&Value::from(true)));
384        assert_eq!(
385            Value::from(false),
386            Value::from(false).and(&Value::from(false))
387        );
388
389        // false with null or missing => false
390        assert_eq!(Value::from(false), Value::Null.and(&Value::from(false)));
391        assert_eq!(Value::from(false), Value::from(false).and(&Value::Null));
392        assert_eq!(Value::from(false), Value::Missing.and(&Value::from(false)));
393        assert_eq!(Value::from(false), Value::from(false).and(&Value::Missing));
394
395        // Null propagation => Null
396        assert_eq!(Value::Null, Value::Null.and(&Value::Null));
397        assert_eq!(Value::Null, Value::Missing.and(&Value::Missing));
398        assert_eq!(Value::Null, Value::Null.and(&Value::Missing));
399        assert_eq!(Value::Null, Value::Missing.and(&Value::Null));
400        assert_eq!(Value::Null, Value::Null.and(&Value::from(true)));
401        assert_eq!(Value::Null, Value::Missing.and(&Value::from(true)));
402        assert_eq!(Value::Null, Value::from(true).and(&Value::Null));
403        assert_eq!(Value::Null, Value::from(true).and(&Value::Missing));
404
405        // Data type mismatch cases => Missing
406        assert_eq!(Value::Missing, Value::from(123).and(&Value::from(false)));
407        assert_eq!(Value::Missing, Value::from(false).and(&Value::from(123)));
408        assert_eq!(Value::Missing, Value::from(123).and(&Value::from(true)));
409        assert_eq!(Value::Missing, Value::from(true).and(&Value::from(123)));
410
411        // OR
412        assert_eq!(Value::from(true), Value::from(false).or(&Value::from(true)));
413        assert_eq!(Value::from(true), Value::from(true).or(&Value::from(false)));
414        assert_eq!(Value::from(true), Value::from(true).or(&Value::from(true)));
415        assert_eq!(
416            Value::from(false),
417            Value::from(false).or(&Value::from(false))
418        );
419
420        // true with null or missing => true
421        assert_eq!(Value::from(true), Value::Null.or(&Value::from(true)));
422        assert_eq!(Value::from(true), Value::from(true).or(&Value::Null));
423        assert_eq!(Value::from(true), Value::Missing.or(&Value::from(true)));
424        assert_eq!(Value::from(true), Value::from(true).or(&Value::Missing));
425
426        // Null propagation => Null
427        assert_eq!(Value::Null, Value::Null.or(&Value::Null));
428        assert_eq!(Value::Null, Value::Missing.or(&Value::Missing));
429        assert_eq!(Value::Null, Value::Null.or(&Value::Missing));
430        assert_eq!(Value::Null, Value::Missing.or(&Value::Null));
431        assert_eq!(Value::Null, Value::Null.or(&Value::from(false)));
432        assert_eq!(Value::Null, Value::Missing.or(&Value::from(false)));
433        assert_eq!(Value::Null, Value::from(false).or(&Value::Null));
434        assert_eq!(Value::Null, Value::from(false).or(&Value::Missing));
435
436        // Data type mismatch cases => Missing
437        assert_eq!(Value::Missing, Value::from(123).or(&Value::from(false)));
438        assert_eq!(Value::Missing, Value::from(false).or(&Value::from(123)));
439        assert_eq!(Value::Missing, Value::from(123).or(&Value::from(true)));
440        assert_eq!(Value::Missing, Value::from(true).or(&Value::from(123)));
441    }
442
443    #[test]
444    fn partiql_value_equality() {
445        // TODO: many equality tests missing. Can use conformance tests to fill the gap or some other
446        //  tests
447
448        fn nullable_eq(lhs: Value, rhs: Value) -> Value {
449            let wrap = EqualityValue::<false, false, Value>;
450            let lhs = wrap(&lhs);
451            let rhs = wrap(&rhs);
452            NullableEq::eq(&lhs, &rhs)
453        }
454
455        fn nullable_neq(lhs: Value, rhs: Value) -> Value {
456            let wrap = EqualityValue::<false, false, Value>;
457            let lhs = wrap(&lhs);
458            let rhs = wrap(&rhs);
459            NullableEq::neq(&lhs, &rhs)
460        }
461
462        // Eq
463        assert_eq!(
464            Value::from(true),
465            nullable_eq(Value::from(true), Value::from(true))
466        );
467        assert_eq!(
468            Value::from(false),
469            nullable_eq(Value::from(true), Value::from(false))
470        );
471        // Container examples from spec section 7.1.1 https://partiql.org/assets/PartiQL-Specification.pdf#subsubsection.7.1.1
472        assert_eq!(
473            Value::from(true),
474            nullable_eq(Value::from(bag![3, 2, 4, 2]), Value::from(bag![2, 2, 3, 4]))
475        );
476        assert_eq!(
477            Value::from(true),
478            nullable_eq(
479                Value::from(tuple![("a", 1), ("b", 2)]),
480                Value::from(tuple![("a", 1), ("b", 2)])
481            )
482        );
483        assert_eq!(
484            Value::from(true),
485            nullable_eq(
486                Value::from(tuple![("a", list![0, 1]), ("b", 2)]),
487                Value::from(tuple![("a", list![0, 1]), ("b", 2)])
488            )
489        );
490        assert_eq!(
491            Value::from(false),
492            nullable_eq(Value::from(bag![3, 4, 2]), Value::from(bag![2, 2, 3, 4]))
493        );
494        assert_eq!(
495            Value::from(true),
496            nullable_eq(Value::from(list![1, 2]), Value::from(list![1e0, 2.0]))
497        );
498        assert_eq!(
499            Value::from(false),
500            nullable_eq(Value::from(list![1, 2]), Value::from(list![2.0, 1e0]))
501        );
502        assert_eq!(
503            Value::from(true),
504            nullable_eq(Value::from(bag![1, 2]), Value::from(bag![2.0, 1e0]))
505        );
506        assert_eq!(
507            Value::from(false),
508            nullable_eq(
509                Value::from(tuple![("a", 1), ("b", 2)]),
510                Value::from(tuple![("a", 1)])
511            )
512        );
513        assert_eq!(
514            Value::from(false),
515            nullable_eq(
516                Value::from(tuple![("a", list![0, 1]), ("b", 2)]),
517                Value::from(tuple![("a", list![0, 1, 2]), ("b", 2)])
518            )
519        );
520        assert_eq!(
521            Value::from(false),
522            nullable_eq(
523                Value::from(tuple![("a", 1), ("b", 2)]),
524                Value::from(tuple![("a", 1), ("b", Value::Null)])
525            )
526        );
527        assert_eq!(
528            Value::from(false),
529            nullable_eq(
530                Value::from(tuple![("a", list![0, 1]), ("b", 2)]),
531                Value::from(tuple![("a", list![Value::Null, 1]), ("b", 2)])
532            )
533        );
534        assert_eq!(Value::Null, nullable_eq(Value::from(true), Value::Null));
535        assert_eq!(Value::Null, nullable_eq(Value::Null, Value::from(true)));
536        assert_eq!(
537            Value::Missing,
538            nullable_eq(Value::from(true), Value::Missing)
539        );
540        assert_eq!(
541            Value::Missing,
542            nullable_eq(Value::Missing, Value::from(true))
543        );
544
545        // different, comparable types result in boolean true
546        assert_eq!(
547            Value::from(true),
548            nullable_eq(Value::from(1), Value::from(1.0))
549        );
550        assert_eq!(
551            Value::from(true),
552            nullable_eq(Value::from(1.0), Value::from(1))
553        );
554        assert_eq!(
555            Value::from(true),
556            nullable_eq(Value::from(1), Value::from(dec!(1.0)))
557        );
558        assert_eq!(
559            Value::from(true),
560            nullable_eq(Value::from(dec!(1.0)), Value::from(1))
561        );
562        assert_eq!(
563            Value::from(true),
564            nullable_eq(Value::from(1.0), Value::from(dec!(1.0)))
565        );
566        assert_eq!(
567            Value::from(true),
568            nullable_eq(Value::from(dec!(1.0)), Value::from(1.0))
569        );
570        // different, comparable types result in boolean false
571        assert_eq!(
572            Value::from(false),
573            nullable_eq(Value::from(1), Value::from(2.0))
574        );
575        assert_eq!(
576            Value::from(false),
577            nullable_eq(Value::from(1.0), Value::from(2))
578        );
579        assert_eq!(
580            Value::from(false),
581            nullable_eq(Value::from(1), Value::from(dec!(2.0)))
582        );
583        assert_eq!(
584            Value::from(false),
585            nullable_eq(Value::from(dec!(1.0)), Value::from(2))
586        );
587        assert_eq!(
588            Value::from(false),
589            nullable_eq(Value::from(1.0), Value::from(dec!(2.0)))
590        );
591        assert_eq!(
592            Value::from(false),
593            nullable_eq(Value::from(dec!(1.0)), Value::from(2.0))
594        );
595        assert_eq!(
596            Value::from(false),
597            nullable_eq(Value::from(1), Value::from(f64::NEG_INFINITY))
598        );
599        assert_eq!(
600            Value::from(false),
601            nullable_eq(Value::from(f64::NEG_INFINITY), Value::from(1))
602        );
603        // different, non-comparable types result in boolean true
604        assert_eq!(
605            Value::from(false),
606            nullable_eq(Value::from(true), Value::from("abc"))
607        );
608        assert_eq!(
609            Value::from(false),
610            nullable_eq(Value::from("abc"), Value::from(true))
611        );
612
613        // Neq
614        assert_eq!(
615            Value::from(false),
616            nullable_neq(Value::from(true), Value::from(true))
617        );
618        assert_eq!(
619            Value::from(true),
620            nullable_neq(Value::from(true), Value::from(false))
621        );
622        // Container examples from spec section 7.1.1 https://partiql.org/assets/PartiQL-Specification.pdf#subsubsection.7.1.1
623        // (opposite result of eq cases)
624        assert_eq!(
625            Value::from(false),
626            nullable_neq(Value::from(bag![3, 2, 4, 2]), Value::from(bag![2, 2, 3, 4]))
627        );
628        assert_eq!(
629            Value::from(false),
630            nullable_neq(
631                Value::from(tuple![("a", 1), ("b", 2)]),
632                Value::from(tuple![("a", 1), ("b", 2)])
633            )
634        );
635        assert_eq!(
636            Value::from(false),
637            nullable_neq(
638                Value::from(tuple![("a", list![0, 1]), ("b", 2)]),
639                Value::from(tuple![("a", list![0, 1]), ("b", 2)])
640            )
641        );
642        assert_eq!(
643            Value::from(true),
644            nullable_neq(Value::from(bag![3, 4, 2]), Value::from(bag![2, 2, 3, 4]))
645        );
646        assert_eq!(
647            Value::from(true),
648            nullable_neq(
649                Value::from(tuple![("a", 1), ("b", 2)]),
650                Value::from(tuple![("a", 1)])
651            )
652        );
653        assert_eq!(
654            Value::from(true),
655            nullable_neq(
656                Value::from(tuple![("a", list![0, 1]), ("b", 2)]),
657                Value::from(tuple![("a", list![0, 1, 2]), ("b", 2)])
658            )
659        );
660        assert_eq!(
661            Value::from(true),
662            nullable_neq(
663                Value::from(tuple![("a", 1), ("b", 2)]),
664                Value::from(tuple![("a", 1), ("b", Value::Null)])
665            )
666        );
667        assert_eq!(
668            Value::from(true),
669            nullable_neq(
670                Value::from(tuple![("a", list![0, 1]), ("b", 2)]),
671                Value::from(tuple![("a", list![Value::Null, 1]), ("b", 2)])
672            )
673        );
674        assert_eq!(Value::Null, nullable_neq(Value::from(true), Value::Null));
675        assert_eq!(Value::Null, nullable_neq(Value::Null, Value::from(true)));
676        assert_eq!(
677            Value::Missing,
678            nullable_neq(Value::from(true), Value::Missing)
679        );
680        assert_eq!(
681            Value::Missing,
682            nullable_neq(Value::Missing, Value::from(true))
683        );
684
685        // different, comparable types result in boolean true
686        assert_eq!(
687            Value::from(true),
688            nullable_neq(Value::from(1), Value::from(2.0))
689        );
690        assert_eq!(
691            Value::from(true),
692            nullable_neq(Value::from(1.0), Value::from(2))
693        );
694        assert_eq!(
695            Value::from(true),
696            nullable_neq(Value::from(1), Value::from(dec!(2.0)))
697        );
698        assert_eq!(
699            Value::from(true),
700            nullable_neq(Value::from(dec!(1.0)), Value::from(2))
701        );
702        assert_eq!(
703            Value::from(true),
704            nullable_neq(Value::from(1.0), Value::from(dec!(2.0)))
705        );
706        assert_eq!(
707            Value::from(true),
708            nullable_neq(Value::from(dec!(1.0)), Value::from(2.0))
709        );
710        assert_eq!(
711            Value::from(true),
712            nullable_neq(Value::from(1), Value::from(f64::NEG_INFINITY))
713        );
714        assert_eq!(
715            Value::from(true),
716            nullable_neq(Value::from(f64::NEG_INFINITY), Value::from(1))
717        );
718        // different, comparable types result in boolean false
719        assert_eq!(
720            Value::from(false),
721            nullable_neq(Value::from(1), Value::from(1.0))
722        );
723        assert_eq!(
724            Value::from(false),
725            nullable_neq(Value::from(1.0), Value::from(1))
726        );
727        assert_eq!(
728            Value::from(false),
729            nullable_neq(Value::from(1), Value::from(dec!(1.0)))
730        );
731        assert_eq!(
732            Value::from(false),
733            nullable_neq(Value::from(dec!(1.0)), Value::from(1))
734        );
735        assert_eq!(
736            Value::from(false),
737            nullable_neq(Value::from(1.0), Value::from(dec!(1.0)))
738        );
739        assert_eq!(
740            Value::from(false),
741            nullable_neq(Value::from(dec!(1.0)), Value::from(1.0))
742        );
743        // different, non-comparable types result in boolean true
744        assert_eq!(
745            Value::from(true),
746            nullable_neq(Value::from(true), Value::from("abc"))
747        );
748        assert_eq!(
749            Value::from(true),
750            nullable_neq(Value::from("abc"), Value::from(true))
751        );
752    }
753
754    #[test]
755    fn partiql_value_comparison() {
756        // LT
757        assert_eq!(
758            Value::from(true),
759            NullableOrd::lt(&Value::from(1), &Value::from(2))
760        );
761        assert_eq!(
762            Value::from(false),
763            NullableOrd::lt(&Value::from(1), &Value::from(0))
764        );
765        assert_eq!(
766            Value::from(false),
767            NullableOrd::lt(&Value::from(1), &Value::from(1))
768        );
769
770        // GT
771        assert_eq!(
772            Value::from(false),
773            NullableOrd::gt(&Value::from(1), &Value::from(2))
774        );
775        assert_eq!(
776            Value::from(true),
777            NullableOrd::gt(&Value::from(1), &Value::from(0))
778        );
779        assert_eq!(
780            Value::from(false),
781            NullableOrd::gt(&Value::from(1), &Value::from(1))
782        );
783
784        // LTEQ
785        assert_eq!(
786            Value::from(true),
787            NullableOrd::lteq(&Value::from(1), &Value::from(2))
788        );
789        assert_eq!(
790            Value::from(false),
791            NullableOrd::lteq(&Value::from(1), &Value::from(0))
792        );
793        assert_eq!(
794            Value::from(true),
795            NullableOrd::lteq(&Value::from(1), &Value::from(1))
796        );
797
798        // GTEQ
799        assert_eq!(
800            Value::from(false),
801            NullableOrd::gteq(&Value::from(1), &Value::from(2))
802        );
803        assert_eq!(
804            Value::from(true),
805            NullableOrd::gteq(&Value::from(1), &Value::from(0))
806        );
807        assert_eq!(
808            Value::from(true),
809            NullableOrd::gteq(&Value::from(1), &Value::from(1))
810        );
811
812        // Missing propagation
813        assert_eq!(
814            Value::Missing,
815            NullableOrd::lt(&Value::Missing, &Value::from(2))
816        );
817        assert_eq!(
818            Value::Missing,
819            NullableOrd::lt(&Value::from(1), &Value::Missing)
820        );
821        assert_eq!(
822            Value::Missing,
823            NullableOrd::lt(&Value::Null, &Value::Missing)
824        );
825        assert_eq!(
826            Value::Missing,
827            NullableOrd::lt(&Value::Missing, &Value::Null)
828        );
829        assert_eq!(
830            Value::Missing,
831            NullableOrd::gt(&Value::Missing, &Value::from(2))
832        );
833        assert_eq!(
834            Value::Missing,
835            NullableOrd::gt(&Value::from(1), &Value::Missing)
836        );
837        assert_eq!(
838            Value::Missing,
839            NullableOrd::gt(&Value::Null, &Value::Missing)
840        );
841        assert_eq!(
842            Value::Missing,
843            NullableOrd::gt(&Value::Missing, &Value::Null)
844        );
845        assert_eq!(
846            Value::Missing,
847            NullableOrd::lteq(&Value::Missing, &Value::from(2))
848        );
849        assert_eq!(
850            Value::Missing,
851            NullableOrd::lteq(&Value::from(1), &Value::Missing)
852        );
853        assert_eq!(
854            Value::Missing,
855            NullableOrd::lteq(&Value::Null, &Value::Missing)
856        );
857        assert_eq!(
858            Value::Missing,
859            NullableOrd::lteq(&Value::Missing, &Value::Null)
860        );
861        assert_eq!(
862            Value::Missing,
863            NullableOrd::gteq(&Value::Missing, &Value::from(2))
864        );
865        assert_eq!(
866            Value::Missing,
867            NullableOrd::gteq(&Value::from(1), &Value::Missing)
868        );
869        assert_eq!(
870            Value::Missing,
871            NullableOrd::gteq(&Value::Null, &Value::Missing)
872        );
873        assert_eq!(
874            Value::Missing,
875            NullableOrd::gteq(&Value::Missing, &Value::Null)
876        );
877
878        // Null propagation
879        assert_eq!(Value::Null, NullableOrd::lt(&Value::Null, &Value::from(2)));
880        assert_eq!(Value::Null, NullableOrd::lt(&Value::from(1), &Value::Null));
881        assert_eq!(Value::Null, NullableOrd::gt(&Value::Null, &Value::from(2)));
882        assert_eq!(Value::Null, NullableOrd::gt(&Value::from(1), &Value::Null));
883        assert_eq!(
884            Value::Null,
885            NullableOrd::lteq(&Value::Null, &Value::from(2))
886        );
887        assert_eq!(
888            Value::Null,
889            NullableOrd::lteq(&Value::from(1), &Value::Null)
890        );
891        assert_eq!(
892            Value::Null,
893            NullableOrd::gteq(&Value::Null, &Value::from(2))
894        );
895        assert_eq!(
896            Value::Null,
897            NullableOrd::gteq(&Value::from(1), &Value::Null)
898        );
899
900        // Data type mismatch
901        assert_eq!(
902            Value::Missing,
903            NullableOrd::lt(&Value::from(1), &Value::from("abc"))
904        );
905        assert_eq!(
906            Value::Missing,
907            NullableOrd::lt(&Value::from("abc"), &Value::from(1))
908        );
909        assert_eq!(
910            Value::Missing,
911            NullableOrd::gt(&Value::from(1), &Value::from("abc"))
912        );
913        assert_eq!(
914            Value::Missing,
915            NullableOrd::gt(&Value::from("abc"), &Value::from(1))
916        );
917        assert_eq!(
918            Value::Missing,
919            NullableOrd::lteq(&Value::from(1), &Value::from("abc"))
920        );
921        assert_eq!(
922            Value::Missing,
923            NullableOrd::lteq(&Value::from("abc"), &Value::from(1))
924        );
925        assert_eq!(
926            Value::Missing,
927            NullableOrd::gteq(&Value::from(1), &Value::from("abc"))
928        );
929        assert_eq!(
930            Value::Missing,
931            NullableOrd::gteq(&Value::from("abc"), &Value::from(1))
932        );
933
934        // Numeric type comparison
935        // LT
936        assert_eq!(
937            Value::from(true),
938            NullableOrd::lt(&Value::from(1), &Value::from(2.0))
939        );
940        assert_eq!(
941            Value::from(true),
942            NullableOrd::lt(&Value::from(1), &Value::Decimal(Box::new(dec!(2.0))))
943        );
944        assert_eq!(
945            Value::from(true),
946            NullableOrd::lt(&Value::from(1.0), &Value::from(2))
947        );
948        assert_eq!(
949            Value::from(true),
950            NullableOrd::lt(&Value::from(1.0), &Value::Decimal(Box::new(dec!(2.0))))
951        );
952        assert_eq!(
953            Value::from(true),
954            NullableOrd::lt(&Value::Decimal(Box::new(dec!(1.0))), &Value::from(2))
955        );
956        assert_eq!(
957            Value::from(true),
958            NullableOrd::lt(&Value::Decimal(Box::new(dec!(1.0))), &Value::from(2.))
959        );
960
961        // GT
962        assert_eq!(
963            Value::from(false),
964            NullableOrd::gt(&Value::from(1), &Value::from(2.0))
965        );
966        assert_eq!(
967            Value::from(false),
968            NullableOrd::gt(&Value::from(1), &Value::Decimal(Box::new(dec!(2.0))))
969        );
970        assert_eq!(
971            Value::from(false),
972            NullableOrd::gt(&Value::from(1.0), &Value::from(2))
973        );
974        assert_eq!(
975            Value::from(false),
976            NullableOrd::gt(&Value::from(1.0), &Value::Decimal(Box::new(dec!(2.0))))
977        );
978        assert_eq!(
979            Value::from(false),
980            NullableOrd::gt(&Value::Decimal(Box::new(dec!(1.0))), &Value::from(2))
981        );
982        assert_eq!(
983            Value::from(false),
984            NullableOrd::gt(&Value::Decimal(Box::new(dec!(1.0))), &Value::from(2.))
985        );
986
987        // LTEQ
988        assert_eq!(
989            Value::from(true),
990            NullableOrd::lteq(&Value::from(1), &Value::from(2.0))
991        );
992        assert_eq!(
993            Value::from(true),
994            NullableOrd::lteq(&Value::from(1), &Value::Decimal(Box::new(dec!(2.0))))
995        );
996        assert_eq!(
997            Value::from(true),
998            NullableOrd::lteq(&Value::from(1.0), &Value::from(2))
999        );
1000        assert_eq!(
1001            Value::from(true),
1002            NullableOrd::lteq(&Value::from(1.0), &Value::Decimal(Box::new(dec!(2.0))))
1003        );
1004        assert_eq!(
1005            Value::from(true),
1006            NullableOrd::lteq(&Value::Decimal(Box::new(dec!(1.0))), &Value::from(2))
1007        );
1008        assert_eq!(
1009            Value::from(true),
1010            NullableOrd::lteq(&Value::Decimal(Box::new(dec!(1.0))), &Value::from(2.))
1011        );
1012
1013        // GTEQ
1014        assert_eq!(
1015            Value::from(false),
1016            NullableOrd::gteq(&Value::from(1), &Value::from(2.0))
1017        );
1018        assert_eq!(
1019            Value::from(false),
1020            NullableOrd::gteq(&Value::from(1), &Value::Decimal(Box::new(dec!(2.0))))
1021        );
1022        assert_eq!(
1023            Value::from(false),
1024            NullableOrd::gteq(&Value::from(1.0), &Value::from(2))
1025        );
1026        assert_eq!(
1027            Value::from(false),
1028            NullableOrd::gteq(&Value::from(1.0), &Value::Decimal(Box::new(dec!(2.0))))
1029        );
1030        assert_eq!(
1031            Value::from(false),
1032            NullableOrd::gteq(&Value::Decimal(Box::new(dec!(1.0))), &Value::from(2))
1033        );
1034        assert_eq!(
1035            Value::from(false),
1036            NullableOrd::gteq(&Value::Decimal(Box::new(dec!(1.0))), &Value::from(2.))
1037        );
1038    }
1039
1040    #[test]
1041    fn tuple_concat() {
1042        let lhs = Tuple::from([("a", 1), ("b", 2), ("c", 3), ("d", 44)]);
1043        let rhs = Tuple::from([("a", 11), ("b", 22), ("c", 33), ("e", 55)]);
1044        assert_eq!(
1045            Tuple::from([("a", 11), ("b", 22), ("c", 33), ("d", 44), ("e", 55)]),
1046            lhs.tuple_concat(&rhs)
1047        );
1048    }
1049
1050    #[test]
1051    fn tuple_get() {
1052        let tuple = Tuple::from([("a", 1), ("A", 2), ("a", 3), ("A", 4)]);
1053        // case sensitive
1054        assert_eq!(
1055            Some(&Value::from(1)),
1056            tuple.get(&BindingsName::CaseSensitive(Cow::Owned("a".to_string())))
1057        );
1058        assert_eq!(
1059            Some(&Value::from(2)),
1060            tuple.get(&BindingsName::CaseSensitive(Cow::Owned("A".to_string())))
1061        );
1062        // case insensitive
1063        assert_eq!(
1064            Some(&Value::from(1)),
1065            tuple.get(&BindingsName::CaseInsensitive(Cow::Owned("a".to_string())))
1066        );
1067        assert_eq!(
1068            Some(&Value::from(1)),
1069            tuple.get(&BindingsName::CaseInsensitive(Cow::Owned("A".to_string())))
1070        );
1071    }
1072
1073    #[test]
1074    fn tuple_remove() {
1075        let mut tuple = Tuple::from([("a", 1), ("A", 2), ("a", 3), ("A", 4)]);
1076        // case sensitive
1077        assert_eq!(
1078            Some(Value::from(2)),
1079            tuple.remove(&BindingsName::CaseSensitive(Cow::Owned("A".to_string())))
1080        );
1081        assert_eq!(
1082            Some(Value::from(1)),
1083            tuple.remove(&BindingsName::CaseSensitive(Cow::Owned("a".to_string())))
1084        );
1085        // case insensitive
1086        assert_eq!(
1087            Some(Value::from(3)),
1088            tuple.remove(&BindingsName::CaseInsensitive(Cow::Owned("A".to_string())))
1089        );
1090        assert_eq!(
1091            Some(Value::from(4)),
1092            tuple.remove(&BindingsName::CaseInsensitive(Cow::Owned("a".to_string())))
1093        );
1094    }
1095
1096    #[test]
1097    fn bag_of_tuple_equality() {
1098        // Asserts the following PartiQL Values are equal
1099        // <<{
1100        //   'outer_elem_1': 1,
1101        //   'outer_elem_2': <<{
1102        //      'inner_elem_1': {'bar': 4},
1103        //      'inner_elem_2': {'foo': 3},
1104        //   }>>
1105        // }>>
1106        // with
1107        // <<{
1108        //   'outer_elem_2': <<{
1109        //      'inner_elem_2': {'foo': 3},
1110        //      'inner_elem_1': {'bar': 4},
1111        //   }>>
1112        //   'outer_elem_1': 1,
1113        // }>>
1114        let bag1 = bag!(tuple![
1115            ("outer_elem_1", 1),
1116            (
1117                "outer_elem_2",
1118                bag![tuple![
1119                    ("inner_elem_1", tuple![("bar", 3)]),
1120                    ("inner_elem_2", tuple![("foo", 4)])
1121                ]]
1122            )
1123        ]);
1124        let bag2 = bag!(tuple![
1125            (
1126                "outer_elem_2",
1127                bag![tuple![
1128                    ("inner_elem_2", tuple![("foo", 4)]),
1129                    ("inner_elem_1", tuple![("bar", 3)])
1130                ]]
1131            ),
1132            ("outer_elem_1", 1)
1133        ]);
1134        assert_eq!(bag1, bag2);
1135    }
1136
1137    #[test]
1138    fn duplicate_tuple_elems() {
1139        let tuple1 = tuple![("a", 1), ("a", 1), ("b", 2)];
1140        let tuple2 = tuple![("a", 1), ("b", 2)];
1141        assert_ne!(tuple1, tuple2);
1142    }
1143
1144    #[test]
1145    fn tuple_hashing() {
1146        let tuple1 = tuple![("a", 1), ("b", 2)];
1147        let mut s: HashSet<Tuple> = HashSet::from([tuple1]);
1148        assert_eq!(1, s.len());
1149        let tuple2 = tuple![("b", 2), ("a", 1)];
1150        s.insert(tuple2);
1151        assert_eq!(1, s.len());
1152    }
1153
1154    #[test]
1155    fn null_sorted_value_ord_simple_nulls_first() {
1156        let v1 = Value::Missing;
1157        let v2 = Value::Boolean(true);
1158        let null_sorted_v1 = NullSortedValue::<true, Value>(&v1);
1159        let null_sorted_v2 = NullSortedValue::<true, Value>(&v2);
1160        assert_eq!(Ordering::Less, null_sorted_v1.cmp(&null_sorted_v2));
1161
1162        let v3 = Value::Null;
1163        let null_sorted_v3 = NullSortedValue::<true, Value>(&v3);
1164        assert_eq!(Ordering::Less, null_sorted_v3.cmp(&null_sorted_v2));
1165        assert_eq!(Ordering::Equal, null_sorted_v1.cmp(&null_sorted_v3));
1166    }
1167
1168    #[test]
1169    fn null_sorted_value_ord_simple_nulls_last() {
1170        let v1 = Value::Missing;
1171        let v2 = Value::Boolean(true);
1172        let null_sorted_v1 = NullSortedValue::<false, Value>(&v1);
1173        let null_sorted_v2 = NullSortedValue::<false, Value>(&v2);
1174        assert_eq!(Ordering::Greater, null_sorted_v1.cmp(&null_sorted_v2));
1175
1176        let v3 = Value::Null;
1177        let null_sorted_v3 = NullSortedValue::<false, Value>(&v3);
1178        assert_eq!(Ordering::Greater, null_sorted_v3.cmp(&null_sorted_v2));
1179        assert_eq!(Ordering::Equal, null_sorted_v1.cmp(&null_sorted_v3));
1180    }
1181
1182    #[test]
1183    fn null_sorted_value_ord_collection_nulls_first() {
1184        // list
1185        let v1 = list![Value::Missing].into();
1186        let v2 = list![Value::Boolean(true)].into();
1187        let null_sorted_v1 = NullSortedValue::<true, Value>(&v1);
1188        let null_sorted_v2 = NullSortedValue::<true, Value>(&v2);
1189        assert_eq!(Ordering::Less, null_sorted_v1.cmp(&null_sorted_v2));
1190
1191        let v3 = list![Value::Null].into();
1192        let null_sorted_v3 = NullSortedValue::<true, Value>(&v3);
1193        assert_eq!(Ordering::Less, null_sorted_v3.cmp(&null_sorted_v2));
1194        assert_eq!(Ordering::Equal, null_sorted_v1.cmp(&null_sorted_v3));
1195
1196        // bag
1197        let v1 = bag![Value::Missing].into();
1198        let v2 = bag![Value::Boolean(true)].into();
1199        let null_sorted_v1 = NullSortedValue::<true, Value>(&v1);
1200        let null_sorted_v2 = NullSortedValue::<true, Value>(&v2);
1201        assert_eq!(Ordering::Less, null_sorted_v1.cmp(&null_sorted_v2));
1202
1203        let v3 = bag![Value::Null].into();
1204        let null_sorted_v3 = NullSortedValue::<true, Value>(&v3);
1205        assert_eq!(Ordering::Less, null_sorted_v3.cmp(&null_sorted_v2));
1206        assert_eq!(Ordering::Equal, null_sorted_v1.cmp(&null_sorted_v3));
1207
1208        // tuple
1209        let v1 = tuple![("a", Value::Missing)].into();
1210        let v2 = tuple![("a", Value::Boolean(true))].into();
1211        let null_sorted_v1 = NullSortedValue::<true, Value>(&v1);
1212        let null_sorted_v2 = NullSortedValue::<true, Value>(&v2);
1213        assert_eq!(Ordering::Less, null_sorted_v1.cmp(&null_sorted_v2));
1214
1215        let v3 = tuple![("a", Value::Null)].into();
1216        let null_sorted_v3 = NullSortedValue::<true, Value>(&v3);
1217        assert_eq!(Ordering::Less, null_sorted_v3.cmp(&null_sorted_v2));
1218        assert_eq!(Ordering::Equal, null_sorted_v1.cmp(&null_sorted_v3));
1219    }
1220
1221    #[test]
1222    fn null_sorted_value_ord_collection_nulls_last() {
1223        // list
1224        let v1 = list![Value::Missing].into();
1225        let v2 = list![Value::Boolean(true)].into();
1226        let null_sorted_v1 = NullSortedValue::<false, Value>(&v1);
1227        let null_sorted_v2 = NullSortedValue::<false, Value>(&v2);
1228        assert_eq!(Ordering::Greater, null_sorted_v1.cmp(&null_sorted_v2));
1229
1230        let v3 = list![Value::Null].into();
1231        let null_sorted_v3 = NullSortedValue::<false, Value>(&v3);
1232        assert_eq!(Ordering::Greater, null_sorted_v3.cmp(&null_sorted_v2));
1233        assert_eq!(Ordering::Equal, null_sorted_v1.cmp(&null_sorted_v3));
1234
1235        // bag
1236        let v1 = bag![Value::Missing].into();
1237        let v2 = bag![Value::Boolean(true)].into();
1238        let null_sorted_v1 = NullSortedValue::<false, Value>(&v1);
1239        let null_sorted_v2 = NullSortedValue::<false, Value>(&v2);
1240        assert_eq!(Ordering::Greater, null_sorted_v1.cmp(&null_sorted_v2));
1241
1242        let v3 = bag![Value::Null].into();
1243        let null_sorted_v3 = NullSortedValue::<false, Value>(&v3);
1244        assert_eq!(Ordering::Greater, null_sorted_v3.cmp(&null_sorted_v2));
1245        assert_eq!(Ordering::Equal, null_sorted_v1.cmp(&null_sorted_v3));
1246
1247        // tuple
1248        let v1 = tuple![("a", Value::Missing)].into();
1249        let v2 = tuple![("a", Value::Boolean(true))].into();
1250        let null_sorted_v1 = NullSortedValue::<false, Value>(&v1);
1251        let null_sorted_v2 = NullSortedValue::<false, Value>(&v2);
1252        assert_eq!(Ordering::Greater, null_sorted_v1.cmp(&null_sorted_v2));
1253
1254        let v3 = tuple![("a", Value::Null)].into();
1255        let null_sorted_v3 = NullSortedValue::<false, Value>(&v3);
1256        assert_eq!(Ordering::Greater, null_sorted_v3.cmp(&null_sorted_v2));
1257        assert_eq!(Ordering::Equal, null_sorted_v1.cmp(&null_sorted_v3));
1258    }
1259}
partiql_value/lib.rs

partiql_value/
lib.rs
