Skip to main content

uqa_sql/routines/invocation/descriptions/
body.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Body metadata follows the selected call's original, live conversion boundaries.
8
9use super::{
10    conversion_slots, ColumnType, Produced, ProductionControl, RoutineCallDescription,
11    RoutineConversionEnvironment, RoutineValueDescription, SQLError, Value, ValueRetentionError,
12};
13use crate::{
14    ast::{CreateFunction, FunctionReturns},
15    binding::statements::AnalyzedResult,
16    routines::{
17        declaration::RoutineTypeCatalog,
18        result_check::{
19            sql_function_result_layout, SQLFunctionResultKind, SQLFunctionResultLayout,
20        },
21    },
22};
23use std::{borrow::Cow, sync::OnceLock};
24use uqa_core::memory::MemoryReservation;
25
26pub(super) struct ResultDescription {
27    columns: Option<Produced<Vec<Option<ColumnType>>>>,
28    record: Option<Produced<Vec<Option<ColumnType>>>>,
29    layout: Produced<SQLFunctionResultLayout>,
30    conversions: Produced<Vec<OnceLock<Produced<RoutineValueDescription>>>>,
31    _memory: Option<MemoryReservation>,
32}
33
34fn input_types(result: Option<&AnalyzedResult>) -> Option<&[Option<ColumnType>]> {
35    result.and_then(AnalyzedResult::column_types)
36}
37
38fn input_record(result: Option<&AnalyzedResult>) -> Option<&[Option<ColumnType>]> {
39    result
40        .and_then(|result| result.record_fields(0))
41        .map(AsRef::as_ref)
42}
43
44pub(super) fn fixed_result(definition: &CreateFunction) -> bool {
45    let mut outputs = definition.output_params();
46    if outputs.clone().next().is_some() {
47        return outputs.all(|parameter| super::fixed_name(&parameter.type_name));
48    }
49    match &definition.returns {
50        FunctionReturns::Scalar { type_name } | FunctionReturns::SetOf { type_name } => {
51            super::fixed_name(type_name)
52        }
53        FunctionReturns::None | FunctionReturns::Table => true,
54    }
55}
56
57impl ResultDescription {
58    fn matches(&self, result: Option<&AnalyzedResult>) -> bool {
59        self.columns.as_ref().map(|types| types.as_slice()) == input_types(result)
60            && self.record.as_ref().map(|types| types.as_slice()) == input_record(result)
61    }
62
63    fn new(
64        result: Option<&AnalyzedResult>,
65        layout: &SQLFunctionResultLayout,
66        control: &ProductionControl<'_>,
67    ) -> Result<Box<Self>, ValueRetentionError> {
68        let memory = control.reserve(size_of::<Self>())?;
69        let columns = input_types(result)
70            .map(|types| crate::routines::result_check::retention::copy_types(types, control))
71            .transpose()?;
72        let record = input_record(result)
73            .map(|types| crate::routines::result_check::retention::copy_types(types, control))
74            .transpose()?;
75        let layout = layout.clone_with_control(control)?;
76        let count = if layout.kind == SQLFunctionResultKind::Tuple {
77            layout.columns.as_ref().map_or(0, Vec::len)
78        } else {
79            1
80        };
81        let conversions = conversion_slots(count, control)?;
82        Ok(Box::new(Self {
83            columns,
84            record,
85            layout,
86            conversions,
87            _memory: memory,
88        }))
89    }
90}
91
92impl RoutineCallDescription {
93    /// Resolve a concrete SQL-body input at its original position, after invocation coercion. Only the selected call's exact parameter spelling can reuse this slot.
94    pub fn body_parameter_type<'a>(
95        &'a self,
96        index: usize,
97        name: &str,
98        environment: RoutineConversionEnvironment<'_>,
99    ) -> Result<Cow<'a, ColumnType>, SQLError> {
100        environment.control.check()?;
101        let invocation = self.binding.invocation.as_ref().expect("retained call");
102        let reusable = invocation
103            .parameter_types
104            .get(index)
105            .is_some_and(|ty| ty == name)
106            && self.is_current((environment.scope)().as_ref());
107        if reusable {
108            if let Some(ty) = self.body_parameters[index].get() {
109                return Ok(Cow::Borrowed(ty));
110            }
111        }
112        let ty = ColumnType::from_sql_name(name)
113            .ok()
114            .or_else(|| environment.values.catalog_column_type(name))
115            .ok_or_else(|| SQLError::TypeMismatch(format!("unknown type `{name}`")))?;
116        if reusable && self.is_current((environment.scope)().as_ref()) {
117            match ty.clone_with_control(&environment.control) {
118                Ok(copied) => {
119                    let _ = self.body_parameters[index].set(copied);
120                }
121                Err(ValueRetentionError::Memory(_)) => {}
122                Err(error) => return Err(error.into()),
123            }
124        }
125        Ok(Cow::Owned(ty))
126    }
127
128    /// Reuse the selected function's successful result check only for the complete output type/record description in the original scope. Callers still perform caller-specific anonymous-record checks at their original boundary.
129    pub fn body_result_layout<'a>(
130        &'a self,
131        types: &dyn RoutineTypeCatalog,
132        definition: &CreateFunction,
133        result: Option<&AnalyzedResult>,
134        environment: RoutineConversionEnvironment<'_>,
135    ) -> Result<Cow<'a, SQLFunctionResultLayout>, SQLError> {
136        environment.control.check()?;
137        let reusable = self.is_current((environment.scope)().as_ref());
138        if reusable {
139            if let Some(saved) = self.body_result.get().filter(|saved| saved.matches(result)) {
140                return Ok(Cow::Borrowed(&saved.layout));
141            }
142        }
143        let layout = sql_function_result_layout(types, definition, result)?;
144        if reusable
145            && self.body_result.get().is_none()
146            && fixed_result(definition)
147            && self.is_current((environment.scope)().as_ref())
148        {
149            match ResultDescription::new(result, &layout, &environment.control) {
150                Ok(saved) => {
151                    if self.body_result.set(saved).is_ok() {
152                        return Ok(Cow::Borrowed(
153                            &self
154                                .body_result
155                                .get()
156                                .expect("published result description")
157                                .layout,
158                        ));
159                    }
160                }
161                Err(ValueRetentionError::Memory(_)) => {}
162                Err(error) => return Err(error.into()),
163            }
164        }
165        Ok(Cow::Owned(layout))
166    }
167
168    /// Convert every returned value with live callbacks. Body effects and earlier output callbacks can invalidate the scope before this conversion.
169    pub fn coerce_body_result(
170        &self,
171        layout: &SQLFunctionResultLayout,
172        index: usize,
173        value: &Value,
174        source: Option<&ColumnType>,
175        environment: RoutineConversionEnvironment<'_>,
176    ) -> Result<Value, SQLError> {
177        environment.control.check()?;
178        let target = if layout.kind == SQLFunctionResultKind::Tuple {
179            layout
180                .columns
181                .as_ref()
182                .and_then(|columns| columns.get(index))
183                .map_or(&layout.declared_type, |column| &column.ty)
184        } else {
185            &layout.declared_type
186        };
187        if self.is_current((environment.scope)().as_ref()) {
188            if let Some(saved) = self.body_result.get().filter(|saved| {
189                std::ptr::eq(
190                    std::ptr::from_ref(&*saved.layout),
191                    std::ptr::from_ref(layout),
192                )
193            }) {
194                if let Some(slot) = saved.conversions.get(index) {
195                    if let Some(description) = slot.get() {
196                        return description.coerce(environment.values, value, source);
197                    }
198                    return self.coerce(&target.catalog_name(), slot, value, source, environment);
199                }
200            }
201        }
202        crate::assignment::routines::coerce_routine_value_from(
203            environment.values,
204            value,
205            &target.catalog_name(),
206            source,
207        )
208    }
209}