use super::{analyze_reusable_inputs, StatementAnalysisContext};
use crate::{plan::UnifiedPlan, ColumnType, SQLError, SQLParam};
use std::sync::Arc;
use uqa_core::memory::{Produced, ProductionControl, ProductionVec};
struct ParameterShape {
declared: bool,
resolved: Option<ColumnType>,
}
fn parameter_shapes(
params: &[SQLParam],
control: &ProductionControl<'_>,
) -> Result<Option<Produced<Vec<ParameterShape>>>, SQLError> {
let mut shapes = ProductionVec::new(*control);
shapes.reserve(params.len())?;
for parameter in params {
let resolved = match crate::type_resolution::parameter_type_with_control(parameter, control)
{
Ok(resolved) => resolved,
Err(error)
if error.sqlstate() == Some("53200")
|| matches!(error.primary(), SQLError::Cancelled(_)) =>
{
return Err(error)
}
Err(_) => return Ok(None),
};
let (resolved, memory) = match resolved {
Some(resolved) => {
let (ty, memory) = resolved.into_parts();
(Some(ty), memory)
}
None => (None, control.empty_reservation()),
};
shapes.push_produced(control.finish(
ParameterShape {
declared: parameter.declared_scalar_type().is_some(),
resolved,
},
memory,
)?)?;
}
Ok(Some(shapes.finish()?))
}
#[derive(Clone)]
pub struct AnalyzedStatement(Arc<Produced<AnalyzedStorage>>);
struct AnalyzedStorage {
plan: UnifiedPlan,
parameters: Vec<ParameterShape>,
}
impl AnalyzedStatement {
pub fn plan_for(&self, params: &[SQLParam]) -> Option<&UnifiedPlan> {
(params.len() == self.0.parameters.len()
&& params
.iter()
.zip(&self.0.parameters)
.all(|(parameter, shape)| {
parameter.declared_scalar_type().is_some() == shape.declared
&& crate::type_resolution::parameter_type_matches(
parameter,
shape.resolved.as_ref(),
)
}))
.then_some(&self.0.plan)
}
pub fn capture_with_control(
plan: &UnifiedPlan,
params: &[SQLParam],
control: &ProductionControl<'_>,
) -> Result<Option<Self>, SQLError> {
Self::capture_ref_with_control(plan.into(), params, control)
}
pub fn capture_ref_with_control(
plan: crate::plan::PlanRef<'_>,
params: &[SQLParam],
control: &ProductionControl<'_>,
) -> Result<Option<Self>, SQLError> {
let Some(parameters) = parameter_shapes(params, control)? else {
return Ok(None);
};
let plan = plan.clone_with_control(control)?;
let (plan, memory) = plan.into_parts();
let (parameters, parameter_memory) = parameters.into_parts();
let storage = control.finish(
AnalyzedStorage { plan, parameters },
control.combine(memory, parameter_memory),
)?;
Ok(Some(Self(storage.into_shared(control)?)))
}
pub fn reserved_bytes(&self) -> usize {
self.0.reserved_bytes()
}
pub fn ptr_eq(&self, other: &Self) -> bool {
Arc::ptr_eq(&self.0, &other.0)
}
}
pub fn analyze_for_statement_reuse(
context: &StatementAnalysisContext<'_>,
mut plan: UnifiedPlan,
params: &[SQLParam],
) -> Result<(UnifiedPlan, Option<AnalyzedStatement>), SQLError> {
let (_, reusable) = analyze_reusable_inputs(context, &mut plan, params)?;
let retained = if reusable {
AnalyzedStatement::capture_with_control(&plan, params, &ProductionControl::uncontrolled())?
} else {
None
};
Ok((plan, retained))
}