Skip to main content

reifydb_export/
model.rs

1// SPDX-License-Identifier: Apache-2.0
2// Copyright (c) 2026 ReifyDB
3
4use std::collections::HashMap;
5
6use reifydb_core::interface::catalog::{
7	dictionary::Dictionary, namespace::Namespace, queue::Queue, ringbuffer::RingBuffer, series::Series,
8	sumtype::SumType, table::Table,
9};
10use reifydb_value::value::{Value, value_type::ValueType};
11
12pub struct ObjectRows {
13	pub columns: Vec<String>,
14	pub rows: Vec<Vec<Value>>,
15}
16
17pub struct TableExport {
18	pub table: Table,
19	pub rows: Option<ObjectRows>,
20}
21
22pub struct QueueExport {
23	pub queue: Queue,
24}
25
26pub struct RingBufferExport {
27	pub ringbuffer: RingBuffer,
28	pub rows: Option<ObjectRows>,
29}
30
31pub struct SeriesExport {
32	pub series: Series,
33	pub rows: Option<ObjectRows>,
34}
35
36pub struct ExportModel {
37	pub namespaces: Vec<Namespace>,
38	pub sumtypes: Vec<SumType>,
39	pub dictionaries: Vec<Dictionary>,
40	pub tables: Vec<TableExport>,
41	pub ringbuffers: Vec<RingBufferExport>,
42	pub queues: Vec<QueueExport>,
43	pub series: Vec<SeriesExport>,
44	pub resolver: NameResolver,
45}
46
47pub struct NameResolver {
48	pub namespaces: HashMap<u64, String>,
49	pub dictionaries: HashMap<u64, ResolvedDictionary>,
50	pub sumtypes: HashMap<u64, ResolvedSumType>,
51}
52
53pub struct ResolvedDictionary {
54	pub qualified_name: String,
55	pub value_type: ValueType,
56}
57
58pub struct ResolvedSumType {
59	pub qualified_name: String,
60	pub variants: Vec<ResolvedVariant>,
61}
62
63pub struct ResolvedVariant {
64	pub tag: u8,
65	pub name: String,
66	pub fields: Vec<String>,
67}
68
69impl NameResolver {
70	pub fn empty() -> Self {
71		Self {
72			namespaces: HashMap::new(),
73			dictionaries: HashMap::new(),
74			sumtypes: HashMap::new(),
75		}
76	}
77
78	pub fn dictionary(&self, id: u64) -> Option<&ResolvedDictionary> {
79		self.dictionaries.get(&id)
80	}
81
82	pub fn sumtype(&self, id: u64) -> Option<&ResolvedSumType> {
83		self.sumtypes.get(&id)
84	}
85
86	pub fn sumtype_variant(&self, id: u64, tag: u8) -> Option<&ResolvedVariant> {
87		self.sumtypes.get(&id).and_then(|st| st.variants.iter().find(|v| v.tag == tag))
88	}
89
90	pub fn sumtype_variant_name(&self, id: u64, tag: u8) -> Option<&str> {
91		self.sumtype_variant(id, tag).map(|v| v.name.as_str())
92	}
93}