Skip to main content

uqa_execution/catalog/read/
production.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Selected immutable table metadata shares its catalog owner while candidate and canonical names are admitted.
8
9use super::{CatalogReadView, CatalogTableSnapshot, RelationNameResolution, SQLError};
10use uqa_core::{
11    memory::{Produced, ProductionControl},
12    RelationName, RelationReference,
13};
14
15mod hierarchy;
16
17impl CatalogReadView {
18    /// Analysis selects a declaration without reading runtime sequence positions or security payloads.
19    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}