uqa_sql/routines/invocation/descriptions/
body.rs1use 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(¶meter.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 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 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 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}