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