use crate::ast::{ColumnType, FunctionBinding};
use crate::{SQLError, SQLParam};
use uqa_core::memory::{Produced, ProductionControl};
use crate::{scalar_call_argument, schema::ScalarTypeSchema, ScalarExpr};
use super::{fixed_builtin, scalar_type_inner, FunctionTypeResolver};
mod concat;
mod production;
pub(super) mod targets;
pub(crate) use targets::builtin_function_argument_targets_with_control;
mod signatures;
pub(super) use concat::{array_concat_argument, array_concat_types};
pub(super) use production::builtin_function_type_with_control;
#[derive(Clone, Copy)]
pub(super) struct FunctionTypeCall<'a> {
pub name: &'a str,
pub binding: Option<&'a FunctionBinding>,
pub args: &'a [ScalarExpr],
}
pub fn builtin_function_type(
name: &str,
args: &[ScalarExpr],
order_by: &[crate::ScalarOrder],
schema: &dyn ScalarTypeSchema,
params: &[SQLParam],
) -> Result<Option<ColumnType>, SQLError> {
builtin_function_type_inner(name, None, args, order_by, schema, params, None)
}
pub fn builtin_function_type_with_resolver(
name: &str,
args: &[ScalarExpr],
order_by: &[crate::ScalarOrder],
schema: &dyn ScalarTypeSchema,
params: &[SQLParam],
resolver: &dyn FunctionTypeResolver,
) -> Result<Option<ColumnType>, SQLError> {
builtin_function_type_inner(name, None, args, order_by, schema, params, Some(resolver))
}
pub(crate) fn builtin_function_type_with_resolver_and_control(
name: &str,
args: &[ScalarExpr],
order_by: &[crate::ScalarOrder],
schema: &dyn ScalarTypeSchema,
params: &[SQLParam],
resolver: &dyn FunctionTypeResolver,
control: &ProductionControl<'_>,
) -> Result<Option<Produced<ColumnType>>, SQLError> {
builtin_function_type_with_control(
FunctionTypeCall {
name,
binding: None,
args,
},
order_by,
params,
Some(resolver),
&mut |expression| {
super::scalar_type_with_resolver_and_control(
expression,
schema,
params,
Some(resolver),
control,
)
},
control,
)
}
#[must_use]
pub fn builtin_function_argument_targets(
name: &str,
argument_types: &[Option<ColumnType>],
) -> Vec<Option<ColumnType>> {
builtin_function_argument_targets_with_control(
name,
argument_types,
&ProductionControl::uncontrolled(),
)
.expect("ordinary target production has no resource failure")
.into_uncontrolled()
.expect("ordinary target vector")
}
pub(super) fn compatible_array_argument(name: &str, position: usize) -> bool {
name == "array_cat" || position == usize::from(name == "array_prepend")
}
pub(super) fn compatible_array_result_type(
name: &str,
argument_types: &[Option<ColumnType>],
control: &ProductionControl<'_>,
) -> Result<Option<Produced<ColumnType>>, SQLError> {
let mut element: Option<Produced<ColumnType>> = None;
for (position, argument) in argument_types.iter().enumerate() {
control.check()?;
let Some(argument) = argument else { continue };
let candidate = if compatible_array_argument(name, position) {
let Some(element) = super::array_element_type(argument) else {
return Ok(None);
};
element
} else {
argument
};
element = Some(match element {
None => candidate.clone_with_control(control)?,
Some(previous) => {
super::common::common_type_with_control(&previous, candidate, control)?
}
});
}
element
.map(|element| ColumnType::array_with_control(element, control).map_err(Into::into))
.transpose()
}
pub(super) fn builtin_function_type_inner(
name: &str,
binding: Option<&FunctionBinding>,
args: &[ScalarExpr],
order_by: &[crate::ScalarOrder],
schema: &dyn ScalarTypeSchema,
params: &[SQLParam],
resolver: Option<&dyn FunctionTypeResolver>,
) -> Result<Option<ColumnType>, SQLError> {
let control = ProductionControl::uncontrolled();
if binding.and_then(|binding| binding.dispatch)
== Some(crate::ast::FunctionDispatch::FieldSelect)
{
if let Some(field) = binding.and_then(|binding| binding.composite_field()) {
return Ok(Some(field.result_type.clone()));
}
return super::inference::field_selection_type(args, schema, params, resolver, &control)
.map(|ty| {
ty.map(|ty| {
ty.into_uncontrolled()
.expect("ordinary field selection type")
})
});
}
let mut infer = |expression: &ScalarExpr| {
scalar_type_inner(expression, schema, params, resolver)?
.map(|ty| {
control
.finish(ty, control.empty_reservation())
.map_err(Into::into)
})
.transpose()
};
builtin_function_type_with_control(
FunctionTypeCall {
name,
binding,
args,
},
order_by,
params,
resolver,
&mut infer,
&control,
)
.map(|ty| {
ty.map(|ty| {
ty.into_uncontrolled()
.expect("ordinary builtin result type")
})
})
}
pub(super) fn named_argument(expression: &ScalarExpr) -> (Option<String>, &ScalarExpr) {
scalar_call_argument(expression).map_or((None, expression), |argument| {
(argument.name.map(str::to_string), argument.value)
})
}
pub(super) fn named_argument_value(expression: &ScalarExpr) -> &ScalarExpr {
scalar_call_argument(expression).map_or(expression, |argument| argument.value)
}