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