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