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 temporary_schema(&self) -> Option<String> {
179 self.temporary_namespace_allocated()
180 .then(|| self.temporary_schema_name())
181 }
182
183 fn shell_by_type_oid(&self, oid: u32) -> Option<uqa_sql::catalog::shell_type::StoredShellType> {
184 self.durable
185 .shells
186 .read()
187 .values()
188 .find(|definition| definition.oid == oid)
189 .cloned()
190 }
191
192 fn schema_security(&self, name: &str) -> Option<BoundSchemaSecurity> {
193 self.schema_security_for_privilege(name)
194 }
195 fn resolve_drop_type_oid(&self, name: &str) -> Result<Option<i64>, SQLError> {
196 uqa_execution::catalog::projection::resolve_type_object_oid(&self.catalog_execution(), name)
197 }
198 fn format_drop_type(&self, oid: i64) -> Result<Option<String>, String> {
199 uqa_execution::catalog::projection::format_type_object(&self.catalog_execution(), oid)
200 }
201 fn enum_by_type_oid(&self, oid: u32) -> Option<uqa_sql::catalog::enum_type::StoredEnum> {
202 self.durable
203 .enums
204 .read()
205 .values()
206 .find(|definition| definition.oid == oid || definition.array_oid == oid)
207 .cloned()
208 }
209 fn composite_by_type_oid(
210 &self,
211 oid: u32,
212 ) -> Option<uqa_sql::catalog::composite_type::StoredComposite> {
213 self.durable
214 .composites
215 .read()
216 .values()
217 .find(|definition| definition.oid == oid || definition.array_oid == oid)
218 .cloned()
219 }
220 fn user_array_element(&self, oid: u32) -> Option<u32> {
221 self.durable.domains.read().values().find_map(|domain| {
222 (uqa_sql::catalog::type_metadata::pg_type_array_oid(&domain.column_type())
223 == i64::from(oid))
224 .then_some(domain.oid)
225 })
226 }
227 fn row_type_relation(
228 &self,
229 oid: u32,
230 ) -> Option<uqa_sql::schema::domains::removal::RowTypeRelation> {
231 uqa_execution::catalog::projection::row_type_relation(&self.catalog_execution(), oid)
232 .ok()
233 .flatten()
234 }
235}
236impl TypeObjectAuthority for Engine {
237 fn schema_usage(&self, schema: &str, role: &RoleReference) -> bool {
238 self.schema_has_privilege_for_role(
239 schema,
240 role,
241 uqa_sql::catalog::security::schema::SchemaAclPrivilege::Usage,
242 )
243 }
244 fn current_user_has_role_privileges(
245 &self,
246 role: &dyn uqa_sql::catalog::roles::identity::RoleSubject,
247 ) -> bool {
248 Engine::current_user_has_role_privileges(self, role)
249 }
250}
251impl DomainDropNotices for Engine {
252 fn domain_drop_notice(&self, notice: uqa_sql::SQLNotice) {
253 self.push_sql_notice(notice);
254 }
255}
256
257impl uqa_execution::schema::domains::alteration::DomainValidationTables for Engine {
258 fn latest_table_snapshot(
259 &self,
260 name: &str,
261 ) -> Result<std::sync::Arc<dyn uqa_execution::query::table_read::TableRead>, SQLError> {
262 let table = self.require_table(name)?;
263 self.detach_query_table(&table, &table, None)
264 .map(|table| table as std::sync::Arc<dyn uqa_execution::query::table_read::TableRead>)
265 }
266}