1use 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(¤t.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}