Skip to main content

uqa_sql/semantics/
table_functions.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Table-function binding, declared result types, and source aliases.
8
9use crate::ast::{
10    ColumnType, FunctionBinding, FunctionParamMode, FunctionReturns, RoutineInvocationBinding,
11};
12use crate::routines::{RoutineResolution, SQLUserFunction};
13use crate::type_resolution::{BuiltinFunctionOverload, FunctionTypeResolver};
14use crate::{RowSchema, SQLError, SQLParam, ScalarExpr};
15use std::sync::Arc;
16
17mod column_definitions;
18pub use column_definitions::{
19    validate_table_function_column_definition, ColumnDefinitionRequest,
20    SETOF_COLUMN_DEFINITION_PREFIX,
21};
22
23pub struct ResolvedUserTableFunction {
24    pub function: Arc<SQLUserFunction>,
25    pub binding: FunctionBinding,
26}
27
28/// Correct the old integer series declaration, which recorded a nonexistent default on the three-argument overload. This only accepts the exact builtin catalog shape; it never resolves a persisted call by its display name.
29pub(crate) fn upgrade_legacy_table_function_binding(
30    binding: &mut Option<FunctionBinding>,
31    argument_count: usize,
32) -> bool {
33    let Some(binding) = binding else {
34        return false;
35    };
36    if argument_count != 2
37        || !binding.builtin
38        || binding.object_id.is_some()
39        || binding.name != "pg_catalog.generate_series"
40        || binding.dispatch.is_some()
41        || binding.invocation.is_some()
42        || binding.resolution_error.is_some()
43    {
44        return false;
45    }
46    let [first, second, third] = binding.argument_types.as_slice() else {
47        return false;
48    };
49    if !matches!(first.as_str(), "integer" | "bigint") || first != second || first != third {
50        return false;
51    }
52    binding.argument_types.truncate(2);
53    true
54}
55
56pub fn user_function_output_columns_for(function: &SQLUserFunction) -> Option<Vec<String>> {
57    let outputs = function.def.output_params();
58    outputs.clone().next()?;
59    Some(
60        outputs
61            .enumerate()
62            .map(|(position, parameter)| {
63                if parameter.name.is_empty() {
64                    format!("column{}", position + 1)
65                } else {
66                    parameter.name.clone()
67                }
68            })
69            .collect(),
70    )
71}
72
73/// A named composite returned by a function expands to its live attributes in FROM, including a single composite OUT parameter.
74pub fn user_function_composite_result(
75    routines: &dyn RoutineResolution,
76    function: &SQLUserFunction,
77    invocation: Option<&RoutineInvocationBinding>,
78) -> Result<Option<Arc<crate::expr::composites::CompositeTypeDescriptor>>, SQLError> {
79    let mut outputs = function.def.output_params();
80    if outputs.clone().nth(1).is_some() {
81        return Ok(None);
82    }
83    let declared = match (&function.def.returns, outputs.next()) {
84        (_, Some(output)) => Some(output.type_name.as_str()),
85        (FunctionReturns::Scalar { type_name } | FunctionReturns::SetOf { type_name }, None) => {
86            Some(type_name.as_str())
87        }
88        _ => None,
89    };
90    let Some(name) = invocation
91        .and_then(|value| value.return_type.as_deref())
92        .or(declared)
93    else {
94        return Ok(None);
95    };
96    // A polymorphic result without a resolved invocation type names no composite.
97    if crate::type_resolution::routine_polymorphic_type(name).is_some() {
98        return Ok(None);
99    }
100    let Some(ColumnType::Composite(reference)) = routines.resolve_type_name(name)? else {
101        return Ok(None);
102    };
103    crate::expr::composites::descriptor(routines.composite_types(), reference.oid).map(Some)
104}
105
106/// The columns a user function in FROM declares, before column aliases: a named composite result's attributes, including those of a single composite OUT parameter, or else the OUT parameters. `None` for a function with neither, whose single column the FROM item names.
107pub fn user_function_declared_columns(
108    routines: &dyn RoutineResolution,
109    function: &SQLUserFunction,
110    invocation: Option<&RoutineInvocationBinding>,
111) -> Result<Option<Vec<String>>, SQLError> {
112    Ok(
113        user_function_composite_result(routines, function, invocation)?
114            .map(|descriptor| {
115                descriptor
116                    .attributes
117                    .iter()
118                    .map(|attribute| attribute.name.clone())
119                    .collect()
120            })
121            .or_else(|| user_function_output_columns_for(function)),
122    )
123}
124
125/// Derive a user FROM function's width from its result type before applying aliases. Only an anonymous record takes its shape from the column definition list; aliases never add fields to a scalar result.
126pub fn user_table_function_columns(
127    routines: &dyn RoutineResolution,
128    function: &SQLUserFunction,
129    invocation: Option<&RoutineInvocationBinding>,
130    output_name: &str,
131    alias: Option<&str>,
132    column_aliases: &[String],
133    ordinality: bool,
134) -> Result<Vec<String>, SQLError> {
135    let columns = if column_definitions::user_function_result_class(routines, function, invocation)?
136        == column_definitions::ResultClass::Record
137    {
138        column_aliases.to_vec()
139    } else {
140        user_function_declared_columns(routines, function, invocation)?
141            .unwrap_or_else(|| vec![alias.unwrap_or(output_name).to_string()])
142    };
143    let columns = apply_table_function_aliases(columns, column_aliases, ordinality);
144    validate_table_function_alias_count(
145        alias.unwrap_or(output_name),
146        columns.len(),
147        column_aliases.len(),
148    )?;
149    Ok(columns)
150}
151
152pub fn resolve_user_table_function(
153    routines: &dyn RoutineResolution,
154    name: &str,
155    binding: Option<&FunctionBinding>,
156    args: &[ScalarExpr],
157    input_schema: &RowSchema,
158    params: &[SQLParam],
159    resolver: &dyn FunctionTypeResolver,
160) -> Result<Option<ResolvedUserTableFunction>, SQLError> {
161    let Some(binding) = resolve_table_function_binding(
162        routines,
163        name,
164        binding,
165        args,
166        input_schema,
167        params,
168        resolver,
169    )?
170    else {
171        return Ok(None);
172    };
173    if binding.builtin {
174        return Ok(None);
175    }
176    let (argument_names, argument_types, explicit_variadic) =
177        crate::function_call_argument_signature(args, input_schema, params, Some(resolver))?;
178    let Some(matched) = routines.resolve_static_sql_function_match(
179        name,
180        Some(&binding),
181        &argument_names,
182        &argument_types,
183        explicit_variadic,
184    )?
185    else {
186        return Ok(None);
187    };
188    Ok(Some(ResolvedUserTableFunction {
189        binding: matched.binding(),
190        function: matched.function,
191    }))
192}
193
194pub fn resolve_table_function_binding(
195    routines: &dyn RoutineResolution,
196    name: &str,
197    binding: Option<&FunctionBinding>,
198    args: &[ScalarExpr],
199    input_schema: &RowSchema,
200    params: &[SQLParam],
201    resolver: &dyn FunctionTypeResolver,
202) -> Result<Option<FunctionBinding>, SQLError> {
203    if let Some(binding) = binding {
204        return Ok(Some(binding.clone()));
205    }
206    let (argument_names, argument_types, explicit_variadic) =
207        crate::function_call_argument_signature(args, input_schema, params, Some(resolver))?;
208    if crate::type_resolution::function_arguments_have_runtime_types(args, &argument_types)? {
209        return Ok(None);
210    }
211    resolve_table_function_binding_for_types(
212        routines,
213        name,
214        binding,
215        crate::type_resolution::RoutineCallDescriptor {
216            argument_names: &argument_names,
217            argument_types: &argument_types,
218            explicit_variadic,
219        },
220    )
221}
222
223/// Select a call whose dynamic inputs have now produced values, preserving every statically declared argument type and the original SQL unknown-literal rules.
224pub fn resolve_runtime_table_function_binding(
225    routines: &dyn RoutineResolution,
226    name: &str,
227    args: &[ScalarExpr],
228    values: &[(Option<String>, uqa_core::Value)],
229    input_schema: &RowSchema,
230    params: &[SQLParam],
231    resolver: &dyn FunctionTypeResolver,
232) -> Result<Option<FunctionBinding>, SQLError> {
233    let (argument_names, mut argument_types, explicit_variadic) =
234        crate::function_call_argument_signature(args, input_schema, params, Some(resolver))?;
235    let arguments = crate::scalar_call_arguments(args)?;
236    assert_eq!(arguments.len(), values.len());
237    for ((argument, ty), (_, value)) in arguments.iter().zip(&mut argument_types).zip(values) {
238        if crate::type_resolution::runtime_input(argument.value, ty.as_ref()) {
239            *ty = crate::type_resolution::value_type(value);
240        }
241    }
242    resolve_table_function_binding_for_types(
243        routines,
244        name,
245        None,
246        crate::type_resolution::RoutineCallDescriptor {
247            argument_names: &argument_names,
248            argument_types: &argument_types,
249            explicit_variadic,
250        },
251    )
252}
253
254/// Select a FROM call from arguments already analyzed in their owning scalar-subquery scope.
255pub(crate) fn resolve_table_function_binding_for_types(
256    routines: &dyn RoutineResolution,
257    name: &str,
258    binding: Option<&FunctionBinding>,
259    call: crate::type_resolution::RoutineCallDescriptor<'_>,
260) -> Result<Option<FunctionBinding>, SQLError> {
261    if let Some(binding) = binding {
262        return Ok(Some(binding.clone()));
263    }
264    let crate::type_resolution::RoutineCallDescriptor {
265        argument_names,
266        argument_types,
267        explicit_variadic,
268    } = call;
269    let identity = name.to_ascii_lowercase();
270    let builtin = crate::semantics::builtin_function_dispatch_name(&identity);
271    let builtins = builtin_table_function_overloads(&builtin, argument_types);
272    if !builtins.is_empty() || has_builtin_table_function_overloads(&builtin) {
273        return routines
274            .resolve_table_function_overload_with_builtins(
275                name,
276                None,
277                argument_names,
278                argument_types,
279                explicit_variadic,
280                &builtins,
281            )
282            .map(|resolved| resolved.map(|resolved| resolved.binding));
283    }
284    let builtin_surface = is_builtin_table_function(&builtin)
285        || crate::registry::is_operator_join_table_function(&builtin)
286        || routines.has_registered_table_function(&identity);
287    if routines.lookup_visible_sql_functions(name)?.is_none() {
288        return Ok(None);
289    }
290    match routines.resolve_static_sql_function_match(
291        name,
292        None,
293        argument_names,
294        argument_types,
295        explicit_variadic,
296    ) {
297        Ok(Some(function)) => Ok(Some(function.binding())),
298        Ok(None) => Ok(None),
299        Err(error) if builtin_surface && error.sqlstate() == Some("42883") => Ok(None),
300        Err(error) => Err(error),
301    }
302}
303
304fn has_builtin_table_function_overloads(name: &str) -> bool {
305    matches!(
306        name,
307        "generate_series"
308            | "pg_listening_channels"
309            | "unnest"
310            | "regexp_matches"
311            | "regexp_split_to_table"
312            | "string_to_table"
313            | "json_array_elements"
314            | "jsonb_array_elements"
315            | "json_array_elements_text"
316            | "jsonb_array_elements_text"
317            | "json_object_keys"
318            | "jsonb_object_keys"
319            | "json_each"
320            | "jsonb_each"
321            | "json_each_text"
322            | "jsonb_each_text"
323            | "pg_get_sequence_data"
324            | "pg_sequence_parameters"
325            | "aclexplode"
326    )
327}
328
329fn builtin_table_function_overloads(
330    name: &str,
331    argument_types: &[Option<ColumnType>],
332) -> Vec<BuiltinFunctionOverload> {
333    let canonical_name = format!("pg_catalog.{name}");
334    let overload = |argument_types: Vec<ColumnType>,
335                    default_arguments: usize,
336                    return_type: ColumnType| BuiltinFunctionOverload {
337        variadic: false,
338        name: canonical_name.clone(),
339        argument_names: vec![None; argument_types.len()],
340        argument_types,
341        default_arguments,
342        return_type,
343    };
344    match name {
345        "pg_listening_channels" => vec![overload(Vec::new(), 0, ColumnType::Text)],
346        "generate_series" => crate::type_resolution::fixed_builtin_overloads(name)
347            .expect("generate_series has fixed catalog signatures")
348            .into_iter()
349            .filter(|overload| {
350                matches!(
351                    overload.return_type,
352                    ColumnType::Integer | ColumnType::BigInteger
353                )
354            })
355            .collect(),
356        "unnest" => {
357            let [Some(argument)] = argument_types else {
358                return Vec::new();
359            };
360            let Some(element) = crate::type_resolution::array_element_type(argument) else {
361                return Vec::new();
362            };
363            vec![overload(vec![ColumnType::AnyArray], 0, element.clone())]
364        }
365        // The scalar and FROM positions select from the same catalog signatures.
366        "regexp_matches" | "regexp_split_to_table" => {
367            crate::type_resolution::fixed_builtin_overloads(name)
368                .expect("regular-expression set functions have fixed catalog signatures")
369        }
370        "string_to_table" => vec![overload(
371            vec![ColumnType::Text, ColumnType::Text],
372            0,
373            ColumnType::Text,
374        )],
375        "json_array_elements" => vec![overload(vec![ColumnType::Json], 0, ColumnType::Json)],
376        "jsonb_array_elements" => vec![overload(vec![ColumnType::JsonB], 0, ColumnType::JsonB)],
377        "json_array_elements_text" | "json_object_keys" => {
378            vec![overload(vec![ColumnType::Json], 0, ColumnType::Text)]
379        }
380        "jsonb_array_elements_text" | "jsonb_object_keys" => {
381            vec![overload(vec![ColumnType::JsonB], 0, ColumnType::Text)]
382        }
383        "json_each" | "json_each_text" => {
384            vec![overload(vec![ColumnType::Json], 0, ColumnType::Record)]
385        }
386        "jsonb_each" | "jsonb_each_text" => {
387            vec![overload(vec![ColumnType::JsonB], 0, ColumnType::Record)]
388        }
389        "pg_get_sequence_data" => vec![overload(vec![ColumnType::Regclass], 0, ColumnType::Record)],
390        "pg_sequence_parameters" => {
391            vec![overload(vec![ColumnType::Oid], 0, ColumnType::Record)]
392        }
393        "aclexplode" => vec![overload(
394            vec![ColumnType::Array(Box::new(ColumnType::AclItem))],
395            0,
396            ColumnType::Record,
397        )],
398        _ => Vec::new(),
399    }
400}
401
402pub fn is_builtin_table_function(name: &str) -> bool {
403    matches!(
404        name,
405        "generate_series"
406            | "pg_listening_channels"
407            | "unnest"
408            | "regexp_matches"
409            | "regexp_split_to_table"
410            | "string_to_table"
411            | "json_array_elements"
412            | "jsonb_array_elements"
413            | "json_array_elements_text"
414            | "jsonb_array_elements_text"
415            | "json_object_keys"
416            | "jsonb_object_keys"
417            | "json_each"
418            | "jsonb_each"
419            | "json_each_text"
420            | "jsonb_each_text"
421            | "pg_get_sequence_data"
422            | "pg_sequence_parameters"
423            | "aclexplode"
424            | "create_analyzer"
425            | "drop_analyzer"
426            | "list_analyzers"
427            | "analyze_text"
428            | "fts_index_stats"
429            | "set_table_analyzer"
430            | "pagerank"
431            | "graph_pagerank"
432            | "hits"
433            | "graph_hits"
434            | "betweenness"
435            | "graph_betweenness"
436            | "graph_edges"
437            | "rpq"
438            | "cypher"
439    )
440}
441
442pub fn table_function_empty_schema(
443    name: &str,
444    output_name: &str,
445    alias: Option<&str>,
446    column_aliases: &[String],
447    output_width: usize,
448    ordinality: bool,
449) -> Vec<String> {
450    let lower = crate::semantics::builtin_function_dispatch_name(name);
451    let columns = if lower == "unnest" {
452        let width = output_width.max(1);
453        let default_column = if width == 1 {
454            alias.unwrap_or(output_name)
455        } else {
456            output_name
457        };
458        vec![default_column.to_string(); width]
459    } else {
460        match lower.as_ref() {
461            "json_each" | "jsonb_each" | "json_each_text" | "jsonb_each_text" => {
462                vec!["key".into(), "value".into()]
463            }
464            "pg_get_sequence_data" => vec!["last_value".into(), "is_called".into()],
465            "aclexplode" => vec![
466                "grantor".into(),
467                "grantee".into(),
468                "privilege_type".into(),
469                "is_grantable".into(),
470            ],
471            "pg_sequence_parameters" => vec![
472                "start_value".into(),
473                "minimum_value".into(),
474                "maximum_value".into(),
475                "increment".into(),
476                "cycle_option".into(),
477                "cache_size".into(),
478                "data_type".into(),
479            ],
480            "pagerank" | "graph_pagerank" | "hits" | "graph_hits" | "betweenness"
481            | "graph_betweenness" => vec!["_doc_id".into(), "_score".into()],
482            "rpq" => vec!["vertex_id".into()],
483            "list_analyzers" => vec!["analyzer_name".into()],
484            "analyze_text" => vec!["analysis".into()],
485            "fts_index_stats" => vec![
486                "table_name".into(),
487                "field".into(),
488                "analyzer".into(),
489                "posting_count".into(),
490                "doc_length_count".into(),
491                "indexed_doc_count".into(),
492                "term_count".into(),
493                "total_field_length".into(),
494            ],
495            "text_similarity_join"
496            | "vector_similarity_join"
497            | "graph_join"
498            | "hybrid_join"
499            | "cross_paradigm_join" => {
500                vec!["left_doc_id".into(), "right_doc_id".into(), "_score".into()]
501            }
502            "generate_series"
503            | "pg_listening_channels"
504            | "regexp_matches"
505            | "regexp_split_to_table"
506            | "string_to_table"
507            | "json_array_elements"
508            | "jsonb_array_elements"
509            | "json_array_elements_text"
510            | "jsonb_array_elements_text"
511            | "json_object_keys"
512            | "jsonb_object_keys" => vec![scalar_table_function_default_column(
513                &lower,
514                output_name,
515                alias,
516                &[],
517            )],
518            _ => {
519                let minimum_width = 1;
520                let aliased_value_width = if ordinality && column_aliases.len() > minimum_width {
521                    column_aliases.len() - 1
522                } else {
523                    column_aliases.len()
524                };
525                vec![
526                    scalar_table_function_default_column(&lower, output_name, alias, &[]);
527                    minimum_width.max(aliased_value_width)
528                ]
529            }
530        }
531    };
532    apply_table_function_aliases(columns, column_aliases, ordinality)
533}
534
535pub fn apply_table_function_aliases(
536    mut columns: Vec<String>,
537    column_aliases: &[String],
538    ordinality: bool,
539) -> Vec<String> {
540    if ordinality {
541        columns.push("ordinality".into());
542    }
543    for (column, alias) in columns.iter_mut().zip(column_aliases) {
544        column.clone_from(alias);
545    }
546    columns
547}
548
549pub fn validate_table_function_alias_count(
550    table_alias: &str,
551    available: usize,
552    specified: usize,
553) -> Result<(), SQLError> {
554    if specified <= available {
555        return Ok(());
556    }
557    Err(SQLError::Routine {
558        sqlstate: "42P10".into(),
559        message: format!(
560            "table \"{table_alias}\" has {available} columns available but {specified} columns specified"
561        ),
562    })
563}
564
565pub struct TableFunctionTypeRequest<'a> {
566    pub name: &'a str,
567    pub binding: Option<&'a FunctionBinding>,
568    pub args: &'a [ScalarExpr],
569    pub user_function: Option<&'a SQLUserFunction>,
570    pub user_invocation: Option<&'a RoutineInvocationBinding>,
571    pub declared_types: &'a [String],
572    pub columns: &'a [String],
573    pub ordinality: bool,
574}
575
576#[expect(
577    clippy::too_many_lines,
578    reason = "preserves source schema and row identity"
579)]
580pub fn table_function_column_types(
581    routines: &dyn RoutineResolution,
582    request: TableFunctionTypeRequest<'_>,
583    input_schema: &crate::RowSchema,
584    params: &[SQLParam],
585    resolver: &dyn FunctionTypeResolver,
586) -> Vec<Option<ColumnType>> {
587    let TableFunctionTypeRequest {
588        name,
589        binding,
590        args,
591        user_function,
592        user_invocation,
593        declared_types,
594        columns,
595        ordinality,
596    } = request;
597    let value_columns = if ordinality {
598        columns
599            .get(..columns.len().saturating_sub(1))
600            .unwrap_or(&[])
601    } else {
602        columns
603    };
604    let align = |types: Vec<Option<ColumnType>>| {
605        if types.len() == value_columns.len() {
606            types
607        } else if let [ty] = types.as_slice() {
608            vec![ty.clone(); value_columns.len()]
609        } else {
610            vec![None; value_columns.len()]
611        }
612    };
613    let mut types = if !declared_types.is_empty() {
614        align(
615            declared_types
616                .iter()
617                .map(|ty| ColumnType::from_sql_name(ty).ok())
618                .collect(),
619        )
620    } else if let Some(function) = user_function {
621        align(user_function_column_types(
622            routines,
623            function,
624            user_invocation,
625        ))
626    } else {
627        let normalized = crate::semantics::builtin_function_dispatch_name(name);
628        align(match normalized.as_ref() {
629            "pg_listening_channels" => vec![Some(ColumnType::Text)],
630            "generate_series" => vec![resolve_table_function_binding(
631                routines,
632                name,
633                binding,
634                args,
635                input_schema,
636                params,
637                resolver,
638            )
639            .ok()
640            .flatten()
641            .as_ref()
642            .and_then(crate::type_resolution::fixed_builtin_return_type)],
643            "analyze_text" => vec![Some(ColumnType::JsonB)],
644            "unnest" => args
645                .iter()
646                .map(|argument| {
647                    crate::scalar_type_with_resolver(argument, input_schema, params, resolver)
648                        .ok()
649                        .flatten()
650                        .and_then(|ty| crate::type_resolution::array_element_type(&ty).cloned())
651                })
652                .collect(),
653            "regexp_matches" => vec![Some(ColumnType::Array(Box::new(ColumnType::Text)))],
654            "regexp_split_to_table"
655            | "string_to_table"
656            | "json_object_keys"
657            | "jsonb_object_keys" => vec![Some(ColumnType::Text)],
658            "json_array_elements" => vec![Some(ColumnType::Json)],
659            "jsonb_array_elements" => vec![Some(ColumnType::JsonB)],
660            "json_array_elements_text" | "jsonb_array_elements_text" => {
661                vec![Some(ColumnType::Text)]
662            }
663            "json_each" => vec![Some(ColumnType::Text), Some(ColumnType::Json)],
664            "jsonb_each" => vec![Some(ColumnType::Text), Some(ColumnType::JsonB)],
665            "json_each_text" | "jsonb_each_text" => {
666                vec![Some(ColumnType::Text), Some(ColumnType::Text)]
667            }
668            "pg_get_sequence_data" => {
669                vec![Some(ColumnType::BigInteger), Some(ColumnType::Boolean)]
670            }
671            "pg_sequence_parameters" => vec![
672                Some(ColumnType::BigInteger),
673                Some(ColumnType::BigInteger),
674                Some(ColumnType::BigInteger),
675                Some(ColumnType::BigInteger),
676                Some(ColumnType::Boolean),
677                Some(ColumnType::BigInteger),
678                Some(ColumnType::Oid),
679            ],
680            "aclexplode" => vec![
681                Some(ColumnType::Oid),
682                Some(ColumnType::Oid),
683                Some(ColumnType::Text),
684                Some(ColumnType::Boolean),
685            ],
686            "pagerank" | "graph_pagerank" | "hits" | "graph_hits" | "betweenness"
687            | "graph_betweenness" => vec![
688                Some(ColumnType::BigInteger),
689                Some(ColumnType::DoublePrecision),
690            ],
691            "rpq" => vec![Some(ColumnType::BigInteger)],
692            "text_similarity_join"
693            | "vector_similarity_join"
694            | "graph_join"
695            | "hybrid_join"
696            | "cross_paradigm_join" => vec![
697                Some(ColumnType::BigInteger),
698                Some(ColumnType::BigInteger),
699                Some(ColumnType::DoublePrecision),
700            ],
701            _ => user_table_function_column_types(
702                routines,
703                name,
704                args,
705                input_schema,
706                params,
707                resolver,
708            ),
709        })
710    };
711    if ordinality {
712        types.push(Some(ColumnType::BigInteger));
713    }
714    types
715}
716
717fn user_table_function_column_types(
718    routines: &dyn RoutineResolution,
719    name: &str,
720    args: &[ScalarExpr],
721    input_schema: &crate::RowSchema,
722    params: &[SQLParam],
723    resolver: &dyn FunctionTypeResolver,
724) -> Vec<Option<ColumnType>> {
725    let Ok((argument_names, argument_types, explicit_variadic)) =
726        crate::function_call_argument_signature(args, input_schema, params, Some(resolver))
727    else {
728        return Vec::new();
729    };
730    let Ok(Some(matched)) = routines.resolve_static_sql_function_match(
731        name,
732        None,
733        &argument_names,
734        &argument_types,
735        explicit_variadic,
736    ) else {
737        return Vec::new();
738    };
739    user_function_column_types(routines, &matched.function, Some(&matched.invocation))
740}
741
742fn user_function_column_types(
743    routines: &dyn RoutineResolution,
744    function: &SQLUserFunction,
745    invocation: Option<&RoutineInvocationBinding>,
746) -> Vec<Option<ColumnType>> {
747    if let Ok(Some(descriptor)) = user_function_composite_result(routines, function, invocation) {
748        return descriptor
749            .attributes
750            .iter()
751            .map(|attribute| Some(attribute.ty.clone()))
752            .collect();
753    }
754    let outputs = function
755        .def
756        .params
757        .iter()
758        .enumerate()
759        .filter(|(_, parameter)| {
760            matches!(
761                parameter.mode,
762                FunctionParamMode::Out | FunctionParamMode::InOut | FunctionParamMode::Table
763            )
764        })
765        .collect::<Vec<_>>();
766    if !outputs.is_empty() {
767        return outputs
768            .into_iter()
769            .map(|(index, parameter)| {
770                let type_name = invocation
771                    .and_then(|binding| binding.parameter_types.get(index))
772                    .unwrap_or(&parameter.type_name);
773                resolve_table_function_column_type(routines, type_name)
774            })
775            .collect();
776    }
777    match &function.def.returns {
778        FunctionReturns::Scalar { type_name } | FunctionReturns::SetOf { type_name } => {
779            let type_name = invocation
780                .and_then(|binding| binding.return_type.as_ref())
781                .unwrap_or(type_name);
782            vec![resolve_table_function_column_type(routines, type_name)]
783        }
784        FunctionReturns::None | FunctionReturns::Table => Vec::new(),
785    }
786}
787
788fn resolve_table_function_column_type(
789    routines: &dyn RoutineResolution,
790    type_name: &str,
791) -> Option<ColumnType> {
792    routines
793        .resolve_type_name(type_name)
794        .ok()
795        .flatten()
796        .or_else(|| ColumnType::from_sql_name(type_name).ok())
797}
798
799pub fn is_json_array_table_function(name: &str) -> bool {
800    matches!(
801        name,
802        "json_array_elements"
803            | "jsonb_array_elements"
804            | "json_array_elements_text"
805            | "jsonb_array_elements_text"
806    )
807}
808
809pub fn scalar_table_function_default_column(
810    normalized_name: &str,
811    output_name: &str,
812    alias: Option<&str>,
813    column_aliases: &[String],
814) -> String {
815    column_aliases.first().cloned().unwrap_or_else(|| {
816        if is_json_array_table_function(normalized_name) {
817            "value".into()
818        } else {
819            alias.unwrap_or(output_name).to_string()
820        }
821    })
822}
823pub fn join_alias_columns(
824    schema: &crate::RowSchema,
825    alias: &str,
826    column_aliases: &[String],
827) -> Result<Vec<String>, SQLError> {
828    let available = schema.len();
829    let specified = column_aliases.len();
830    if specified > available {
831        return Err(SQLError::Routine {
832            sqlstate: "42P10".into(),
833            message: format!(
834                "join expression \"{alias}\" has {available} columns available but {specified} columns specified"
835            ),
836        });
837    }
838    Ok(schema
839        .columns()
840        .iter()
841        .enumerate()
842        .map(|(position, column)| {
843            column_aliases
844                .get(position)
845                .cloned()
846                .unwrap_or_else(|| schema.public_name(position).unwrap_or(column).to_string())
847        })
848        .collect())
849}
850
851pub fn alias_join_schema(
852    schema: &crate::RowSchema,
853    alias: Option<&str>,
854    column_aliases: &[String],
855) -> Result<crate::RowSchema, SQLError> {
856    let Some(alias) = alias else {
857        if column_aliases.is_empty() {
858            return Ok(schema.clone());
859        }
860        return Err(SQLError::Internal(
861            "JOIN column aliases exist without a relation alias".into(),
862        ));
863    };
864    let columns = join_alias_columns(schema, alias, column_aliases)?;
865    Ok(
866        crate::RowSchema::with_qualified_types(alias, columns, schema.column_types().to_vec())
867            .with_column_diagnostic_names_from(schema),
868    )
869}
870
871#[cfg(test)]
872mod tests;