reifydb_core/key/
namespace_handler.rs

1// SPDX-License-Identifier: AGPL-3.0-or-later
2// Copyright (c) 2025 ReifyDB
3
4use crate::{
5	encoded::key::{EncodedKey, EncodedKeyRange},
6	interface::catalog::id::{HandlerId, NamespaceId},
7	key::{EncodableKey, KeyKind},
8	util::encoding::keycode::{deserializer::KeyDeserializer, serializer::KeySerializer},
9};
10
11const VERSION: u8 = 1;
12
13#[derive(Debug, Clone, PartialEq)]
14pub struct NamespaceHandlerKey {
15	pub namespace: NamespaceId,
16	pub handler: HandlerId,
17}
18
19impl NamespaceHandlerKey {
20	pub fn new(namespace: NamespaceId, handler: HandlerId) -> Self {
21		Self {
22			namespace,
23			handler,
24		}
25	}
26
27	pub fn encoded(namespace: impl Into<NamespaceId>, handler: impl Into<HandlerId>) -> EncodedKey {
28		Self::new(namespace.into(), handler.into()).encode()
29	}
30
31	pub fn full_scan(namespace: NamespaceId) -> EncodedKeyRange {
32		EncodedKeyRange::start_end(Some(Self::link_start(namespace)), Some(Self::link_end(namespace)))
33	}
34
35	fn link_start(namespace: NamespaceId) -> EncodedKey {
36		let mut serializer = KeySerializer::with_capacity(10);
37		serializer.extend_u8(VERSION).extend_u8(Self::KIND as u8).extend_u64(namespace);
38		serializer.to_encoded_key()
39	}
40
41	fn link_end(namespace: NamespaceId) -> EncodedKey {
42		let mut serializer = KeySerializer::with_capacity(10);
43		serializer.extend_u8(VERSION).extend_u8(Self::KIND as u8).extend_u64(*namespace - 1);
44		serializer.to_encoded_key()
45	}
46}
47
48impl EncodableKey for NamespaceHandlerKey {
49	const KIND: KeyKind = KeyKind::NamespaceHandler;
50
51	fn encode(&self) -> EncodedKey {
52		let mut serializer = KeySerializer::with_capacity(18);
53		serializer
54			.extend_u8(VERSION)
55			.extend_u8(Self::KIND as u8)
56			.extend_u64(self.namespace)
57			.extend_u64(self.handler);
58		serializer.to_encoded_key()
59	}
60
61	fn decode(key: &EncodedKey) -> Option<Self> {
62		let mut de = KeyDeserializer::from_bytes(key.as_slice());
63
64		let version = de.read_u8().ok()?;
65		if version != VERSION {
66			return None;
67		}
68
69		let kind: KeyKind = de.read_u8().ok()?.try_into().ok()?;
70		if kind != Self::KIND {
71			return None;
72		}
73
74		let namespace = de.read_u64().ok()?;
75		let handler = de.read_u64().ok()?;
76
77		Some(Self {
78			namespace: NamespaceId(namespace),
79			handler: HandlerId(handler),
80		})
81	}
82}
83
84#[cfg(test)]
85pub mod tests {
86	use super::{EncodableKey, NamespaceHandlerKey};
87	use crate::interface::catalog::id::{HandlerId, NamespaceId};
88
89	#[test]
90	fn test_encode_decode() {
91		let key = NamespaceHandlerKey {
92			namespace: NamespaceId(0xABCD),
93			handler: HandlerId(0x123456789ABCDEF0),
94		};
95		let encoded = key.encode();
96		let expected: Vec<u8> = vec![
97			0xFE, // version
98			0xD0, // kind (NamespaceHandler = 0x2F, encoded as 0xFF ^ 0x2F)
99			0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x54, 0x32, 0xED, 0xCB, 0xA9, 0x87, 0x65, 0x43, 0x21, 0x0F,
100		];
101		assert_eq!(encoded.as_slice(), expected);
102
103		let decoded = NamespaceHandlerKey::decode(&encoded).unwrap();
104		assert_eq!(decoded.namespace, NamespaceId(0xABCD));
105		assert_eq!(decoded.handler, HandlerId(0x123456789ABCDEF0));
106	}
107
108	#[test]
109	fn test_order_preserving() {
110		let key1 = NamespaceHandlerKey {
111			namespace: NamespaceId(1),
112			handler: HandlerId(100),
113		};
114		let key2 = NamespaceHandlerKey {
115			namespace: NamespaceId(1),
116			handler: HandlerId(200),
117		};
118		let key3 = NamespaceHandlerKey {
119			namespace: NamespaceId(2),
120			handler: HandlerId(1),
121		};
122
123		let encoded1 = key1.encode();
124		let encoded2 = key2.encode();
125		let encoded3 = key3.encode();
126
127		assert!(encoded3 < encoded2, "ordering not preserved");
128		assert!(encoded2 < encoded1, "ordering not preserved");
129	}
130}
reifydb_core/key/namespace_handler.rs

reifydb_core/key/
namespace_handler.rs
