1use crate::Engine;
8use uqa_core::Value;
9use uqa_execution::routines::{
10 context::{
11 RoutineExpressions, RoutinePortals, RoutineStatements, RoutineTransactions,
12 StatementResultCheck,
13 },
14 transaction::RoutineSessionId,
15 RoutineContext,
16};
17use uqa_sql::{
18 assignment::routines::RoutineValueContext,
19 ast::{ColumnType, Expr, FetchCursorStmt, Statement},
20 plan::{ExpressionPlan, UnifiedPlan},
21 SQLError, SQLParam, SQLResult,
22};
23impl Engine {
24 pub(crate) fn routine_session_id(&self) -> RoutineSessionId {
25 RoutineSessionId(std::sync::Arc::as_ptr(&self.session) as usize)
26 }
27 pub(crate) fn routine_execution_context(&self) -> RoutineContext<'_> {
28 RoutineContext {
29 expressions: self,
30 statements: self,
31 transactions: self,
32 portals: self,
33 session: self.routine_session_id(),
34 runtime: self.query_runtime_view(),
35 planning: None,
36 }
37 }
38}
39impl RoutineValueContext for Engine {
40 fn catalog_column_type_with_control(
41 &self,
42 name: &str,
43 control: &uqa_core::memory::ProductionControl<'_>,
44 ) -> Result<Option<uqa_core::memory::Produced<ColumnType>>, SQLError> {
45 uqa_execution::catalog::projection::resolve_catalog_column_type_with_control(
46 &self.catalog_execution(),
47 name,
48 control,
49 )
50 }
51
52 fn catalog_column_type(&self, name: &str) -> Option<ColumnType> {
53 uqa_execution::catalog::projection::resolve_catalog_column_type(
54 &self.catalog_execution(),
55 name,
56 )
57 }
58}
59impl RoutineExpressions for Engine {
60 fn expression_type_with_control(
61 &self,
62 plan: &ExpressionPlan,
63 params: &[SQLParam],
64 control: &uqa_core::memory::ProductionControl<'_>,
65 ) -> Result<Option<uqa_core::memory::Produced<ColumnType>>, SQLError> {
66 let scope = super::query_scope::new_for_current_routine_with_control(self, control)?;
67 let mut binding =
68 uqa_execution::query::binding::binding_context_with_control(&scope, control)?;
69 binding.scalar_subqueries = &plan.subqueries;
70 let resolver = uqa_sql::binding::scoped_types::BindingTypeResolver {
71 routines: self,
72 scope: &binding,
73 };
74 let empty = uqa_sql::RowSchema::empty_with_control(control)?;
75 uqa_sql::type_resolution::scalar_type_with_resolver_and_control(
76 &plan.scalar,
77 &empty,
78 params,
79 Some(&resolver),
80 control,
81 )
82 }
83 fn column_type_name(&self, name: &str) -> Result<ColumnType, SQLError> {
84 uqa_execution::catalog::projection::resolve_catalog_column_type_name(
85 &self.catalog_execution(),
86 name,
87 )
88 }
89 fn evaluate(&self, expression: &Expr) -> Result<Value, SQLError> {
90 crate::capabilities::query_expressions::eval_lowered_expression(self, expression, None, &[])
91 }
92 fn evaluate_with_type(
93 &self,
94 expression: &Expr,
95 ) -> Result<uqa_execution::query::catalog_expression::TypedCatalogValue, SQLError> {
96 crate::capabilities::query_expressions::eval_lowered_expression_with_type(
97 self,
98 expression,
99 None,
100 &[],
101 )
102 }
103 fn expression_type(
104 &self,
105 plan: &ExpressionPlan,
106 params: &[SQLParam],
107 ) -> Result<Option<ColumnType>, SQLError> {
108 let mut scope = super::query_scope::new_for_current_routine(self)?;
109 let resources =
110 uqa_execution::query::relational::QueryExpressionFactory::production_resources(self)?;
111 scope.scalar_subqueries =
112 uqa_sql::plan::RetainedQueryArena::capture(&plan.subqueries, &resources.control())?;
113 let hook = uqa_execution::query::relational::context::QueryExpressionFactory::bind_scope(
114 self, &scope,
115 )?;
116 uqa_execution::scalar_type_with_resolver(
117 &plan.scalar,
118 &uqa_execution::RowSchema::default(),
119 params,
120 hook.as_ref(),
121 )
122 }
123}
124impl RoutineStatements for Engine {
125 fn with_statement_scope_with_control(
126 &self,
127 control: &uqa_core::memory::ProductionControl<'_>,
128 analyze: uqa_execution::routines::context::ControlledStatementScopeOperation<'_>,
129 ) -> Result<(), SQLError> {
130 let scope = super::query_scope::new_for_current_routine_with_control(self, control)?;
131 analyze(
132 self,
133 uqa_execution::query::binding::binding_context_with_control(&scope, control)?,
134 )
135 }
136 fn planning_resources(&self) -> Result<uqa_core::memory::OwnedProductionControl, SQLError> {
137 let retained = self.query_retention_control()?;
138 Ok(uqa_core::memory::ProductionControl::new(
139 retained.memory(),
140 retained.cancellation(),
141 &self.runtime.cancellation,
142 )
143 .capture())
144 }
145
146 fn body_input_context(
147 &self,
148 ) -> Option<uqa_execution::routines::sql_body::inputs::SQLRoutineInputContext<'_>> {
149 Some(
150 uqa_execution::routines::sql_body::inputs::SQLRoutineInputContext {
151 cache: self.session.routine_bodies.sql_inputs(),
152 analysis: self.prepared_definition_context(),
153 },
154 )
155 }
156
157 fn plpgsql_preparations(
158 &self,
159 definition: &uqa_sql::ast::CreateFunction,
160 parsed: &uqa_sql::plpgsql::PLpgSQLFunction,
161 control: &uqa_core::memory::ProductionControl<'_>,
162 ) -> Result<std::sync::Arc<uqa_execution::routines::preparation::PLpgSQLPreparations>, SQLError>
163 {
164 self.session
165 .routine_bodies
166 .plpgsql_preparations(definition, parsed, control)
167 }
168 fn analyze_static_plan(
169 &self,
170 plan: &mut UnifiedPlan,
171 parameters: &[SQLParam],
172 ) -> Result<uqa_sql::binding::statements::ProceduralPlanAnalysis, SQLError> {
173 uqa_sql::binding::statements::analyze_procedural_plan(
174 &self.statement_planning_context().analysis,
175 &uqa_sql::routines::resolution::RoutineOverloadContext { catalog: self },
176 self,
177 plan,
178 parameters,
179 )
180 }
181 fn analyze_static_plan_owned(
182 &self,
183 plan: uqa_sql::plan::MutableExecutablePlan,
184 parameters: &[SQLParam],
185 control: &uqa_core::memory::ProductionControl<'_>,
186 ) -> Result<uqa_sql::binding::statements::OwnedProceduralPlanAnalysis, SQLError> {
187 uqa_sql::binding::statements::analyze_procedural_plan_owned(
188 &self.statement_planning_context().analysis,
189 &uqa_sql::routines::resolution::RoutineOverloadContext { catalog: self },
190 self,
191 plan,
192 parameters,
193 control,
194 )
195 }
196 fn parser_settings(&self) -> uqa_sql::parser::ParserSettings {
197 Engine::parser_settings(self)
198 }
199 fn execute_body_statement(
200 &self,
201 plan: UnifiedPlan,
202 params: &[SQLParam],
203 check: Option<StatementResultCheck<'_>>,
204 ) -> Result<SQLResult, SQLError> {
205 let context = self.compiled_statement_context();
206 match check {
207 Some(check) => uqa_execution::statement::compiled::execute_checked_plan(
208 &context, plan, params, check,
209 ),
210 None => uqa_execution::statement::compiled::execute_plan(&context, plan, params),
211 }
212 }
213
214 fn select_body_plan(
215 &self,
216 entry: &uqa_sql::prepared::entry::PreparedStatementPlan,
217 params: &[SQLParam],
218 control: &uqa_core::memory::ProductionControl<'_>,
219 ) -> Result<uqa_sql::prepared::planning::PreparedPlanSelection, SQLError> {
220 let _statement_thread = self.statement_thread_context().enter();
221 uqa_planner::statement_planning::prepared::selection::select_analyzed_entry_with_control(
222 &uqa_planner::statement_planning::prepared::selection::PreparedPlanningContext {
223 session: self,
224 analysis: self.prepared_definition_context(),
225 optimization: self,
226 },
227 entry,
228 params,
229 control,
230 )
231 }
232 fn select_simple_expression_plan(
233 &self,
234 entry: &uqa_sql::prepared::entry::PreparedStatementPlan,
235 params: &[SQLParam],
236 control: &uqa_core::memory::ProductionControl<'_>,
237 ) -> Result<uqa_sql::prepared::planning::PreparedPlanSelection, SQLError> {
238 let _statement_thread = self.statement_thread_context().enter();
239 uqa_planner::statement_planning::prepared::selection::select_simple_expression_entry_with_control(
240 &uqa_planner::statement_planning::prepared::selection::PreparedPlanningContext {
241 session: self,
242 analysis: self.prepared_definition_context(),
243 optimization: self,
244 },
245 entry,
246 params,
247 control,
248 )
249 }
250 fn execute_selected_body_plan(
251 &self,
252 plan: &UnifiedPlan,
253 params: &[SQLParam],
254 ) -> Result<SQLResult, SQLError> {
255 uqa_execution::statement::compiled::execute_selected_plan(
256 &self.compiled_statement_context(),
257 plan,
258 params,
259 )
260 }
261 fn execute_bound(
262 &self,
263 statement: Statement,
264 params: &[SQLParam],
265 ) -> Result<SQLResult, SQLError> {
266 uqa_execution::statement::compiled::execute(
267 &self.compiled_statement_context(),
268 statement,
269 params,
270 )
271 }
272 fn execute_text(&self, text: &str, params: &[SQLParam]) -> Result<SQLResult, SQLError> {
273 uqa_execution::statement::batch::execute_nested(
274 &self.batch_execution_context(),
275 text,
276 params,
277 )
278 }
279 fn optimize_plan(
280 &self,
281 plan: UnifiedPlan,
282 ) -> Result<uqa_sql::plan::SharedExecutablePlan, SQLError> {
283 uqa_planner::statement_planning::executable::optimize_shared_plan(
284 &self.statement_planning_context(),
285 plan,
286 )
287 }
288 fn optimize_owned_plan(
289 &self,
290 plan: uqa_sql::plan::MutableExecutablePlan,
291 control: &uqa_core::memory::ProductionControl<'_>,
292 ) -> Result<uqa_sql::plan::SharedExecutablePlan, SQLError> {
293 uqa_planner::statement_planning::executable::optimize_owned_with_control(
294 &self.statement_planning_context(),
295 plan,
296 control,
297 )?
298 .into_shared(control)
299 }
300 fn assertions_enabled(&self) -> bool {
301 self.plpgsql_asserts_enabled()
302 }
303 fn load_language_library(&self, language: &str) {
304 self.load_language(language);
305 }
306 fn with_statement_scope(
307 &self,
308 analyze: uqa_execution::routines::context::StatementScopeOperation<'_>,
309 ) -> Result<(), SQLError> {
310 let scope = super::query_scope::new_for_current_routine(self)?;
311 analyze(
312 self,
313 &uqa_execution::query::binding::binding_context(&scope)?,
314 )
315 }
316}
317impl RoutineTransactions for Engine {
318 fn depth(&self) -> usize {
319 self.transaction_depth()
320 }
321 fn begin(&self) -> Result<(), SQLError> {
322 self.begin()
323 }
324 fn commit(&self) -> Result<(), SQLError> {
325 self.commit()
326 }
327 fn rollback(&self) -> Result<(), SQLError> {
328 self.rollback()
329 }
330 fn finish_procedural_transaction(&self, commit: bool, chain: bool) -> Result<(), SQLError> {
331 self.finish_procedural_transaction(commit, chain)
332 }
333}
334impl RoutinePortals for Engine {
335 fn ensure_available(&self, name: &str) -> Result<(), SQLError> {
336 uqa_execution::statement::portal::declaration::ensure_plpgsql_session_portal_available(
337 self, name,
338 )
339 }
340 fn open(
341 &self,
342 params: &[SQLParam],
343 name: &str,
344 scroll: Option<bool>,
345 plan: &UnifiedPlan,
346 source_sql: &str,
347 ) -> Result<(), SQLError> {
348 uqa_execution::statement::portal::declaration::open_plpgsql_session_portal(
349 &self
350 .portal_execution_context()
351 .with_source_sql(Some(source_sql)),
352 params,
353 name,
354 scroll,
355 plan,
356 )
357 }
358 fn fetch(&self, request: &FetchCursorStmt) -> Result<SQLResult, SQLError> {
359 self.fetch_session_portal(request)
360 }
361 fn close(&self, name: &str) -> Result<(), SQLError> {
362 self.close_session_portal(name)
363 }
364 fn allocate_name(&self) -> String {
365 self.allocate_session_portal_name()
366 }
367 fn pin(&self, name: &str) -> Result<(), SQLError> {
368 self.pin_session_portal(name)
369 }
370 fn unpin(&self, name: &str) -> Result<(), SQLError> {
371 self.unpin_session_portal(name)
372 }
373}