Skip to main content

uqa_engine/capabilities/
table_creation.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bind table creation to active query generations and schema publication state.
8use crate::{session::StatementReadSnapshot, Engine};
9use uqa_core::DocId;
10use uqa_execution::mutation::publication::DocumentVectors;
11use uqa_execution::query::CteScope;
12use uqa_execution::schema::ctas::{
13    entry::{TableAsTransactions, TableAsWrite},
14    CreateTableAsContext, TableAsNamespace, TableAsPublication, TableAsQuerySource,
15};
16use uqa_execution::schema::table_creation::entry::{TableCreationTransactions, TableCreationWrite};
17use uqa_sql::catalog::errors::storage_error;
18use uqa_sql::{
19    ast::{ColumnDef, OnCommitAction, RelationPersistence},
20    plan::QueryPlan,
21    SQLError, SQLParam, SQLResult,
22};
23use uqa_storage::document_store::Document;
24impl Engine {
25    pub(crate) fn create_table_as_context<'a>(
26        &'a self,
27        analysis_scope: &'a CteScope<StatementReadSnapshot>,
28    ) -> CreateTableAsContext<'a, StatementReadSnapshot> {
29        CreateTableAsContext {
30            creation: self.relation_creation_context(),
31            analysis_scope,
32            routines: self,
33            queries: self,
34            namespace: self,
35            publication: self,
36            vectors: self,
37            notices: &self.runtime.notices,
38        }
39    }
40}
41impl TableAsTransactions<StatementReadSnapshot> for Engine {
42    fn transaction_is_active(&self) -> bool {
43        self.transaction_depth() != 0
44    }
45    fn with_new_transaction(
46        &self,
47        write: TableAsWrite<'_, StatementReadSnapshot>,
48    ) -> Result<SQLResult, SQLError> {
49        self.transaction(|engine| engine.with_current_scope(write))
50    }
51    fn with_current_scope(
52        &self,
53        write: TableAsWrite<'_, StatementReadSnapshot>,
54    ) -> Result<SQLResult, SQLError> {
55        let scope = super::query_scope::new_for_current_routine(self);
56        write(&self.create_table_as_context(&scope))
57    }
58}
59impl TableCreationTransactions for Engine {
60    fn with_new_table_transaction(
61        &self,
62        write: TableCreationWrite<'_>,
63    ) -> Result<SQLResult, SQLError> {
64        self.transaction(|engine| {
65            let result = write(&engine.create_table_context())?;
66            engine.publish_catalog_constraint_tuples()?;
67            Ok(result)
68        })
69    }
70}
71impl TableAsQuerySource for Engine {
72    fn optimize(&self, plan: &QueryPlan) -> Result<QueryPlan, SQLError> {
73        crate::capabilities::statement_planning::optimize_engine_query(self, plan)
74    }
75    fn execute(&self, plan: &QueryPlan, params: &[SQLParam]) -> Result<SQLResult, SQLError> {
76        let mut scope = super::query_scope::new_for_current_routine(self);
77        uqa_execution::query::statement::execute_query_plan_with_ctes(
78            &self.query_execution_context(),
79            plan,
80            params,
81            &mut scope,
82        )
83    }
84}
85impl TableAsNamespace for Engine {
86    fn relation_exists(&self, name: &str) -> Result<bool, SQLError> {
87        self.relation_kind_at(name)
88            .map(|kind| kind.is_some())
89            .map_err(|error| storage_error("CREATE TABLE AS", &error))
90    }
91
92    fn prepare_writer(&self) -> Result<bool, SQLError> {
93        self.prepare_explicit_transaction_writer()
94    }
95}
96impl TableAsPublication for Engine {
97    fn create_relation(
98        &self,
99        name: &str,
100        persistence: RelationPersistence,
101        on_commit: OnCommitAction,
102        owner: &uqa_execution::catalog::security::roles::locking::RoleBinding,
103    ) -> Result<(), SQLError> {
104        self.create_table_with_lifecycle(
105            name,
106            uqa_analysis::analyzer::standard_analyzer("english"),
107            Vec::new(),
108            persistence,
109            on_commit,
110            owner,
111            None,
112        )
113        .map_err(|error| storage_error("CREATE TABLE AS", &error))
114    }
115    fn create_vector_field(
116        &self,
117        name: &str,
118        column: &str,
119        dimensions: u32,
120    ) -> Result<bool, SQLError> {
121        Engine::create_vector_field(self, name, column, dimensions)
122            .map_err(|error| storage_error("CREATE TABLE AS vector field", &error))
123    }
124    fn publish_columns(&self, name: &str, columns: &[ColumnDef]) -> Result<(), SQLError> {
125        let constraints = self
126            .try_declared_table_constraints(name)
127            .map_err(|error| storage_error("CREATE TABLE AS schema", &error))?;
128        uqa_execution::schema::publication::replace_constraint_state(
129            &self.schema_publication_context(),
130            name,
131            columns.to_vec(),
132            constraints,
133        )
134        .map_err(|error| storage_error("CREATE TABLE AS schema", &error))
135    }
136    fn insert_document(
137        &self,
138        table: &str,
139        id: DocId,
140        document: Document,
141        vectors: DocumentVectors,
142    ) -> Result<(), SQLError> {
143        self.add_document_with_vector_values(table, id, document, vectors)
144    }
145}
146
147impl Engine {
148    pub(crate) fn table_declaration_context(
149        &self,
150    ) -> uqa_sql::schema::table_creation::declaration::CreateTableAnalysisContext<'_> {
151        uqa_sql::schema::table_creation::declaration::CreateTableAnalysisContext {
152            types: self,
153            schema: self,
154            bindings: self,
155            inheritance: uqa_sql::schema::inheritance::InheritanceContext {
156                catalog: self,
157                partitions: self.partition_context(),
158                roles: self,
159            },
160            index_names: self,
161            foreign_keys: self.foreign_key_definition_context(),
162        }
163    }
164}
165
166impl Engine {
167    pub(crate) fn create_table_context(
168        &self,
169    ) -> uqa_execution::schema::table_creation::CreateTableContext<'_> {
170        let runtime = self.query_runtime_view();
171        uqa_execution::schema::table_creation::CreateTableContext {
172            creation: self.relation_creation_context(),
173            namespace: self,
174            analysis: self.table_declaration_context(),
175            sequences: self.implicit_sequence_context(),
176            ownership: self.implicit_ownership_context(),
177            schema_transactions: self,
178            publication: self,
179            identities: self.catalog_identity_reservation_context(),
180            notices: runtime.notices,
181        }
182    }
183}
184impl uqa_execution::schema::table_creation::TableCreationNamespace for Engine {
185    fn prepare_writer(&self) -> Result<bool, SQLError> {
186        self.prepare_explicit_transaction_writer()
187    }
188
189    fn relation_exists(&self, name: &str) -> Result<bool, SQLError> {
190        self.resolve_bound_relation_kind(name)
191            .map(|resolution| matches!(resolution, super::RelationResolution::Found(_, _)))
192    }
193}
194impl uqa_execution::schema::table_creation::TableCreationPublication for Engine {
195    fn create_table(
196        &self,
197        name: &str,
198        persistence: RelationPersistence,
199        on_commit: OnCommitAction,
200        owner: &uqa_execution::catalog::security::roles::locking::RoleBinding,
201        catalog_oids: uqa_sql::catalog::relation_oids::RelationCatalogOids,
202    ) -> uqa_storage::StorageBackendResult<()> {
203        self.create_table_with_lifecycle(
204            name,
205            uqa_analysis::analyzer::standard_analyzer("english"),
206            Vec::new(),
207            persistence,
208            on_commit,
209            owner,
210            Some(catalog_oids),
211        )
212    }
213    fn create_vector_field(
214        &self,
215        table: &str,
216        field: String,
217        dimensions: u32,
218    ) -> uqa_storage::StorageBackendResult<bool> {
219        Engine::create_vector_field(self, table, field, dimensions)
220    }
221    fn install_hierarchy(
222        &self,
223        table: &str,
224        hierarchy: uqa_sql::ast::TableHierarchy,
225    ) -> uqa_storage::StorageBackendResult<()> {
226        self.install_table_hierarchy(table, hierarchy)
227    }
228    fn validate_default_partition_rows(
229        &self,
230        parent: &str,
231        bound: &uqa_sql::ast::PartitionBound,
232    ) -> Result<(), SQLError> {
233        uqa_execution::schema::hierarchy::validate_default_partition_exclusion(
234            &self.hierarchy_execution_context(),
235            parent,
236            bound,
237        )
238    }
239    fn persist_schema(&self, table: &str) -> uqa_storage::StorageBackendResult<bool> {
240        self.try_persist_table_schema(table)
241    }
242    fn refresh_value_indexes(&self, table: &str) -> uqa_storage::StorageBackendResult<()> {
243        self.refresh_value_indexes_for_table(table)
244    }
245}