Skip to main content

uqa_engine/capabilities/
domains.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bind domain declaration consumers to current namespace, expression, and publication state.
8
9use crate::Engine;
10use uqa_execution::schema::domains::{DomainCreationContext, DomainDeclarationBinding};
11use uqa_sql::catalog::roles::RoleReference;
12use uqa_sql::{ast::CreateDomain, catalog::domain::StoredDomain, SQLError};
13
14impl Engine {
15    pub(crate) fn domain_alter_context(
16        &self,
17    ) -> uqa_execution::schema::domains::alteration::DomainAlterContext<
18        '_,
19        crate::session::StatementReadSnapshot,
20    > {
21        use uqa_execution::schema::domains::alteration::{
22            DomainAlterContext, DomainValidationInputs,
23        };
24        DomainAlterContext {
25            types: self.type_lifecycle_context(),
26            bindings: self,
27            deletion: self,
28            validation: DomainValidationInputs {
29                catalog: self.catalog_execution(),
30                tables: self,
31                locks: self,
32                identities: self,
33                composites: self,
34                expressions: self,
35                cancellation: self.cancellation_token(),
36            },
37        }
38    }
39
40    pub(crate) fn domain_creation_context(&self) -> DomainCreationContext<'_> {
41        DomainCreationContext {
42            shells: self.shell_completion_context(),
43            creation: self.relation_creation_context(),
44            identities: self.catalog_identity_reservation_context(),
45            writer: self,
46            bindings: self,
47            allocate_identity: || {
48                crate::new_nonzero_catalog_identity("domain", "object identity")
49                    .map_err(|error| SQLError::Internal(error.to_string()))
50            },
51            publication: self,
52            enums: self,
53            composites: self,
54            changes: self,
55        }
56    }
57}
58impl uqa_execution::schema::domains::alteration::DomainConstraintBinding for Engine {
59    fn bind_added_check(
60        &self,
61        definition: &CreateDomain,
62        check: uqa_sql::ast::DomainCheck,
63    ) -> Result<uqa_sql::ast::DomainCheck, SQLError> {
64        let scope = super::query_scope::new_for_catalog_binding(self)?;
65        let binding = uqa_execution::query::binding::binding_context(&scope)?;
66        let names = self
67            .schema_publication_context()
68            .constraint_names()
69            .automatic_names(&definition.name)?;
70        uqa_sql::schema::domains::prepare_added_check(
71            &uqa_sql::schema::SchemaBindingContext {
72                catalog: self,
73                binding: &binding,
74            },
75            definition,
76            check,
77            &names,
78        )
79    }
80    fn bind_added_not_null(
81        &self,
82        definition: &CreateDomain,
83        constraint: uqa_sql::ast::DomainNotNull,
84    ) -> Result<uqa_sql::ast::DomainNotNull, SQLError> {
85        let names = self
86            .schema_publication_context()
87            .constraint_names()
88            .automatic_names(&definition.name)?;
89        uqa_sql::schema::domains::prepare_added_not_null(definition, constraint, &names)
90    }
91}
92impl DomainDeclarationBinding for Engine {
93    fn bind_domain_declaration(&self, definition: &mut CreateDomain) -> Result<(), SQLError> {
94        let scope = super::query_scope::new_for_catalog_binding(self)?;
95        let binding = uqa_execution::query::binding::binding_context(&scope)?;
96        let names = self
97            .schema_publication_context()
98            .constraint_names()
99            .automatic_names(&definition.name)?;
100        uqa_sql::schema::domains::prepare_domain_definition(
101            &uqa_sql::schema::SchemaBindingContext {
102                catalog: self,
103                binding: &binding,
104            },
105            self,
106            definition,
107            &names,
108        )
109    }
110}
111use std::collections::BTreeMap;
112use uqa_execution::schema::domains::dependencies::{
113    DomainDependencyCatalog, DomainDependencyContext, DomainRegistryPublication,
114};
115
116impl Engine {
117    pub(crate) fn domain_dependency_context(&self) -> DomainDependencyContext<'_> {
118        DomainDependencyContext {
119            catalog: self,
120            publication: self,
121            enums: self,
122            composites: self,
123            shells: self,
124            changes: self,
125        }
126    }
127}
128impl DomainDependencyCatalog for Engine {
129    fn domain_definitions(&self) -> BTreeMap<String, StoredDomain> {
130        self.durable.domains.read().clone()
131    }
132}
133impl DomainRegistryPublication for Engine {
134    fn domain_registry(&self) -> uqa_execution::catalog::domain::DomainRegistryRead<'_> {
135        Box::new(self.durable.domains.read())
136    }
137    fn domain_catalog(&self) -> Option<&dyn uqa_storage::CatalogFacade> {
138        self.storage.catalog.as_deref()
139    }
140    fn publish_domain_definitions(
141        &self,
142        registry: BTreeMap<String, StoredDomain>,
143    ) -> Result<(), SQLError> {
144        *self.durable.domains.write() = registry;
145        self.publish_catalog_constraint_tuples()
146    }
147}
148
149use uqa_execution::schema::domains::removal::{DomainDropNotices, DomainRemovalContext};
150use uqa_sql::catalog::security::BoundSchemaSecurity;
151use uqa_sql::schema::domains::removal::{
152    TypeObjectAuthority, TypeObjectBinding, TypeObjectCatalog,
153};
154
155impl Engine {
156    pub(crate) fn domain_removal_context(&self) -> DomainRemovalContext<'_> {
157        DomainRemovalContext {
158            refresh: self,
159            binding: TypeObjectBinding {
160                catalog: self,
161                authority: self,
162                session: self,
163            },
164            deletion: self,
165            notices: self,
166        }
167    }
168}
169impl TypeObjectCatalog for Engine {
170    fn temporary_schema(&self) -> Option<String> {
171        self.temporary_namespace_allocated()
172            .then(|| self.temporary_schema_name())
173    }
174
175    fn shell_by_type_oid(&self, oid: u32) -> Option<uqa_sql::catalog::shell_type::StoredShellType> {
176        self.durable
177            .shells
178            .read()
179            .values()
180            .find(|definition| definition.oid == oid)
181            .cloned()
182    }
183
184    fn schema_security(&self, name: &str) -> Option<BoundSchemaSecurity> {
185        self.schema_security_for_privilege(name)
186    }
187    fn resolve_drop_type_oid(&self, name: &str) -> Result<Option<i64>, SQLError> {
188        uqa_execution::catalog::projection::resolve_type_object_oid(&self.catalog_execution(), name)
189    }
190    fn format_drop_type(&self, oid: i64) -> Result<Option<String>, String> {
191        uqa_execution::catalog::projection::format_type_object(&self.catalog_execution(), oid)
192    }
193    fn enum_by_type_oid(&self, oid: u32) -> Option<uqa_sql::catalog::enum_type::StoredEnum> {
194        self.durable
195            .enums
196            .read()
197            .values()
198            .find(|definition| definition.oid == oid || definition.array_oid == oid)
199            .cloned()
200    }
201    fn composite_by_type_oid(
202        &self,
203        oid: u32,
204    ) -> Option<uqa_sql::catalog::composite_type::StoredComposite> {
205        self.durable
206            .composites
207            .read()
208            .values()
209            .find(|definition| definition.oid == oid || definition.array_oid == oid)
210            .cloned()
211    }
212    fn user_array_element(&self, oid: u32) -> Option<u32> {
213        self.durable.domains.read().values().find_map(|domain| {
214            (uqa_sql::catalog::type_metadata::pg_type_array_oid(&domain.column_type())
215                == i64::from(oid))
216            .then_some(domain.oid)
217        })
218    }
219    fn row_type_relation(
220        &self,
221        oid: u32,
222    ) -> Option<uqa_sql::schema::domains::removal::RowTypeRelation> {
223        uqa_execution::catalog::projection::row_type_relation(&self.catalog_execution(), oid)
224            .ok()
225            .flatten()
226    }
227}
228impl TypeObjectAuthority for Engine {
229    fn schema_usage(&self, schema: &str, role: &RoleReference) -> bool {
230        self.schema_has_privilege_for_role(
231            schema,
232            role,
233            uqa_sql::catalog::security::schema::SchemaAclPrivilege::Usage,
234        )
235    }
236    fn current_user_has_role_privileges(
237        &self,
238        role: &dyn uqa_sql::catalog::roles::identity::RoleSubject,
239    ) -> bool {
240        Engine::current_user_has_role_privileges(self, role)
241    }
242}
243impl DomainDropNotices for Engine {
244    fn domain_drop_notice(&self, notice: uqa_sql::SQLNotice) {
245        self.push_sql_notice(notice);
246    }
247}
248
249impl uqa_execution::schema::domains::alteration::DomainValidationTables for Engine {
250    fn latest_table_snapshot(
251        &self,
252        name: &str,
253    ) -> Result<std::sync::Arc<dyn uqa_execution::query::table_read::TableRead>, SQLError> {
254        let table = self.require_table(name)?;
255        self.detach_query_table(&table, &table, None)
256            .map(|table| table as std::sync::Arc<dyn uqa_execution::query::table_read::TableRead>)
257    }
258}