Skip to main content

uqa_sql/semantics/table_functions/
production.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Selected function result metadata admits final column names before producing their buffers.
8
9use 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(&parameter.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}