reifydb_core/key/
procedure_param.rs1use reifydb_codec::key::{
5 deserializer::KeyDeserializer,
6 encoded::{EncodedKey, EncodedKeyRange},
7 serializer::KeySerializer,
8};
9
10use super::{EncodableKey, KeyKind};
11use crate::interface::catalog::id::ProcedureId;
12
13#[derive(Debug, Clone, PartialEq)]
14pub struct ProcedureParamKey {
15 pub procedure: ProcedureId,
16 pub param_index: u16,
17}
18
19impl EncodableKey for ProcedureParamKey {
20 const KIND: KeyKind = KeyKind::ProcedureParam;
21
22 fn encode(&self) -> EncodedKey {
23 let mut serializer = KeySerializer::with_capacity(11);
24 serializer.extend_u8(Self::KIND as u8).extend_u64(self.procedure).extend_u16(self.param_index);
25 serializer.to_encoded_key()
26 }
27
28 fn decode(key: &EncodedKey) -> Option<Self> {
29 let mut de = KeyDeserializer::from_bytes(key.as_slice());
30
31 let kind: KeyKind = de.read_u8().ok()?.try_into().ok()?;
32 if kind != Self::KIND {
33 return None;
34 }
35
36 let procedure = de.read_u64().ok()?;
37 let param_index = de.read_u16().ok()?;
38
39 Some(Self {
40 procedure: ProcedureId::from_raw(procedure),
41 param_index,
42 })
43 }
44}
45
46impl ProcedureParamKey {
47 pub fn encoded(procedure: impl Into<ProcedureId>, param_index: u16) -> EncodedKey {
48 Self {
49 procedure: procedure.into(),
50 param_index,
51 }
52 .encode()
53 }
54
55 pub fn full_scan(procedure: ProcedureId) -> EncodedKeyRange {
56 EncodedKeyRange::start_end(Some(Self::params_start(procedure)), Some(Self::params_end(procedure)))
57 }
58
59 fn params_start(procedure: ProcedureId) -> EncodedKey {
60 let mut serializer = KeySerializer::with_capacity(9);
61 serializer.extend_u8(Self::KIND as u8).extend_u64(procedure);
62 serializer.to_encoded_key()
63 }
64
65 fn params_end(procedure: ProcedureId) -> EncodedKey {
66 let mut serializer = KeySerializer::with_capacity(9);
67 serializer.extend_u8(Self::KIND as u8).extend_u64(*procedure - 1);
68 serializer.to_encoded_key()
69 }
70}
71
72#[cfg(test)]
73pub mod tests {
74 use super::{EncodableKey, ProcedureParamKey};
75 use crate::interface::catalog::id::ProcedureId;
76
77 #[test]
78 fn test_encode_decode() {
79 let key = ProcedureParamKey {
80 procedure: ProcedureId::from_raw(0xCAFE),
81 param_index: 7,
82 };
83 let encoded = key.encode();
84 let key = ProcedureParamKey::decode(&encoded).unwrap();
85 assert_eq!(key.procedure, 0xCAFE);
86 assert_eq!(key.param_index, 7);
87 }
88}