1use crate::Engine;
9use uqa_execution::schema::view_creation::{
10 self,
11 context::{
12 MaterializedViewAccess, MaterializedViewWrite, ViewCreationCatalog, ViewCreationContext,
13 ViewCreationTransactions, ViewCreationWrite, ViewOwnerQuery, ViewPlanBinding,
14 ViewQueryOwners,
15 },
16};
17use uqa_sql::{
18 catalog::stored_view::StoredView, plan::QueryPlan, RowSchema, SQLError, SQLParam, SQLResult,
19};
20use uqa_storage::StorageBackendResult;
21
22impl Engine {
23 pub fn register_view(
24 &self,
25 name: &str,
26 body: uqa_sql::ast::SelectStmt,
27 ) -> Result<(), SQLError> {
28 self.with_implicit_definition_transaction(|engine| {
29 view_creation::register_view(engine, name, body)
30 })
31 }
32 fn view_creation_context(&self) -> ViewCreationContext<'_> {
33 ViewCreationContext {
34 catalog: self,
35 identities: self.catalog_identity_reservation_context(),
36 views: self,
37 locks: self,
38 namespace: self.relation_creation_context(),
39 names: self,
40 owners: self,
41 access: self,
42 bindings: self,
43 routines: self,
44 regroles: self,
45 aliases: self,
46 rewrite: self.view_rewrite_context(),
47 queries: self,
48 query_owners: self,
49 publication: self,
50 changes: self,
51 notices: &self.runtime.notices,
52 }
53 }
54}
55impl ViewCreationTransactions for Engine {
56 fn explain_existing_target(&self, name: &str, if_not_exists: bool) -> Result<bool, SQLError> {
57 view_creation::explain_existing_target(&self.view_creation_context(), name, if_not_exists)
58 }
59 fn with_view_creation(&self, write: ViewCreationWrite<'_>) -> Result<(), SQLError> {
60 self.with_definition_publication(|engine| write(&engine.view_creation_context()))
61 }
62 fn with_materialized_view_creation(
63 &self,
64 write: MaterializedViewWrite<'_>,
65 ) -> Result<Option<u64>, SQLError> {
66 self.with_definition_publication(|engine| write(&engine.view_creation_context()))
67 }
68}
69impl ViewCreationCatalog for Engine {
70 fn synchronize(&self) -> StorageBackendResult<()> {
71 self.synchronize_catalog_registries()
72 }
73}
74impl ViewPlanBinding for Engine {
75 fn lock_relations(&self, plan: &QueryPlan) -> Result<(), SQLError> {
76 uqa_execution::query::locking::lock_query_relations(self.row_lock_context(), plan)
77 }
78 fn bind_relations(&self, plan: &mut QueryPlan) -> Result<bool, SQLError> {
79 self.bind_stored_query_relations(plan, "CREATE VIEW", true)
80 }
81 fn bind_routines(
82 &self,
83 plan: &mut QueryPlan,
84 params: &[SQLParam],
85 ) -> Result<RowSchema, SQLError> {
86 let scope = super::query_scope::new_for_catalog_binding(self)?;
87 uqa_execution::query::binding::bind_query_plan_routines_for_storage(
88 self, plan, params, &scope, None,
89 )
90 }
91 fn bind_type_identities(&self, plan: &mut QueryPlan) -> Result<(), SQLError> {
92 uqa_sql::binding::stored_types::bind_query_plan_type_identities(plan, &mut |name| {
93 uqa_sql::FunctionTypeResolver::resolve_type_name(self, name)
94 })
95 }
96 fn assign_input_collations(&self, plan: &mut QueryPlan) -> Result<(), SQLError> {
97 let scope = super::query_scope::new_for_catalog_binding(self)?;
98 uqa_execution::query::binding::assign_query_plan_input_collations(self, plan, &scope)
99 }
100}
101
102impl MaterializedViewAccess for Engine {
103 fn ensure_maintenance(&self, name: &str, view: &StoredView) -> Result<(), SQLError> {
104 uqa_sql::catalog::security::view_ownership::ensure_materialized_view_maintenance(
105 self.view_ownership_context(),
106 name,
107 view,
108 )
109 }
110}
111impl ViewQueryOwners for Engine {
112 fn with_owner(
113 &self,
114 owner: &uqa_sql::catalog::roles::RoleReference,
115 operation: ViewOwnerQuery<'_>,
116 ) -> Result<SQLResult, SQLError> {
117 self.with_current_user_context(owner, || operation(self))
118 }
119}
120
121impl Engine {
122 pub(crate) fn view_ownership_context(
123 &self,
124 ) -> uqa_sql::catalog::security::view_ownership::ViewOwnershipContext<'_> {
125 uqa_sql::catalog::security::view_ownership::ViewOwnershipContext {
126 session: self,
127 roles: self,
128 schemas: self,
129 }
130 }
131 pub(crate) fn ensure_view_owner(
132 &self,
133 name: &str,
134 view: &StoredView,
135 ) -> Result<String, SQLError> {
136 uqa_sql::catalog::security::view_ownership::ensure_view_owner(
137 self.view_ownership_context(),
138 name,
139 view,
140 )
141 }
142}
143impl uqa_sql::catalog::security::view_ownership::ViewOwnerSchemas for Engine {
144 fn schema_security(
145 &self,
146 schema: &str,
147 ) -> Option<uqa_sql::catalog::security::BoundSchemaSecurity> {
148 self.schema_security_for_privilege(schema)
149 }
150}
151
152impl uqa_execution::catalog::view::ViewIdentityAllocation for Engine {
153 fn allocate_identity(&self) -> StorageBackendResult<[u8; 16]> {
154 crate::new_view_object_id()
155 }
156}