Skip to main content

uqa_engine/capabilities/
routine_execution.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7use 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}