reifydb-export 0.9.0

Logical export of ReifyDB catalog shapes and row data to RQL scripts
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026 ReifyDB

use std::collections::HashMap;

use reifydb_core::interface::catalog::{
	dictionary::Dictionary, namespace::Namespace, queue::Queue, ringbuffer::RingBuffer, series::Series,
	sumtype::SumType, table::Table,
};
use reifydb_value::value::{Value, value_type::ValueType};

pub struct ObjectRows {
	pub columns: Vec<String>,
	pub rows: Vec<Vec<Value>>,
}

pub struct TableExport {
	pub table: Table,
	pub rows: Option<ObjectRows>,
}

pub struct QueueExport {
	pub queue: Queue,
}

pub struct RingBufferExport {
	pub ringbuffer: RingBuffer,
	pub rows: Option<ObjectRows>,
}

pub struct SeriesExport {
	pub series: Series,
	pub rows: Option<ObjectRows>,
}

pub struct ExportModel {
	pub namespaces: Vec<Namespace>,
	pub sumtypes: Vec<SumType>,
	pub dictionaries: Vec<Dictionary>,
	pub tables: Vec<TableExport>,
	pub ringbuffers: Vec<RingBufferExport>,
	pub queues: Vec<QueueExport>,
	pub series: Vec<SeriesExport>,
	pub resolver: NameResolver,
}

pub struct NameResolver {
	pub namespaces: HashMap<u64, String>,
	pub dictionaries: HashMap<u64, ResolvedDictionary>,
	pub sumtypes: HashMap<u64, ResolvedSumType>,
}

pub struct ResolvedDictionary {
	pub qualified_name: String,
	pub value_type: ValueType,
}

pub struct ResolvedSumType {
	pub qualified_name: String,
	pub variants: Vec<ResolvedVariant>,
}

pub struct ResolvedVariant {
	pub tag: u8,
	pub name: String,
	pub fields: Vec<String>,
}

impl NameResolver {
	pub fn empty() -> Self {
		Self {
			namespaces: HashMap::new(),
			dictionaries: HashMap::new(),
			sumtypes: HashMap::new(),
		}
	}

	pub fn dictionary(&self, id: u64) -> Option<&ResolvedDictionary> {
		self.dictionaries.get(&id)
	}

	pub fn sumtype(&self, id: u64) -> Option<&ResolvedSumType> {
		self.sumtypes.get(&id)
	}

	pub fn sumtype_variant(&self, id: u64, tag: u8) -> Option<&ResolvedVariant> {
		self.sumtypes.get(&id).and_then(|st| st.variants.iter().find(|v| v.tag == tag))
	}

	pub fn sumtype_variant_name(&self, id: u64, tag: u8) -> Option<&str> {
		self.sumtype_variant(id, tag).map(|v| v.name.as_str())
	}
}