1use 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}