reifydb-catalog 0.4.13

Database catalog and metadata management for ReifyDB
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

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

use reifydb_core::interface::{
	catalog::id::{NamespaceId, RingBufferId, TableId, ViewId},
	resolved::{ResolvedNamespace, ResolvedRingBuffer, ResolvedTable, ResolvedView},
};
use reifydb_transaction::transaction::Transaction;
use reifydb_type::fragment::Fragment;
use tracing::instrument;

use super::Catalog;
use crate::Result;

impl Catalog {
	/// Resolve a namespace ID to a fully resolved namespace with identifier
	#[instrument(name = "catalog::resolve::namespace", level = "trace", skip(self, txn))]
	pub fn resolve_namespace(
		&self,
		txn: &mut Transaction<'_>,
		namespace_id: NamespaceId,
	) -> Result<ResolvedNamespace> {
		let def = self.get_namespace(txn, namespace_id)?;
		let ident = Fragment::internal(def.name());
		Ok(ResolvedNamespace::new(ident, def))
	}

	/// Resolve a table ID to a fully resolved table with namespace and identifiers
	#[instrument(name = "catalog::resolve::table", level = "trace", skip(self, txn))]
	pub fn resolve_table(&self, txn: &mut Transaction<'_>, table_id: TableId) -> Result<ResolvedTable> {
		let table = self.get_table(txn, table_id)?;
		let resolved_namespace = self.resolve_namespace(txn, table.namespace)?;
		let table_ident = Fragment::internal(table.name.clone());

		Ok(ResolvedTable::new(table_ident, resolved_namespace, table))
	}

	/// Resolve a view ID to a fully resolved view with namespace and identifiers
	#[instrument(name = "catalog::resolve::view", level = "trace", skip(self, txn))]
	pub fn resolve_view(&self, txn: &mut Transaction<'_>, view_id: ViewId) -> Result<ResolvedView> {
		let view = self.get_view(txn, view_id)?;
		let resolved_namespace = self.resolve_namespace(txn, view.namespace())?;
		let view_ident = Fragment::internal(view.name());

		Ok(ResolvedView::new(view_ident, resolved_namespace, view))
	}

	/// Resolve a ring buffer ID to a fully resolved ring buffer with namespace and identifiers
	#[instrument(name = "catalog::resolve::ringbuffer", level = "trace", skip(self, txn))]
	pub fn resolve_ringbuffer(
		&self,
		txn: &mut Transaction<'_>,
		ringbuffer_id: RingBufferId,
	) -> Result<ResolvedRingBuffer> {
		let ringbuffer = self.get_ringbuffer(txn, ringbuffer_id)?;
		let resolved_namespace = self.resolve_namespace(txn, ringbuffer.namespace)?;
		let ringbuffer_ident = Fragment::internal(ringbuffer.name.clone());

		Ok(ResolvedRingBuffer::new(ringbuffer_ident, resolved_namespace, ringbuffer))
	}

	/// Resolve column names for a target entity (table, ring buffer, or dictionary) by name.
	pub fn resolve_column_names(
		&self,
		txn: &mut Transaction<'_>,
		namespace_name: &str,
		target_name: &str,
	) -> Result<Vec<String>> {
		let namespace_id = if let Some(ns) = self.find_namespace_by_name(txn, namespace_name)? {
			ns.id()
		} else {
			return Ok(vec![]);
		};

		if let Some(table) = self.find_table_by_name(txn, namespace_id, target_name)? {
			return Ok(table.columns.iter().map(|c| c.name.clone()).collect());
		}

		if let Some(rb_def) = self.find_ringbuffer_by_name(txn, namespace_id, target_name)? {
			return Ok(rb_def.columns.iter().map(|c| c.name.clone()).collect());
		}

		if self.find_dictionary_by_name(txn, namespace_id, target_name)?.is_some() {
			return Ok(vec!["id".to_string(), "value".to_string()]);
		}

		Ok(vec![])
	}
}