1use super::{
10 column_definitions::ResultClass, ColumnType, FunctionReturns, RoutineInvocationBinding,
11 RoutineResolution, SQLError, SQLUserFunction,
12};
13use crate::expr::composites::{descriptor_with_control, OwnedCompositeTypeDescriptor};
14use uqa_core::memory::{Produced, ProductionControl, ProductionVec};
15
16pub(super) fn composite_result_oid_with_control(
17 routines: &dyn RoutineResolution,
18 function: &SQLUserFunction,
19 invocation: Option<&RoutineInvocationBinding>,
20 control: &ProductionControl<'_>,
21) -> Result<Option<u32>, SQLError> {
22 control.check()?;
23 let mut outputs = function.def.output_params();
24 if outputs.clone().nth(1).is_some() {
25 return Ok(None);
26 }
27 let declared = match (&function.def.returns, outputs.next()) {
28 (_, Some(output)) => Some(output.type_name.as_str()),
29 (FunctionReturns::Scalar { type_name } | FunctionReturns::SetOf { type_name }, None) => {
30 Some(type_name.as_str())
31 }
32 _ => None,
33 };
34 let Some(name) = invocation
35 .and_then(|value| value.return_type.as_deref())
36 .or(declared)
37 else {
38 return Ok(None);
39 };
40 if crate::type_resolution::routine_polymorphic_type_with_control(name, control)?.is_some() {
41 return Ok(None);
42 }
43 let ty = routines.resolve_type_name_with_control(name, control)?;
44 Ok(match ty.as_deref() {
45 Some(ColumnType::Composite(reference)) => Some(reference.oid),
46 _ => None,
47 })
48}
49
50pub fn user_function_composite_result_with_control(
51 routines: &dyn RoutineResolution,
52 function: &SQLUserFunction,
53 invocation: Option<&RoutineInvocationBinding>,
54 control: &ProductionControl<'_>,
55) -> Result<Option<OwnedCompositeTypeDescriptor>, SQLError> {
56 composite_result_oid_with_control(routines, function, invocation, control)?
57 .map(|oid| descriptor_with_control(routines.composite_types(), oid, control))
58 .transpose()
59}
60
61pub fn user_function_output_columns_with_control(
62 function: &SQLUserFunction,
63 control: &ProductionControl<'_>,
64) -> Result<Option<Produced<Vec<String>>>, SQLError> {
65 output_columns(function, &[], false, control)
66}
67
68pub fn apply_table_function_aliases_with_control(
69 names: &[String],
70 aliases: &[String],
71 ordinality: bool,
72 control: &ProductionControl<'_>,
73) -> Result<Produced<Vec<String>>, SQLError> {
74 columns(
75 names.iter().map(|name| ColumnName::Written(name)),
76 names.len(),
77 aliases,
78 ordinality,
79 control,
80 )
81}
82
83pub fn user_function_declared_columns_with_control(
84 routines: &dyn RoutineResolution,
85 function: &SQLUserFunction,
86 invocation: Option<&RoutineInvocationBinding>,
87 control: &ProductionControl<'_>,
88) -> Result<Option<Produced<Vec<String>>>, SQLError> {
89 declared_columns(routines, function, invocation, &[], false, control)
90}
91
92#[expect(
93 clippy::too_many_arguments,
94 reason = "selected source metadata and its caller-owned admission scope remain independently borrowed"
95)]
96pub fn user_table_function_columns_with_control(
97 routines: &dyn RoutineResolution,
98 function: &SQLUserFunction,
99 invocation: Option<&RoutineInvocationBinding>,
100 output_name: &str,
101 alias: Option<&str>,
102 aliases: &[String],
103 ordinality: bool,
104 control: &ProductionControl<'_>,
105) -> Result<Produced<Vec<String>>, SQLError> {
106 let columns =
107 if user_function_result_class_with_control(routines, function, invocation, control)?
108 == ResultClass::Record
109 {
110 columns(
111 aliases.iter().map(|name| ColumnName::Written(name)),
112 aliases.len(),
113 aliases,
114 ordinality,
115 control,
116 )?
117 } else if let Some(columns) =
118 declared_columns(routines, function, invocation, aliases, ordinality, control)?
119 {
120 columns
121 } else {
122 columns(
123 std::iter::once(ColumnName::Written(alias.unwrap_or(output_name))),
124 1,
125 aliases,
126 ordinality,
127 control,
128 )?
129 };
130 validate_table_function_alias_count_with_control(
131 alias.unwrap_or(output_name),
132 columns.len(),
133 aliases.len(),
134 control,
135 )?;
136 Ok(columns)
137}
138
139fn declared_columns(
140 routines: &dyn RoutineResolution,
141 function: &SQLUserFunction,
142 invocation: Option<&RoutineInvocationBinding>,
143 aliases: &[String],
144 ordinality: bool,
145 control: &ProductionControl<'_>,
146) -> Result<Option<Produced<Vec<String>>>, SQLError> {
147 match user_function_composite_result_with_control(routines, function, invocation, control)? {
148 Some(descriptor) => columns(
149 descriptor
150 .attributes
151 .iter()
152 .map(|attribute| ColumnName::Written(&attribute.name)),
153 descriptor.attributes.len(),
154 aliases,
155 ordinality,
156 control,
157 )
158 .map(Some),
159 None => output_columns(function, aliases, ordinality, control),
160 }
161}
162
163fn output_columns(
164 function: &SQLUserFunction,
165 aliases: &[String],
166 ordinality: bool,
167 control: &ProductionControl<'_>,
168) -> Result<Option<Produced<Vec<String>>>, SQLError> {
169 control.check()?;
170 let outputs = function.def.output_params();
171 if outputs.clone().next().is_none() {
172 return Ok(None);
173 }
174 let count = outputs.clone().count();
175 columns(
176 outputs.enumerate().map(|(index, parameter)| {
177 if parameter.name.is_empty() {
178 ColumnName::Ordinal(index + 1)
179 } else {
180 ColumnName::Written(¶meter.name)
181 }
182 }),
183 count,
184 aliases,
185 ordinality,
186 control,
187 )
188 .map(Some)
189}
190
191enum ColumnName<'a> {
192 Written(&'a str),
193 Ordinal(usize),
194}
195
196fn columns<'a>(
197 names: impl Iterator<Item = ColumnName<'a>>,
198 count: usize,
199 aliases: &[String],
200 ordinality: bool,
201 control: &ProductionControl<'_>,
202) -> Result<Produced<Vec<String>>, SQLError> {
203 let mut output = ProductionVec::new(*control);
204 output.reserve(count + usize::from(ordinality))?;
205 for (index, name) in names.enumerate() {
206 control.check()?;
207 output.push_produced(match aliases.get(index) {
208 Some(alias) => control.copy_text(alias)?,
209 None => match name {
210 ColumnName::Written(name) => control.copy_text(name)?,
211 ColumnName::Ordinal(index) => control.format(format_args!("column{index}"))?,
212 },
213 })?;
214 }
215 if ordinality {
216 output.push_produced(
217 control.copy_text(aliases.get(count).map_or("ordinality", String::as_str))?,
218 )?;
219 }
220 Ok(output.finish()?)
221}
222
223pub(super) fn user_function_result_class_with_control(
224 routines: &dyn RoutineResolution,
225 function: &SQLUserFunction,
226 invocation: Option<&RoutineInvocationBinding>,
227 control: &ProductionControl<'_>,
228) -> Result<ResultClass, SQLError> {
229 control.check()?;
230 if crate::routines::routine_returns_anonymous_record_with_control(&function.def, control)? {
231 return Ok(ResultClass::Record);
232 }
233 if function.def.output_params().nth(1).is_some() {
234 return Ok(ResultClass::OutParameters);
235 }
236 let output = function
237 .def
238 .params
239 .iter()
240 .enumerate()
241 .find(|(_, parameter)| {
242 matches!(
243 parameter.mode,
244 crate::ast::FunctionParamMode::Out
245 | crate::ast::FunctionParamMode::InOut
246 | crate::ast::FunctionParamMode::Table
247 )
248 });
249 let (declared, concrete) = match (output, &function.def.returns) {
250 (Some((position, output)), _) => (
251 output.type_name.as_str(),
252 invocation
253 .and_then(|invocation| invocation.parameter_types.get(position))
254 .map(String::as_str),
255 ),
256 (None, FunctionReturns::Scalar { type_name } | FunctionReturns::SetOf { type_name }) => (
257 type_name.as_str(),
258 invocation.and_then(|invocation| invocation.return_type.as_deref()),
259 ),
260 _ => return Ok(ResultClass::Scalar),
261 };
262 let name = concrete.unwrap_or(declared);
263 if crate::type_resolution::routine_polymorphic_type_with_control(name, control)?.is_some() {
264 return Ok(ResultClass::Unclassified);
265 }
266 Ok(routines
267 .resolve_type_name_with_control(name, control)?
268 .as_deref()
269 .map_or(
270 ResultClass::Scalar,
271 super::column_definitions::type_result_class,
272 ))
273}
274
275pub fn validate_table_function_alias_count_with_control(
276 table_alias: &str,
277 available: usize,
278 specified: usize,
279 control: &ProductionControl<'_>,
280) -> Result<(), SQLError> {
281 control.check()?;
282 if specified <= available {
283 return Ok(());
284 }
285 let message = control.format(format_args!("table \"{table_alias}\" has {available} columns available but {specified} columns specified"))?;
286 let sqlstate = control.copy_text("42P10")?;
287 Err(SQLError::Routine {
288 sqlstate: sqlstate.into_parts().0,
289 message: message.into_parts().0,
290 })
291}