Enum datafusion_expr::TypeSignature

pub enum TypeSignature {
    Variadic(Vec<DataType>),
    VariadicEqual,
    VariadicAny,
    Uniform(usize, Vec<DataType>),
    Exact(Vec<DataType>),
    Any(usize),
    OneOf(Vec<TypeSignature>),
    ArraySignature(ArrayFunctionSignature),
}

A function’s type signature defines the types of arguments the function supports.

Functions typically support only a few different types of arguments compared to the different datatypes in Arrow. To make functions easy to use, when possible DataFusion automatically coerces (add casts to) function arguments so they match the type signature.

For example, a function like cos may only be implemented for Float64 arguments. To support a query that calles cos with a different argument type, such as cos(int_column), type coercion automatically adds a cast such as cos(CAST int_column AS DOUBLE) during planning.

Data Types

Types to match are represented using Arrow’s DataType. DataType::Timestamp has an optional variable timezone specification. To specify a function can handle a timestamp with ANY timezone, use the TIMEZONE_WILDCARD. For example:

let type_signature = TypeSignature::Exact(vec![
  // A nanosecond precision timestamp with ANY timezone
  // matches  Timestamp(Nanosecond, Some("+0:00"))
  // matches  Timestamp(Nanosecond, Some("+5:00"))
  // does not match  Timestamp(Nanosecond, None)
  DataType::Timestamp(TimeUnit::Nanosecond, Some(TIMEZONE_WILDCARD.into())),
]);

Variants

Variadic(Vec<DataType>)

One or more arguments of an common type out of a list of valid types.

Examples

A function such as concat is Variadic(vec![DataType::Utf8, DataType::LargeUtf8])

VariadicEqual

One or more arguments of an arbitrary but equal type. DataFusion attempts to coerce all argument types to match the first argument’s type

Examples

Given types in signature should be coercible to the same final type. A function such as make_array is VariadicEqual.

make_array(i32, i64) -> make_array(i64, i64)

VariadicAny

One or more arguments with arbitrary types

Uniform(usize, Vec<DataType>)

Fixed number of arguments of an arbitrary but equal type out of a list of valid types.

Examples

1. A function of one argument of f64 is Uniform(1, vec![DataType::Float64])
2. A function of one argument of f64 or f32 is Uniform(1, vec![DataType::Float32, DataType::Float64])

Exact(Vec<DataType>)

Exact number of arguments of an exact type

Any(usize)

Fixed number of arguments of arbitrary types If a function takes 0 argument, its TypeSignature should be Any(0)

OneOf(Vec<TypeSignature>)

Matches exactly one of a list of TypeSignatures. Coercion is attempted to match the signatures in order, and stops after the first success, if any.

Examples

Function make_array takes 0 or more arguments with arbitrary types, its TypeSignature is OneOf(vec![Any(0), VariadicAny]).

ArraySignature(ArrayFunctionSignature)

Specifies Signatures for array functions

Implementations

impl TypeSignature

pub fn supports_zero_argument(&self) -> bool

Check whether 0 input argument is valid for given TypeSignature

Trait Implementations

impl Clone for TypeSignature

fn clone(&self) -> TypeSignature

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TypeSignature

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for TypeSignature

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for TypeSignature

fn eq(&self, other: &TypeSignature) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for TypeSignature

impl StructuralPartialEq for TypeSignature