Enum BinaryFunc

pub enum BinaryFunc {
    Eq,
    NotEq,
    Lt,
    Lte,
    Gt,
    Gte,
    AddInt16,
    AddInt32,
    AddInt64,
    AddUInt16,
    AddUInt32,
    AddUInt64,
    AddFloat32,
    AddFloat64,
    SubInt16,
    SubInt32,
    SubInt64,
    SubUInt16,
    SubUInt32,
    SubUInt64,
    SubFloat32,
    SubFloat64,
    MulInt16,
    MulInt32,
    MulInt64,
    MulUInt16,
    MulUInt32,
    MulUInt64,
    MulFloat32,
    MulFloat64,
    DivInt16,
    DivInt32,
    DivInt64,
    DivUInt16,
    DivUInt32,
    DivUInt64,
    DivFloat32,
    DivFloat64,
    ModInt16,
    ModInt32,
    ModInt64,
    ModUInt16,
    ModUInt32,
    ModUInt64,
}

BinaryFunc is a function that takes two arguments. Also notice this enum doesn’t contain function arguments, since the arguments are stored in the expression.

TODO(discord9): support more binary functions for more types

Variants

Eq

NotEq

Lt

Lte

Gt

Gte

AddInt16

AddInt32

AddInt64

AddUInt16

AddUInt32

AddUInt64

AddFloat32

AddFloat64

SubInt16

SubInt32

SubInt64

SubUInt16

SubUInt32

SubUInt64

SubFloat32

SubFloat64

MulInt16

MulInt32

MulInt64

MulUInt16

MulUInt32

MulUInt64

MulFloat32

MulFloat64

DivInt16

DivInt32

DivInt64

DivUInt16

DivUInt32

DivUInt64

DivFloat32

DivFloat64

ModInt16

ModInt32

ModInt64

ModUInt16

ModUInt32

ModUInt64

Implementations

impl BinaryFunc

pub fn signature(&self) -> Signature

Use null type to ref to any type

pub fn add(input_type: ConcreteDataType) -> Result<Self, Error>

pub fn sub(input_type: ConcreteDataType) -> Result<Self, Error>

pub fn mul(input_type: ConcreteDataType) -> Result<Self, Error>

pub fn div(input_type: ConcreteDataType) -> Result<Self, Error>

pub fn specialization( generic: GenericFn, input_type: ConcreteDataType, ) -> Result<Self, Error>

Get the specialization of the binary function based on the generic function and the input type

pub(crate) fn infer_type_from( generic: GenericFn, arg_exprs: &[ScalarExpr], arg_types: &[Option<ConcreteDataType>], ) -> Result<ConcreteDataType, Error>

try it’s best to infer types from the input types and expressions

if it can’t found out types, will return None

pub fn is_valid_func_name(name: &str) -> bool

pub fn from_str_expr_and_type( name: &str, arg_exprs: &[ScalarExpr], arg_types: &[Option<ConcreteDataType>], ) -> Result<(Self, Signature), Error>

choose the appropriate specialization based on the input types return a specialization of the binary function and it’s actual input and output type(so no null type present)

will try it best to extract from arg_types and arg_exprs to get the input types if arg_types is not enough, it will try to extract from arg_exprs if arg_exprs is literal with known type

pub fn eval_batch( &self, batch: &Batch, expr1: &ScalarExpr, expr2: &ScalarExpr, ) -> Result<VectorRef, EvalError>

pub fn eval( &self, values: &[Value], expr1: &ScalarExpr, expr2: &ScalarExpr, ) -> Result<Value, EvalError>

Evaluate the function with given values and expression

Arguments

• values: The values to be used in the evaluation

• expr1: The first arg to be evaluated, will extract the value from the values and evaluate the expression

• expr2: The second arg to be evaluated

pub fn reverse_compare(&self) -> Result<Self, Error>

Reverse the comparison operator, i.e. a < b becomes b > a, equal and not equal are unchanged.

Trait Implementations

impl Clone for BinaryFunc

fn clone(&self) -> BinaryFunc

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BinaryFunc

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BinaryFunc

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for BinaryFunc

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 IntoEnumIterator for BinaryFunc

type Iterator = BinaryFuncIter

fn iter() -> BinaryFuncIter

impl Ord for BinaryFunc

fn cmp(&self, other: &BinaryFunc) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for BinaryFunc

fn eq(&self, other: &BinaryFunc) -> 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 BinaryFunc

fn partial_cmp(&self, other: &BinaryFunc) -> 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 Serialize for BinaryFunc

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for BinaryFunc

impl Eq for BinaryFunc

impl StructuralPartialEq for BinaryFunc