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