Struct tidb_query_expr::types::function::Arg

pub struct Arg<A: RpnFnArg, Rem: ArgDef> {
    arg: A,
    rem: Rem,
}

RPN function argument definitions in the form of a linked list.

For example, if an RPN function foo(Int, Real, Decimal) is applied to input of a scalar of integer, a vector of reals and a vector of decimals, the constructed ArgDef will be Arg<ScalarArg<Int>, Arg<VectorValue<Real>, Arg<VectorValue<Decimal>, Null>>>. Null indicates the end of the argument list.

Fields

arg: A

rem: Rem

Implementations

impl<A: RpnFnArg, Rem: ArgDef> Arg<A, Rem>

pub fn extract(&self, row: usize) -> (A::Type, &Rem)

Gets the value of the head argument in the given row and returns the remaining argument list.

pub fn get_bit_vec(&self) -> ((Option<&BitVec>, bool), &Rem)

Gets the bit vector of each arg

Trait Implementations

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Decimal>>> AbsDecimal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> AbsInt_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> AbsReal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> AbsUint_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> Acos_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> AddDateAndString_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Duration>>, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> AddDatetimeAndDuration_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> AddDatetimeAndString_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Duration>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Duration>>> AddDurationAndDuration_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Duration>>> AddDurationAndString_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Duration>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> AddStringAndDuration_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<A: RpnFnArg, Rem: ArgDef> ArgDef for Arg<A, Rem>

impl<'arg_, A: ArithmeticOpWithCtx, Arg1_: RpnFnArg<Type = Option<&'arg_ A::T>>, Arg0_: RpnFnArg<Type = Option<&'arg_ A::T>>> ArithmeticWithCtx_Fn<A> for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, A: ArithmeticOp, Arg1_: RpnFnArg<Type = Option<&'arg_ A::T>>, Arg0_: RpnFnArg<Type = Option<&'arg_ A::T>>> Arithmetic_Fn<A> for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Ascii_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> Asin_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> Atan1Arg_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Real>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> Atan2Args_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> Bin_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> BitAnd_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> BitCount_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> BitLength_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> BitNeg_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> BitOr_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> BitXor_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, From: ConvertTo<To> + Evaluable + EvaluableRet, To: Evaluable + EvaluableRet, Arg0_: RpnFnArg<Type = Option<&'arg_ From>>> CastAnyAsAny_Fn<From, To> for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, From: ConvertTo<Bytes> + Evaluable + EvaluableRet, Arg0_: RpnFnArg<Type = Option<&'arg_ From>>> CastAnyAsBytes_Fn<From> for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, From: Evaluable + EvaluableRet + ConvertTo<Decimal>, Arg0_: RpnFnArg<Type = Option<&'arg_ From>>> CastAnyAsDecimal_Fn<From> for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, From: ConvertTo<Json> + Evaluable + EvaluableRet, Arg0_: RpnFnArg<Type = Option<&'arg_ From>>> CastAnyAsJson_Fn<From> for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, T: ConvertTo<Bytes> + Evaluable + EvaluableRet, Arg0_: RpnFnArg<Type = Option<&'arg_ T>>> CastAnyAsString_Fn<T> for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> CastBinaryStringAsInt_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> CastBinaryStringAsSignedReal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> CastBinaryStringAsUnsignedReal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> CastBoolAsJson_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> CastBytesAsDecimal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> CastBytesAsDuration_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Decimal>>> CastDecimalAsDuration_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Decimal>>> CastDecimalAsSignedDecimal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Decimal>>> CastDecimalAsTime_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Decimal>>> CastDecimalAsUint_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Decimal>>> CastDecimalAsUnsignedDecimal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Decimal>>> CastDecimalAsUnsignedReal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Duration>>> CastDurationAsDuration_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Duration>>> CastDurationAsTime_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<EnumRef<'arg_>>>> CastEnumAsBytes_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<EnumRef<'arg_>>>> CastEnumAsDecimal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<EnumRef<'arg_>>>> CastEnumAsDuration_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<EnumRef<'arg_>>>> CastEnumAsInt_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<EnumRef<'arg_>>>> CastEnumAsJson_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<EnumRef<'arg_>>>> CastEnumAsReal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<EnumRef<'arg_>>>> CastEnumAsTime_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> CastFloatRealAsString_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> CastIntAsDuration_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> CastIntAsIntOthers_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> CastIntAsTime_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, To: Evaluable + EvaluableRet + ConvertFrom<Json>, Arg0_: RpnFnArg<Type = Option<JsonRef<'arg_>>>> CastJsonAsAny_Fn<To> for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<JsonRef<'arg_>>>> CastJsonAsBytes_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<JsonRef<'arg_>>>> CastJsonAsDecimal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<JsonRef<'arg_>>>> CastJsonAsDuration_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<JsonRef<'arg_>>>> CastJsonAsJson_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<JsonRef<'arg_>>>> CastJsonAsUint_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> CastRealAsDecimal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> CastRealAsDuration_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> CastRealAsSignedReal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> CastRealAsTime_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> CastRealAsUint_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> CastRealAsUnsignedReal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<SetRef<'arg_>>>> CastSetAsInt_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> CastSignedIntAsSignedReal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ i64>>> CastSignedIntAsUnsignedDecimal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> CastSignedIntAsUnsignedInt_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> CastSignedIntAsUnsignedReal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> CastStringAsInt_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> CastStringAsJson_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> CastStringAsSignedReal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> CastStringAsString_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> CastStringAsTime_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> CastStringAsUnsignedDecimal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> CastStringAsUnsignedReal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> CastTimeAsDuration_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Time>>> CastTimeAsTime_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> CastUintAsJson_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> CastUintAsString_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ i64>>> CastUnsignedIntAsSignedOrUnsignedDecimal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> CastUnsignedIntAsSignedOrUnsignedReal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> CastYearAsString_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> CastYearAsTime_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, C: Ceil, Arg0_: RpnFnArg<Type = Option<&'arg_ C::Input>>> Ceil_Fn<C> for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> CharLengthUtf8_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> CharLength_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, C: Collator, F: CmpOp, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> CompareBytes_Fn<C, F> for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, F: CmpOp, Arg1_: RpnFnArg<Type = Option<JsonRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<JsonRef<'arg_>>>> CompareJson_Fn<F> for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, C: Comparer, Arg1_: RpnFnArg<Type = Option<&'arg_ C::T>>, Arg0_: RpnFnArg<Type = Option<&'arg_ C::T>>> Compare_Fn<C> for Arg<Arg0_, Arg<Arg1_, Null>> where
    C: Comparer, 

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Compress_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg2_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Conv_Fn for Arg<Arg0_, Arg<Arg1_, Arg<Arg2_, Null>>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> Cos_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> Cot_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Crc32_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ DateTime>>, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> DateDiff_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> DateFormat_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> Date_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> DayName_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> DayOfMonth_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> DayOfWeek_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> DayOfYear_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<A: Debug + RpnFnArg, Rem: Debug + ArgDef> Debug for Arg<A, Rem>

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

Formats the value using the given formatter.

impl<'arg_, K: KeepNull, Arg0_: RpnFnArg<Type = Option<&'arg_ Decimal>>> DecimalIsFalse_Fn<K> for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, K: KeepNull, Arg0_: RpnFnArg<Type = Option<&'arg_ Decimal>>> DecimalIsTrue_Fn<K> for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> Degrees_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Duration>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Duration>>> DurationDurationTimeDiff_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> Exp_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, C: Collator, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> FindInSet_Fn<C> for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, T: Floor, Arg0_: RpnFnArg<Type = Option<&'arg_ T::Input>>> Floor_Fn<T> for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> FromBase64_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> FromDays_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> HexIntArg_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> HexStrArg_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Duration>>> Hour_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg2_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> IfConditionBytes_Fn for Arg<Arg0_, Arg<Arg1_, Arg<Arg2_, Null>>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg2_: RpnFnArg<Type = Option<JsonRef<'arg_>>>, Arg1_: RpnFnArg<Type = Option<JsonRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> IfConditionJson_Fn for Arg<Arg0_, Arg<Arg1_, Arg<Arg2_, Null>>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, T: Evaluable + EvaluableRet, Arg2_: RpnFnArg<Type = Option<&'arg_ T>>, Arg1_: RpnFnArg<Type = Option<&'arg_ T>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> IfCondition_Fn<T> for Arg<Arg0_, Arg<Arg1_, Arg<Arg2_, Null>>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> IfNullBytes_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<JsonRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<JsonRef<'arg_>>>> IfNullJson_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, T: Evaluable + EvaluableRet, Arg1_: RpnFnArg<Type = Option<&'arg_ T>>, Arg0_: RpnFnArg<Type = Option<&'arg_ T>>> IfNull_Fn<T> for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Inet6Aton_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Inet6Ntoa_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> InetAton_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> InetNtoa_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg3_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg2_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Insert_Fn for Arg<Arg0_, Arg<Arg1_, Arg<Arg2_, Arg<Arg3_, Null>>>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> InstrUtf8_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Instr_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Decimal>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Decimal>>> IntDivideDecimal_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, K: KeepNull, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> IntIsFalse_Fn<K> for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, K: KeepNull, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> IntIsTrue_Fn<K> for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> IsIpv4Compat_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> IsIpv4Mapped_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> IsIpv4_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> IsIpv6_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> IsNullBytes_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<JsonRef<'arg_>>>> IsNullJson_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, T: Evaluable + EvaluableRet, Arg0_: RpnFnArg<Type = Option<&'arg_ T>>> IsNull_Fn<T> for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<JsonRef<'arg_>>>> JsonDepth_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> JsonQuote_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<JsonRef<'arg_>>>> JsonType_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<JsonRef<'arg_>>>> JsonUnquote_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> LastDay_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> LeftShift_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> LeftUtf8_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Left_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Length_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, C: Collator, Arg2_: RpnFnArg<Type = Option<&'arg_ i64>>, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Like_Fn<C> for Arg<Arg0_, Arg<Arg1_, Arg<Arg2_, Null>>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, C: Collator, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Locate2ArgsUtf8_Fn<C> for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Locate2Args_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, C: Collator, Arg2_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Locate3ArgsUtf8_Fn<C> for Arg<Arg0_, Arg<Arg1_, Arg<Arg2_, Null>>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg2_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Locate3Args_Fn for Arg<Arg0_, Arg<Arg1_, Arg<Arg2_, Null>>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> Log10_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> Log1Arg_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Real>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> Log2Arg_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> Log2_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ i64>>, Arg0_: RpnFnArg<Type = Option<&'arg_ i64>>> LogicalAnd_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ i64>>, Arg0_: RpnFnArg<Type = Option<&'arg_ i64>>> LogicalOr_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ i64>>, Arg0_: RpnFnArg<Type = Option<&'arg_ i64>>> LogicalXor_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> LowerUtf8_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Lower_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg2_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> LpadUtf8_Fn for Arg<Arg0_, Arg<Arg1_, Arg<Arg2_, Null>>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg2_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Lpad_Fn for Arg<Arg0_, Arg<Arg1_, Arg<Arg2_, Null>>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Ltrim_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> MakeDate_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg2_: RpnFnArg<Type = Option<&'arg_ Real>>, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> MakeTime_Fn for Arg<Arg0_, Arg<Arg1_, Arg<Arg2_, Null>>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Md5_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Duration>>> MicroSecond_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Duration>>> Minute_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> MonthName_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> Month_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> OctInt_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> OctString_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, C: Collator, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Ord_Fn<C> for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Password_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> PeriodAdd_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> PeriodDiff_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Real>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> Pow_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Quote_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> Radians_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ i64>>> RandWithSeedFirstGen_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> RandomBytes_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, K: KeepNull, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> RealIsFalse_Fn<K> for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, K: KeepNull, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> RealIsTrue_Fn<K> for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> RegexpUtf8_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Regexp_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Repeat_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg2_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Replace_Fn for Arg<Arg0_, Arg<Arg1_, Arg<Arg2_, Null>>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> ReverseUtf8_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Reverse_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> RightShift_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> RightUtf8_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Right_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Decimal>>> RoundDec_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> RoundInt_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> RoundReal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Decimal>>> RoundWithFracDec_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> RoundWithFracInt_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> RoundWithFracReal_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg2_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> RpadUtf8_Fn for Arg<Arg0_, Arg<Arg1_, Arg<Arg2_, Null>>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg2_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Rpad_Fn for Arg<Arg0_, Arg<Arg1_, Arg<Arg2_, Null>>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Rtrim_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Duration>>> Second_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Sha1_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Sha2_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> Sign_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> Sin_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> Space_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> Sqrt_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, C: Collator, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Strcmp_Fn<C> for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Duration>>, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> SubDatetimeAndDuration_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> SubDatetimeAndString_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Duration>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Duration>>> SubDurationAndDuration_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Duration>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> SubStringAndDuration_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Substring2Args_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg2_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Substring3Args_Fn for Arg<Arg0_, Arg<Arg1_, Arg<Arg2_, Null>>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg2_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> SubstringIndex_Fn for Arg<Arg0_, Arg<Arg1_, Arg<Arg2_, Null>>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> Tan_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Duration>>> TimeToSec_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> ToBase64_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> ToDays_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> ToSeconds_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Trim1Arg_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Trim2Args_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg2_: RpnFnArg<Type = Option<&'arg_ i64>>, Arg1_: RpnFnArg<Type = Option<BytesRef<'arg_>>>, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Trim3Args_Fn for Arg<Arg0_, Arg<Arg1_, Arg<Arg2_, Null>>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Decimal>>> TruncateDecimalWithInt_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Decimal>>> TruncateDecimalWithUint_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> TruncateIntWithInt_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> TruncateIntWithUint_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> TruncateRealWithInt_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> TruncateRealWithUint_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> TruncateUintWithInt_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> TruncateUintWithUint_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Decimal>>> UnaryMinusDecimal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> UnaryMinusInt_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> UnaryMinusReal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> UnaryMinusUint_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Decimal>>> UnaryNotDecimal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Int>>> UnaryNotInt_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ Real>>> UnaryNotReal_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Uncompress_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> UncompressedLength_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Unhex_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> UpperUtf8_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<BytesRef<'arg_>>>> Upper_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> WeekDay_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> WeekOfYear_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> WeekWithMode_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> WeekWithoutMode_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg1_: RpnFnArg<Type = Option<&'arg_ Int>>, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> YearWeekWithMode_Fn for Arg<Arg0_, Arg<Arg1_, Null>>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> YearWeekWithoutMode_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>

impl<'arg_, Arg0_: RpnFnArg<Type = Option<&'arg_ DateTime>>> Year_Fn for Arg<Arg0_, Null>

default fn eval(
    self,
    ctx: &mut EvalContext,
    output_rows: usize,
    args: &[RpnStackNode<'_>],
    extra: &mut RpnFnCallExtra<'_>,
    metadata: &(dyn Any + Send)
) -> Result<VectorValue>