reifydb-catalog 0.4.9

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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

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

use std::sync::Arc;

use reifydb_core::{
	interface::catalog::vtable::VTable,
	value::column::{Column, columns::Columns, data::ColumnData},
};
use reifydb_metric_old::metric::MetricReader;
use reifydb_store_single::SingleStore;
use reifydb_transaction::transaction::Transaction;
use reifydb_type::fragment::Fragment;

use crate::{
	Result,
	system::SystemCatalog,
	vtable::{BaseVTable, Batch, VTableContext},
};

/// Virtual table that exposes storage statistics for indexes
///
/// Note: Index storage is tracked at the KeyKind level, not per-individual-index.
/// This table currently returns empty results. Per-index tracking may be added
/// in a future enhancement.
pub struct SystemIndexStorageStats {
	pub(crate) vtable: Arc<VTable>,
	exhausted: bool,
	#[allow(dead_code)]
	stats_reader: MetricReader<SingleStore>,
}

impl SystemIndexStorageStats {
	pub fn new(stats_reader: MetricReader<SingleStore>) -> Self {
		Self {
			vtable: SystemCatalog::get_system_index_storage_stats_table().clone(),
			exhausted: false,
			stats_reader,
		}
	}
}

impl BaseVTable for SystemIndexStorageStats {
	fn initialize(&mut self, _txn: &mut Transaction<'_>, _ctx: VTableContext) -> Result<()> {
		self.exhausted = false;
		Ok(())
	}

	fn next(&mut self, _txn: &mut Transaction<'_>) -> Result<Option<Batch>> {
		if self.exhausted {
			return Ok(None);
		}

		// Index storage is tracked at the KeyKind level (KeyKind::Index, KeyKind::IndexEntry)
		// not at the per-index level. Per-index tracking would require parsing index keys
		// to extract IndexId, which is not currently implemented.
		//
		// Return empty result for now - this can be enhanced in the future to provide
		// aggregate stats by KeyKind or by implementing per-index Id tracking.

		let columns = vec![
			Column {
				name: Fragment::internal("id"),
				data: ColumnData::uint8_with_capacity(0),
			},
			Column {
				name: Fragment::internal("table_id"),
				data: ColumnData::uint8_with_capacity(0),
			},
			Column {
				name: Fragment::internal("tier"),
				data: ColumnData::utf8_with_capacity(0),
			},
			Column {
				name: Fragment::internal("current_key_bytes"),
				data: ColumnData::uint8_with_capacity(0),
			},
			Column {
				name: Fragment::internal("current_value_bytes"),
				data: ColumnData::uint8_with_capacity(0),
			},
			Column {
				name: Fragment::internal("current_total_bytes"),
				data: ColumnData::uint8_with_capacity(0),
			},
			Column {
				name: Fragment::internal("current_count"),
				data: ColumnData::uint8_with_capacity(0),
			},
			Column {
				name: Fragment::internal("historical_key_bytes"),
				data: ColumnData::uint8_with_capacity(0),
			},
			Column {
				name: Fragment::internal("historical_value_bytes"),
				data: ColumnData::uint8_with_capacity(0),
			},
			Column {
				name: Fragment::internal("historical_total_bytes"),
				data: ColumnData::uint8_with_capacity(0),
			},
			Column {
				name: Fragment::internal("historical_count"),
				data: ColumnData::uint8_with_capacity(0),
			},
			Column {
				name: Fragment::internal("total_bytes"),
				data: ColumnData::uint8_with_capacity(0),
			},
			Column {
				name: Fragment::internal("cdc_key_bytes"),
				data: ColumnData::uint8_with_capacity(0),
			},
			Column {
				name: Fragment::internal("cdc_value_bytes"),
				data: ColumnData::uint8_with_capacity(0),
			},
			Column {
				name: Fragment::internal("cdc_total_bytes"),
				data: ColumnData::uint8_with_capacity(0),
			},
			Column {
				name: Fragment::internal("cdc_count"),
				data: ColumnData::uint8_with_capacity(0),
			},
		];

		self.exhausted = true;
		Ok(Some(Batch {
			columns: Columns::new(columns),
		}))
	}

	fn vtable(&self) -> &VTable {
		&self.vtable
	}
}