Skip to main content

reifydb_core/interface/
identifier.rs

1// SPDX-License-Identifier: Apache-2.0
2// Copyright (c) 2025 ReifyDB
3
4use reifydb_type::fragment::Fragment;
5use serde::{Deserialize, Serialize};
6
7/// Column identifier with schema qualification
8#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9pub struct ColumnIdentifier {
10	pub schema: ColumnSchema,
11	pub name: Fragment,
12}
13
14impl ColumnIdentifier {
15	pub fn with_schema(namespace: Fragment, schema: Fragment, name: Fragment) -> Self {
16		Self {
17			schema: ColumnSchema::Qualified {
18				namespace,
19				name: schema,
20			},
21			name,
22		}
23	}
24
25	pub fn with_alias(alias: Fragment, name: Fragment) -> Self {
26		Self {
27			schema: ColumnSchema::Alias(alias),
28			name,
29		}
30	}
31
32	pub fn into_owned(self) -> ColumnIdentifier {
33		ColumnIdentifier {
34			schema: self.schema,
35			name: self.name,
36		}
37	}
38
39	pub fn to_static(&self) -> ColumnIdentifier {
40		ColumnIdentifier {
41			schema: self.schema.clone(),
42			name: Fragment::internal(self.name.text()),
43		}
44	}
45}
46
47/// How a column is qualified in plans (always fully qualified)
48#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
49pub enum ColumnSchema {
50	/// Fully qualified by namespace.schema
51	Qualified {
52		namespace: Fragment,
53		name: Fragment,
54	},
55	/// Qualified by alias (which maps to a fully qualified schema)
56	Alias(Fragment),
57}
58
59impl ColumnSchema {
60	pub fn into_owned(self) -> ColumnSchema {
61		match self {
62			ColumnSchema::Qualified {
63				namespace,
64				name,
65			} => ColumnSchema::Qualified {
66				namespace,
67				name,
68			},
69			ColumnSchema::Alias(alias) => ColumnSchema::Alias(alias),
70		}
71	}
72
73	pub fn to_static(&self) -> ColumnSchema {
74		match self {
75			ColumnSchema::Qualified {
76				namespace,
77				name,
78			} => ColumnSchema::Qualified {
79				namespace: Fragment::internal(namespace.text()),
80				name: Fragment::internal(name.text()),
81			},
82			ColumnSchema::Alias(alias) => ColumnSchema::Alias(Fragment::internal(alias.text())),
83		}
84	}
85
86	pub fn as_fragment(&self) -> &Fragment {
87		match self {
88			ColumnSchema::Qualified {
89				name,
90				..
91			} => name,
92			ColumnSchema::Alias(alias) => alias,
93		}
94	}
95}