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