use crate::ast::{
ColumnType, FunctionBinding, FunctionParamMode, FunctionReturns, RoutineInvocationBinding,
};
use crate::routines::{routine_returns_anonymous_record, RoutineResolution, SQLUserFunction};
use crate::type_resolution::FunctionTypeResolver;
use crate::{RowSchema, SQLError, SQLParam, ScalarExpr};
pub const SETOF_COLUMN_DEFINITION_PREFIX: &str = "setof ";
const MAX_COLUMN_DEFINITIONS: usize = 1600;
pub struct ColumnDefinitionRequest<'a> {
pub name: &'a str,
pub binding: Option<&'a FunctionBinding>,
pub user_function: Option<&'a SQLUserFunction>,
pub user_invocation: Option<&'a RoutineInvocationBinding>,
pub args: &'a [ScalarExpr],
pub declared_types: &'a [String],
pub column_names: &'a [String],
}
#[derive(Clone, Copy, PartialEq, Eq)]
pub(super) enum ResultClass {
Record,
OutParameters,
NamedComposite,
Scalar,
Unclassified,
}
pub fn validate_table_function_column_definition(
routines: &dyn RoutineResolution,
request: ColumnDefinitionRequest<'_>,
input_schema: &RowSchema,
params: &[SQLParam],
resolver: &dyn FunctionTypeResolver,
) -> Result<(), SQLError> {
let class = match request.user_function {
Some(function) => user_function_result_class(routines, function, request.user_invocation)?,
None if request.binding.is_some_and(|binding| !binding.builtin) => {
ResultClass::Unclassified
}
None => builtin_result_class(&request, input_schema, params, resolver),
};
let syntax_error = |message: &str| SQLError::Routine {
sqlstate: "42601".into(),
message: message.into(),
};
if request.declared_types.is_empty() {
return if class == ResultClass::Record {
Err(syntax_error(
"a column definition list is required for functions returning \"record\"",
))
} else {
Ok(())
};
}
match class {
ResultClass::Record => validate_record_column_definitions(routines, &request),
ResultClass::OutParameters => Err(redundant_out_column_definition_error()),
ResultClass::NamedComposite => Err(syntax_error(
"a column definition list is redundant for a function returning a named composite type",
)),
ResultClass::Scalar => Err(syntax_error(
"a column definition list is only allowed for functions returning \"record\"",
)),
ResultClass::Unclassified => Ok(()),
}
}
fn validate_record_column_definitions(
routines: &dyn RoutineResolution,
request: &ColumnDefinitionRequest<'_>,
) -> Result<(), SQLError> {
if request.declared_types.len() > MAX_COLUMN_DEFINITIONS {
return Err(SQLError::Routine {
sqlstate: "54011".into(),
message: format!(
"column definition lists can have at most {MAX_COLUMN_DEFINITIONS} entries"
),
});
}
let mut pseudo_types = Vec::new();
for (position, declared) in request.declared_types.iter().enumerate() {
let column = request
.column_names
.get(position)
.map_or("", String::as_str);
if declared.starts_with(SETOF_COLUMN_DEFINITION_PREFIX) {
return Err(SQLError::Routine {
sqlstate: "42P16".into(),
message: format!("column \"{column}\" cannot be declared SETOF"),
});
}
let pseudo = crate::catalog::type_metadata::routine_pseudo_type_name(
crate::catalog::type_metadata::routine_type_oid(declared),
);
if pseudo.is_none() {
let ty = routines.resolve_type_name(declared)?.map_or_else(
|| {
ColumnType::from_sql_name(declared).map_err(|_| SQLError::Routine {
sqlstate: "42704".into(),
message: format!("type \"{declared}\" does not exist"),
})
},
Ok,
)?;
routines.require_type_usage(&ty)?;
}
pseudo_types.push(pseudo);
}
let mut names = std::collections::BTreeSet::new();
for name in request.column_names {
if !names.insert(name) {
return Err(SQLError::Routine {
sqlstate: "42701".into(),
message: format!("column name \"{name}\" specified more than once"),
});
}
}
for (column, pseudo) in request.column_names.iter().zip(pseudo_types) {
if let Some(pseudo) = pseudo.filter(|pseudo| *pseudo != "record") {
return Err(SQLError::Routine {
sqlstate: "42P16".into(),
message: format!("column \"{column}\" has pseudo-type {pseudo}"),
});
}
}
Ok(())
}
pub(super) fn user_function_result_class(
routines: &dyn RoutineResolution,
function: &SQLUserFunction,
invocation: Option<&RoutineInvocationBinding>,
) -> Result<ResultClass, SQLError> {
if routine_returns_anonymous_record(&function.def) {
return Ok(ResultClass::Record);
}
if function.def.output_params().nth(1).is_some() {
return Ok(ResultClass::OutParameters);
}
let output = function
.def
.params
.iter()
.enumerate()
.find(|(_, parameter)| {
matches!(
parameter.mode,
FunctionParamMode::Out | FunctionParamMode::InOut | FunctionParamMode::Table
)
});
let (declared, concrete) = match (output, &function.def.returns) {
(Some((position, output)), _) => (
output.type_name.as_str(),
invocation
.and_then(|invocation| invocation.parameter_types.get(position))
.map(String::as_str),
),
(None, FunctionReturns::Scalar { type_name } | FunctionReturns::SetOf { type_name }) => (
type_name.as_str(),
invocation.and_then(|invocation| invocation.return_type.as_deref()),
),
_ => return Ok(ResultClass::Scalar),
};
let type_name = concrete.unwrap_or(declared);
if crate::type_resolution::routine_polymorphic_type(type_name).is_some() {
return Ok(ResultClass::Unclassified);
}
Ok(match routines.resolve_type_name(type_name)? {
Some(ty) => type_result_class(&ty),
None => ResultClass::Scalar,
})
}
fn builtin_result_class(
request: &ColumnDefinitionRequest<'_>,
input_schema: &RowSchema,
params: &[SQLParam],
resolver: &dyn FunctionTypeResolver,
) -> ResultClass {
let builtin = crate::semantics::builtin_function_dispatch_name(request.name);
match builtin.as_ref() {
"json_each"
| "jsonb_each"
| "json_each_text"
| "jsonb_each_text"
| "pg_get_sequence_data"
| "pg_sequence_parameters"
| "aclexplode" => ResultClass::OutParameters,
"generate_series"
| "pg_listening_channels"
| "regexp_matches"
| "regexp_split_to_table"
| "string_to_table"
| "json_array_elements"
| "jsonb_array_elements"
| "json_array_elements_text"
| "jsonb_array_elements_text"
| "json_object_keys"
| "jsonb_object_keys" => ResultClass::Scalar,
"unnest" => match request.args {
[argument] => {
crate::scalar_type_with_resolver(argument, input_schema, params, resolver)
.ok()
.flatten()
.and_then(|ty| crate::type_resolution::array_element_type(&ty).cloned())
.map_or(
ResultClass::Unclassified,
|element| match type_result_class(&element) {
ResultClass::Record => ResultClass::Unclassified,
class => class,
},
)
}
_ => ResultClass::Unclassified,
},
_ => ResultClass::Unclassified,
}
}
fn type_result_class(ty: &ColumnType) -> ResultClass {
match ty {
ColumnType::Domain { base, .. } => type_result_class(base),
ColumnType::Composite(_) => ResultClass::NamedComposite,
ColumnType::Record => ResultClass::Record,
_ => ResultClass::Scalar,
}
}
fn redundant_out_column_definition_error() -> SQLError {
SQLError::Routine {
sqlstate: "42601".into(),
message: "a column definition list is redundant for a function with OUT parameters".into(),
}
}