Enum Coercion

pub enum Coercion {
    Exact {
        desired_type: TypeSignatureClass,
    },
    Implicit {
        desired_type: TypeSignatureClass,
        implicit_coercion: ImplicitCoercion,
    },
}

Represents type coercion rules for function arguments, specifying both the desired type and optional implicit coercion rules for source types.

Examples

use datafusion_expr_common::signature::{Coercion, TypeSignatureClass};
use datafusion_common::types::{NativeType, logical_binary, logical_string};

// Exact coercion that only accepts timestamp types
let exact = Coercion::new_exact(TypeSignatureClass::Timestamp);

// Implicit coercion that accepts string types but can coerce from binary types
let implicit = Coercion::new_implicit(
    TypeSignatureClass::Native(logical_string()),
    vec![TypeSignatureClass::Native(logical_binary())],
    NativeType::String
);

There are two variants:

• Exact - Only accepts arguments that exactly match the desired type
• Implicit - Accepts the desired type and can coerce from specified source types

Variants

Exact

Coercion that only accepts arguments exactly matching the desired type.

Fields

desired_type: TypeSignatureClass

The required type for the argument

Implicit

Coercion that accepts the desired type and can implicitly coerce from other types.

Fields

desired_type: TypeSignatureClass

The primary desired type for the argument

implicit_coercion: ImplicitCoercion

Rules for implicit coercion from other types

Implementations

impl Coercion

pub fn new_exact(desired_type: TypeSignatureClass) -> Coercion

pub fn new_implicit( desired_type: TypeSignatureClass, allowed_source_types: Vec<TypeSignatureClass>, default_casted_type: NativeType, ) -> Coercion

Create a new coercion with implicit coercion rules.

allowed_source_types defines the possible types that can be coerced to desired_type. default_casted_type is the default type to be used for coercion if we cast from other types via allowed_source_types.

pub fn allowed_source_types(&self) -> &[TypeSignatureClass]

pub fn default_casted_type(&self) -> Option<&NativeType>

pub fn desired_type(&self) -> &TypeSignatureClass

pub fn implicit_coercion(&self) -> Option<&ImplicitCoercion>

Trait Implementations

impl Clone for Coercion

fn clone(&self) -> Coercion

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Coercion

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

Formats the value using the given formatter.

impl Display for Coercion

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

Formats the value using the given formatter.

impl Hash for Coercion

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

where H: Hasher,

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 Coercion

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for Coercion

fn partial_cmp(&self, other: &Coercion) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Coercion