gluesql_core/data/
key.rs

1use {
2    crate::{
3        data::{Interval, Value},
4        result::{Error, Result},
5    },
6    chrono::{Datelike, NaiveDate, NaiveDateTime, NaiveTime, Timelike},
7    ordered_float::OrderedFloat,
8    rust_decimal::Decimal,
9    serde::{Deserialize, Serialize},
10    std::{cmp::Ordering, fmt::Debug, net::IpAddr},
11    thiserror::Error as ThisError,
12};
13
14#[derive(ThisError, Debug, PartialEq, Eq, Serialize)]
15pub enum KeyError {
16    #[error("FLOAT data type cannot be converted to Big-Endian bytes for comparison")]
17    FloatToCmpBigEndianNotSupported,
18
19    #[error("MAP data type cannot be used as Key")]
20    MapTypeKeyNotSupported,
21
22    #[error("LIST data type cannot be used as Key")]
23    ListTypeKeyNotSupported,
24
25    #[error("POINT data type cannot be used as Key")]
26    PointTypeKeyNotSupported,
27}
28
29#[derive(PartialEq, Eq, Hash, Clone, Debug, Serialize, Deserialize)]
30pub enum Key {
31    I8(i8),
32    I16(i16),
33    I32(i32),
34    I64(i64),
35    I128(i128),
36    U8(u8),
37    U16(u16),
38    U32(u32),
39    U64(u64),
40    U128(u128),
41    F32(OrderedFloat<f32>),
42    F64(OrderedFloat<f64>),
43    Decimal(Decimal),
44    Bool(bool),
45    Str(String),
46    Bytea(Vec<u8>),
47    Date(NaiveDate),
48    Timestamp(NaiveDateTime),
49    Time(NaiveTime),
50    Interval(Interval),
51    Uuid(u128),
52    Inet(IpAddr),
53    None,
54}
55
56impl Ord for Key {
57    fn cmp(&self, other: &Self) -> Ordering {
58        match (self, other) {
59            (Key::I8(l), Key::I8(r)) => l.cmp(r),
60            (Key::I16(l), Key::I16(r)) => l.cmp(r),
61            (Key::I32(l), Key::I32(r)) => l.cmp(r),
62            (Key::I64(l), Key::I64(r)) => l.cmp(r),
63            (Key::I128(l), Key::I128(r)) => l.cmp(r),
64            (Key::U8(l), Key::U8(r)) => l.cmp(r),
65            (Key::U16(l), Key::U16(r)) => l.cmp(r),
66            (Key::U32(l), Key::U32(r)) => l.cmp(r),
67            (Key::U64(l), Key::U64(r)) => l.cmp(r),
68            (Key::U128(l), Key::U128(r)) | (Key::Uuid(l), Key::Uuid(r)) => l.cmp(r),
69            (Key::F32(l), Key::F32(r)) => l.total_cmp(&r.0),
70            (Key::F64(l), Key::F64(r)) => l.total_cmp(&r.0),
71            (Key::Decimal(l), Key::Decimal(r)) => l.cmp(r),
72            (Key::Bool(l), Key::Bool(r)) => l.cmp(r),
73            (Key::Str(l), Key::Str(r)) => l.cmp(r),
74            (Key::Bytea(l), Key::Bytea(r)) => l.cmp(r),
75            (Key::Date(l), Key::Date(r)) => l.cmp(r),
76            (Key::Timestamp(l), Key::Timestamp(r)) => l.cmp(r),
77            (Key::Time(l), Key::Time(r)) => l.cmp(r),
78            (Key::Interval(l), Key::Interval(r)) => l.partial_cmp(r).unwrap_or(match (l, r) {
79                (Interval::Month(_), Interval::Microsecond(_)) => Ordering::Greater,
80                _ => Ordering::Less,
81            }),
82            (Key::Inet(l), Key::Inet(r)) => l.cmp(r),
83            (Key::None, Key::None) => Ordering::Equal,
84            (Key::None, _) => Ordering::Greater,
85            (_, Key::None) => Ordering::Less,
86
87            (left, right) => {
88                if left.to_order() <= right.to_order() {
89                    Ordering::Greater
90                } else {
91                    Ordering::Less
92                }
93            }
94        }
95    }
96}
97
98impl PartialOrd for Key {
99    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
100        Some(self.cmp(other))
101    }
102}
103
104impl TryFrom<Value> for Key {
105    type Error = Error;
106
107    fn try_from(value: Value) -> Result<Self> {
108        use Value::*;
109
110        match value {
111            Bool(v) => Ok(Key::Bool(v)),
112            I8(v) => Ok(Key::I8(v)),
113            I16(v) => Ok(Key::I16(v)),
114            I32(v) => Ok(Key::I32(v)),
115            I64(v) => Ok(Key::I64(v)),
116            I128(v) => Ok(Key::I128(v)),
117            U8(v) => Ok(Key::U8(v)),
118            U16(v) => Ok(Key::U16(v)),
119            U32(v) => Ok(Key::U32(v)),
120            U64(v) => Ok(Key::U64(v)),
121            U128(v) => Ok(Key::U128(v)),
122            F32(v) => Ok(Key::F32(OrderedFloat(v))),
123            F64(v) => Ok(Key::F64(OrderedFloat(v))),
124            Decimal(v) => Ok(Key::Decimal(v)),
125            Str(v) => Ok(Key::Str(v)),
126            Bytea(v) => Ok(Key::Bytea(v)),
127            Inet(v) => Ok(Key::Inet(v)),
128            Date(v) => Ok(Key::Date(v)),
129            Timestamp(v) => Ok(Key::Timestamp(v)),
130            Time(v) => Ok(Key::Time(v)),
131            Interval(v) => Ok(Key::Interval(v)),
132            Uuid(v) => Ok(Key::Uuid(v)),
133            Null => Ok(Key::None),
134            Map(_) => Err(KeyError::MapTypeKeyNotSupported.into()),
135            List(_) => Err(KeyError::ListTypeKeyNotSupported.into()),
136            Point(_) => Err(KeyError::PointTypeKeyNotSupported.into()),
137        }
138    }
139}
140
141impl TryFrom<&Value> for Key {
142    type Error = Error;
143
144    fn try_from(value: &Value) -> Result<Self> {
145        value.clone().try_into()
146    }
147}
148
149impl From<Key> for Value {
150    fn from(key: Key) -> Self {
151        match key {
152            Key::Bool(v) => Value::Bool(v),
153            Key::I8(v) => Value::I8(v),
154            Key::I16(v) => Value::I16(v),
155            Key::I32(v) => Value::I32(v),
156            Key::I64(v) => Value::I64(v),
157            Key::I128(v) => Value::I128(v),
158            Key::U8(v) => Value::U8(v),
159            Key::U16(v) => Value::U16(v),
160            Key::U32(v) => Value::U32(v),
161            Key::U64(v) => Value::U64(v),
162            Key::U128(v) => Value::U128(v),
163            Key::F32(v) => Value::F32(v.0),
164            Key::F64(v) => Value::F64(v.0),
165            Key::Decimal(v) => Value::Decimal(v),
166            Key::Str(v) => Value::Str(v),
167            Key::Bytea(v) => Value::Bytea(v),
168            Key::Inet(v) => Value::Inet(v),
169            Key::Date(v) => Value::Date(v),
170            Key::Timestamp(v) => Value::Timestamp(v),
171            Key::Time(v) => Value::Time(v),
172            Key::Interval(v) => Value::Interval(v),
173            Key::Uuid(v) => Value::Uuid(v),
174            Key::None => Value::Null,
175        }
176    }
177}
178
179const VALUE: u8 = 0;
180const NONE: u8 = 1;
181
182impl Key {
183    /// Key to Big-Endian for comparison purpose
184    pub fn to_cmp_be_bytes(&self) -> Result<Vec<u8>> {
185        Ok(match self {
186            Key::Bool(v) => {
187                if *v {
188                    vec![VALUE, 1]
189                } else {
190                    vec![VALUE, 0]
191                }
192            }
193            Key::I8(v) => {
194                let sign = u8::from(*v >= 0);
195
196                [VALUE, sign]
197                    .iter()
198                    .chain(v.to_be_bytes().iter())
199                    .copied()
200                    .collect::<Vec<_>>()
201            }
202            Key::I16(v) => {
203                let sign = u8::from(*v >= 0);
204
205                [VALUE, sign]
206                    .iter()
207                    .chain(v.to_be_bytes().iter())
208                    .copied()
209                    .collect::<Vec<_>>()
210            }
211            Key::I32(v) => {
212                let sign = u8::from(*v >= 0);
213
214                [VALUE, sign]
215                    .iter()
216                    .chain(v.to_be_bytes().iter())
217                    .copied()
218                    .collect::<Vec<_>>()
219            }
220            Key::I64(v) => {
221                let sign = u8::from(*v >= 0);
222
223                [VALUE, sign]
224                    .iter()
225                    .chain(v.to_be_bytes().iter())
226                    .copied()
227                    .collect::<Vec<_>>()
228            }
229            Key::I128(v) => {
230                let sign = u8::from(*v >= 0);
231
232                [VALUE, sign]
233                    .iter()
234                    .chain(v.to_be_bytes().iter())
235                    .copied()
236                    .collect::<Vec<_>>()
237            }
238            Key::U8(v) => [VALUE, 1]
239                .iter()
240                .chain(v.to_be_bytes().iter())
241                .copied()
242                .collect::<Vec<_>>(),
243            Key::U16(v) => [VALUE, 1]
244                .iter()
245                .chain(v.to_be_bytes().iter())
246                .copied()
247                .collect::<Vec<_>>(),
248            Key::U32(v) => [VALUE, 1]
249                .iter()
250                .chain(v.to_be_bytes().iter())
251                .copied()
252                .collect::<Vec<_>>(),
253            Key::U64(v) => [VALUE, 1]
254                .iter()
255                .chain(v.to_be_bytes().iter())
256                .copied()
257                .collect::<Vec<_>>(),
258            Key::U128(v) => [VALUE, 1]
259                .iter()
260                .chain(v.to_be_bytes().iter())
261                .copied()
262                .collect::<Vec<_>>(),
263            Key::F32(_) | Key::F64(_) => {
264                return Err(KeyError::FloatToCmpBigEndianNotSupported.into());
265            }
266            Key::Decimal(v) => {
267                let sign = u8::from(v.is_sign_positive());
268                let convert = |v: Decimal| {
269                    let v = v.unpack();
270                    let v = i128::from(v.lo) + (i128::from(v.mid) << 32) + (i128::from(v.hi) << 64);
271
272                    if sign == 0 { -v } else { v }
273                };
274
275                [VALUE, sign]
276                    .into_iter()
277                    .chain(convert(v.trunc()).to_be_bytes())
278                    .chain(convert(v.fract()).to_be_bytes())
279                    .collect::<Vec<_>>()
280            }
281            Key::Str(v) => [VALUE]
282                .iter()
283                .chain(v.as_bytes().iter())
284                .copied()
285                .collect::<Vec<_>>(),
286            Key::Bytea(v) => v.clone(),
287            Key::Inet(v) => match v {
288                IpAddr::V4(v) => v.octets().to_vec(),
289                IpAddr::V6(v) => v.octets().to_vec(),
290            },
291            Key::Date(date) => [VALUE]
292                .iter()
293                .chain(date.num_days_from_ce().to_be_bytes().iter())
294                .copied()
295                .collect::<Vec<_>>(),
296            Key::Time(time) => {
297                let secs = time.num_seconds_from_midnight();
298                let frac = time.nanosecond();
299
300                [VALUE]
301                    .iter()
302                    .chain(secs.to_be_bytes().iter())
303                    .chain(frac.to_be_bytes().iter())
304                    .copied()
305                    .collect::<Vec<_>>()
306            }
307            Key::Timestamp(datetime) => {
308                let date = datetime.num_days_from_ce();
309                let secs = datetime.num_seconds_from_midnight();
310                let frac = datetime.nanosecond();
311
312                [VALUE]
313                    .iter()
314                    .chain(date.to_be_bytes().iter())
315                    .chain(secs.to_be_bytes().iter())
316                    .chain(frac.to_be_bytes().iter())
317                    .copied()
318                    .collect::<Vec<_>>()
319            }
320            Key::Interval(interval) => {
321                let (month, microsec) = match interval {
322                    Interval::Month(month) => (*month, 0),
323                    Interval::Microsecond(microsec) => (0, *microsec),
324                };
325
326                [VALUE]
327                    .iter()
328                    .chain(month.to_be_bytes().iter())
329                    .chain(microsec.to_be_bytes().iter())
330                    .copied()
331                    .collect::<Vec<_>>()
332            }
333            Key::Uuid(v) => [VALUE]
334                .iter()
335                .chain(v.to_be_bytes().iter())
336                .copied()
337                .collect::<Vec<_>>(),
338            Key::None => vec![NONE],
339        })
340    }
341
342    fn to_order(&self) -> u8 {
343        match self {
344            Key::I8(_) => 1,
345            Key::I16(_) => 2,
346            Key::I32(_) => 3,
347            Key::I64(_) => 4,
348            Key::I128(_) => 5,
349            Key::U8(_) => 6,
350            Key::U16(_) => 7,
351            Key::U32(_) => 8,
352            Key::U64(_) => 9,
353            Key::U128(_) => 10,
354            Key::F32(_) => 11,
355            Key::F64(_) => 12,
356            Key::Decimal(_) => 13,
357            Key::Bool(_) => 14,
358            Key::Str(_) => 15,
359            Key::Bytea(_) => 16,
360            Key::Date(_) => 17,
361            Key::Timestamp(_) => 18,
362            Key::Time(_) => 19,
363            Key::Interval(_) => 20,
364            Key::Uuid(_) => 21,
365            Key::Inet(_) => 22,
366            Key::None => 23,
367        }
368    }
369}
370
371#[cfg(test)]
372mod tests {
373    use {
374        crate::{
375            data::{Interval, Key, KeyError, Point, Value},
376            executor::evaluate_stateless,
377            parse_sql::parse_expr,
378            result::Result,
379            translate::{NO_PARAMS, translate_expr},
380        },
381        chrono::{DateTime, NaiveDate, NaiveTime},
382        futures::executor::block_on,
383        rust_decimal::Decimal,
384        std::{cmp::Ordering, collections::BTreeMap, net::IpAddr, str::FromStr},
385    };
386
387    fn convert(sql: &str) -> Result<Key> {
388        let parsed = parse_expr(sql).expect(sql);
389        let expr = translate_expr(&parsed, NO_PARAMS).expect(sql);
390
391        block_on(evaluate_stateless(None, &expr))
392            .expect(sql)
393            .try_into()
394    }
395
396    #[test]
397    fn evaluated_to_key() {
398        // Some
399        assert_eq!(convert("True"), Ok(Key::Bool(true)));
400        assert_eq!(convert("CAST(11 AS INT8)"), Ok(Key::I8(11)));
401        assert_eq!(convert("CAST(11 AS INT16)"), Ok(Key::I16(11)));
402        assert_eq!(convert("CAST(11 AS INT32)"), Ok(Key::I32(11)));
403        assert_eq!(convert("2048"), Ok(Key::I64(2048)));
404        assert_eq!(convert("CAST(1024 AS INT128)"), Ok(Key::I128(1024)));
405        assert_eq!(convert("CAST(11 AS UINT8)"), Ok(Key::U8(11)));
406        assert_eq!(convert("CAST(11 AS UINT16)"), Ok(Key::U16(11)));
407        assert_eq!(convert("CAST(11 AS UINT32)"), Ok(Key::U32(11)));
408        assert_eq!(convert("CAST(11 AS UINT64)"), Ok(Key::U64(11)));
409        assert_eq!(convert("CAST(11 AS UINT128)"), Ok(Key::U128(11)));
410        assert!(matches!(convert("CAST(12.03 AS FLOAT32)"), Ok(Key::F32(_))));
411        assert!(matches!(convert("12.03"), Ok(Key::F64(_))));
412
413        assert_eq!(
414            convert("CAST(123.45 AS DECIMAL)"),
415            Ok(Key::Decimal(Decimal::from_str("123.45").unwrap()))
416        );
417        assert_eq!(
418            convert("CAST(0 AS INET)"),
419            Ok(Key::Inet(IpAddr::from_str("0.0.0.0").unwrap()))
420        );
421
422        assert_eq!(
423            convert("'Hello World'"),
424            Ok(Key::Str("Hello World".to_owned()))
425        );
426        assert_eq!(
427            convert("X'1234'"),
428            Ok(Key::Bytea(hex::decode("1234").unwrap())),
429        );
430        assert!(matches!(convert("DATE '2022-03-03'"), Ok(Key::Date(_))));
431        assert!(matches!(convert("TIME '12:30:00'"), Ok(Key::Time(_))));
432        assert!(matches!(
433            convert("TIMESTAMP '2022-03-03 12:30:00Z'"),
434            Ok(Key::Timestamp(_))
435        ));
436        assert!(matches!(convert("INTERVAL '1' DAY"), Ok(Key::Interval(_))));
437        assert!(matches!(convert("GENERATE_UUID()"), Ok(Key::Uuid(_))));
438
439        // None
440        assert_eq!(convert("NULL"), Ok(Key::None));
441
442        // Error
443        assert_eq!(
444            Key::try_from(Value::Map(BTreeMap::default())),
445            Err(KeyError::MapTypeKeyNotSupported.into())
446        );
447        assert_eq!(
448            Key::try_from(Value::List(Vec::default())),
449            Err(KeyError::ListTypeKeyNotSupported.into())
450        );
451        assert_eq!(
452            convert("SUBSTR('BEEF', 2, 3)"),
453            Ok(Key::Str("EEF".to_owned()))
454        );
455        assert_eq!(convert("POSITION('PORK' IN 'MEAT')"), Ok(Key::I64(0)));
456        assert_eq!(convert("FIND_IDX('Calzone', 'zone')"), Ok(Key::I64(4)));
457        assert_eq!(
458            convert("EXTRACT(SECOND FROM INTERVAL '8' SECOND)"),
459            Ok(Key::I64(8))
460        );
461        assert_eq!(
462            Key::try_from(Value::Point(Point::new(1.0, 2.0))),
463            Err(KeyError::PointTypeKeyNotSupported.into())
464        );
465    }
466
467    #[test]
468    fn cmp() {
469        use {
470            std::{net::IpAddr, str::FromStr},
471            uuid::Uuid,
472        };
473
474        let dec = |v| Decimal::from_str(v).unwrap();
475        let date = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();
476        let timestamp = |v| DateTime::from_timestamp_millis(v).unwrap().naive_utc();
477        let time = |h, m, s| NaiveTime::from_hms_milli_opt(h, m, s, 0).unwrap();
478        let uuid = |v| Uuid::parse_str(v).unwrap().as_u128();
479        let inet = |v| IpAddr::from_str(v).unwrap();
480
481        assert!(Key::I8(10) > Key::I8(3));
482        assert!(Key::I8(1) > Key::I16(1));
483
484        assert!(Key::I16(10) > Key::I16(3));
485        assert!(Key::I16(1) > Key::I32(1));
486
487        assert!(Key::I32(10) > Key::I32(3));
488        assert!(Key::I32(1) > Key::I64(1));
489
490        assert!(Key::I64(10) > Key::I64(3));
491        assert!(Key::I64(1) > Key::I128(1));
492
493        assert!(Key::I128(10) > Key::I128(3));
494        assert!(Key::I128(1) > Key::U8(1));
495
496        assert!(Key::U8(10) > Key::U8(3));
497        assert!(Key::U8(1) > Key::U16(1));
498
499        assert!(Key::U16(10) > Key::U16(3));
500        assert!(Key::U16(1) > Key::Decimal(dec("1")));
501
502        assert!(Key::U32(10) > Key::U32(3));
503        assert!(Key::U32(1) > Key::Decimal(dec("1")));
504
505        assert!(Key::U64(10) > Key::U64(3));
506        assert!(Key::U64(1) > Key::Decimal(dec("1")));
507
508        assert!(Key::U128(10) > Key::U128(3));
509        assert!(Key::U128(1) > Key::Decimal(dec("1")));
510
511        assert!(Key::F32(10.0_f32.into()) > Key::F32(3.0_f32.into()));
512        assert!(Key::F32(1.0_f32.into()) > Key::F64(1.0.into()));
513
514        assert!(Key::F64(10.0.into()) > Key::F64(3.0.into()));
515        assert!(Key::F64(1.0.into()) > Key::Decimal(dec("1")));
516
517        assert!(Key::Decimal(dec("123.45")) > Key::Decimal(dec("0.11")));
518        assert!(Key::Decimal(dec("1")) > Key::Bool(true));
519
520        assert!(Key::Bool(true) > Key::Bool(false));
521        assert!(Key::Bool(true) > Key::Str("zzz".to_owned()));
522
523        assert!(Key::Str("def".to_owned()) > Key::Str("abcd".to_owned()));
524        assert!(Key::Str("hi".to_owned()) > Key::Bytea(vec![101]));
525
526        assert!(Key::Bytea(vec![100]) > Key::Bytea(vec![3]));
527        assert!(Key::Bytea(vec![0]) > Key::Date(date(2023, 1, 1)));
528
529        assert!(Key::Date(date(2023, 3, 1)) > Key::Date(date(1999, 6, 11)));
530        assert!(Key::Date(date(2022, 6, 1)) > Key::Timestamp(timestamp(1_669_000_003)));
531
532        assert!(
533            Key::Timestamp(timestamp(1_662_921_288)) > Key::Timestamp(timestamp(1_661_000_000))
534        );
535        assert!(Key::Timestamp(timestamp(1_668_919_293)) > Key::Time(time(23, 1, 59)));
536
537        assert!(Key::Time(time(20, 1, 9)) > Key::Time(time(10, 0, 3)));
538        assert!(Key::Time(time(1, 2, 3)) > Key::Interval(Interval::Month(12)));
539
540        assert!(Key::Interval(Interval::Month(3)) > Key::Interval(Interval::Month(1)));
541        assert!(
542            Key::Interval(Interval::microseconds(1))
543                > Key::Uuid(uuid("dc98e386-a4d0-45c7-babe-b4238de4b139"))
544        );
545
546        assert!(
547            Key::Uuid(uuid("dc98e386-a4d0-45c7-babe-b4238de4b139"))
548                > Key::Uuid(uuid("550e8400-e29b-41d4-a716-446655440000"))
549        );
550        assert!(
551            Key::Uuid(uuid("dc98e386-a4d0-45c7-babe-b4238de4b139")) > Key::Inet(inet("127.0.0.1"))
552        );
553
554        assert!(Key::Inet(inet("127.0.0.1")) > Key::Inet(inet("0.0.0.1")));
555        assert!(Key::Inet(inet("192.168.1.19")) < Key::None);
556
557        assert_eq!(Key::None.partial_cmp(&Key::None), Some(Ordering::Equal));
558        assert!(Key::None > Key::I8(100));
559    }
560
561    #[test]
562    fn cmp_big_endian() {
563        use crate::data::{Interval as I, Key::*};
564
565        fn cmp(ls: &Result<Vec<u8>>, rs: &Result<Vec<u8>>) -> Ordering {
566            let ls = ls.as_ref().unwrap();
567            let rs = rs.as_ref().unwrap();
568
569            for (l, r) in ls.iter().zip(rs.iter()) {
570                match l.cmp(r) {
571                    Ordering::Equal => {}
572                    ordering => return ordering,
573                }
574            }
575
576            let size_l = ls.len();
577            let size_r = rs.len();
578
579            size_l.cmp(&size_r)
580        }
581
582        let null = None.to_cmp_be_bytes();
583
584        let n1 = Bool(true).to_cmp_be_bytes();
585        let n2 = Bool(false).to_cmp_be_bytes();
586
587        assert_eq!(cmp(&n2, &n2), Ordering::Equal);
588        assert_eq!(cmp(&n1, &n2), Ordering::Greater);
589        assert_eq!(cmp(&n2, &n1), Ordering::Less);
590        assert_eq!(cmp(&n1, &null), Ordering::Less);
591
592        let n1 = I8(-100).to_cmp_be_bytes();
593        let n2 = I8(-10).to_cmp_be_bytes();
594        let n3 = I8(0).to_cmp_be_bytes();
595        let n4 = I8(3).to_cmp_be_bytes();
596        let n5 = I8(20).to_cmp_be_bytes();
597        let n6 = I8(100).to_cmp_be_bytes();
598
599        assert_eq!(cmp(&n1, &n2), Ordering::Less);
600        assert_eq!(cmp(&n3, &n2), Ordering::Greater);
601        assert_eq!(cmp(&n1, &n6), Ordering::Less);
602        assert_eq!(cmp(&n5, &n5), Ordering::Equal);
603        assert_eq!(cmp(&n4, &n5), Ordering::Less);
604        assert_eq!(cmp(&n6, &n4), Ordering::Greater);
605        assert_eq!(cmp(&n4, &null), Ordering::Less);
606
607        let n1 = I16(-100).to_cmp_be_bytes();
608        let n2 = I16(-10).to_cmp_be_bytes();
609        let n3 = I16(0).to_cmp_be_bytes();
610        let n4 = I16(3).to_cmp_be_bytes();
611        let n5 = I16(20).to_cmp_be_bytes();
612        let n6 = I16(100).to_cmp_be_bytes();
613
614        assert_eq!(cmp(&n1, &n2), Ordering::Less);
615        assert_eq!(cmp(&n3, &n2), Ordering::Greater);
616        assert_eq!(cmp(&n1, &n6), Ordering::Less);
617        assert_eq!(cmp(&n5, &n5), Ordering::Equal);
618        assert_eq!(cmp(&n4, &n5), Ordering::Less);
619        assert_eq!(cmp(&n6, &n4), Ordering::Greater);
620        assert_eq!(cmp(&n4, &null), Ordering::Less);
621
622        let n1 = I32(-100).to_cmp_be_bytes();
623        let n2 = I32(-10).to_cmp_be_bytes();
624        let n3 = I32(0).to_cmp_be_bytes();
625        let n4 = I32(3).to_cmp_be_bytes();
626        let n5 = I32(20).to_cmp_be_bytes();
627        let n6 = I32(100).to_cmp_be_bytes();
628
629        assert_eq!(cmp(&n1, &n2), Ordering::Less);
630        assert_eq!(cmp(&n3, &n2), Ordering::Greater);
631        assert_eq!(cmp(&n1, &n6), Ordering::Less);
632        assert_eq!(cmp(&n5, &n5), Ordering::Equal);
633        assert_eq!(cmp(&n4, &n5), Ordering::Less);
634        assert_eq!(cmp(&n6, &n4), Ordering::Greater);
635        assert_eq!(cmp(&n4, &null), Ordering::Less);
636
637        let n1 = I64(-123).to_cmp_be_bytes();
638        let n2 = I64(-11).to_cmp_be_bytes();
639        let n3 = I64(0).to_cmp_be_bytes();
640        let n4 = I64(3).to_cmp_be_bytes();
641        let n5 = I64(20).to_cmp_be_bytes();
642        let n6 = I64(100).to_cmp_be_bytes();
643
644        assert_eq!(cmp(&n1, &n2), Ordering::Less);
645        assert_eq!(cmp(&n3, &n2), Ordering::Greater);
646        assert_eq!(cmp(&n1, &n6), Ordering::Less);
647        assert_eq!(cmp(&n5, &n5), Ordering::Equal);
648        assert_eq!(cmp(&n4, &n5), Ordering::Less);
649        assert_eq!(cmp(&n6, &n4), Ordering::Greater);
650        assert_eq!(cmp(&n4, &null), Ordering::Less);
651
652        let n1 = I128(-123).to_cmp_be_bytes();
653        let n2 = I128(-11).to_cmp_be_bytes();
654        let n3 = I128(0).to_cmp_be_bytes();
655        let n4 = I128(3).to_cmp_be_bytes();
656        let n5 = I128(20).to_cmp_be_bytes();
657        let n6 = I128(100).to_cmp_be_bytes();
658
659        assert_eq!(cmp(&n1, &n2), Ordering::Less);
660        assert_eq!(cmp(&n3, &n2), Ordering::Greater);
661        assert_eq!(cmp(&n1, &n6), Ordering::Less);
662        assert_eq!(cmp(&n5, &n5), Ordering::Equal);
663        assert_eq!(cmp(&n4, &n5), Ordering::Less);
664        assert_eq!(cmp(&n6, &n4), Ordering::Greater);
665        assert_eq!(cmp(&n4, &null), Ordering::Less);
666
667        let n1 = U8(0).to_cmp_be_bytes();
668        let n2 = U8(3).to_cmp_be_bytes();
669        let n3 = U8(20).to_cmp_be_bytes();
670        let n4 = U8(20).to_cmp_be_bytes();
671        assert_eq!(cmp(&n1, &n2), Ordering::Less);
672        assert_eq!(cmp(&n3, &n2), Ordering::Greater);
673        assert_eq!(cmp(&n1, &n4), Ordering::Less);
674        assert_eq!(cmp(&n3, &n4), Ordering::Equal);
675
676        let n1 = U16(0).to_cmp_be_bytes();
677        let n2 = U16(3).to_cmp_be_bytes();
678        let n3 = U16(20).to_cmp_be_bytes();
679        let n4 = U16(20).to_cmp_be_bytes();
680        assert_eq!(cmp(&n1, &n2), Ordering::Less);
681        assert_eq!(cmp(&n3, &n2), Ordering::Greater);
682        assert_eq!(cmp(&n1, &n4), Ordering::Less);
683        assert_eq!(cmp(&n3, &n4), Ordering::Equal);
684
685        let n1 = U32(0).to_cmp_be_bytes();
686        let n2 = U32(3).to_cmp_be_bytes();
687        let n3 = U32(20).to_cmp_be_bytes();
688        let n4 = U32(20).to_cmp_be_bytes();
689        assert_eq!(cmp(&n1, &n2), Ordering::Less);
690        assert_eq!(cmp(&n3, &n2), Ordering::Greater);
691        assert_eq!(cmp(&n1, &n4), Ordering::Less);
692        assert_eq!(cmp(&n3, &n4), Ordering::Equal);
693
694        let n1 = U64(0).to_cmp_be_bytes();
695        let n2 = U64(3).to_cmp_be_bytes();
696        let n3 = U64(20).to_cmp_be_bytes();
697        let n4 = U64(20).to_cmp_be_bytes();
698        assert_eq!(cmp(&n1, &n2), Ordering::Less);
699        assert_eq!(cmp(&n3, &n2), Ordering::Greater);
700        assert_eq!(cmp(&n1, &n4), Ordering::Less);
701        assert_eq!(cmp(&n3, &n4), Ordering::Equal);
702
703        let n1 = U128(0).to_cmp_be_bytes();
704        let n2 = U128(3).to_cmp_be_bytes();
705        let n3 = U128(20).to_cmp_be_bytes();
706        let n4 = U128(20).to_cmp_be_bytes();
707        assert_eq!(cmp(&n1, &n2), Ordering::Less);
708        assert_eq!(cmp(&n3, &n2), Ordering::Greater);
709        assert_eq!(cmp(&n1, &n4), Ordering::Less);
710        assert_eq!(cmp(&n3, &n4), Ordering::Equal);
711
712        let dec = |n| Decimal(rust_decimal::Decimal::from_str(n).unwrap());
713        let n1 = dec("-1200.345678").to_cmp_be_bytes();
714        let n2 = dec("-1.01").to_cmp_be_bytes();
715        let n3 = dec("0").to_cmp_be_bytes();
716        let n4 = dec("3.9").to_cmp_be_bytes();
717        let n5 = dec("300.0").to_cmp_be_bytes();
718        let n6 = dec("3000").to_cmp_be_bytes();
719        assert_eq!(cmp(&n1, &n2), Ordering::Less);
720        assert_eq!(cmp(&n3, &n2), Ordering::Greater);
721        assert_eq!(cmp(&n1, &n6), Ordering::Less);
722        assert_eq!(cmp(&n5, &n5), Ordering::Equal);
723        assert_eq!(cmp(&n4, &n5), Ordering::Less);
724        assert_eq!(cmp(&n6, &n4), Ordering::Greater);
725        assert_eq!(cmp(&n4, &null), Ordering::Less);
726
727        let n1 = Str("a".to_owned()).to_cmp_be_bytes();
728        let n2 = Str("ab".to_owned()).to_cmp_be_bytes();
729        let n3 = Str("aaa".to_owned()).to_cmp_be_bytes();
730        let n4 = Str("aaz".to_owned()).to_cmp_be_bytes();
731        let n5 = Str("c".to_owned()).to_cmp_be_bytes();
732
733        assert_eq!(cmp(&n2, &n2), Ordering::Equal);
734        assert_eq!(cmp(&n1, &n2), Ordering::Less);
735        assert_eq!(cmp(&n3, &n1), Ordering::Greater);
736        assert_eq!(cmp(&n2, &n3), Ordering::Greater);
737        assert_eq!(cmp(&n3, &n4), Ordering::Less);
738        assert_eq!(cmp(&n5, &n4), Ordering::Greater);
739        assert_eq!(cmp(&n1, &null), Ordering::Less);
740
741        let n1 = Bytea(n1.unwrap()).to_cmp_be_bytes();
742        let n2 = Bytea(n2.unwrap()).to_cmp_be_bytes();
743        let n3 = Bytea(n3.unwrap()).to_cmp_be_bytes();
744        let n4 = Bytea(n4.unwrap()).to_cmp_be_bytes();
745        let n5 = Bytea(n5.unwrap()).to_cmp_be_bytes();
746
747        assert_eq!(cmp(&n2, &n2), Ordering::Equal);
748        assert_eq!(cmp(&n1, &n2), Ordering::Less);
749        assert_eq!(cmp(&n3, &n1), Ordering::Greater);
750        assert_eq!(cmp(&n2, &n3), Ordering::Greater);
751        assert_eq!(cmp(&n3, &n4), Ordering::Less);
752        assert_eq!(cmp(&n5, &n4), Ordering::Greater);
753        assert_eq!(cmp(&n1, &null), Ordering::Less);
754
755        let n1 = Inet(IpAddr::from_str("192.168.0.1").unwrap()).to_cmp_be_bytes();
756        let n2 = Inet(IpAddr::from_str("127.0.0.1").unwrap()).to_cmp_be_bytes();
757        let n3 = Inet(IpAddr::from_str("10.0.0.1").unwrap()).to_cmp_be_bytes();
758        let n4 = Inet(IpAddr::from_str("0.0.0.0").unwrap()).to_cmp_be_bytes();
759        let n5 = Inet(IpAddr::from_str("0:0:0:0:0:0:0:1").unwrap()).to_cmp_be_bytes();
760        let n6 = Inet(IpAddr::from_str("::1").unwrap()).to_cmp_be_bytes();
761
762        assert_eq!(cmp(&n1, &n1), Ordering::Equal);
763        assert_eq!(cmp(&n2, &n1), Ordering::Less);
764        assert_eq!(cmp(&n2, &n3), Ordering::Greater);
765        assert_eq!(cmp(&n3, &n4), Ordering::Greater);
766        assert_eq!(cmp(&n1, &null), Ordering::Greater);
767        assert_eq!(cmp(&n5, &n6), Ordering::Equal);
768
769        let n1 = Date(NaiveDate::from_ymd_opt(2021, 1, 1).unwrap()).to_cmp_be_bytes();
770        let n2 = Date(NaiveDate::from_ymd_opt(1989, 3, 20).unwrap()).to_cmp_be_bytes();
771
772        assert_eq!(cmp(&n2, &n2), Ordering::Equal);
773        assert_eq!(cmp(&n1, &n2), Ordering::Greater);
774        assert_eq!(cmp(&n1, &null), Ordering::Less);
775
776        let n1 = Time(NaiveTime::from_hms_milli_opt(20, 1, 9, 100).unwrap()).to_cmp_be_bytes();
777        let n2 = Time(NaiveTime::from_hms_milli_opt(3, 10, 30, 0).unwrap()).to_cmp_be_bytes();
778
779        assert_eq!(cmp(&n2, &n2), Ordering::Equal);
780        assert_eq!(cmp(&n1, &n2), Ordering::Greater);
781        assert_eq!(cmp(&n1, &null), Ordering::Less);
782
783        let n1 = Timestamp(
784            NaiveDate::from_ymd_opt(2021, 1, 1)
785                .unwrap()
786                .and_hms_milli_opt(1, 2, 3, 0)
787                .unwrap(),
788        )
789        .to_cmp_be_bytes();
790        let n2 = Timestamp(
791            NaiveDate::from_ymd_opt(1989, 3, 20)
792                .unwrap()
793                .and_hms_milli_opt(10, 0, 0, 999)
794                .unwrap(),
795        )
796        .to_cmp_be_bytes();
797
798        assert_eq!(cmp(&n2, &n2), Ordering::Equal);
799        assert_eq!(cmp(&n1, &n2), Ordering::Greater);
800        assert_eq!(cmp(&n1, &null), Ordering::Less);
801
802        let n1 = Interval(I::Month(30)).to_cmp_be_bytes();
803        let n2 = Interval(I::Month(2)).to_cmp_be_bytes();
804        let n3 = Interval(I::Microsecond(1000)).to_cmp_be_bytes();
805        let n4 = Interval(I::Microsecond(30)).to_cmp_be_bytes();
806
807        assert_eq!(cmp(&n1, &n1), Ordering::Equal);
808        assert_eq!(cmp(&n2, &n1), Ordering::Less);
809        assert_eq!(cmp(&n2, &n3), Ordering::Greater);
810        assert_eq!(cmp(&n3, &n4), Ordering::Greater);
811        assert_eq!(cmp(&n1, &null), Ordering::Less);
812
813        let n1 = Uuid(100).to_cmp_be_bytes();
814        let n2 = Uuid(101).to_cmp_be_bytes();
815
816        assert_eq!(cmp(&n1, &n1), Ordering::Equal);
817        assert_eq!(cmp(&n1, &n2), Ordering::Less);
818        assert_eq!(cmp(&n2, &n1), Ordering::Greater);
819        assert_eq!(cmp(&n1, &null), Ordering::Less);
820
821        assert_eq!(
822            F64(12.34.into()).to_cmp_be_bytes(),
823            Err(KeyError::FloatToCmpBigEndianNotSupported.into())
824        );
825    }
826
827    #[test]
828    fn from_key_to_value() {
829        use {crate::data::Interval as I, uuid::Uuid};
830
831        assert_eq!(Value::from(Key::I8(2)), Value::I8(2));
832        assert_eq!(Value::from(Key::I16(4)), Value::I16(4));
833        assert_eq!(Value::from(Key::I32(8)), Value::I32(8));
834        assert_eq!(Value::from(Key::I64(16)), Value::I64(16));
835        assert_eq!(Value::from(Key::I128(32)), Value::I128(32));
836        assert_eq!(Value::from(Key::U8(64)), Value::U8(64));
837        assert_eq!(Value::from(Key::U16(128)), Value::U16(128));
838        assert_eq!(Value::from(Key::U32(128)), Value::U32(128));
839        assert_eq!(Value::from(Key::U64(128)), Value::U64(128));
840        assert_eq!(Value::from(Key::U128(128)), Value::U128(128));
841        assert_eq!(Value::from(Key::F32(1.0.into())), Value::F32(1.0_f32));
842        assert_eq!(Value::from(Key::F64(1.0.into())), Value::F64(1.0));
843        assert_eq!(
844            Value::from(Key::Decimal(Decimal::from_str("123.45").unwrap())),
845            Value::Decimal(Decimal::from_str("123.45").unwrap())
846        );
847        assert_eq!(Value::from(Key::Bool(true)), Value::Bool(true));
848        assert_eq!(
849            Value::from(Key::Str("abc".to_owned())),
850            Value::Str("abc".to_owned())
851        );
852        assert_eq!(Value::from(Key::Bytea(vec![])), Value::Bytea(vec![]));
853        assert_eq!(
854            Value::from(Key::Inet(IpAddr::from_str("::1").unwrap())),
855            Value::Inet(IpAddr::from_str("::1").unwrap())
856        );
857        assert_eq!(
858            Value::from(Key::Date(NaiveDate::from_ymd_opt(2023, 1, 23).unwrap())),
859            Value::Date(NaiveDate::from_ymd_opt(2023, 1, 23).unwrap())
860        );
861        assert_eq!(
862            Value::from(Key::Timestamp(
863                DateTime::from_timestamp_millis(1_662_921_288)
864                    .unwrap()
865                    .naive_utc()
866            )),
867            Value::Timestamp(
868                DateTime::from_timestamp_millis(1_662_921_288)
869                    .unwrap()
870                    .naive_utc()
871            )
872        );
873        assert_eq!(
874            Value::from(Key::Time(
875                NaiveTime::from_hms_milli_opt(20, 20, 1, 452).unwrap()
876            )),
877            Value::Time(NaiveTime::from_hms_milli_opt(20, 20, 1, 452).unwrap())
878        );
879        assert_eq!(
880            Value::from(Key::Interval(I::Month(11))),
881            Value::Interval(I::Month(11))
882        );
883        assert_eq!(
884            Value::from(Key::Uuid(
885                Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000")
886                    .unwrap()
887                    .as_u128()
888            )),
889            Value::Uuid(
890                Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000")
891                    .unwrap()
892                    .as_u128()
893            )
894        );
895        matches!(Value::from(Key::None), Value::Null);
896    }
897}
gluesql_core/data/key.rs

gluesql_core/data/
key.rs
