Skip to main content

uqa_engine/capabilities/
view_creation.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bind view lifecycle operations to actual transaction, registry, and role state.
8use 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}