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 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
76pub 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 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
109pub 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
128pub 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
223pub(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 "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(¶meter.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;