Apache DataFusion SQL Query Engine
feat: Use NativeType in get_example_type, information schema (#21737)
theirixd6875ff6fb46
diff --git a/datafusion/catalog/src/information_schema.rs b/datafusion/catalog/src/information_schema.rsindex d9ad7791af..85222bc2f6 100644--- a/datafusion/catalog/src/information_schema.rs+++ b/datafusion/catalog/src/information_schema.rs@@ -32,10 +32,11 @@ use async_trait::async_trait;use datafusion_common::DataFusionError;use datafusion_common::config::{ConfigEntry, ConfigOptions};use datafusion_common::error::Result;-use datafusion_common::types::NativeType;+use datafusion_common::types::{LogicalType, NativeType};use datafusion_execution::TaskContext;use datafusion_execution::runtime_env::RuntimeEnv;use datafusion_expr::function::WindowUDFFieldArgs;+use datafusion_expr::type_coercion::functions::fields_with_udf;use datafusion_expr::{AggregateUDF, ReturnFieldArgs, ScalarUDF, Signature, TypeSignature, WindowUDF,};@@ -43,6 +44,7 @@ use datafusion_expr::{TableType, Volatility};use datafusion_physical_plan::SendableRecordBatchStream;use datafusion_physical_plan::stream::RecordBatchStreamAdapter;use datafusion_physical_plan::streaming::PartitionStream;+use itertools::Itertools;use std::collections::{BTreeSet, HashMap, HashSet};use std::fmt::Debug;use std::sync::Arc;@@ -454,118 +456,99 @@ impl InformationSchemaConfig {}}-/// get the arguments and return types of a UDF-/// returns a tuple of (arg_types, return_type)+/// Origins used to enumerate the physical types a native type can take+const RESOLVE_CAST_SOURCES: [DataType; 2] = [DataType::Null, DataType::LargeUtf8];++/// Build argument fields for `information_schema` to provide possible return types+fn resolve_informational_fields(idx: usize, t: &NativeType) -> Vec<FieldRef> {+ // Since native types map to several physical types, resolve it against+ // ambiguous types to get canonical `DataType`s for the native type.+ // Skip origins the type has no cast from (e.g. `Struct` from `LargeUtf8`)+ RESOLVE_CAST_SOURCES+ .iter()+ .filter_map(|source| t.default_cast_for(source).ok())+ .unique()+ .map(|dt| Arc::new(Field::new(format!("arg_{idx}"), dt, true)))+ .collect()+}++/// Function information schema is a set of tuples - argument types and an optional return type+type FunctionInformationSchema = BTreeSet<(Vec<String>, Option<String>)>;++/// Get the arguments and return types of a function from its signature+fn get_args_and_return_types(+ signature: &Signature,+ return_field: impl Fn(&[FieldRef]) -> Result<FieldRef>,+) -> Result<FunctionInformationSchema> {+ let arg_types = signature.type_signature.get_representative_types();+ if arg_types.is_empty() {+ // Edge case if function doesn't have arguments+ return Ok(BTreeSet::from([(vec![], None)]));+ }+ arg_types+ .into_iter()+ .map(|arg_types| {+ // Get possible types for each input arg+ let arg_fields = arg_types+ .iter()+ .enumerate()+ .map(|(i, t)| resolve_informational_fields(i, t))+ .collect::<Vec<_>>();+ // Build combinations of arg types with the return type+ let return_types = arg_fields+ .into_iter()+ .multi_cartesian_product()+ .filter_map(|arg_fields| return_field(&arg_fields).ok())+ .map(|f| Some(remove_native_type_prefix(&f.data_type().into())))+ .collect::<BTreeSet<_>>();+ let return_types = if return_types.is_empty() {+ // Indicate `None` if the return type cannot be represented from a signature,+ BTreeSet::from([None])+ } else {+ return_types+ };+ let arg_types = arg_types+ .iter()+ .map(remove_native_type_prefix)+ .collect::<Vec<_>>();+ let tuples = return_types+ .into_iter()+ .map(move |return_type| (arg_types.clone(), return_type));+ Ok(tuples)+ })+ .flatten_ok()+ .collect()+}+fn get_udf_args_and_return_types(udf: &Arc<ScalarUDF>,-) -> Result<BTreeSet<(Vec<String>, Option<String>)>> {- let signature = udf.signature();- let arg_types = signature.type_signature.get_example_types();- if arg_types.is_empty() {- Ok(vec![(vec![], None)].into_iter().collect::<BTreeSet<_>>())- } else {- Ok(arg_types- .into_iter()- .map(|arg_types| {- let arg_fields: Vec<FieldRef> = arg_types- .iter()- .enumerate()- .map(|(i, t)| {- Arc::new(Field::new(format!("arg_{i}"), t.clone(), true))- })- .collect();- let scalar_arguments = vec![None; arg_fields.len()];- let return_type = udf- .return_field_from_args(ReturnFieldArgs {- arg_fields: &arg_fields,- scalar_arguments: &scalar_arguments,- })- .map(|f| {- remove_native_type_prefix(&NativeType::from(- f.data_type().clone(),- ))- })- .ok();- let arg_types = arg_types- .into_iter()- .map(|t| remove_native_type_prefix(&NativeType::from(t)))- .collect::<Vec<_>>();- (arg_types, return_type)- })- .collect::<BTreeSet<_>>())- }+) -> Result<FunctionInformationSchema> {+ get_args_and_return_types(udf.signature(), |arg_fields| {+ let arg_fields = &fields_with_udf(arg_fields, udf.as_ref())?;+ let scalar_arguments = &vec![None; arg_fields.len()];+ udf.return_field_from_args(ReturnFieldArgs {+ arg_fields,+ scalar_arguments,+ })+ })}fn get_udaf_args_and_return_types(udaf: &Arc<AggregateUDF>,-) -> Result<BTreeSet<(Vec<String>, Option<String>)>> {- let signature = udaf.signature();- let arg_types = signature.type_signature.get_example_types();- if arg_types.is_empty() {- Ok(vec![(vec![], None)].into_iter().collect::<BTreeSet<_>>())- } else {- Ok(arg_types- .into_iter()- .map(|arg_types| {- let arg_fields: Vec<FieldRef> = arg_types- .iter()- .enumerate()- .map(|(i, t)| {- Arc::new(Field::new(format!("arg_{i}"), t.clone(), true))- })- .collect();- let return_type = udaf- .return_field(&arg_fields)- .map(|f| {- remove_native_type_prefix(&NativeType::from(- f.data_type().clone(),- ))- })- .ok();- let arg_types = arg_types- .into_iter()- .map(|t| remove_native_type_prefix(&NativeType::from(t)))- .collect::<Vec<_>>();- (arg_types, return_type)- })- .collect::<BTreeSet<_>>())- }+) -> Result<FunctionInformationSchema> {+ get_args_and_return_types(udaf.signature(), |arg_fields| {+ let arg_fields = &fields_with_udf(arg_fields, udaf.as_ref())?;+ udaf.return_field(arg_fields)+ })}fn get_udwf_args_and_return_types(udwf: &Arc<WindowUDF>,-) -> Result<BTreeSet<(Vec<String>, Option<String>)>> {- let signature = udwf.signature();- let arg_types = signature.type_signature.get_example_types();- if arg_types.is_empty() {- Ok(vec![(vec![], None)].into_iter().collect::<BTreeSet<_>>())- } else {- Ok(arg_types- .into_iter()- .map(|arg_types| {- let arg_fields: Vec<FieldRef> = arg_types- .iter()- .enumerate()- .map(|(i, t)| {- Arc::new(Field::new(format!("arg_{i}"), t.clone(), true))- })- .collect();- let return_type = udwf- .field(WindowUDFFieldArgs::new(&arg_fields, udwf.name()))- .map(|f| {- remove_native_type_prefix(&NativeType::from(- f.data_type().clone(),- ))- })- .ok();- let arg_types = arg_types- .into_iter()- .map(|t| remove_native_type_prefix(&NativeType::from(t)))- .collect::<Vec<_>>();- (arg_types, return_type)- })- .collect::<BTreeSet<_>>())- }+) -> Result<FunctionInformationSchema> {+ get_args_and_return_types(udwf.signature(), |arg_fields| {+ let arg_fields = &fields_with_udf(arg_fields, udwf.as_ref())?;+ udwf.field(WindowUDFFieldArgs::new(arg_fields, udwf.name()))+ })}#[inline]@@ -1510,6 +1493,9 @@ mod tests {use super::*;use crate::CatalogProvider;use arrow::array::Array;+ use arrow::datatypes::Fields;+ use datafusion_common::ScalarValue;+ use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl};#[test]fn schemata_builder_emits_canonical_schema_and_rows() {@@ -1580,6 +1566,70 @@ mod tests {assert_eq!("BASE TABLE", builder.table_types.finish().value(0));}+ // UDF+ #[derive(Debug, PartialEq, Eq, Hash)]+ struct TestScalarUDF {+ signature: Signature,+ }+ impl ScalarUDFImpl for TestScalarUDF {+ fn name(&self) -> &str {+ "TestScalarUDF"+ }++ fn signature(&self) -> &Signature {+ &self.signature+ }++ fn return_type(&self, arg_types: &[DataType]) -> Result<DataType> {+ Ok(arg_types.last().unwrap().clone())+ }++ fn invoke_with_args(&self, _args: ScalarFunctionArgs) -> Result<ColumnarValue> {+ Ok(ColumnarValue::Scalar(ScalarValue::from("a")))+ }+ }++ #[test]+ fn test_get_udf_args_and_return_types() -> Result<()> {+ // heterogeneous arguments to test mixed arguments retrieval+ let signature = Signature::exact(+ [+ vec![DataType::Int32; 6],+ vec![DataType::Float32; 6],+ vec![DataType::Utf8; 1],+ ]+ .concat(),+ Volatility::Stable,+ );+ let udf = Arc::new(ScalarUDF::from(TestScalarUDF { signature }));+ let result = get_udf_args_and_return_types(&udf)?;+ assert_eq!(result.len(), 1);+ let (args, ret) = result.iter().next().unwrap();+ assert_eq!(+ *args,+ [+ vec![String::from("Int32"); 6],+ vec![String::from("Float32"); 6],+ vec![String::from("String"); 1]+ ]+ .concat()+ );+ assert_eq!(*ret, Some(String::from("String")));++ Ok(())+ }++ #[test]+ fn test_get_udf_args_and_return_types_nested() -> Result<()> {+ let struct_type =+ DataType::Struct(Fields::from(vec![Field::new("a", DataType::Int32, true)]));+ let signature = Signature::exact(vec![struct_type], Volatility::Stable);+ let udf = Arc::new(ScalarUDF::from(TestScalarUDF { signature }));+ let result = get_udf_args_and_return_types(&udf)?;+ assert_eq!(result.len(), 1);+ Ok(())+ }+#[derive(Debug)]struct Fixture;diff --git a/datafusion/common/src/types/native.rs b/datafusion/common/src/types/native.rsindex 580d572af4..19278d04e3 100644--- a/datafusion/common/src/types/native.rs+++ b/datafusion/common/src/types/native.rs@@ -23,7 +23,7 @@ use crate::error::{_internal_err, Result};use arrow::compute::can_cast_types;use arrow::datatypes::{DECIMAL32_MAX_PRECISION, DECIMAL64_MAX_PRECISION, DECIMAL128_MAX_PRECISION, DataType,- Field, FieldRef, Fields, IntervalUnit, TimeUnit, UnionFields,+ Field, FieldRef, Fields, IntervalUnit, TimeUnit, UnionFields, UnionMode,};use std::{fmt::Display, sync::Arc};@@ -432,6 +432,23 @@ impl LogicalType for NativeType {*mode,)}+ // There is no mode to preserve with null origin, so pick dense encoding+ (Self::Union(to_fields), Null) => Union(+ to_fields+ .iter()+ .map(|(type_id, field)| {+ Ok((+ *type_id,+ Arc::new(Field::new(+ field.name.clone(),+ field.logical_type.default_cast_for(&Null)?,+ field.nullable,+ )),+ ))+ })+ .collect::<Result<UnionFields>>()?,+ UnionMode::Dense,+ ),_ => {return _internal_err!("Unavailable default cast for native type {} from physical type {}",@@ -645,4 +662,113 @@ mod tests {))));assert_snapshot!(map, @"Map(non-null String)");}++ #[test]+ fn test_default_cast_for_null_origin() {+ // Native types with several physical types: pick a canonical one+ assert_eq!(+ NativeType::String+ .default_cast_for(&DataType::Null)+ .unwrap(),+ DataType::Utf8View+ );+ assert_eq!(+ NativeType::Binary+ .default_cast_for(&DataType::Null)+ .unwrap(),+ DataType::BinaryView+ );+ assert_eq!(+ NativeType::Date.default_cast_for(&DataType::Null).unwrap(),+ DataType::Date32+ );++ // Decimals pick the narrowest physical type holding the precision+ assert_eq!(+ NativeType::Decimal(9, 2)+ .default_cast_for(&DataType::Null)+ .unwrap(),+ DataType::Decimal32(9, 2)+ );+ assert_eq!(+ NativeType::Decimal(18, 2)+ .default_cast_for(&DataType::Null)+ .unwrap(),+ DataType::Decimal64(18, 2)+ );+ assert_eq!(+ NativeType::Decimal(38, 10)+ .default_cast_for(&DataType::Null)+ .unwrap(),+ DataType::Decimal128(38, 10)+ );+ assert_eq!(+ NativeType::Decimal(50, 2)+ .default_cast_for(&DataType::Null)+ .unwrap(),+ DataType::Decimal256(50, 2)+ );++ // nested types+ let list = NativeType::List(Arc::new(LogicalField::from(&Field::new(+ "item",+ DataType::Int32,+ true,+ ))));+ assert_eq!(+ list.default_cast_for(&DataType::Null).unwrap(),+ DataType::List(Arc::new(Field::new("item", DataType::Int32, true)))+ );++ let struct_type = NativeType::Struct(LogicalFields::from(&Fields::from(vec![+ Field::new("name", DataType::Utf8, false),+ Field::new("age", DataType::Int32, true),+ ])));+ assert_eq!(+ struct_type.default_cast_for(&DataType::Null).unwrap(),+ DataType::Struct(Fields::from(vec![+ // The logical `String` field resolves to its canonical type+ Field::new("name", DataType::Utf8View, false),+ Field::new("age", DataType::Int32, true),+ ]))+ );+ }++ #[test]+ fn test_default_cast_for_union() {+ let origin_fields = UnionFields::try_new(+ vec![3, 7],+ vec![+ Field::new("a", DataType::Int32, true),+ Field::new("b", DataType::Utf8, false),+ ],+ )+ .unwrap();+ let union_type = NativeType::Union(LogicalUnionFields::from(&origin_fields));++ // From a `Null` origin there are only type ids, but no mode or string+ let expected_fields = UnionFields::try_new(+ vec![3, 7],+ vec![+ Field::new("a", DataType::Int32, true),+ Field::new("b", DataType::Utf8View, false),+ ],+ )+ .unwrap();+ assert_eq!(+ union_type.default_cast_for(&DataType::Null).unwrap(),+ DataType::Union(expected_fields, UnionMode::Dense)+ );++ // From a union origin both the mode and the encodings are preserved+ assert_eq!(+ union_type+ .default_cast_for(&DataType::Union(+ origin_fields.clone(),+ UnionMode::Sparse+ ))+ .unwrap(),+ DataType::Union(origin_fields, UnionMode::Sparse)+ );+ }}diff --git a/datafusion/expr-common/src/signature.rs b/datafusion/expr-common/src/signature.rsindex d88cc791e9..cc3c178f56 100644--- a/datafusion/expr-common/src/signature.rs+++ b/datafusion/expr-common/src/signature.rs@@ -416,10 +416,9 @@ impl TypeSignatureClass {////// This is used for `information_schema` and can be used to generate/// documentation or error messages.+ // Deprecated, remove with `get_example_types`fn get_example_types(&self) -> Vec<DataType> {match self {- // TODO: might be too much info to return every single type here- // maybe https://github.com/apache/datafusion/issues/14761 will help here?TypeSignatureClass::Any => vec![],TypeSignatureClass::Native(l) => get_data_types(l.native()),TypeSignatureClass::Timestamp => {@@ -456,6 +455,50 @@ impl TypeSignatureClass {}}+ /// Get example acceptable types for this `TypeSignatureClass`+ ///+ /// This is used for `information_schema` and can be used to generate+ /// documentation or error messages.+ fn get_representative_types(&self) -> Vec<NativeType> {+ match self {+ TypeSignatureClass::Any => vec![],+ TypeSignatureClass::Native(l) => vec![l.native().clone()],+ TypeSignatureClass::Timestamp => {+ vec![+ NativeType::Timestamp(TimeUnit::Nanosecond, None),+ NativeType::Timestamp(+ TimeUnit::Nanosecond,+ Some(TIMEZONE_WILDCARD.into()),+ ),+ ]+ }+ TypeSignatureClass::Time => {+ vec![NativeType::Time(TimeUnit::Nanosecond)]+ }+ TypeSignatureClass::Interval => {+ vec![NativeType::Interval(IntervalUnit::DayTime)]+ }+ TypeSignatureClass::Duration => {+ vec![NativeType::Duration(TimeUnit::Nanosecond)]+ }+ TypeSignatureClass::Integer => {+ vec![NativeType::Int64]+ }+ TypeSignatureClass::Binary => {+ vec![NativeType::Binary]+ }+ TypeSignatureClass::Decimal => vec![Decimal128Type::DEFAULT_TYPE.into()],+ TypeSignatureClass::Float => vec![NativeType::Float64],+ TypeSignatureClass::Numeric => {+ vec![+ NativeType::Float64,+ NativeType::Int64,+ Decimal128Type::DEFAULT_TYPE.into(),+ ]+ }+ }+ }+/// Does the specified `NativeType` match this type signature class?pub fn matches_native_type(&self, logical_type: &NativeType) -> bool {if logical_type == &NativeType::Null {@@ -598,6 +641,7 @@ impl Display for ArrayFunctionArgument {}}+// Deprecated, remove with `get_example_types`static NUMERICS: &[DataType] = &[DataType::Int8,DataType::Int16,@@ -889,6 +933,7 @@ impl TypeSignature {////// This is used for `information_schema` and can be used to generate/// documentation or error messages.+ #[deprecated(since = "55.0.0", note = "See get_representative_types instead")]pub fn get_example_types(&self) -> Vec<Vec<DataType>> {match self {TypeSignature::Exact(types) => vec![types.clone()],@@ -943,8 +988,78 @@ impl TypeSignature {| TypeSignature::UserDefined => vec![],}}++ /// Return example acceptable types for this `TypeSignature'+ ///+ /// Returns a `Vec<NativeType>` for each argument to the function+ ///+ /// This is used for `information_schema` and can be used to generate+ /// documentation or error messages. The returned types are the types a caller may pass.+ /// Callers computing return types must apply coercion themselves.+ pub fn get_representative_types(&self) -> Vec<Vec<NativeType>> {+ match self {+ TypeSignature::Exact(types) => vec![+ types+ .iter()+ .map(|data_type| NativeType::from(data_type.clone()))+ .collect(),+ ],+ TypeSignature::OneOf(types) => types+ .iter()+ .flat_map(|type_sig| type_sig.get_representative_types())+ .collect(),+ TypeSignature::Uniform(arg_count, types) => types+ .iter()+ .cloned()+ .map(|data_type| vec![data_type.into(); *arg_count])+ .collect(),+ TypeSignature::Coercible(coercions) => coercions+ .iter()+ .map(|c| {+ let mut all_types: IndexSet<NativeType> = c+ .desired_type()+ .get_representative_types()+ .into_iter()+ .collect();++ if let Some(implicit_coercion) = c.implicit_coercion() {+ let allowed_casts: Vec<NativeType> = implicit_coercion+ .allowed_source_types+ .iter()+ .flat_map(|t| t.get_representative_types())+ .collect();+ all_types.extend(allowed_casts);+ }++ all_types.into_iter().collect::<Vec<_>>()+ })+ .multi_cartesian_product()+ .collect(),+ TypeSignature::Variadic(types) => types+ .iter()+ .cloned()+ .map(|data_type| vec![data_type.into()])+ .collect(),+ TypeSignature::Numeric(arg_count) => TypeSignatureClass::Numeric+ .get_representative_types()+ .into_iter()+ .map(|t| vec![t; *arg_count])+ .collect(),+ TypeSignature::String(arg_count) => {+ vec![vec![NativeType::String; *arg_count]]+ }+ // TODO: Implement for other types+ TypeSignature::Any(_)+ | TypeSignature::Comparable(_)+ | TypeSignature::Nullary+ | TypeSignature::VariadicAny+ | TypeSignature::ArraySignature(_)+ | TypeSignature::UserDefined => vec![],+ }+ }}+// Deprecated, remove with get_data_typesfn get_data_types(native_type: &NativeType) -> Vec<DataType> {match native_type {NativeType::Null => vec![DataType::Null],@@ -1651,8 +1766,10 @@ mod tests {);}+ // Remove with get_example_types#[test]- fn test_get_possible_types() {+ #[expect(deprecated)]+ fn test_get_example_types() {let type_signature = TypeSignature::Exact(vec![DataType::Int32, DataType::Int64]);let possible_types = type_signature.get_example_types();assert_eq!(possible_types, vec![vec![DataType::Int32, DataType::Int64]]);@@ -1749,6 +1866,88 @@ mod tests {);}+ #[test]+ fn test_get_representative_types() {+ let type_signature = TypeSignature::Exact(vec![DataType::Int32, DataType::Int64]);+ let types = type_signature.get_representative_types();+ assert_eq!(types, vec![vec![NativeType::Int32, NativeType::Int64]]);++ let type_signature = TypeSignature::OneOf(vec![+ TypeSignature::Exact(vec![DataType::Int32, DataType::Int64]),+ TypeSignature::Exact(vec![DataType::Float32, DataType::Float64]),+ ]);+ let types = type_signature.get_representative_types();+ assert_eq!(+ types,+ vec![+ vec![NativeType::Int32, NativeType::Int64],+ vec![NativeType::Float32, NativeType::Float64]+ ]+ );++ let type_signature = TypeSignature::OneOf(vec![+ TypeSignature::Exact(vec![DataType::Int32, DataType::Int64]),+ TypeSignature::Exact(vec![DataType::Float32, DataType::Float64]),+ TypeSignature::Exact(vec![DataType::Utf8]),+ ]);+ let types = type_signature.get_representative_types();+ assert_eq!(+ types,+ vec![+ vec![NativeType::Int32, NativeType::Int64],+ vec![NativeType::Float32, NativeType::Float64],+ vec![NativeType::String]+ ]+ );++ let type_signature =+ TypeSignature::Uniform(2, vec![DataType::Float32, DataType::Int64]);+ let types = type_signature.get_representative_types();+ assert_eq!(+ types,+ vec![+ vec![NativeType::Float32, NativeType::Float32],+ vec![NativeType::Int64, NativeType::Int64]+ ]+ );++ let type_signature = TypeSignature::Coercible(vec![+ Coercion::new_exact(TypeSignatureClass::Native(logical_string())),+ Coercion::new_exact(TypeSignatureClass::Native(logical_int64())),+ ]);+ let types = type_signature.get_representative_types();+ assert_eq!(types, vec![vec![NativeType::String, NativeType::Int64]]);++ let type_signature =+ TypeSignature::Variadic(vec![DataType::Int32, DataType::Int64]);+ let types = type_signature.get_representative_types();+ assert_eq!(+ types,+ vec![vec![NativeType::Int32], vec![NativeType::Int64]]+ );++ let type_signature = TypeSignature::Numeric(2);+ let types = type_signature.get_representative_types();+ assert_eq!(+ types,+ vec![+ vec![NativeType::Float64, NativeType::Float64],+ vec![NativeType::Int64, NativeType::Int64],+ vec![+ Decimal128Type::DEFAULT_TYPE.into(),+ Decimal128Type::DEFAULT_TYPE.into()+ ],+ ]+ );++ let type_signature = TypeSignature::String(2);+ let possible_types = type_signature.get_representative_types();+ assert_eq!(+ possible_types,+ vec![vec![NativeType::String, NativeType::String],]+ );+ }+#[test]fn test_signature_with_parameter_names() {let sig = Signature::exact(diff --git a/datafusion/sqllogictest/test_files/information_schema.slt b/datafusion/sqllogictest/test_files/information_schema.sltindex 82cef82f7b..e9d44c5f14 100644--- a/datafusion/sqllogictest/test_files/information_schema.slt+++ b/datafusion/sqllogictest/test_files/information_schema.slt@@ -850,8 +850,6 @@ string_agg String AGGREGATEquery TTTTTTTBTTTT rowsortselect * from information_schema.routines where routine_name = 'date_trunc' OR routine_name = 'string_agg' OR routine_name = 'rank' ORDER BY routine_name-----datafusion public date_trunc datafusion public date_trunc FUNCTION true Date SCALAR Truncates a timestamp or time value to a specified precision. date_trunc(precision, expression)-datafusion public date_trunc datafusion public date_trunc FUNCTION true String SCALAR Truncates a timestamp or time value to a specified precision. date_trunc(precision, expression)datafusion public date_trunc datafusion public date_trunc FUNCTION true Time(ns) SCALAR Truncates a timestamp or time value to a specified precision. date_trunc(precision, expression)datafusion public date_trunc datafusion public date_trunc FUNCTION true Timestamp(ns) SCALAR Truncates a timestamp or time value to a specified precision. date_trunc(precision, expression)datafusion public date_trunc datafusion public date_trunc FUNCTION true Timestamp(ns, "+TZ") SCALAR Truncates a timestamp or time value to a specified precision. date_trunc(precision, expression)@@ -867,12 +865,12 @@ falsequery TTTITTTTBIselect * from information_schema.parameters where specific_name = 'date_trunc' OR specific_name = 'string_agg' OR specific_name = 'rank' ORDER BY specific_name, rid, data_type;-----datafusion public date_trunc 1 OUT NULL Date NULL false 0datafusion public date_trunc 2 IN expression Date NULL false 0datafusion public date_trunc 1 IN precision String NULL false 0+datafusion public date_trunc 1 OUT NULL Timestamp(ns) NULL false 0datafusion public date_trunc 1 IN precision String NULL false 1datafusion public date_trunc 2 IN expression String NULL false 1-datafusion public date_trunc 1 OUT NULL String NULL false 1+datafusion public date_trunc 1 OUT NULL Timestamp(ns) NULL false 1datafusion public date_trunc 1 IN precision String NULL false 2datafusion public date_trunc 2 IN expression Time(ns) NULL false 2datafusion public date_trunc 1 OUT NULL Time(ns) NULL false 2@@ -900,12 +898,98 @@ repeat String 1 OUT 0query TT??TTT rowsortshow functions like 'date_trunc';-----date_trunc Date [precision, expression] [String, Date] SCALAR Truncates a timestamp or time value to a specified precision. date_trunc(precision, expression)-date_trunc String [precision, expression] [String, String] SCALAR Truncates a timestamp or time value to a specified precision. date_trunc(precision, expression)date_trunc Time(ns) [precision, expression] [String, Time(ns)] SCALAR Truncates a timestamp or time value to a specified precision. date_trunc(precision, expression)+date_trunc Timestamp(ns) [precision, expression] [String, Date] SCALAR Truncates a timestamp or time value to a specified precision. date_trunc(precision, expression)+date_trunc Timestamp(ns) [precision, expression] [String, String] SCALAR Truncates a timestamp or time value to a specified precision. date_trunc(precision, expression)date_trunc Timestamp(ns) [precision, expression] [String, Timestamp(ns)] SCALAR Truncates a timestamp or time value to a specified precision. date_trunc(precision, expression)date_trunc Timestamp(ns, "+TZ") [precision, expression] [String, Timestamp(ns, "+TZ")] SCALAR Truncates a timestamp or time value to a specified precision. date_trunc(precision, expression)+# Schema for function with TypeSignature::Numeric+query TTITI rowsort+select specific_name, data_type, ordinal_position, parameter_mode, rid from information_schema.parameters where specific_name = 'abs';+----+abs Decimal(38, 10) 1 IN 0+abs Decimal(38, 10) 1 OUT 0+abs Float64 1 IN 1+abs Float64 1 OUT 1+abs Int64 1 IN 2+abs Int64 1 OUT 2++query TTT rowsort+select routine_name, data_type, function_type from information_schema.routines where routine_name = 'abs';+----+abs Decimal(38, 10) SCALAR+abs Float64 SCALAR+abs Int64 SCALAR++query TT rowsort+select routine_name, data_type from information_schema.routines where routine_name = 'length';+----+length Int32+length Int64++# Schema for function with TypeSignature::Coercible plus uniform with exact float types+query TTITI rowsort+select specific_name, data_type, ordinal_position, parameter_mode, rid from information_schema.parameters where specific_name = 'floor';+----+floor Decimal(29, 0) 1 OUT 0+floor Decimal(38, 10) 1 IN 0+floor Float32 1 IN 1+floor Float32 1 OUT 1+floor Float64 1 IN 2+floor Float64 1 OUT 2++query TTT rowsort+select routine_name, data_type, function_type from information_schema.routines where routine_name = 'floor';+----+floor Decimal(29, 0) SCALAR+floor Float32 SCALAR+floor Float64 SCALAR++# Schemas for date/duration - exact type for Date32/Date64 (logical type is provided)+query TTITI rowsort+select specific_name, data_type, ordinal_position, parameter_mode, rid from information_schema.parameters where specific_name = 'to_char' and (data_type like '%Date%' or data_type like '%Duration%');+----+to_char Date 1 IN 0+to_char Duration(ms) 1 IN 1+to_char Duration(ns) 1 IN 2+to_char Duration(s) 1 IN 3+to_char Duration(µs) 1 IN 4++query TTT rowsort+select routine_name, data_type, function_type from information_schema.routines where routine_name = 'to_char';+----+to_char String SCALAR++# Return type cannot be deduced from the signature alone+query TTT+select routine_name, data_type, function_type from information_schema.routines where routine_name = 'date_part';+----+date_part NULL SCALAR++# No args+query TTT+select routine_name, data_type, function_type from information_schema.routines where routine_name = 'pi';+----+pi NULL SCALAR++query I+select count(*) from information_schema.parameters where specific_name = 'date_part' and parameter_mode = 'OUT';+----+0++# Verify coerced return type of `generate_series`: it should be Date32+query TI?T rowsort+select specific_name, rid,+ array_agg(data_type order by ordinal_position) filter (where parameter_mode = 'IN') as args,+ max(data_type) filter (where parameter_mode = 'OUT') as return+from information_schema.parameters where specific_name = 'generate_series'+group by specific_name, rid+having args[1] = 'String' and args[2] like 'Date' and args[3] like 'Interval%';+----+generate_series 7 [String, Date, Interval(DayTime)] List(Date)+generate_series 8 [String, Date, Interval(MonthDayNano)] List(Date)+# Table functions (UDTFs) appear in information_schema.routines with# function_type = TABLE and data_type = TABLE.# Note: built-in `generate_series` and `range` are registered as BOTH a