uqa_execution/catalog/read/
production.rs1use super::{CatalogReadView, CatalogTableSnapshot, RelationNameResolution, SQLError};
10use uqa_core::{
11 memory::{Produced, ProductionControl},
12 RelationName, RelationReference,
13};
14
15mod hierarchy;
16
17impl CatalogReadView {
18 pub fn sequence_exists_with_control(
20 &self,
21 resolution: &RelationNameResolution,
22 name: &str,
23 control: &ProductionControl<'_>,
24 ) -> Result<bool, SQLError> {
25 let candidates = self
26 .relation_names()
27 .relation_lookup_candidates_with_control(resolution, name, control)?;
28 for relation in candidates.iter() {
29 control.check()?;
30 if self.snapshot.definitions.sequences.contains_key(relation) {
31 return Ok(true);
32 }
33 if self.relation_exists(relation) {
34 return Ok(false);
35 }
36 }
37 Ok(false)
38 }
39
40 pub fn virtual_relation_resolved_with_control(
41 &self,
42 resolution: &RelationNameResolution,
43 name: &str,
44 control: &ProductionControl<'_>,
45 ) -> Result<Option<uqa_sql::catalog::VirtualRelation>, SQLError> {
46 let candidates = self
47 .relation_names()
48 .relation_lookup_candidates_with_control(resolution, name, control)?;
49 for relation in candidates.iter() {
50 control.check()?;
51 if let Some(relation) =
52 uqa_sql::catalog::VirtualRelation::at(&relation.schema, &relation.name)
53 {
54 return Ok(Some(relation));
55 }
56 if self.relation_exists(relation) {
57 return Ok(None);
58 }
59 }
60 Ok(None)
61 }
62
63 pub fn view_resolved_with_control(
64 &self,
65 resolution: &RelationNameResolution,
66 name: &str,
67 control: &ProductionControl<'_>,
68 ) -> Result<Option<&crate::catalog::view::StoredView>, SQLError> {
69 let candidates = self
70 .relation_names()
71 .relation_lookup_candidates_with_control(resolution, name, control)?;
72 for relation in candidates.iter() {
73 control.check()?;
74 if let Some(view) = self.snapshot.definitions.views.get(relation) {
75 return Ok(Some(view));
76 }
77 if self.relation_exists(relation) {
78 return Ok(None);
79 }
80 }
81 Ok(None)
82 }
83
84 pub fn view_name_resolved_with_control(
85 &self,
86 resolution: &RelationNameResolution,
87 name: &str,
88 control: &ProductionControl<'_>,
89 ) -> Result<Option<Produced<String>>, SQLError> {
90 let candidates = self
91 .relation_names()
92 .relation_lookup_candidates_with_control(resolution, name, control)?;
93 for relation in candidates.iter() {
94 control.check()?;
95 if self.snapshot.definitions.views.contains_key(relation) {
96 return Ok(Some(relation.qualified_name_with_control(control)?));
97 }
98 if self.relation_exists(relation) {
99 return Ok(None);
100 }
101 }
102 Ok(None)
103 }
104
105 pub fn foreign_table_resolved_with_control(
106 &self,
107 resolution: &RelationNameResolution,
108 name: &str,
109 control: &ProductionControl<'_>,
110 ) -> Result<Option<&crate::catalog::foreign::StoredForeignTable>, SQLError> {
111 let candidates = self
112 .relation_names()
113 .relation_lookup_candidates_with_control(resolution, name, control)?;
114 for relation in candidates.iter() {
115 control.check()?;
116 if let Some(table) = self.snapshot.definitions.foreign_tables.get(relation) {
117 return Ok(Some(table));
118 }
119 if self.relation_exists(relation) {
120 return Ok(None);
121 }
122 }
123 Ok(None)
124 }
125 pub fn table_resolved_with_control(
126 &self,
127 resolution: &RelationNameResolution,
128 name: &str,
129 control: &ProductionControl<'_>,
130 ) -> Result<Option<&CatalogTableSnapshot>, SQLError> {
131 let candidates = self
132 .relation_names()
133 .relation_lookup_candidates_with_control(resolution, name, control)?;
134 for relation in candidates.iter() {
135 control.check()?;
136 if let Some(table) = self.snapshot.tables.get(relation) {
137 return Ok(Some(table));
138 }
139 if self.relation_exists(relation) {
140 return Ok(None);
141 }
142 }
143 Ok(None)
144 }
145
146 pub fn table_name_resolved_with_control(
147 &self,
148 resolution: &RelationNameResolution,
149 name: &str,
150 control: &ProductionControl<'_>,
151 ) -> Result<Option<Produced<String>>, SQLError> {
152 let candidates = self
153 .relation_names()
154 .relation_lookup_candidates_with_control(resolution, name, control)?;
155 for relation in candidates.iter() {
156 control.check()?;
157 if self.snapshot.tables.contains_key(relation) {
158 return Ok(Some(
159 RelationReference {
160 schema: Some(RelationName::decoded(&relation.schema)),
161 name: RelationName::decoded(&relation.name),
162 }
163 .render_with_control(control)?,
164 ));
165 }
166 if self.relation_exists(relation) {
167 return Ok(None);
168 }
169 }
170 Ok(None)
171 }
172}