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.cmp(r),
79 (Key::Uuid(l), Key::Uuid(r)) => l.cmp(r),
80 (Key::Inet(l), Key::Inet(r)) => l.cmp(r),
81 (Key::None, Key::None) => Ordering::Equal,
82 (Key::None, _) => Ordering::Greater,
83 (_, Key::None) => Ordering::Less,
84
85 (left, right) => {
86 if left.to_order() <= right.to_order() {
87 Ordering::Greater
88 } else {
89 Ordering::Less
90 }
91 }
92 }
93 }
94}
95
96impl PartialOrd for Key {
97 fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
98 Some(self.cmp(other))
99 }
100}
101
102impl TryFrom<Value> for Key {
103 type Error = Error;
104
105 fn try_from(value: Value) -> Result<Self> {
106 use Value::*;
107
108 match value {
109 Bool(v) => Ok(Key::Bool(v)),
110 I8(v) => Ok(Key::I8(v)),
111 I16(v) => Ok(Key::I16(v)),
112 I32(v) => Ok(Key::I32(v)),
113 I64(v) => Ok(Key::I64(v)),
114 I128(v) => Ok(Key::I128(v)),
115 U8(v) => Ok(Key::U8(v)),
116 U16(v) => Ok(Key::U16(v)),
117 U32(v) => Ok(Key::U32(v)),
118 U64(v) => Ok(Key::U64(v)),
119 U128(v) => Ok(Key::U128(v)),
120 F32(v) => Ok(Key::F32(OrderedFloat(v))),
121 F64(v) => Ok(Key::F64(OrderedFloat(v))),
122 Decimal(v) => Ok(Key::Decimal(v)),
123 Str(v) => Ok(Key::Str(v)),
124 Bytea(v) => Ok(Key::Bytea(v)),
125 Inet(v) => Ok(Key::Inet(v)),
126 Date(v) => Ok(Key::Date(v)),
127 Timestamp(v) => Ok(Key::Timestamp(v)),
128 Time(v) => Ok(Key::Time(v)),
129 Interval(v) => Ok(Key::Interval(v)),
130 Uuid(v) => Ok(Key::Uuid(v)),
131 Null => Ok(Key::None),
132 Map(_) => Err(KeyError::MapTypeKeyNotSupported.into()),
133 List(_) => Err(KeyError::ListTypeKeyNotSupported.into()),
134 Point(_) => Err(KeyError::PointTypeKeyNotSupported.into()),
135 }
136 }
137}
138
139impl TryFrom<&Value> for Key {
140 type Error = Error;
141
142 fn try_from(value: &Value) -> Result<Self> {
143 value.clone().try_into()
144 }
145}
146
147impl From<Key> for Value {
148 fn from(key: Key) -> Self {
149 match key {
150 Key::Bool(v) => Value::Bool(v),
151 Key::I8(v) => Value::I8(v),
152 Key::I16(v) => Value::I16(v),
153 Key::I32(v) => Value::I32(v),
154 Key::I64(v) => Value::I64(v),
155 Key::I128(v) => Value::I128(v),
156 Key::U8(v) => Value::U8(v),
157 Key::U16(v) => Value::U16(v),
158 Key::U32(v) => Value::U32(v),
159 Key::U64(v) => Value::U64(v),
160 Key::U128(v) => Value::U128(v),
161 Key::F32(v) => Value::F32(v.0),
162 Key::F64(v) => Value::F64(v.0),
163 Key::Decimal(v) => Value::Decimal(v),
164 Key::Str(v) => Value::Str(v),
165 Key::Bytea(v) => Value::Bytea(v),
166 Key::Inet(v) => Value::Inet(v),
167 Key::Date(v) => Value::Date(v),
168 Key::Timestamp(v) => Value::Timestamp(v),
169 Key::Time(v) => Value::Time(v),
170 Key::Interval(v) => Value::Interval(v),
171 Key::Uuid(v) => Value::Uuid(v),
172 Key::None => Value::Null,
173 }
174 }
175}
176
177const VALUE: u8 = 0;
178const NONE: u8 = 1;
179
180impl Key {
181 pub fn to_cmp_be_bytes(&self) -> Result<Vec<u8>> {
183 Ok(match self {
184 Key::Bool(v) => {
185 if *v {
186 vec![VALUE, 1]
187 } else {
188 vec![VALUE, 0]
189 }
190 }
191 Key::I8(v) => {
192 let sign = u8::from(*v >= 0);
193
194 [VALUE, sign]
195 .iter()
196 .chain(v.to_be_bytes().iter())
197 .copied()
198 .collect::<Vec<_>>()
199 }
200 Key::I16(v) => {
201 let sign = u8::from(*v >= 0);
202
203 [VALUE, sign]
204 .iter()
205 .chain(v.to_be_bytes().iter())
206 .copied()
207 .collect::<Vec<_>>()
208 }
209 Key::I32(v) => {
210 let sign = u8::from(*v >= 0);
211
212 [VALUE, sign]
213 .iter()
214 .chain(v.to_be_bytes().iter())
215 .copied()
216 .collect::<Vec<_>>()
217 }
218 Key::I64(v) => {
219 let sign = u8::from(*v >= 0);
220
221 [VALUE, sign]
222 .iter()
223 .chain(v.to_be_bytes().iter())
224 .copied()
225 .collect::<Vec<_>>()
226 }
227 Key::I128(v) => {
228 let sign = u8::from(*v >= 0);
229
230 [VALUE, sign]
231 .iter()
232 .chain(v.to_be_bytes().iter())
233 .copied()
234 .collect::<Vec<_>>()
235 }
236 Key::U8(v) => [VALUE, 1]
237 .iter()
238 .chain(v.to_be_bytes().iter())
239 .copied()
240 .collect::<Vec<_>>(),
241 Key::U16(v) => [VALUE, 1]
242 .iter()
243 .chain(v.to_be_bytes().iter())
244 .copied()
245 .collect::<Vec<_>>(),
246 Key::U32(v) => [VALUE, 1]
247 .iter()
248 .chain(v.to_be_bytes().iter())
249 .copied()
250 .collect::<Vec<_>>(),
251 Key::U64(v) => [VALUE, 1]
252 .iter()
253 .chain(v.to_be_bytes().iter())
254 .copied()
255 .collect::<Vec<_>>(),
256 Key::U128(v) => [VALUE, 1]
257 .iter()
258 .chain(v.to_be_bytes().iter())
259 .copied()
260 .collect::<Vec<_>>(),
261 Key::F32(_) | Key::F64(_) => {
262 return Err(KeyError::FloatToCmpBigEndianNotSupported.into());
263 }
264 Key::Decimal(v) => {
265 let sign = u8::from(v.is_sign_positive());
266 let convert = |v: Decimal| {
267 let v = v.unpack();
268 let v = v.lo as i128 + ((v.mid as i128) << 32) + ((v.hi as i128) << 64);
269
270 if sign == 0 {
271 -v
272 } else {
273 v
274 }
275 };
276
277 [VALUE, sign]
278 .into_iter()
279 .chain(convert(v.trunc()).to_be_bytes())
280 .chain(convert(v.fract()).to_be_bytes())
281 .collect::<Vec<_>>()
282 }
283 Key::Str(v) => [VALUE]
284 .iter()
285 .chain(v.as_bytes().iter())
286 .copied()
287 .collect::<Vec<_>>(),
288 Key::Bytea(v) => v.to_vec(),
289 Key::Inet(v) => match v {
290 IpAddr::V4(v) => v.octets().to_vec(),
291 IpAddr::V6(v) => v.octets().to_vec(),
292 },
293 Key::Date(date) => [VALUE]
294 .iter()
295 .chain(date.num_days_from_ce().to_be_bytes().iter())
296 .copied()
297 .collect::<Vec<_>>(),
298 Key::Time(time) => {
299 let secs = time.num_seconds_from_midnight();
300 let frac = time.nanosecond();
301
302 [VALUE]
303 .iter()
304 .chain(secs.to_be_bytes().iter())
305 .chain(frac.to_be_bytes().iter())
306 .copied()
307 .collect::<Vec<_>>()
308 }
309 Key::Timestamp(datetime) => {
310 let date = datetime.num_days_from_ce();
311 let secs = datetime.num_seconds_from_midnight();
312 let frac = datetime.nanosecond();
313
314 [VALUE]
315 .iter()
316 .chain(date.to_be_bytes().iter())
317 .chain(secs.to_be_bytes().iter())
318 .chain(frac.to_be_bytes().iter())
319 .copied()
320 .collect::<Vec<_>>()
321 }
322 Key::Interval(interval) => {
323 let (month, microsec) = match interval {
324 Interval::Month(month) => (*month, 0),
325 Interval::Microsecond(microsec) => (0, *microsec),
326 };
327
328 [VALUE]
329 .iter()
330 .chain(month.to_be_bytes().iter())
331 .chain(microsec.to_be_bytes().iter())
332 .copied()
333 .collect::<Vec<_>>()
334 }
335 Key::Uuid(v) => [VALUE]
336 .iter()
337 .chain(v.to_be_bytes().iter())
338 .copied()
339 .collect::<Vec<_>>(),
340 Key::None => vec![NONE],
341 })
342 }
343
344 fn to_order(&self) -> u8 {
345 match self {
346 Key::I8(_) => 1,
347 Key::I16(_) => 2,
348 Key::I32(_) => 3,
349 Key::I64(_) => 4,
350 Key::I128(_) => 5,
351 Key::U8(_) => 6,
352 Key::U16(_) => 7,
353 Key::U32(_) => 8,
354 Key::U64(_) => 9,
355 Key::U128(_) => 10,
356 Key::F32(_) => 11,
357 Key::F64(_) => 12,
358 Key::Decimal(_) => 13,
359 Key::Bool(_) => 14,
360 Key::Str(_) => 15,
361 Key::Bytea(_) => 16,
362 Key::Date(_) => 17,
363 Key::Timestamp(_) => 18,
364 Key::Time(_) => 19,
365 Key::Interval(_) => 20,
366 Key::Uuid(_) => 21,
367 Key::Inet(_) => 22,
368 Key::None => 23,
369 }
370 }
371}
372
373#[cfg(test)]
374mod tests {
375 use {
376 crate::{
377 data::{Interval, Key, KeyError, Point, Value},
378 executor::evaluate_stateless,
379 parse_sql::parse_expr,
380 result::Result,
381 translate::translate_expr,
382 },
383 chrono::{DateTime, NaiveDate, NaiveTime},
384 futures::executor::block_on,
385 rust_decimal::Decimal,
386 std::{cmp::Ordering, collections::HashMap, net::IpAddr, str::FromStr},
387 };
388
389 fn convert(sql: &str) -> Result<Key> {
390 let parsed = parse_expr(sql).expect(sql);
391 let expr = translate_expr(&parsed).expect(sql);
392
393 block_on(evaluate_stateless(None, &expr))
394 .expect(sql)
395 .try_into()
396 }
397
398 #[test]
399 fn evaluated_to_key() {
400 assert_eq!(convert("True"), Ok(Key::Bool(true)));
402 assert_eq!(convert("CAST(11 AS INT8)"), Ok(Key::I8(11)));
403 assert_eq!(convert("CAST(11 AS INT16)"), Ok(Key::I16(11)));
404 assert_eq!(convert("CAST(11 AS INT32)"), Ok(Key::I32(11)));
405 assert_eq!(convert("2048"), Ok(Key::I64(2048)));
406 assert_eq!(convert("CAST(1024 AS INT128)"), Ok(Key::I128(1024)));
407 assert_eq!(convert("CAST(11 AS UINT8)"), Ok(Key::U8(11)));
408 assert_eq!(convert("CAST(11 AS UINT16)"), Ok(Key::U16(11)));
409 assert_eq!(convert("CAST(11 AS UINT32)"), Ok(Key::U32(11)));
410 assert_eq!(convert("CAST(11 AS UINT64)"), Ok(Key::U64(11)));
411 assert_eq!(convert("CAST(11 AS UINT128)"), Ok(Key::U128(11)));
412 assert!(matches!(convert("CAST(12.03 AS FLOAT32)"), Ok(Key::F32(_))));
413 assert!(matches!(convert("12.03"), Ok(Key::F64(_))));
414
415 assert_eq!(
416 convert("CAST(123.45 AS DECIMAL)"),
417 Ok(Key::Decimal(Decimal::from_str("123.45").unwrap()))
418 );
419 assert_eq!(
420 convert("CAST(0 AS INET)"),
421 Ok(Key::Inet(IpAddr::from_str("0.0.0.0").unwrap()))
422 );
423
424 assert_eq!(
425 convert("'Hello World'"),
426 Ok(Key::Str("Hello World".to_owned()))
427 );
428 assert_eq!(
429 convert("X'1234'"),
430 Ok(Key::Bytea(hex::decode("1234").unwrap())),
431 );
432 assert!(matches!(convert("DATE '2022-03-03'"), Ok(Key::Date(_))));
433 assert!(matches!(convert("TIME '12:30:00'"), Ok(Key::Time(_))));
434 assert!(matches!(
435 convert("TIMESTAMP '2022-03-03 12:30:00Z'"),
436 Ok(Key::Timestamp(_))
437 ));
438 assert!(matches!(convert("INTERVAL '1' DAY"), Ok(Key::Interval(_))));
439 assert!(matches!(convert("GENERATE_UUID()"), Ok(Key::Uuid(_))));
440
441 assert_eq!(convert("NULL"), Ok(Key::None));
443
444 assert_eq!(
446 Key::try_from(Value::Map(HashMap::default())),
447 Err(KeyError::MapTypeKeyNotSupported.into())
448 );
449 assert_eq!(
450 Key::try_from(Value::List(Vec::default())),
451 Err(KeyError::ListTypeKeyNotSupported.into())
452 );
453 assert_eq!(
454 convert("SUBSTR('BEEF', 2, 3)"),
455 Ok(Key::Str("EEF".to_owned()))
456 );
457 assert_eq!(convert("POSITION('PORK' IN 'MEAT')"), Ok(Key::I64(0)));
458 assert_eq!(convert("FIND_IDX('Calzone', 'zone')"), Ok(Key::I64(4)));
459 assert_eq!(
460 convert("EXTRACT(SECOND FROM INTERVAL '8' SECOND)"),
461 Ok(Key::I64(8))
462 );
463 assert_eq!(
464 Key::try_from(Value::Point(Point::new(1.0, 2.0))),
465 Err(KeyError::PointTypeKeyNotSupported.into())
466 );
467 }
468
469 #[test]
470 fn cmp() {
471 use {
472 std::{net::IpAddr, str::FromStr},
473 uuid::Uuid,
474 };
475
476 let dec = |v| Decimal::from_str(v).unwrap();
477 let date = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();
478 let timestamp = |v| DateTime::from_timestamp_millis(v).unwrap().naive_utc();
479 let time = |h, m, s| NaiveTime::from_hms_milli_opt(h, m, s, 0).unwrap();
480 let uuid = |v| Uuid::parse_str(v).unwrap().as_u128();
481 let inet = |v| IpAddr::from_str(v).unwrap();
482
483 assert!(Key::I8(10) > Key::I8(3));
484 assert!(Key::I8(1) > Key::I16(1));
485
486 assert!(Key::I16(10) > Key::I16(3));
487 assert!(Key::I16(1) > Key::I32(1));
488
489 assert!(Key::I32(10) > Key::I32(3));
490 assert!(Key::I32(1) > Key::I64(1));
491
492 assert!(Key::I64(10) > Key::I64(3));
493 assert!(Key::I64(1) > Key::I128(1));
494
495 assert!(Key::I128(10) > Key::I128(3));
496 assert!(Key::I128(1) > Key::U8(1));
497
498 assert!(Key::U8(10) > Key::U8(3));
499 assert!(Key::U8(1) > Key::U16(1));
500
501 assert!(Key::U16(10) > Key::U16(3));
502 assert!(Key::U16(1) > Key::Decimal(dec("1")));
503
504 assert!(Key::U32(10) > Key::U32(3));
505 assert!(Key::U32(1) > Key::Decimal(dec("1")));
506
507 assert!(Key::U64(10) > Key::U64(3));
508 assert!(Key::U64(1) > Key::Decimal(dec("1")));
509
510 assert!(Key::U128(10) > Key::U128(3));
511 assert!(Key::U128(1) > Key::Decimal(dec("1")));
512
513 assert!(Key::F32(10.0_f32.into()) > Key::F32(3.0_f32.into()));
514 assert!(Key::F32(1.0_f32.into()) > Key::F64(1.0.into()));
515
516 assert!(Key::F64(10.0.into()) > Key::F64(3.0.into()));
517 assert!(Key::F64(1.0.into()) > Key::Decimal(dec("1")));
518
519 assert!(Key::Decimal(dec("123.45")) > Key::Decimal(dec("0.11")));
520 assert!(Key::Decimal(dec("1")) > Key::Bool(true));
521
522 assert!(Key::Bool(true) > Key::Bool(false));
523 assert!(Key::Bool(true) > Key::Str("zzz".to_owned()));
524
525 assert!(Key::Str("def".to_owned()) > Key::Str("abcd".to_owned()));
526 assert!(Key::Str("hi".to_owned()) > Key::Bytea(vec![101]));
527
528 assert!(Key::Bytea(vec![100]) > Key::Bytea(vec![3]));
529 assert!(Key::Bytea(vec![0]) > Key::Date(date(2023, 1, 1)));
530
531 assert!(Key::Date(date(2023, 3, 1)) > Key::Date(date(1999, 6, 11)));
532 assert!(Key::Date(date(2022, 6, 1)) > Key::Timestamp(timestamp(1669000003)));
533
534 assert!(Key::Timestamp(timestamp(1662921288)) > Key::Timestamp(timestamp(1661000000)));
535 assert!(Key::Timestamp(timestamp(1668919293)) > 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 => continue,
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(1662921288)
864 .unwrap()
865 .naive_utc()
866 )),
867 Value::Timestamp(
868 DateTime::from_timestamp_millis(1662921288)
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}