Struct FunctionContext 

pub struct FunctionContext<'a> {
    pub fragment: Fragment,
    pub identity: IdentityId,
    pub row_count: usize,
    pub runtime_context: &'a RuntimeContext,
}

Execution context for a function.

A function impl writes impl Routine<FunctionContext> for Foo. The trait’s execute signature has no way to receive &mut Transaction, so a function is guaranteed at the type level to be unable to mutate transactional state.

Functions don’t get catalog/ioc - they’re pure operations on column data. If a future “function” needs catalog access, it should be a procedure instead.

Fields

fragment: Fragment

identity: IdentityId

row_count: usize

runtime_context: &'a RuntimeContext

Trait Implementations

impl<'a> Routine<FunctionContext<'a>> for Abs

fn info(&self) -> &RoutineInfo

fn return_type(&self, input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Acos

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Asin

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Atan

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Atan2

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Avg

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn accepted_types(&self) -> InputTypes

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for BlobB58

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for BlobB64

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for BlobB64url

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for BlobHex

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for BlobUtf8

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Ceil

fn info(&self) -> &RoutineInfo

fn return_type(&self, input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Clamp

fn info(&self) -> &RoutineInfo

fn return_type(&self, input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Cos

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Count

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateAdd

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateAge

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateDay

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateDayOfWeek

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateDayOfYear

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateDaysInMonth

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateDiff

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateEndOfMonth

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateFormat

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateIsLeapYear

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateMonth

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateNew

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateNow

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateQuarter

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateStartOfMonth

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateStartOfYear

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateSubtract

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeAdd

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeAge

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeDate

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeDay

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeDayOfWeek

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeDayOfYear

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeDiff

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeEpoch

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeEpochMillis

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeFormat

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeFromEpoch

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeFromEpochMillis

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeHour

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeMinute

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeMonth

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeNanosecond

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeNew

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeNow

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeQuarter

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeSecond

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeSubtract

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeTime

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeTrunc

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeWeek

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTimeYear

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateTrunc

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateWeek

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DateYear

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DurationAdd

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DurationDays

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DurationFormat

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DurationGetDays

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DurationGetMonths

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DurationGetNanos

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DurationHours

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DurationMillis

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DurationMinutes

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DurationMonths

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DurationNegate

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DurationScale

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DurationSeconds

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DurationSubtract

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DurationTrunc

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DurationWeeks

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for DurationYears

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Euler

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Exp

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Floor

fn info(&self) -> &RoutineInfo

fn return_type(&self, input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for FlowNodeToJson

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for FormatBytes

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for FormatBytesSi

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Gcd

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for GenerateSeries

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Id

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for IsAnonymous

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for IsNone

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn propagates_options(&self) -> bool

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for IsRoot

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for IsSome

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn propagates_options(&self) -> bool

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for IsType

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn propagates_options(&self) -> bool

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for JsonArray

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for JsonObject

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for JsonPretty

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for JsonSerialize

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Lcm

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Log

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Log10

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Log2

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Max

fn info(&self) -> &RoutineInfo

fn return_type(&self, input_types: &[Type]) -> Type

fn accepted_types(&self) -> InputTypes

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Min

fn info(&self) -> &RoutineInfo

fn return_type(&self, input_types: &[Type]) -> Type

fn accepted_types(&self) -> InputTypes

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Modulo

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Now

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Pi

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Power

fn info(&self) -> &RoutineInfo

fn return_type(&self, input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Round

fn info(&self) -> &RoutineInfo

fn return_type(&self, input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for RqlFingerprint

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Series

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Sign

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Sin

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Sqrt

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Sum

fn info(&self) -> &RoutineInfo

fn return_type(&self, input_types: &[Type]) -> Type

fn accepted_types(&self) -> InputTypes

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Tan

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TextAscii

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TextChar

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TextConcat

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TextContains

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TextCount

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TextEndsWith

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TextIndexOf

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TextLength

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TextLower

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TextPadLeft

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TextPadRight

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TextRepeat

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TextReplace

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TextReverse

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TextStartsWith

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TextSubstring

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TextTrim

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TextTrimEnd

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TextTrimStart

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TextUpper

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TimeAdd

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TimeAge

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TimeDiff

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TimeFormat

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TimeHour

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TimeMinute

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TimeNanosecond

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TimeNew

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TimeNow

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TimeSecond

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TimeSubtract

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for TimeTrunc

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Truncate

fn info(&self) -> &RoutineInfo

fn return_type(&self, input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for Type

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[ValueType]) -> ValueType

fn propagates_options(&self) -> bool

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for UuidV4

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl<'a> Routine<FunctionContext<'a>> for UuidV7

fn info(&self) -> &RoutineInfo

fn return_type(&self, _input_types: &[Type]) -> Type

fn execute( &self, ctx: &mut FunctionContext<'a>, args: &Columns, ) -> Result<Columns, RoutineError>

Execute the routine.

fn accepted_types(&self) -> InputTypes

fn propagates_options(&self) -> bool

fn call(&self, ctx: &mut C, args: &Columns) -> Result<Columns, RoutineError>

Calls the routine, automatically propagating Option columns if propagates_options() returns true. The option-propagation behaviour is identical for both contexts, hence the shared default.

impl Context for FunctionContext<'_>