1use std::{
5 borrow::Borrow,
6 cmp::Ordering,
7 collections::Bound,
8 fmt,
9 hash::{Hash, Hasher},
10 iter, mem,
11 ops::{Deref, RangeBounds},
12 sync::Arc,
13};
14
15use reifydb_value::{
16 util::hash::Hash128,
17 value::{
18 blob::Blob,
19 date::Date,
20 datetime::DateTime,
21 duration::Duration,
22 identity::IdentityId,
23 row_number::RowNumber,
24 time::Time,
25 uuid::{Uuid4, Uuid7},
26 },
27};
28use serde::{
29 de::{Deserialize, Deserializer},
30 ser::{Serialize, Serializer},
31};
32
33use crate::key::serializer::KeySerializer;
34
35fn decode_binary(s: &str) -> Vec<u8> {
36 let mut buf = [0; 4];
37 let mut bytes = Vec::new();
38 for c in s.chars() {
39 match c as u32 {
40 b @ 0x80..=0xff => bytes.push(b as u8),
41 _ => bytes.extend(c.encode_utf8(&mut buf).as_bytes()),
42 }
43 }
44 bytes
45}
46
47pub const INLINE_CAP: usize = 39;
48
49#[derive(Clone)]
50pub enum EncodedKey {
51 Inline {
52 len: u8,
53 buf: [u8; INLINE_CAP],
54 },
55 Shared(Arc<[u8]>),
56}
57
58const _: () = assert!(mem::size_of::<EncodedKey>() == INLINE_CAP + 1 + mem::size_of::<usize>());
59
60impl EncodedKey {
61 pub fn new(key: impl AsRef<[u8]>) -> Self {
62 let key = key.as_ref();
63 if key.len() <= INLINE_CAP {
64 let mut buf = [0u8; INLINE_CAP];
65 buf[..key.len()].copy_from_slice(key);
66 EncodedKey::Inline {
67 len: key.len() as u8,
68 buf,
69 }
70 } else {
71 EncodedKey::Shared(Arc::from(key))
72 }
73 }
74
75 pub fn builder() -> EncodedKeyBuilder {
76 EncodedKeyBuilder::new()
77 }
78
79 pub fn as_bytes(&self) -> &[u8] {
80 self.as_slice()
81 }
82
83 pub fn as_slice(&self) -> &[u8] {
84 match self {
85 EncodedKey::Inline {
86 len,
87 buf,
88 } => &buf[..*len as usize],
89 EncodedKey::Shared(bytes) => bytes,
90 }
91 }
92
93 pub fn to_vec(&self) -> Vec<u8> {
94 self.as_slice().to_vec()
95 }
96}
97
98impl Deref for EncodedKey {
99 type Target = [u8];
100
101 fn deref(&self) -> &[u8] {
102 self.as_slice()
103 }
104}
105
106impl AsRef<[u8]> for EncodedKey {
107 fn as_ref(&self) -> &[u8] {
108 self.as_slice()
109 }
110}
111
112impl Borrow<[u8]> for EncodedKey {
113 fn borrow(&self) -> &[u8] {
114 self.as_slice()
115 }
116}
117
118impl PartialEq for EncodedKey {
119 fn eq(&self, other: &Self) -> bool {
120 self.as_slice() == other.as_slice()
121 }
122}
123
124impl Eq for EncodedKey {}
125
126impl PartialOrd for EncodedKey {
127 fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
128 Some(self.cmp(other))
129 }
130}
131
132impl Ord for EncodedKey {
133 fn cmp(&self, other: &Self) -> Ordering {
134 self.as_slice().cmp(other.as_slice())
135 }
136}
137
138impl Hash for EncodedKey {
139 fn hash<H: Hasher>(&self, state: &mut H) {
140 self.as_slice().hash(state);
141 }
142}
143
144impl PartialEq<Vec<u8>> for EncodedKey {
145 fn eq(&self, other: &Vec<u8>) -> bool {
146 self.as_slice() == other.as_slice()
147 }
148}
149
150impl PartialEq<[u8]> for EncodedKey {
151 fn eq(&self, other: &[u8]) -> bool {
152 self.as_slice() == other
153 }
154}
155
156impl Serialize for EncodedKey {
157 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
158 self.as_slice().serialize(serializer)
159 }
160}
161
162impl<'de> Deserialize<'de> for EncodedKey {
163 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
164 let vec = Vec::<u8>::deserialize(deserializer)?;
165 Ok(EncodedKey::new(vec))
166 }
167}
168
169impl fmt::Debug for EncodedKey {
170 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
171 write!(f, "EncodedKey({:02x?})", self.as_slice())
172 }
173}
174
175pub struct EncodedKeyBuilder {
176 serializer: KeySerializer,
177}
178
179impl EncodedKeyBuilder {
180 pub fn new() -> Self {
181 Self {
182 serializer: KeySerializer::new(),
183 }
184 }
185
186 pub fn with_capacity(capacity: usize) -> Self {
187 Self {
188 serializer: KeySerializer::with_capacity(capacity),
189 }
190 }
191
192 pub fn build(self) -> EncodedKey {
193 self.serializer.to_encoded_key()
194 }
195
196 pub fn bool(mut self, value: bool) -> Self {
197 self.serializer.extend_bool(value);
198 self
199 }
200
201 pub fn f32(mut self, value: f32) -> Self {
202 self.serializer.extend_f32(value);
203 self
204 }
205
206 pub fn f64(mut self, value: f64) -> Self {
207 self.serializer.extend_f64(value);
208 self
209 }
210
211 pub fn i8<T: Into<i8>>(mut self, value: T) -> Self {
212 self.serializer.extend_i8(value);
213 self
214 }
215
216 pub fn i16<T: Into<i16>>(mut self, value: T) -> Self {
217 self.serializer.extend_i16(value);
218 self
219 }
220
221 pub fn i32<T: Into<i32>>(mut self, value: T) -> Self {
222 self.serializer.extend_i32(value);
223 self
224 }
225
226 pub fn i64<T: Into<i64>>(mut self, value: T) -> Self {
227 self.serializer.extend_i64(value);
228 self
229 }
230
231 pub fn i128<T: Into<i128>>(mut self, value: T) -> Self {
232 self.serializer.extend_i128(value);
233 self
234 }
235
236 pub fn u8<T: Into<u8>>(mut self, value: T) -> Self {
237 self.serializer.extend_u8(value);
238 self
239 }
240
241 pub fn u16<T: Into<u16>>(mut self, value: T) -> Self {
242 self.serializer.extend_u16(value);
243 self
244 }
245
246 pub fn u32<T: Into<u32>>(mut self, value: T) -> Self {
247 self.serializer.extend_u32(value);
248 self
249 }
250
251 pub fn u64<T: Into<u64>>(mut self, value: T) -> Self {
252 self.serializer.extend_u64(value);
253 self
254 }
255
256 pub fn u128<T: Into<u128>>(mut self, value: T) -> Self {
257 self.serializer.extend_u128(value);
258 self
259 }
260
261 pub fn bytes<T: AsRef<[u8]>>(mut self, bytes: T) -> Self {
262 self.serializer.extend_bytes(bytes);
263 self
264 }
265
266 pub fn str<T: AsRef<str>>(mut self, s: T) -> Self {
267 self.serializer.extend_str(s);
268 self
269 }
270
271 pub fn raw(mut self, bytes: &[u8]) -> Self {
272 self.serializer.extend_raw(bytes);
273 self
274 }
275
276 pub fn len(&self) -> usize {
277 self.serializer.len()
278 }
279
280 pub fn is_empty(&self) -> bool {
281 self.serializer.is_empty()
282 }
283
284 pub fn date(mut self, date: &Date) -> Self {
285 self.serializer.extend_date(date);
286 self
287 }
288
289 pub fn datetime(mut self, datetime: &DateTime) -> Self {
290 self.serializer.extend_datetime(datetime);
291 self
292 }
293
294 pub fn time(mut self, time: &Time) -> Self {
295 self.serializer.extend_time(time);
296 self
297 }
298
299 pub fn duration(mut self, duration: &Duration) -> Self {
300 self.serializer.extend_duration(duration);
301 self
302 }
303
304 pub fn row_number(mut self, row_number: &RowNumber) -> Self {
305 self.serializer.extend_row_number(row_number);
306 self
307 }
308
309 pub fn identity_id(mut self, id: &IdentityId) -> Self {
310 self.serializer.extend_identity_id(id);
311 self
312 }
313
314 pub fn uuid4(mut self, uuid: &Uuid4) -> Self {
315 self.serializer.extend_uuid4(uuid);
316 self
317 }
318
319 pub fn uuid7(mut self, uuid: &Uuid7) -> Self {
320 self.serializer.extend_uuid7(uuid);
321 self
322 }
323
324 pub fn blob(mut self, blob: &Blob) -> Self {
325 self.serializer.extend_blob(blob);
326 self
327 }
328}
329
330impl Default for EncodedKeyBuilder {
331 fn default() -> Self {
332 Self::new()
333 }
334}
335
336pub trait IntoEncodedKey {
337 fn into_encoded_key(self) -> EncodedKey;
338}
339
340impl IntoEncodedKey for EncodedKey {
341 fn into_encoded_key(self) -> EncodedKey {
342 self
343 }
344}
345
346impl IntoEncodedKey for &str {
347 fn into_encoded_key(self) -> EncodedKey {
348 let mut serializer = KeySerializer::new();
349 serializer.extend_str(self);
350 serializer.to_encoded_key()
351 }
352}
353
354impl IntoEncodedKey for String {
355 fn into_encoded_key(self) -> EncodedKey {
356 let mut serializer = KeySerializer::new();
357 serializer.extend_str(&self);
358 serializer.to_encoded_key()
359 }
360}
361
362impl IntoEncodedKey for Vec<u8> {
363 fn into_encoded_key(self) -> EncodedKey {
364 let mut serializer = KeySerializer::new();
365 serializer.extend_bytes(&self);
366 serializer.to_encoded_key()
367 }
368}
369
370impl IntoEncodedKey for &[u8] {
371 fn into_encoded_key(self) -> EncodedKey {
372 let mut serializer = KeySerializer::new();
373 serializer.extend_bytes(self);
374 serializer.to_encoded_key()
375 }
376}
377
378impl IntoEncodedKey for u64 {
379 fn into_encoded_key(self) -> EncodedKey {
380 let mut serializer = KeySerializer::with_capacity(8);
381 serializer.extend_u64(self);
382 serializer.to_encoded_key()
383 }
384}
385
386impl IntoEncodedKey for i64 {
387 fn into_encoded_key(self) -> EncodedKey {
388 let mut serializer = KeySerializer::with_capacity(8);
389 serializer.extend_i64(self);
390 serializer.to_encoded_key()
391 }
392}
393
394impl IntoEncodedKey for u32 {
395 fn into_encoded_key(self) -> EncodedKey {
396 let mut serializer = KeySerializer::with_capacity(4);
397 serializer.extend_u32(self);
398 serializer.to_encoded_key()
399 }
400}
401
402impl IntoEncodedKey for i32 {
403 fn into_encoded_key(self) -> EncodedKey {
404 let mut serializer = KeySerializer::with_capacity(4);
405 serializer.extend_i32(self);
406 serializer.to_encoded_key()
407 }
408}
409
410impl IntoEncodedKey for u16 {
411 fn into_encoded_key(self) -> EncodedKey {
412 let mut serializer = KeySerializer::with_capacity(2);
413 serializer.extend_u16(self);
414 serializer.to_encoded_key()
415 }
416}
417
418impl IntoEncodedKey for i16 {
419 fn into_encoded_key(self) -> EncodedKey {
420 let mut serializer = KeySerializer::with_capacity(2);
421 serializer.extend_i16(self);
422 serializer.to_encoded_key()
423 }
424}
425
426impl IntoEncodedKey for u8 {
427 fn into_encoded_key(self) -> EncodedKey {
428 let mut serializer = KeySerializer::with_capacity(1);
429 serializer.extend_u8(self);
430 serializer.to_encoded_key()
431 }
432}
433
434impl IntoEncodedKey for i8 {
435 fn into_encoded_key(self) -> EncodedKey {
436 let mut serializer = KeySerializer::with_capacity(1);
437 serializer.extend_i8(self);
438 serializer.to_encoded_key()
439 }
440}
441
442impl IntoEncodedKey for &u64 {
443 fn into_encoded_key(self) -> EncodedKey {
444 (*self).into_encoded_key()
445 }
446}
447
448impl IntoEncodedKey for &i64 {
449 fn into_encoded_key(self) -> EncodedKey {
450 (*self).into_encoded_key()
451 }
452}
453
454impl IntoEncodedKey for &u32 {
455 fn into_encoded_key(self) -> EncodedKey {
456 (*self).into_encoded_key()
457 }
458}
459
460impl IntoEncodedKey for &i32 {
461 fn into_encoded_key(self) -> EncodedKey {
462 (*self).into_encoded_key()
463 }
464}
465
466impl IntoEncodedKey for &u16 {
467 fn into_encoded_key(self) -> EncodedKey {
468 (*self).into_encoded_key()
469 }
470}
471
472impl IntoEncodedKey for &i16 {
473 fn into_encoded_key(self) -> EncodedKey {
474 (*self).into_encoded_key()
475 }
476}
477
478impl IntoEncodedKey for &u8 {
479 fn into_encoded_key(self) -> EncodedKey {
480 (*self).into_encoded_key()
481 }
482}
483
484impl IntoEncodedKey for &i8 {
485 fn into_encoded_key(self) -> EncodedKey {
486 (*self).into_encoded_key()
487 }
488}
489
490impl IntoEncodedKey for &Hash128 {
491 fn into_encoded_key(self) -> EncodedKey {
492 let mut serializer = KeySerializer::with_capacity(16);
493 serializer.extend_u128(self.0);
494 serializer.to_encoded_key()
495 }
496}
497
498impl IntoEncodedKey for RowNumber {
499 fn into_encoded_key(self) -> EncodedKey {
500 self.0.into_encoded_key()
501 }
502}
503
504impl IntoEncodedKey for &RowNumber {
505 fn into_encoded_key(self) -> EncodedKey {
506 self.0.into_encoded_key()
507 }
508}
509
510impl IntoEncodedKey for (String, String) {
511 fn into_encoded_key(self) -> EncodedKey {
512 let mut serializer = KeySerializer::new();
513 serializer.extend_str(&self.0);
514 serializer.extend_str(&self.1);
515 serializer.to_encoded_key()
516 }
517}
518
519impl IntoEncodedKey for &(String, String) {
520 fn into_encoded_key(self) -> EncodedKey {
521 let mut serializer = KeySerializer::new();
522 serializer.extend_str(&self.0);
523 serializer.extend_str(&self.1);
524 serializer.to_encoded_key()
525 }
526}
527
528impl IntoEncodedKey for (&str, &str) {
529 fn into_encoded_key(self) -> EncodedKey {
530 let mut serializer = KeySerializer::new();
531 serializer.extend_str(self.0);
532 serializer.extend_str(self.1);
533 serializer.to_encoded_key()
534 }
535}
536
537impl IntoEncodedKey for (Arc<str>, Arc<str>) {
538 fn into_encoded_key(self) -> EncodedKey {
539 let mut serializer = KeySerializer::new();
540 serializer.extend_str(&self.0);
541 serializer.extend_str(&self.1);
542 serializer.to_encoded_key()
543 }
544}
545
546impl IntoEncodedKey for &(Arc<str>, Arc<str>) {
547 fn into_encoded_key(self) -> EncodedKey {
548 let mut serializer = KeySerializer::new();
549 serializer.extend_str(&self.0);
550 serializer.extend_str(&self.1);
551 serializer.to_encoded_key()
552 }
553}
554
555impl IntoEncodedKey for (String, String, String) {
556 fn into_encoded_key(self) -> EncodedKey {
557 let mut serializer = KeySerializer::new();
558 serializer.extend_str(&self.0);
559 serializer.extend_str(&self.1);
560 serializer.extend_str(&self.2);
561 serializer.to_encoded_key()
562 }
563}
564
565impl IntoEncodedKey for &(String, String, String) {
566 fn into_encoded_key(self) -> EncodedKey {
567 let mut serializer = KeySerializer::new();
568 serializer.extend_str(&self.0);
569 serializer.extend_str(&self.1);
570 serializer.extend_str(&self.2);
571 serializer.to_encoded_key()
572 }
573}
574
575impl IntoEncodedKey for &String {
576 fn into_encoded_key(self) -> EncodedKey {
577 let mut serializer = KeySerializer::new();
578 serializer.extend_str(self);
579 serializer.to_encoded_key()
580 }
581}
582
583#[derive(Clone, Debug)]
584pub struct EncodedKeyRange {
585 pub start: Bound<EncodedKey>,
586 pub end: Bound<EncodedKey>,
587}
588
589impl EncodedKeyRange {
590 pub fn new(start: Bound<EncodedKey>, end: Bound<EncodedKey>) -> Self {
591 Self {
592 start,
593 end,
594 }
595 }
596
597 pub fn prefix(prefix: &[u8]) -> Self {
598 let start = Bound::Included(EncodedKey::new(prefix));
599 let end = match prefix.iter().rposition(|&b| b != 0xff) {
600 Some(i) => Bound::Excluded(EncodedKey::new(
601 prefix.iter().take(i).copied().chain(iter::once(prefix[i] + 1)).collect::<Vec<_>>(),
602 )),
603 None => Bound::Unbounded,
604 };
605 Self {
606 start,
607 end,
608 }
609 }
610
611 pub fn start_end(start: Option<EncodedKey>, end: Option<EncodedKey>) -> Self {
612 let start = match start {
613 Some(s) => Bound::Included(s),
614 None => Bound::Unbounded,
615 };
616
617 let end = match end {
618 Some(e) => Bound::Included(e),
619 None => Bound::Unbounded,
620 };
621
622 Self {
623 start,
624 end,
625 }
626 }
627
628 pub fn all() -> Self {
629 Self {
630 start: Bound::Unbounded,
631 end: Bound::Unbounded,
632 }
633 }
634
635 pub fn parse(str: &str) -> Self {
636 let (mut start, mut end) = (Bound::<EncodedKey>::Unbounded, Bound::<EncodedKey>::Unbounded);
637
638 if let Some(dot_pos) = str.find("..") {
639 let start_part = &str[..dot_pos];
640 let end_part = &str[dot_pos + 2..];
641
642 if !start_part.is_empty() {
643 start = Bound::Included(EncodedKey::new(decode_binary(start_part)));
644 }
645
646 if let Some(end_str) = end_part.strip_prefix('=') {
647 if !end_str.is_empty() {
648 end = Bound::Included(EncodedKey::new(decode_binary(end_str)));
649 }
650 } else if !end_part.is_empty() {
651 end = Bound::Excluded(EncodedKey::new(decode_binary(end_part)));
652 }
653
654 Self {
655 start,
656 end,
657 }
658 } else {
659 Self {
660 start: Bound::Included(EncodedKey::new([0xff])),
661 end: Bound::Excluded(EncodedKey::new([0xff])),
662 }
663 }
664 }
665}
666
667impl RangeBounds<EncodedKey> for EncodedKeyRange {
668 fn start_bound(&self) -> Bound<&EncodedKey> {
669 self.start.as_ref()
670 }
671
672 fn end_bound(&self) -> Bound<&EncodedKey> {
673 self.end.as_ref()
674 }
675}