1use 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
28pub(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
73pub 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 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
106pub 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
125pub 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
223pub 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
254pub(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 "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(¶meter.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;