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