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