Skip to main content

uqa_engine/capabilities/
prepared.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Adapt current routine scope and session parameter metadata to prepared-statement services.
8
9use crate::{capabilities::ScopedEngineHook, Engine};
10use uqa_execution::query::prepared::{
11    ArgumentBindingContext, PreparedArgumentScopes, ScopedArgumentOperation,
12};
13use uqa_execution::scalar::plan::PhysicalEvalContext;
14use uqa_sql::{
15    plan::{ExpressionPlan, UnifiedPlan},
16    prepared::arguments::ArgumentValidationContext,
17    SQLError, SQLParam,
18};
19
20impl Engine {
21    pub(crate) fn note_prepared_relation_change(&self, relation: &uqa_core::RelationIdentity) {
22        self.mutation_coordinator()
23            .note_prepared_relation_change(relation);
24    }
25
26    pub(crate) fn note_prepared_table_change(&self, table: &crate::TableState) {
27        self.mutation_coordinator()
28            .note_prepared_table_change(table);
29    }
30
31    pub(crate) fn note_prepared_catalog_change(
32        &self,
33        change: uqa_execution::statement::prepared::invalidation::PreparedCatalogChange,
34    ) {
35        self.mutation_coordinator()
36            .note_prepared_catalog_change(change);
37    }
38
39    pub(crate) fn prepared_definition_context(
40        &self,
41    ) -> uqa_sql::prepared::definition::PreparedDefinitionContext<'_> {
42        uqa_sql::prepared::definition::PreparedDefinitionContext {
43            types: self,
44            routines: self,
45            procedures: self,
46            scopes: self,
47            session: self,
48            aliases: self,
49        }
50    }
51
52    pub(crate) fn prepared_registration_context(
53        &self,
54    ) -> uqa_execution::statement::prepared::PreparedRegistrationContext<'_> {
55        uqa_execution::statement::prepared::PreparedRegistrationContext {
56            analysis: self.prepared_definition_context(),
57            aggregates: self,
58            registry: self,
59            transaction_timestamp_micros: self.session_transaction_clock_micros(),
60            interval_style: Some(self.session.interval_style()),
61            date_order: Some(uqa_sql::semantics::parameters::datestyle::date_order(
62                &self.session.setting("DateStyle"),
63            )),
64            cancellation: &self.runtime.cancellation,
65            clock: uqa_sql::expr::clock_timestamp_micros,
66        }
67    }
68}
69
70impl uqa_sql::prepared::utility::PreparedSessionMetadata for Engine {
71    fn show_result_schema(&self, name: &str) -> Result<uqa_sql::RowSchema, SQLError> {
72        uqa_execution::statement::show::show_schema(self, name)
73    }
74    fn portal_result_schema(&self, name: &str) -> Option<uqa_sql::RowSchema> {
75        self.session
76            .portals
77            .lock()
78            .get(name)
79            .map(|portal| portal.schema.clone())
80    }
81    fn prepared_result_schema(&self, name: &str) -> Option<uqa_sql::RowSchema> {
82        self.session
83            .prepared
84            .read()
85            .get(name)
86            .and_then(|entry| entry.result_schema.clone())
87    }
88}
89
90impl PreparedArgumentScopes for Engine {
91    fn with_scope(
92        &self,
93        parameters: &[SQLParam],
94        operation: &mut ScopedArgumentOperation<'_>,
95    ) -> Result<Vec<SQLParam>, SQLError> {
96        let scope = super::query_scope::new_for_current_routine(self);
97        let hook = ScopedEngineHook::new(self, &scope);
98        let evaluation = PhysicalEvalContext::new(None, parameters)
99            .with_function_hook(&hook)
100            .with_subquery_runner(&hook);
101        let cast_type = |name: &str| {
102            uqa_execution::catalog::projection::resolve_catalog_column_type(
103                &self.catalog_execution(),
104                name,
105            )
106        };
107        let mut analyze_type = |argument: &ExpressionPlan| {
108            uqa_execution::query::binding::analyze_expression_plan_type(
109                self, argument, parameters, &scope,
110            )
111        };
112        operation(ArgumentBindingContext {
113            validation: ArgumentValidationContext {
114                aggregates: self,
115                volatility: self,
116                cast_type: &cast_type,
117                routines: self,
118                parameters,
119            },
120            assignment: self,
121            analyze_type: &mut analyze_type,
122            evaluation,
123        })
124    }
125}
126
127struct PreparedDefinitionWrite<'a>(
128    parking_lot::RwLockWriteGuard<
129        'a,
130        std::collections::BTreeMap<String, uqa_sql::prepared::entry::PreparedStatementPlan>,
131    >,
132);
133
134impl uqa_execution::statement::prepared::PreparedDefinitionWrite for PreparedDefinitionWrite<'_> {
135    fn insert(
136        &mut self,
137        name: String,
138        definition: uqa_sql::prepared::entry::PreparedStatementPlan,
139    ) {
140        self.0.insert(name, definition);
141    }
142}
143
144impl uqa_execution::statement::prepared::PreparedDefinitionRegistry for Engine {
145    fn write_definitions(
146        &self,
147    ) -> Box<dyn uqa_execution::statement::prepared::PreparedDefinitionWrite + '_> {
148        Box::new(PreparedDefinitionWrite(self.session.prepared.write()))
149    }
150}
151
152impl uqa_planner::statement_planning::prepared::selection::PreparedPlanSession for Engine {
153    fn prepared_entry(
154        &self,
155        name: &str,
156    ) -> Option<uqa_sql::prepared::entry::PreparedStatementPlan> {
157        self.session.prepared.read().get(name).cloned()
158    }
159    fn plan_cache_mode(&self) -> Result<String, SQLError> {
160        self.show_variable("plan_cache_mode")
161    }
162    fn publish_usage(
163        &self,
164        name: &str,
165        logical_plan: &std::sync::Arc<UnifiedPlan>,
166        update: uqa_sql::prepared::planning::PreparedPlanUpdate,
167    ) {
168        if let Some(current) = self.session.prepared.write().get_mut(name) {
169            if std::sync::Arc::ptr_eq(&current.logical_plan, logical_plan) {
170                current.record_execution(update);
171            }
172        }
173    }
174}
175
176impl uqa_planner::statement_planning::prepared::selection::PreparedPlanOptimization for Engine {
177    fn optimize_plan(&self, plan: UnifiedPlan) -> Result<UnifiedPlan, SQLError> {
178        super::statement_planning::optimize_engine_plan(self, plan)
179    }
180    fn estimate_plan(
181        &self,
182        plan: &UnifiedPlan,
183    ) -> Result<uqa_planner::plan_cost::PlanCost, SQLError> {
184        super::statement_planning::estimate_engine_plan(self, plan)
185    }
186}
187
188impl uqa_sql::prepared::planning::PreparedPlanProvider for Engine {
189    fn plan_for_execution(
190        &self,
191        name: &str,
192        parameters: &[SQLParam],
193    ) -> Result<Option<UnifiedPlan>, SQLError> {
194        uqa_planner::statement_planning::prepared::selection::select_plan(
195            &uqa_planner::statement_planning::prepared::selection::PreparedPlanningContext {
196                session: self,
197                analysis: self.prepared_definition_context(),
198                optimization: self,
199            },
200            name,
201            parameters,
202        )
203    }
204}