reifydb_core/interface/catalog/
view.rs1use reifydb_type::value::sumtype::SumTypeId;
5use serde::{Deserialize, Serialize};
6
7use crate::interface::catalog::{
8 column::Column,
9 id::{NamespaceId, RingBufferId, SeriesId, TableId, ViewId},
10 key::PrimaryKey,
11 schema::SchemaId,
12 series::SeriesKey,
13};
14
15#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
16pub enum ViewKind {
17 Deferred,
18 Transactional,
19}
20
21#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
22#[repr(u8)]
23pub enum ViewStorageKind {
24 Table = 1,
25 RingBuffer = 2,
26 Series = 3,
27}
28
29#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
30pub struct TableView {
31 pub id: ViewId,
32 pub namespace: NamespaceId,
33 pub name: String,
34 pub kind: ViewKind,
35 pub columns: Vec<Column>,
36 pub primary_key: Option<PrimaryKey>,
37 pub underlying: TableId,
38}
39
40#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
41pub struct RingBufferView {
42 pub id: ViewId,
43 pub namespace: NamespaceId,
44 pub name: String,
45 pub kind: ViewKind,
46 pub columns: Vec<Column>,
47 pub primary_key: Option<PrimaryKey>,
48 pub underlying: RingBufferId,
49 pub capacity: u64,
50 pub propagate_evictions: bool,
51}
52
53#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
54pub struct SeriesView {
55 pub id: ViewId,
56 pub namespace: NamespaceId,
57 pub name: String,
58 pub kind: ViewKind,
59 pub columns: Vec<Column>,
60 pub primary_key: Option<PrimaryKey>,
61 pub underlying: SeriesId,
62 pub key: SeriesKey,
63 pub tag: Option<SumTypeId>,
64}
65
66#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
67pub enum View {
68 Table(TableView),
69 RingBuffer(RingBufferView),
70 Series(SeriesView),
71}
72
73impl View {
74 pub fn id(&self) -> ViewId {
75 match self {
76 View::Table(t) => t.id,
77 View::RingBuffer(rb) => rb.id,
78 View::Series(s) => s.id,
79 }
80 }
81
82 pub fn namespace(&self) -> NamespaceId {
83 match self {
84 View::Table(t) => t.namespace,
85 View::RingBuffer(rb) => rb.namespace,
86 View::Series(s) => s.namespace,
87 }
88 }
89
90 pub fn name(&self) -> &str {
91 match self {
92 View::Table(t) => &t.name,
93 View::RingBuffer(rb) => &rb.name,
94 View::Series(s) => &s.name,
95 }
96 }
97
98 pub fn kind(&self) -> ViewKind {
99 match self {
100 View::Table(t) => t.kind,
101 View::RingBuffer(rb) => rb.kind,
102 View::Series(s) => s.kind,
103 }
104 }
105
106 pub fn columns(&self) -> &[Column] {
107 match self {
108 View::Table(t) => &t.columns,
109 View::RingBuffer(rb) => &rb.columns,
110 View::Series(s) => &s.columns,
111 }
112 }
113
114 pub fn columns_mut(&mut self) -> &mut Vec<Column> {
115 match self {
116 View::Table(t) => &mut t.columns,
117 View::RingBuffer(rb) => &mut rb.columns,
118 View::Series(s) => &mut s.columns,
119 }
120 }
121
122 pub fn primary_key(&self) -> Option<&PrimaryKey> {
123 match self {
124 View::Table(t) => t.primary_key.as_ref(),
125 View::RingBuffer(rb) => rb.primary_key.as_ref(),
126 View::Series(s) => s.primary_key.as_ref(),
127 }
128 }
129
130 pub fn storage_kind(&self) -> ViewStorageKind {
131 match self {
132 View::Table(_) => ViewStorageKind::Table,
133 View::RingBuffer(_) => ViewStorageKind::RingBuffer,
134 View::Series(_) => ViewStorageKind::Series,
135 }
136 }
137
138 pub fn underlying_id(&self) -> SchemaId {
143 match self {
144 View::Table(t) => SchemaId::Table(t.underlying),
145 View::RingBuffer(rb) => SchemaId::RingBuffer(rb.underlying),
146 View::Series(s) => SchemaId::Series(s.underlying),
147 }
148 }
149
150 pub fn set_name(&mut self, new_name: String) {
151 match self {
152 View::Table(t) => t.name = new_name,
153 View::RingBuffer(rb) => rb.name = new_name,
154 View::Series(s) => s.name = new_name,
155 }
156 }
157
158 pub fn set_namespace(&mut self, new_namespace: NamespaceId) {
159 match self {
160 View::Table(t) => t.namespace = new_namespace,
161 View::RingBuffer(rb) => rb.namespace = new_namespace,
162 View::Series(s) => s.namespace = new_namespace,
163 }
164 }
165}