reifydb_core/key/
mod.rs

1// SPDX-License-Identifier: Apache-2.0
2// Copyright (c) 2026 ReifyDB
3
4use authentication::AuthenticationKey;
5use binding::BindingKey;
6use cdc_consumer::CdcConsumerKey;
7use column::ColumnKey;
8use column_sequence::ColumnSequenceKey;
9use column_snapshot::{ColumnSnapshotKey, SeriesColumnSnapshotKey, TableColumnSnapshotKey};
10use columns::ColumnsKey;
11use dictionary::{DictionaryEntryIndexKey, DictionaryEntryKey, DictionaryKey};
12use flow::FlowKey;
13use granted_role::GrantedRoleKey;
14use handler::HandlerKey;
15use identity::IdentityKey;
16use identity_attribute::IdentityAttributeKey;
17use identity_attribute_value::IdentityAttributeValueKey;
18use index::IndexKey;
19use index_entry::IndexEntryKey;
20use kind::KeyKind;
21use namespace::NamespaceKey;
22use namespace_binding::NamespaceBindingKey;
23use namespace_dictionary::NamespaceDictionaryKey;
24use namespace_flow::NamespaceFlowKey;
25use namespace_handler::NamespaceHandlerKey;
26use namespace_procedure::NamespaceProcedureKey;
27use namespace_queue::NamespaceQueueKey;
28use namespace_ringbuffer::NamespaceRingBufferKey;
29use namespace_series::NamespaceSeriesKey;
30use namespace_sink::NamespaceSinkKey;
31use namespace_source::NamespaceSourceKey;
32use namespace_sumtype::NamespaceSumTypeKey;
33use namespace_table::NamespaceTableKey;
34use namespace_view::NamespaceViewKey;
35use operator_state::OperatorStateKey;
36use output_frontier::OutputFrontierKey;
37use partition::PartitionKey;
38use partitioned_row::PartitionedRowKey;
39use policy::PolicyKey;
40use policy_op::PolicyOpKey;
41use primary_key::PrimaryKeyKey;
42use procedure::ProcedureKey;
43use procedure_param::ProcedureParamKey;
44use property::ColumnPropertyKey;
45use queue::QueueKey;
46use queue_deduplication::QueueDeduplicationKey;
47use reifydb_codec::{
48	key as keycode,
49	key::encoded::{EncodedKey, EncodedKeyRange},
50};
51use relationship::RelationshipKey;
52use ringbuffer::{RingBufferKey, RingBufferMetadataKey};
53use role::RoleKey;
54use row::RowKey;
55use row_sequence::RowSequenceKey;
56use series::{SeriesKey, SeriesMetadataKey};
57use sink::SinkKey;
58use source::SourceKey;
59use sumtype::SumTypeKey;
60use system_sequence::SystemSequenceKey;
61use system_version::SystemVersionKey;
62use table::TableKey;
63use token::TokenKey;
64use transaction_version::TransactionVersionKey;
65use version_epoch::VersionEpochKey;
66use view::ViewKey;
67
68pub mod authentication;
69pub mod binding;
70pub mod catalog;
71pub mod cdc_consumer;
72pub mod cdc_exclude;
73pub mod column;
74pub mod column_sequence;
75pub mod column_snapshot;
76pub mod columns;
77pub mod config;
78pub mod dictionary;
79pub mod flow;
80pub mod flow_edge;
81pub mod flow_version;
82pub mod granted_role;
83pub mod handler;
84pub mod identity;
85pub mod identity_attribute;
86pub mod identity_attribute_value;
87pub mod index;
88pub mod index_entry;
89pub mod kind;
90pub mod migration;
91pub mod migration_event;
92pub mod namespace;
93pub mod namespace_binding;
94pub mod namespace_dictionary;
95pub mod namespace_flow;
96pub mod namespace_handler;
97pub mod namespace_procedure;
98pub mod namespace_queue;
99pub mod namespace_ringbuffer;
100pub mod namespace_series;
101pub mod namespace_sink;
102pub mod namespace_source;
103pub mod namespace_sumtype;
104pub mod namespace_table;
105pub mod namespace_view;
106pub mod operator;
107pub mod operator_settings;
108pub mod operator_state;
109pub mod output_frontier;
110pub mod partition;
111pub mod partitioned_row;
112pub mod policy;
113pub mod policy_op;
114pub mod primary_key;
115pub mod procedure;
116pub mod procedure_param;
117pub mod property;
118pub mod queue;
119pub mod queue_deduplication;
120pub mod relationship;
121pub mod ringbuffer;
122pub mod role;
123pub mod row;
124pub mod row_sequence;
125pub mod row_settings;
126pub mod row_shape;
127pub mod series;
128pub mod series_row;
129pub mod sink;
130pub mod source;
131pub mod sumtype;
132pub mod system_sequence;
133pub mod system_version;
134pub mod table;
135pub mod token;
136pub mod transaction_version;
137pub mod variant_handler;
138pub mod version_epoch;
139pub mod view;
140#[derive(Debug)]
141pub enum Key {
142	CdcConsumer(CdcConsumerKey),
143	Namespace(NamespaceKey),
144	NamespaceTable(NamespaceTableKey),
145	NamespaceView(NamespaceViewKey),
146	NamespaceFlow(NamespaceFlowKey),
147	SystemSequence(SystemSequenceKey),
148	Table(TableKey),
149	Flow(FlowKey),
150	Column(ColumnKey),
151	Columns(ColumnsKey),
152	Index(IndexKey),
153	IndexEntry(IndexEntryKey),
154	OperatorState(OperatorStateKey),
155	OutputFrontier(OutputFrontierKey),
156	PrimaryKey(PrimaryKeyKey),
157	Row(RowKey),
158	PartitionedRow(PartitionedRowKey),
159	Partition(PartitionKey),
160	RowSequence(RowSequenceKey),
161	TableColumnSequence(ColumnSequenceKey),
162	TableColumnProperty(ColumnPropertyKey),
163	SystemVersion(SystemVersionKey),
164	TransactionVersion(TransactionVersionKey),
165	VersionEpoch(VersionEpochKey),
166	View(ViewKey),
167	Queue(QueueKey),
168	NamespaceQueue(NamespaceQueueKey),
169	QueueDeduplication(QueueDeduplicationKey),
170	RingBuffer(RingBufferKey),
171	RingBufferMetadata(RingBufferMetadataKey),
172	NamespaceRingBuffer(NamespaceRingBufferKey),
173	Dictionary(DictionaryKey),
174	DictionaryEntry(DictionaryEntryKey),
175	DictionaryEntryIndex(DictionaryEntryIndexKey),
176	NamespaceDictionary(NamespaceDictionaryKey),
177	SumType(SumTypeKey),
178	NamespaceSumType(NamespaceSumTypeKey),
179	Handler(HandlerKey),
180	NamespaceHandler(NamespaceHandlerKey),
181	Series(SeriesKey),
182	SeriesMetadata(SeriesMetadataKey),
183	NamespaceSeries(NamespaceSeriesKey),
184	Identity(IdentityKey),
185	IdentityAttribute(IdentityAttributeKey),
186	IdentityAttributeValue(IdentityAttributeValueKey),
187	Authentication(AuthenticationKey),
188	Role(RoleKey),
189	GrantedRole(GrantedRoleKey),
190	Policy(PolicyKey),
191	PolicyOp(PolicyOpKey),
192	Token(TokenKey),
193	Source(SourceKey),
194	NamespaceSource(NamespaceSourceKey),
195	Sink(SinkKey),
196	NamespaceSink(NamespaceSinkKey),
197	Procedure(ProcedureKey),
198	NamespaceProcedure(NamespaceProcedureKey),
199	ProcedureParam(ProcedureParamKey),
200	Binding(BindingKey),
201	NamespaceBinding(NamespaceBindingKey),
202	ColumnSnapshot(ColumnSnapshotKey),
203	SeriesColumnSnapshot(SeriesColumnSnapshotKey),
204	TableColumnSnapshot(TableColumnSnapshotKey),
205	Relationship(RelationshipKey),
206}
207
208impl Key {
209	pub fn encode(&self) -> EncodedKey {
210		match &self {
211			Key::CdcConsumer(key) => key.encode(),
212			Key::Namespace(key) => key.encode(),
213			Key::NamespaceTable(key) => key.encode(),
214			Key::NamespaceView(key) => key.encode(),
215			Key::NamespaceFlow(key) => key.encode(),
216			Key::Table(key) => key.encode(),
217			Key::Flow(key) => key.encode(),
218			Key::Column(key) => key.encode(),
219			Key::Columns(key) => key.encode(),
220			Key::TableColumnProperty(key) => key.encode(),
221			Key::Index(key) => key.encode(),
222			Key::IndexEntry(key) => key.encode(),
223			Key::OperatorState(key) => key.encode(),
224			Key::OutputFrontier(key) => key.encode(),
225			Key::PrimaryKey(key) => key.encode(),
226			Key::Row(key) => key.encode(),
227			Key::PartitionedRow(key) => key.encode(),
228			Key::Partition(key) => key.encode(),
229			Key::RowSequence(key) => key.encode(),
230			Key::TableColumnSequence(key) => key.encode(),
231			Key::SystemSequence(key) => key.encode(),
232			Key::SystemVersion(key) => key.encode(),
233			Key::TransactionVersion(key) => key.encode(),
234			Key::VersionEpoch(key) => key.encode(),
235			Key::View(key) => key.encode(),
236			Key::Queue(key) => key.encode(),
237			Key::NamespaceQueue(key) => key.encode(),
238			Key::QueueDeduplication(key) => key.encode(),
239			Key::RingBuffer(key) => key.encode(),
240			Key::RingBufferMetadata(key) => key.encode(),
241			Key::NamespaceRingBuffer(key) => key.encode(),
242			Key::Dictionary(key) => key.encode(),
243			Key::DictionaryEntry(key) => key.encode(),
244			Key::DictionaryEntryIndex(key) => key.encode(),
245			Key::NamespaceDictionary(key) => key.encode(),
246			Key::SumType(key) => key.encode(),
247			Key::NamespaceSumType(key) => key.encode(),
248			Key::Handler(key) => key.encode(),
249			Key::NamespaceHandler(key) => key.encode(),
250			Key::Series(key) => key.encode(),
251			Key::SeriesMetadata(key) => key.encode(),
252			Key::NamespaceSeries(key) => key.encode(),
253			Key::Identity(key) => key.encode(),
254			Key::IdentityAttribute(key) => key.encode(),
255			Key::IdentityAttributeValue(key) => key.encode(),
256			Key::Authentication(key) => key.encode(),
257			Key::Role(key) => key.encode(),
258			Key::GrantedRole(key) => key.encode(),
259			Key::Policy(key) => key.encode(),
260			Key::PolicyOp(key) => key.encode(),
261			Key::Token(key) => key.encode(),
262			Key::Source(key) => key.encode(),
263			Key::NamespaceSource(key) => key.encode(),
264			Key::Sink(key) => key.encode(),
265			Key::NamespaceSink(key) => key.encode(),
266			Key::Procedure(key) => key.encode(),
267			Key::NamespaceProcedure(key) => key.encode(),
268			Key::ProcedureParam(key) => key.encode(),
269			Key::Binding(key) => key.encode(),
270			Key::NamespaceBinding(key) => key.encode(),
271			Key::ColumnSnapshot(key) => key.encode(),
272			Key::SeriesColumnSnapshot(key) => key.encode(),
273			Key::TableColumnSnapshot(key) => key.encode(),
274			Key::Relationship(key) => key.encode(),
275		}
276	}
277}
278
279pub trait EncodableKey {
280	const KIND: KeyKind;
281
282	fn encode(&self) -> EncodedKey;
283
284	fn decode(key: &EncodedKey) -> Option<Self>
285	where
286		Self: Sized;
287}
288
289pub trait EncodableKeyRange {
290	const KIND: KeyKind;
291
292	fn start(&self) -> Option<EncodedKey>;
293
294	fn end(&self) -> Option<EncodedKey>;
295
296	fn decode(range: &EncodedKeyRange) -> (Option<Self>, Option<Self>)
297	where
298		Self: Sized;
299}
300
301impl Key {
302	pub fn kind(key: impl AsRef<[u8]>) -> Option<KeyKind> {
303		let key = key.as_ref();
304		if key.is_empty() {
305			return None;
306		}
307
308		keycode::deserialize(&key[0..1]).ok()
309	}
310
311	pub fn decode(key: &EncodedKey) -> Option<Self> {
312		if key.is_empty() {
313			return None;
314		}
315
316		let kind: KeyKind = keycode::deserialize(&key[0..1]).ok()?;
317		match kind {
318			KeyKind::CdcConsumer => CdcConsumerKey::decode(key).map(Self::CdcConsumer),
319			KeyKind::Columns => ColumnsKey::decode(key).map(Self::Columns),
320			KeyKind::ColumnProperty => ColumnPropertyKey::decode(key).map(Self::TableColumnProperty),
321			KeyKind::Namespace => NamespaceKey::decode(key).map(Self::Namespace),
322			KeyKind::NamespaceTable => NamespaceTableKey::decode(key).map(Self::NamespaceTable),
323			KeyKind::NamespaceView => NamespaceViewKey::decode(key).map(Self::NamespaceView),
324			KeyKind::NamespaceFlow => NamespaceFlowKey::decode(key).map(Self::NamespaceFlow),
325			KeyKind::Table => TableKey::decode(key).map(Self::Table),
326			KeyKind::Flow => FlowKey::decode(key).map(Self::Flow),
327			KeyKind::Column => ColumnKey::decode(key).map(Self::Column),
328			KeyKind::Index => IndexKey::decode(key).map(Self::Index),
329			KeyKind::IndexEntry => IndexEntryKey::decode(key).map(Self::IndexEntry),
330			KeyKind::OperatorState => OperatorStateKey::decode(key).map(Self::OperatorState),
331			KeyKind::OutputFrontier => OutputFrontierKey::decode(key).map(Self::OutputFrontier),
332			KeyKind::Row => RowKey::decode(key).map(Self::Row),
333			KeyKind::PartitionedRow => PartitionedRowKey::decode(key).map(Self::PartitionedRow),
334			KeyKind::Partition => PartitionKey::decode(key).map(Self::Partition),
335			KeyKind::RowSequence => RowSequenceKey::decode(key).map(Self::RowSequence),
336			KeyKind::ColumnSequence => ColumnSequenceKey::decode(key).map(Self::TableColumnSequence),
337			KeyKind::SystemSequence => SystemSequenceKey::decode(key).map(Self::SystemSequence),
338			KeyKind::SystemVersion => SystemVersionKey::decode(key).map(Self::SystemVersion),
339			KeyKind::TransactionVersion => TransactionVersionKey::decode(key).map(Self::TransactionVersion),
340			KeyKind::VersionEpoch => VersionEpochKey::decode(key).map(Self::VersionEpoch),
341			KeyKind::View => ViewKey::decode(key).map(Self::View),
342			KeyKind::PrimaryKey => PrimaryKeyKey::decode(key).map(Self::PrimaryKey),
343			KeyKind::Queue => QueueKey::decode(key).map(Self::Queue),
344			KeyKind::NamespaceQueue => NamespaceQueueKey::decode(key).map(Self::NamespaceQueue),
345			KeyKind::QueueDeduplication => QueueDeduplicationKey::decode(key).map(Self::QueueDeduplication),
346			KeyKind::RingBuffer => RingBufferKey::decode(key).map(Self::RingBuffer),
347			KeyKind::RingBufferMetadata => RingBufferMetadataKey::decode(key).map(Self::RingBufferMetadata),
348			KeyKind::NamespaceRingBuffer => {
349				NamespaceRingBufferKey::decode(key).map(Self::NamespaceRingBuffer)
350			}
351			KeyKind::Operator
352			| KeyKind::OperatorByFlow
353			| KeyKind::FlowEdge
354			| KeyKind::FlowEdgeByFlow
355			| KeyKind::FlowVersion => None,
356			KeyKind::Dictionary => DictionaryKey::decode(key).map(Self::Dictionary),
357			KeyKind::DictionaryEntry => DictionaryEntryKey::decode(key).map(Self::DictionaryEntry),
358			KeyKind::DictionaryEntryIndex => {
359				DictionaryEntryIndexKey::decode(key).map(Self::DictionaryEntryIndex)
360			}
361			KeyKind::NamespaceDictionary => {
362				NamespaceDictionaryKey::decode(key).map(Self::NamespaceDictionary)
363			}
364			KeyKind::SumType => SumTypeKey::decode(key).map(Self::SumType),
365			KeyKind::NamespaceSumType => NamespaceSumTypeKey::decode(key).map(Self::NamespaceSumType),
366			KeyKind::Handler => HandlerKey::decode(key).map(Self::Handler),
367			KeyKind::NamespaceHandler => NamespaceHandlerKey::decode(key).map(Self::NamespaceHandler),
368			KeyKind::VariantHandler => None,
369			KeyKind::Metric => None,
370			KeyKind::Subscription | KeyKind::SubscriptionColumn | KeyKind::SubscriptionRow => None,
371			KeyKind::RowShape | KeyKind::RowShapeField => None,
372			KeyKind::Series => SeriesKey::decode(key).map(Self::Series),
373			KeyKind::NamespaceSeries => NamespaceSeriesKey::decode(key).map(Self::NamespaceSeries),
374			KeyKind::SeriesMetadata => SeriesMetadataKey::decode(key).map(Self::SeriesMetadata),
375			KeyKind::Identity => IdentityKey::decode(key).map(Self::Identity),
376			KeyKind::IdentityAttribute => IdentityAttributeKey::decode(key).map(Self::IdentityAttribute),
377			KeyKind::IdentityAttributeValue => {
378				IdentityAttributeValueKey::decode(key).map(Self::IdentityAttributeValue)
379			}
380			KeyKind::Authentication => AuthenticationKey::decode(key).map(Self::Authentication),
381			KeyKind::Role => RoleKey::decode(key).map(Self::Role),
382			KeyKind::GrantedRole => GrantedRoleKey::decode(key).map(Self::GrantedRole),
383			KeyKind::Policy => PolicyKey::decode(key).map(Self::Policy),
384			KeyKind::PolicyOp => PolicyOpKey::decode(key).map(Self::PolicyOp),
385			KeyKind::Migration | KeyKind::MigrationEvent => None,
386			KeyKind::Token => TokenKey::decode(key).map(Self::Token),
387			KeyKind::ConfigStorage => None,
388			KeyKind::Source
389			| KeyKind::NamespaceSource
390			| KeyKind::Sink
391			| KeyKind::NamespaceSink
392			| KeyKind::SourceCheckpoint => None,
393			KeyKind::RowSettings => None,
394			KeyKind::OperatorSettings => None,
395			KeyKind::Procedure => ProcedureKey::decode(key).map(Self::Procedure),
396			KeyKind::NamespaceProcedure => NamespaceProcedureKey::decode(key).map(Self::NamespaceProcedure),
397			KeyKind::ProcedureParam => ProcedureParamKey::decode(key).map(Self::ProcedureParam),
398			KeyKind::Binding => BindingKey::decode(key).map(Self::Binding),
399			KeyKind::NamespaceBinding => None,
400			KeyKind::ColumnSnapshot => ColumnSnapshotKey::decode(key).map(Self::ColumnSnapshot),
401			KeyKind::SeriesColumnSnapshot => {
402				SeriesColumnSnapshotKey::decode(key).map(Self::SeriesColumnSnapshot)
403			}
404			KeyKind::TableColumnSnapshot => {
405				TableColumnSnapshotKey::decode(key).map(Self::TableColumnSnapshot)
406			}
407			KeyKind::Relationship => RelationshipKey::decode(key).map(Self::Relationship),
408		}
409	}
410}
411
412#[cfg(test)]
413pub mod tests {
414	use reifydb_value::value::{row_number::RowNumber, sumtype::SumTypeId};
415
416	use crate::{
417		interface::catalog::{
418			flow::OperatorId,
419			id::{ColumnId, ColumnPropertyId, IndexId, NamespaceId, RelationshipId, SequenceId, TableId},
420			object::ObjectId,
421			storage::StorageId,
422		},
423		key::{
424			Key,
425			column::ColumnKey,
426			column_sequence::ColumnSequenceKey,
427			columns::ColumnsKey,
428			index::IndexKey,
429			namespace::NamespaceKey,
430			namespace_sumtype::NamespaceSumTypeKey,
431			namespace_table::NamespaceTableKey,
432			operator_state::{GroupId, Keyspace, OperatorStateKey},
433			property::ColumnPropertyKey,
434			relationship::RelationshipKey,
435			row::RowKey,
436			row_sequence::RowSequenceKey,
437			sumtype::SumTypeKey,
438			system_sequence::SystemSequenceKey,
439			table::TableKey,
440			transaction_version::TransactionVersionKey,
441		},
442	};
443
444	#[test]
445	fn test_table_columns() {
446		let key = Key::Columns(ColumnsKey {
447			column: ColumnId(42),
448		});
449
450		let encoded = key.encode();
451		let decoded = Key::decode(&encoded).expect("Failed to decode key");
452
453		match decoded {
454			Key::Columns(decoded_inner) => {
455				assert_eq!(decoded_inner.column, 42);
456			}
457			_ => unreachable!(),
458		}
459	}
460
461	#[test]
462	fn test_column() {
463		let key = Key::Column(ColumnKey {
464			object: ObjectId::table(1),
465			column: ColumnId(42),
466		});
467
468		let encoded = key.encode();
469		let decoded = Key::decode(&encoded).expect("Failed to decode key");
470
471		match decoded {
472			Key::Column(decoded_inner) => {
473				assert_eq!(decoded_inner.object, ObjectId::table(1));
474				assert_eq!(decoded_inner.column, 42);
475			}
476			_ => unreachable!(),
477		}
478	}
479
480	#[test]
481	fn test_column_property() {
482		let key = Key::TableColumnProperty(ColumnPropertyKey {
483			column: ColumnId(42),
484			property: ColumnPropertyId(999_999),
485		});
486
487		let encoded = key.encode();
488		let decoded = Key::decode(&encoded).expect("Failed to decode key");
489
490		match decoded {
491			Key::TableColumnProperty(decoded_inner) => {
492				assert_eq!(decoded_inner.column, 42);
493				assert_eq!(decoded_inner.property, 999_999);
494			}
495			_ => unreachable!(),
496		}
497	}
498
499	#[test]
500	fn test_namespace() {
501		let key = Key::Namespace(NamespaceKey {
502			namespace: NamespaceId(42),
503		});
504
505		let encoded = key.encode();
506		let decoded = Key::decode(&encoded).expect("Failed to decode key");
507
508		match decoded {
509			Key::Namespace(decoded_inner) => {
510				assert_eq!(decoded_inner.namespace, 42);
511			}
512			_ => unreachable!(),
513		}
514	}
515
516	#[test]
517	fn test_namespace_table() {
518		let key = Key::NamespaceTable(NamespaceTableKey {
519			namespace: NamespaceId(42),
520			table: TableId(999_999),
521		});
522
523		let encoded = key.encode();
524		let decoded = Key::decode(&encoded).expect("Failed to decode key");
525
526		match decoded {
527			Key::NamespaceTable(decoded_inner) => {
528				assert_eq!(decoded_inner.namespace, 42);
529				assert_eq!(decoded_inner.table, 999_999);
530			}
531			_ => unreachable!(),
532		}
533	}
534
535	#[test]
536	fn test_system_sequence() {
537		let key = Key::SystemSequence(SystemSequenceKey {
538			sequence: SequenceId(42),
539		});
540
541		let encoded = key.encode();
542		let decoded = Key::decode(&encoded).expect("Failed to decode key");
543
544		match decoded {
545			Key::SystemSequence(decoded_inner) => {
546				assert_eq!(decoded_inner.sequence, 42);
547			}
548			_ => unreachable!(),
549		}
550	}
551
552	#[test]
553	fn test_table() {
554		let key = Key::Table(TableKey {
555			table: TableId(42),
556		});
557
558		let encoded = key.encode();
559		let decoded = Key::decode(&encoded).expect("Failed to decode key");
560
561		match decoded {
562			Key::Table(decoded_inner) => {
563				assert_eq!(decoded_inner.table, 42);
564			}
565			_ => unreachable!(),
566		}
567	}
568
569	#[test]
570	fn test_index() {
571		let key = Key::Index(IndexKey {
572			object: ObjectId::table(42),
573			index: IndexId::primary(999_999),
574		});
575
576		let encoded = key.encode();
577		let decoded = Key::decode(&encoded).expect("Failed to decode key");
578
579		match decoded {
580			Key::Index(decoded_inner) => {
581				assert_eq!(decoded_inner.object, ObjectId::table(42));
582				assert_eq!(decoded_inner.index, 999_999);
583			}
584			_ => unreachable!(),
585		}
586	}
587
588	#[test]
589	fn test_row() {
590		let key = Key::Row(RowKey {
591			storage: StorageId::table(42),
592			row: RowNumber(999_999),
593		});
594
595		let encoded = key.encode();
596		let decoded = Key::decode(&encoded).expect("Failed to decode key");
597
598		match decoded {
599			Key::Row(decoded_inner) => {
600				assert_eq!(decoded_inner.storage, StorageId::table(42));
601				assert_eq!(decoded_inner.row, 999_999);
602			}
603			_ => unreachable!(),
604		}
605	}
606
607	#[test]
608	fn test_row_sequence() {
609		let key = Key::RowSequence(RowSequenceKey {
610			object: ObjectId::table(42),
611		});
612
613		let encoded = key.encode();
614		let decoded = Key::decode(&encoded).expect("Failed to decode key");
615
616		match decoded {
617			Key::RowSequence(decoded_inner) => {
618				assert_eq!(decoded_inner.object, ObjectId::table(42));
619			}
620			_ => unreachable!(),
621		}
622	}
623
624	#[test]
625	fn test_column_sequence() {
626		let key = Key::TableColumnSequence(ColumnSequenceKey {
627			object: ObjectId::table(42),
628			column: ColumnId(123),
629		});
630
631		let encoded = key.encode();
632		let decoded = Key::decode(&encoded).expect("Failed to decode key");
633
634		match decoded {
635			Key::TableColumnSequence(decoded_inner) => {
636				assert_eq!(decoded_inner.object, ObjectId::table(42));
637				assert_eq!(decoded_inner.column, 123);
638			}
639			_ => unreachable!(),
640		}
641	}
642
643	#[test]
644	fn test_transaction_version() {
645		let key = Key::TransactionVersion(TransactionVersionKey {});
646		let encoded = key.encode();
647		Key::decode(&encoded).expect("Failed to decode key");
648	}
649
650	#[test]
651	fn test_operator_state() {
652		let key = Key::OperatorState(OperatorStateKey {
653			operator: OperatorId(0xCAFEBABE),
654			group: GroupId::ROOT,
655			keyspace: Keyspace::CUSTOM,
656			suffix: vec![1, 2, 3],
657		});
658
659		let encoded = key.encode();
660		let decoded = Key::decode(&encoded).expect("Failed to decode key");
661
662		match decoded {
663			Key::OperatorState(decoded_inner) => {
664				assert_eq!(decoded_inner.operator, 0xCAFEBABE);
665				assert_eq!(decoded_inner.suffix, vec![1, 2, 3]);
666			}
667			_ => unreachable!(),
668		}
669	}
670
671	#[test]
672	fn test_sumtype_key() {
673		let key = Key::SumType(SumTypeKey {
674			sumtype: SumTypeId(42),
675		});
676
677		let encoded = key.encode();
678		let decoded = Key::decode(&encoded).expect("Failed to decode key");
679
680		match decoded {
681			Key::SumType(decoded_inner) => {
682				assert_eq!(decoded_inner.sumtype, 42);
683			}
684			_ => unreachable!(),
685		}
686	}
687
688	#[test]
689	fn test_relationship() {
690		let key = Key::Relationship(RelationshipKey {
691			relationship: RelationshipId(42),
692		});
693
694		let encoded = key.encode();
695		let decoded = Key::decode(&encoded).expect("Failed to decode key");
696
697		match decoded {
698			Key::Relationship(decoded_inner) => {
699				assert_eq!(decoded_inner.relationship, 42);
700			}
701			_ => unreachable!(),
702		}
703	}
704
705	#[test]
706	fn test_namespace_sumtype_key() {
707		let key = Key::NamespaceSumType(NamespaceSumTypeKey {
708			namespace: NamespaceId(42),
709			sumtype: SumTypeId(999_999),
710		});
711
712		let encoded = key.encode();
713		let decoded = Key::decode(&encoded).expect("Failed to decode key");
714
715		match decoded {
716			Key::NamespaceSumType(decoded_inner) => {
717				assert_eq!(decoded_inner.namespace, 42);
718				assert_eq!(decoded_inner.sumtype, 999_999);
719			}
720			_ => unreachable!(),
721		}
722	}
723}
reifydb_core/key/mod.rs

reifydb_core/key/
mod.rs
