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        rust_decimal::Decimal,
383        std::{cmp::Ordering, collections::BTreeMap, net::IpAddr, str::FromStr},
384    };
385
386    fn convert(sql: &str) -> Result<Key> {
387        let parsed = parse_expr(sql).expect(sql);
388        let expr = translate_expr(&parsed, NO_PARAMS).expect(sql).into();
389
390        evaluate_stateless(None, &expr).expect(sql).try_into()
391    }
392
393    #[test]
394    fn evaluated_to_key() {
395        // Some
396        assert_eq!(convert("True"), Ok(Key::Bool(true)));
397        assert_eq!(convert("CAST(11 AS INT8)"), Ok(Key::I8(11)));
398        assert_eq!(convert("CAST(11 AS INT16)"), Ok(Key::I16(11)));
399        assert_eq!(convert("CAST(11 AS INT32)"), Ok(Key::I32(11)));
400        assert_eq!(convert("2048"), Ok(Key::I64(2048)));
401        assert_eq!(convert("CAST(1024 AS INT128)"), Ok(Key::I128(1024)));
402        assert_eq!(convert("CAST(11 AS UINT8)"), Ok(Key::U8(11)));
403        assert_eq!(convert("CAST(11 AS UINT16)"), Ok(Key::U16(11)));
404        assert_eq!(convert("CAST(11 AS UINT32)"), Ok(Key::U32(11)));
405        assert_eq!(convert("CAST(11 AS UINT64)"), Ok(Key::U64(11)));
406        assert_eq!(convert("CAST(11 AS UINT128)"), Ok(Key::U128(11)));
407        assert!(matches!(convert("CAST(12.03 AS FLOAT32)"), Ok(Key::F32(_))));
408        assert!(matches!(convert("12.03"), Ok(Key::F64(_))));
409
410        assert_eq!(
411            convert("CAST(123.45 AS DECIMAL)"),
412            Ok(Key::Decimal(Decimal::from_str("123.45").unwrap()))
413        );
414        assert_eq!(
415            convert("CAST(0 AS INET)"),
416            Ok(Key::Inet(IpAddr::from_str("0.0.0.0").unwrap()))
417        );
418
419        assert_eq!(
420            convert("'Hello World'"),
421            Ok(Key::Str("Hello World".to_owned()))
422        );
423        assert_eq!(
424            convert("X'1234'"),
425            Ok(Key::Bytea(hex::decode("1234").unwrap())),
426        );
427        assert!(matches!(convert("DATE '2022-03-03'"), Ok(Key::Date(_))));
428        assert!(matches!(convert("TIME '12:30:00'"), Ok(Key::Time(_))));
429        assert!(matches!(
430            convert("TIMESTAMP '2022-03-03 12:30:00Z'"),
431            Ok(Key::Timestamp(_))
432        ));
433        assert!(matches!(convert("INTERVAL '1' DAY"), Ok(Key::Interval(_))));
434        assert!(matches!(convert("GENERATE_UUID()"), Ok(Key::Uuid(_))));
435
436        // None
437        assert_eq!(convert("NULL"), Ok(Key::None));
438
439        // Error
440        assert_eq!(
441            Key::try_from(Value::Map(BTreeMap::default())),
442            Err(KeyError::MapTypeKeyNotSupported.into())
443        );
444        assert_eq!(
445            Key::try_from(Value::List(Vec::default())),
446            Err(KeyError::ListTypeKeyNotSupported.into())
447        );
448        assert_eq!(
449            convert("SUBSTR('BEEF', 2, 3)"),
450            Ok(Key::Str("EEF".to_owned()))
451        );
452        assert_eq!(convert("POSITION('PORK' IN 'MEAT')"), Ok(Key::I64(0)));
453        assert_eq!(convert("FIND_IDX('Calzone', 'zone')"), Ok(Key::I64(4)));
454        assert_eq!(
455            convert("EXTRACT(SECOND FROM INTERVAL '8' SECOND)"),
456            Ok(Key::I64(8))
457        );
458        assert_eq!(
459            Key::try_from(Value::Point(Point::new(1.0, 2.0))),
460            Err(KeyError::PointTypeKeyNotSupported.into())
461        );
462    }
463
464    #[test]
465    fn cmp() {
466        use {
467            std::{net::IpAddr, str::FromStr},
468            uuid::Uuid,
469        };
470
471        let dec = |v| Decimal::from_str(v).unwrap();
472        let date = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();
473        let timestamp = |v| DateTime::from_timestamp_millis(v).unwrap().naive_utc();
474        let time = |h, m, s| NaiveTime::from_hms_milli_opt(h, m, s, 0).unwrap();
475        let uuid = |v| Uuid::parse_str(v).unwrap().as_u128();
476        let inet = |v| IpAddr::from_str(v).unwrap();
477
478        assert!(Key::I8(10) > Key::I8(3));
479        assert!(Key::I8(1) > Key::I16(1));
480
481        assert!(Key::I16(10) > Key::I16(3));
482        assert!(Key::I16(1) > Key::I32(1));
483
484        assert!(Key::I32(10) > Key::I32(3));
485        assert!(Key::I32(1) > Key::I64(1));
486
487        assert!(Key::I64(10) > Key::I64(3));
488        assert!(Key::I64(1) > Key::I128(1));
489
490        assert!(Key::I128(10) > Key::I128(3));
491        assert!(Key::I128(1) > Key::U8(1));
492
493        assert!(Key::U8(10) > Key::U8(3));
494        assert!(Key::U8(1) > Key::U16(1));
495
496        assert!(Key::U16(10) > Key::U16(3));
497        assert!(Key::U16(1) > Key::Decimal(dec("1")));
498
499        assert!(Key::U32(10) > Key::U32(3));
500        assert!(Key::U32(1) > Key::Decimal(dec("1")));
501
502        assert!(Key::U64(10) > Key::U64(3));
503        assert!(Key::U64(1) > Key::Decimal(dec("1")));
504
505        assert!(Key::U128(10) > Key::U128(3));
506        assert!(Key::U128(1) > Key::Decimal(dec("1")));
507
508        assert!(Key::F32(10.0_f32.into()) > Key::F32(3.0_f32.into()));
509        assert!(Key::F32(1.0_f32.into()) > Key::F64(1.0.into()));
510
511        assert!(Key::F64(10.0.into()) > Key::F64(3.0.into()));
512        assert!(Key::F64(1.0.into()) > Key::Decimal(dec("1")));
513
514        assert!(Key::Decimal(dec("123.45")) > Key::Decimal(dec("0.11")));
515        assert!(Key::Decimal(dec("1")) > Key::Bool(true));
516
517        assert!(Key::Bool(true) > Key::Bool(false));
518        assert!(Key::Bool(true) > Key::Str("zzz".to_owned()));
519
520        assert!(Key::Str("def".to_owned()) > Key::Str("abcd".to_owned()));
521        assert!(Key::Str("hi".to_owned()) > Key::Bytea(vec![101]));
522
523        assert!(Key::Bytea(vec![100]) > Key::Bytea(vec![3]));
524        assert!(Key::Bytea(vec![0]) > Key::Date(date(2023, 1, 1)));
525
526        assert!(Key::Date(date(2023, 3, 1)) > Key::Date(date(1999, 6, 11)));
527        assert!(Key::Date(date(2022, 6, 1)) > Key::Timestamp(timestamp(1_669_000_003)));
528
529        assert!(
530            Key::Timestamp(timestamp(1_662_921_288)) > Key::Timestamp(timestamp(1_661_000_000))
531        );
532        assert!(Key::Timestamp(timestamp(1_668_919_293)) > Key::Time(time(23, 1, 59)));
533
534        assert!(Key::Time(time(20, 1, 9)) > Key::Time(time(10, 0, 3)));
535        assert!(Key::Time(time(1, 2, 3)) > Key::Interval(Interval::Month(12)));
536
537        assert!(Key::Interval(Interval::Month(3)) > Key::Interval(Interval::Month(1)));
538        assert!(
539            Key::Interval(Interval::microseconds(1))
540                > Key::Uuid(uuid("dc98e386-a4d0-45c7-babe-b4238de4b139"))
541        );
542
543        assert!(
544            Key::Uuid(uuid("dc98e386-a4d0-45c7-babe-b4238de4b139"))
545                > Key::Uuid(uuid("550e8400-e29b-41d4-a716-446655440000"))
546        );
547        assert!(
548            Key::Uuid(uuid("dc98e386-a4d0-45c7-babe-b4238de4b139")) > Key::Inet(inet("127.0.0.1"))
549        );
550
551        assert!(Key::Inet(inet("127.0.0.1")) > Key::Inet(inet("0.0.0.1")));
552        assert!(Key::Inet(inet("192.168.1.19")) < Key::None);
553
554        assert_eq!(Key::None.partial_cmp(&Key::None), Some(Ordering::Equal));
555        assert!(Key::None > Key::I8(100));
556    }
557
558    #[test]
559    fn cmp_big_endian() {
560        use crate::data::{Interval as I, Key::*};
561
562        fn cmp(ls: &Result<Vec<u8>>, rs: &Result<Vec<u8>>) -> Ordering {
563            let ls = ls.as_ref().unwrap();
564            let rs = rs.as_ref().unwrap();
565
566            for (l, r) in ls.iter().zip(rs.iter()) {
567                match l.cmp(r) {
568                    Ordering::Equal => {}
569                    ordering => return ordering,
570                }
571            }
572
573            let size_l = ls.len();
574            let size_r = rs.len();
575
576            size_l.cmp(&size_r)
577        }
578
579        let null = None.to_cmp_be_bytes();
580
581        let n1 = Bool(true).to_cmp_be_bytes();
582        let n2 = Bool(false).to_cmp_be_bytes();
583
584        assert_eq!(cmp(&n2, &n2), Ordering::Equal);
585        assert_eq!(cmp(&n1, &n2), Ordering::Greater);
586        assert_eq!(cmp(&n2, &n1), Ordering::Less);
587        assert_eq!(cmp(&n1, &null), Ordering::Less);
588
589        let n1 = I8(-100).to_cmp_be_bytes();
590        let n2 = I8(-10).to_cmp_be_bytes();
591        let n3 = I8(0).to_cmp_be_bytes();
592        let n4 = I8(3).to_cmp_be_bytes();
593        let n5 = I8(20).to_cmp_be_bytes();
594        let n6 = I8(100).to_cmp_be_bytes();
595
596        assert_eq!(cmp(&n1, &n2), Ordering::Less);
597        assert_eq!(cmp(&n3, &n2), Ordering::Greater);
598        assert_eq!(cmp(&n1, &n6), Ordering::Less);
599        assert_eq!(cmp(&n5, &n5), Ordering::Equal);
600        assert_eq!(cmp(&n4, &n5), Ordering::Less);
601        assert_eq!(cmp(&n6, &n4), Ordering::Greater);
602        assert_eq!(cmp(&n4, &null), Ordering::Less);
603
604        let n1 = I16(-100).to_cmp_be_bytes();
605        let n2 = I16(-10).to_cmp_be_bytes();
606        let n3 = I16(0).to_cmp_be_bytes();
607        let n4 = I16(3).to_cmp_be_bytes();
608        let n5 = I16(20).to_cmp_be_bytes();
609        let n6 = I16(100).to_cmp_be_bytes();
610
611        assert_eq!(cmp(&n1, &n2), Ordering::Less);
612        assert_eq!(cmp(&n3, &n2), Ordering::Greater);
613        assert_eq!(cmp(&n1, &n6), Ordering::Less);
614        assert_eq!(cmp(&n5, &n5), Ordering::Equal);
615        assert_eq!(cmp(&n4, &n5), Ordering::Less);
616        assert_eq!(cmp(&n6, &n4), Ordering::Greater);
617        assert_eq!(cmp(&n4, &null), Ordering::Less);
618
619        let n1 = I32(-100).to_cmp_be_bytes();
620        let n2 = I32(-10).to_cmp_be_bytes();
621        let n3 = I32(0).to_cmp_be_bytes();
622        let n4 = I32(3).to_cmp_be_bytes();
623        let n5 = I32(20).to_cmp_be_bytes();
624        let n6 = I32(100).to_cmp_be_bytes();
625
626        assert_eq!(cmp(&n1, &n2), Ordering::Less);
627        assert_eq!(cmp(&n3, &n2), Ordering::Greater);
628        assert_eq!(cmp(&n1, &n6), Ordering::Less);
629        assert_eq!(cmp(&n5, &n5), Ordering::Equal);
630        assert_eq!(cmp(&n4, &n5), Ordering::Less);
631        assert_eq!(cmp(&n6, &n4), Ordering::Greater);
632        assert_eq!(cmp(&n4, &null), Ordering::Less);
633
634        let n1 = I64(-123).to_cmp_be_bytes();
635        let n2 = I64(-11).to_cmp_be_bytes();
636        let n3 = I64(0).to_cmp_be_bytes();
637        let n4 = I64(3).to_cmp_be_bytes();
638        let n5 = I64(20).to_cmp_be_bytes();
639        let n6 = I64(100).to_cmp_be_bytes();
640
641        assert_eq!(cmp(&n1, &n2), Ordering::Less);
642        assert_eq!(cmp(&n3, &n2), Ordering::Greater);
643        assert_eq!(cmp(&n1, &n6), Ordering::Less);
644        assert_eq!(cmp(&n5, &n5), Ordering::Equal);
645        assert_eq!(cmp(&n4, &n5), Ordering::Less);
646        assert_eq!(cmp(&n6, &n4), Ordering::Greater);
647        assert_eq!(cmp(&n4, &null), Ordering::Less);
648
649        let n1 = I128(-123).to_cmp_be_bytes();
650        let n2 = I128(-11).to_cmp_be_bytes();
651        let n3 = I128(0).to_cmp_be_bytes();
652        let n4 = I128(3).to_cmp_be_bytes();
653        let n5 = I128(20).to_cmp_be_bytes();
654        let n6 = I128(100).to_cmp_be_bytes();
655
656        assert_eq!(cmp(&n1, &n2), Ordering::Less);
657        assert_eq!(cmp(&n3, &n2), Ordering::Greater);
658        assert_eq!(cmp(&n1, &n6), Ordering::Less);
659        assert_eq!(cmp(&n5, &n5), Ordering::Equal);
660        assert_eq!(cmp(&n4, &n5), Ordering::Less);
661        assert_eq!(cmp(&n6, &n4), Ordering::Greater);
662        assert_eq!(cmp(&n4, &null), Ordering::Less);
663
664        let n1 = U8(0).to_cmp_be_bytes();
665        let n2 = U8(3).to_cmp_be_bytes();
666        let n3 = U8(20).to_cmp_be_bytes();
667        let n4 = U8(20).to_cmp_be_bytes();
668        assert_eq!(cmp(&n1, &n2), Ordering::Less);
669        assert_eq!(cmp(&n3, &n2), Ordering::Greater);
670        assert_eq!(cmp(&n1, &n4), Ordering::Less);
671        assert_eq!(cmp(&n3, &n4), Ordering::Equal);
672
673        let n1 = U16(0).to_cmp_be_bytes();
674        let n2 = U16(3).to_cmp_be_bytes();
675        let n3 = U16(20).to_cmp_be_bytes();
676        let n4 = U16(20).to_cmp_be_bytes();
677        assert_eq!(cmp(&n1, &n2), Ordering::Less);
678        assert_eq!(cmp(&n3, &n2), Ordering::Greater);
679        assert_eq!(cmp(&n1, &n4), Ordering::Less);
680        assert_eq!(cmp(&n3, &n4), Ordering::Equal);
681
682        let n1 = U32(0).to_cmp_be_bytes();
683        let n2 = U32(3).to_cmp_be_bytes();
684        let n3 = U32(20).to_cmp_be_bytes();
685        let n4 = U32(20).to_cmp_be_bytes();
686        assert_eq!(cmp(&n1, &n2), Ordering::Less);
687        assert_eq!(cmp(&n3, &n2), Ordering::Greater);
688        assert_eq!(cmp(&n1, &n4), Ordering::Less);
689        assert_eq!(cmp(&n3, &n4), Ordering::Equal);
690
691        let n1 = U64(0).to_cmp_be_bytes();
692        let n2 = U64(3).to_cmp_be_bytes();
693        let n3 = U64(20).to_cmp_be_bytes();
694        let n4 = U64(20).to_cmp_be_bytes();
695        assert_eq!(cmp(&n1, &n2), Ordering::Less);
696        assert_eq!(cmp(&n3, &n2), Ordering::Greater);
697        assert_eq!(cmp(&n1, &n4), Ordering::Less);
698        assert_eq!(cmp(&n3, &n4), Ordering::Equal);
699
700        let n1 = U128(0).to_cmp_be_bytes();
701        let n2 = U128(3).to_cmp_be_bytes();
702        let n3 = U128(20).to_cmp_be_bytes();
703        let n4 = U128(20).to_cmp_be_bytes();
704        assert_eq!(cmp(&n1, &n2), Ordering::Less);
705        assert_eq!(cmp(&n3, &n2), Ordering::Greater);
706        assert_eq!(cmp(&n1, &n4), Ordering::Less);
707        assert_eq!(cmp(&n3, &n4), Ordering::Equal);
708
709        let dec = |n| Decimal(rust_decimal::Decimal::from_str(n).unwrap());
710        let n1 = dec("-1200.345678").to_cmp_be_bytes();
711        let n2 = dec("-1.01").to_cmp_be_bytes();
712        let n3 = dec("0").to_cmp_be_bytes();
713        let n4 = dec("3.9").to_cmp_be_bytes();
714        let n5 = dec("300.0").to_cmp_be_bytes();
715        let n6 = dec("3000").to_cmp_be_bytes();
716        assert_eq!(cmp(&n1, &n2), Ordering::Less);
717        assert_eq!(cmp(&n3, &n2), Ordering::Greater);
718        assert_eq!(cmp(&n1, &n6), Ordering::Less);
719        assert_eq!(cmp(&n5, &n5), Ordering::Equal);
720        assert_eq!(cmp(&n4, &n5), Ordering::Less);
721        assert_eq!(cmp(&n6, &n4), Ordering::Greater);
722        assert_eq!(cmp(&n4, &null), Ordering::Less);
723
724        let n1 = Str("a".to_owned()).to_cmp_be_bytes();
725        let n2 = Str("ab".to_owned()).to_cmp_be_bytes();
726        let n3 = Str("aaa".to_owned()).to_cmp_be_bytes();
727        let n4 = Str("aaz".to_owned()).to_cmp_be_bytes();
728        let n5 = Str("c".to_owned()).to_cmp_be_bytes();
729
730        assert_eq!(cmp(&n2, &n2), Ordering::Equal);
731        assert_eq!(cmp(&n1, &n2), Ordering::Less);
732        assert_eq!(cmp(&n3, &n1), Ordering::Greater);
733        assert_eq!(cmp(&n2, &n3), Ordering::Greater);
734        assert_eq!(cmp(&n3, &n4), Ordering::Less);
735        assert_eq!(cmp(&n5, &n4), Ordering::Greater);
736        assert_eq!(cmp(&n1, &null), Ordering::Less);
737
738        let n1 = Bytea(n1.unwrap()).to_cmp_be_bytes();
739        let n2 = Bytea(n2.unwrap()).to_cmp_be_bytes();
740        let n3 = Bytea(n3.unwrap()).to_cmp_be_bytes();
741        let n4 = Bytea(n4.unwrap()).to_cmp_be_bytes();
742        let n5 = Bytea(n5.unwrap()).to_cmp_be_bytes();
743
744        assert_eq!(cmp(&n2, &n2), Ordering::Equal);
745        assert_eq!(cmp(&n1, &n2), Ordering::Less);
746        assert_eq!(cmp(&n3, &n1), Ordering::Greater);
747        assert_eq!(cmp(&n2, &n3), Ordering::Greater);
748        assert_eq!(cmp(&n3, &n4), Ordering::Less);
749        assert_eq!(cmp(&n5, &n4), Ordering::Greater);
750        assert_eq!(cmp(&n1, &null), Ordering::Less);
751
752        let n1 = Inet(IpAddr::from_str("192.168.0.1").unwrap()).to_cmp_be_bytes();
753        let n2 = Inet(IpAddr::from_str("127.0.0.1").unwrap()).to_cmp_be_bytes();
754        let n3 = Inet(IpAddr::from_str("10.0.0.1").unwrap()).to_cmp_be_bytes();
755        let n4 = Inet(IpAddr::from_str("0.0.0.0").unwrap()).to_cmp_be_bytes();
756        let n5 = Inet(IpAddr::from_str("0:0:0:0:0:0:0:1").unwrap()).to_cmp_be_bytes();
757        let n6 = Inet(IpAddr::from_str("::1").unwrap()).to_cmp_be_bytes();
758
759        assert_eq!(cmp(&n1, &n1), Ordering::Equal);
760        assert_eq!(cmp(&n2, &n1), Ordering::Less);
761        assert_eq!(cmp(&n2, &n3), Ordering::Greater);
762        assert_eq!(cmp(&n3, &n4), Ordering::Greater);
763        assert_eq!(cmp(&n1, &null), Ordering::Greater);
764        assert_eq!(cmp(&n5, &n6), Ordering::Equal);
765
766        let n1 = Date(NaiveDate::from_ymd_opt(2021, 1, 1).unwrap()).to_cmp_be_bytes();
767        let n2 = Date(NaiveDate::from_ymd_opt(1989, 3, 20).unwrap()).to_cmp_be_bytes();
768
769        assert_eq!(cmp(&n2, &n2), Ordering::Equal);
770        assert_eq!(cmp(&n1, &n2), Ordering::Greater);
771        assert_eq!(cmp(&n1, &null), Ordering::Less);
772
773        let n1 = Time(NaiveTime::from_hms_milli_opt(20, 1, 9, 100).unwrap()).to_cmp_be_bytes();
774        let n2 = Time(NaiveTime::from_hms_milli_opt(3, 10, 30, 0).unwrap()).to_cmp_be_bytes();
775
776        assert_eq!(cmp(&n2, &n2), Ordering::Equal);
777        assert_eq!(cmp(&n1, &n2), Ordering::Greater);
778        assert_eq!(cmp(&n1, &null), Ordering::Less);
779
780        let n1 = Timestamp(
781            NaiveDate::from_ymd_opt(2021, 1, 1)
782                .unwrap()
783                .and_hms_milli_opt(1, 2, 3, 0)
784                .unwrap(),
785        )
786        .to_cmp_be_bytes();
787        let n2 = Timestamp(
788            NaiveDate::from_ymd_opt(1989, 3, 20)
789                .unwrap()
790                .and_hms_milli_opt(10, 0, 0, 999)
791                .unwrap(),
792        )
793        .to_cmp_be_bytes();
794
795        assert_eq!(cmp(&n2, &n2), Ordering::Equal);
796        assert_eq!(cmp(&n1, &n2), Ordering::Greater);
797        assert_eq!(cmp(&n1, &null), Ordering::Less);
798
799        let n1 = Interval(I::Month(30)).to_cmp_be_bytes();
800        let n2 = Interval(I::Month(2)).to_cmp_be_bytes();
801        let n3 = Interval(I::Microsecond(1000)).to_cmp_be_bytes();
802        let n4 = Interval(I::Microsecond(30)).to_cmp_be_bytes();
803
804        assert_eq!(cmp(&n1, &n1), Ordering::Equal);
805        assert_eq!(cmp(&n2, &n1), Ordering::Less);
806        assert_eq!(cmp(&n2, &n3), Ordering::Greater);
807        assert_eq!(cmp(&n3, &n4), Ordering::Greater);
808        assert_eq!(cmp(&n1, &null), Ordering::Less);
809
810        let n1 = Uuid(100).to_cmp_be_bytes();
811        let n2 = Uuid(101).to_cmp_be_bytes();
812
813        assert_eq!(cmp(&n1, &n1), Ordering::Equal);
814        assert_eq!(cmp(&n1, &n2), Ordering::Less);
815        assert_eq!(cmp(&n2, &n1), Ordering::Greater);
816        assert_eq!(cmp(&n1, &null), Ordering::Less);
817
818        assert_eq!(
819            F64(12.34.into()).to_cmp_be_bytes(),
820            Err(KeyError::FloatToCmpBigEndianNotSupported.into())
821        );
822    }
823
824    #[test]
825    fn from_key_to_value() {
826        use {crate::data::Interval as I, uuid::Uuid};
827
828        assert_eq!(Value::from(Key::I8(2)), Value::I8(2));
829        assert_eq!(Value::from(Key::I16(4)), Value::I16(4));
830        assert_eq!(Value::from(Key::I32(8)), Value::I32(8));
831        assert_eq!(Value::from(Key::I64(16)), Value::I64(16));
832        assert_eq!(Value::from(Key::I128(32)), Value::I128(32));
833        assert_eq!(Value::from(Key::U8(64)), Value::U8(64));
834        assert_eq!(Value::from(Key::U16(128)), Value::U16(128));
835        assert_eq!(Value::from(Key::U32(128)), Value::U32(128));
836        assert_eq!(Value::from(Key::U64(128)), Value::U64(128));
837        assert_eq!(Value::from(Key::U128(128)), Value::U128(128));
838        assert_eq!(Value::from(Key::F32(1.0.into())), Value::F32(1.0_f32));
839        assert_eq!(Value::from(Key::F64(1.0.into())), Value::F64(1.0));
840        assert_eq!(
841            Value::from(Key::Decimal(Decimal::from_str("123.45").unwrap())),
842            Value::Decimal(Decimal::from_str("123.45").unwrap())
843        );
844        assert_eq!(Value::from(Key::Bool(true)), Value::Bool(true));
845        assert_eq!(
846            Value::from(Key::Str("abc".to_owned())),
847            Value::Str("abc".to_owned())
848        );
849        assert_eq!(Value::from(Key::Bytea(vec![])), Value::Bytea(vec![]));
850        assert_eq!(
851            Value::from(Key::Inet(IpAddr::from_str("::1").unwrap())),
852            Value::Inet(IpAddr::from_str("::1").unwrap())
853        );
854        assert_eq!(
855            Value::from(Key::Date(NaiveDate::from_ymd_opt(2023, 1, 23).unwrap())),
856            Value::Date(NaiveDate::from_ymd_opt(2023, 1, 23).unwrap())
857        );
858        assert_eq!(
859            Value::from(Key::Timestamp(
860                DateTime::from_timestamp_millis(1_662_921_288)
861                    .unwrap()
862                    .naive_utc()
863            )),
864            Value::Timestamp(
865                DateTime::from_timestamp_millis(1_662_921_288)
866                    .unwrap()
867                    .naive_utc()
868            )
869        );
870        assert_eq!(
871            Value::from(Key::Time(
872                NaiveTime::from_hms_milli_opt(20, 20, 1, 452).unwrap()
873            )),
874            Value::Time(NaiveTime::from_hms_milli_opt(20, 20, 1, 452).unwrap())
875        );
876        assert_eq!(
877            Value::from(Key::Interval(I::Month(11))),
878            Value::Interval(I::Month(11))
879        );
880        assert_eq!(
881            Value::from(Key::Uuid(
882                Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000")
883                    .unwrap()
884                    .as_u128()
885            )),
886            Value::Uuid(
887                Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000")
888                    .unwrap()
889                    .as_u128()
890            )
891        );
892        matches!(Value::from(Key::None), Value::Null);
893    }
894}
gluesql_core/data/key.rs

gluesql_core/data/
key.rs
