Package org.apache.druid.math.expr

Interface ApplyFunction

All Superinterfaces:

NamedFunction

All Known Implementing Classes:

ApplyFunction.AllMatchFunction, ApplyFunction.AnyMatchFunction, ApplyFunction.BaseFoldFunction, ApplyFunction.BaseMapFunction, ApplyFunction.CartesianFoldFunction, ApplyFunction.CartesianMapFunction, ApplyFunction.FilterFunction, ApplyFunction.FoldFunction, ApplyFunction.MapFunction, ApplyFunction.MatchFunction

public interface ApplyFunction
extends NamedFunction

Base interface describing the mechanism used to evaluate an ApplyFunctionExpr, which 'applies' a LambdaExpr to one or more array Expr. All ApplyFunction implementations are immutable.

Nested Class Summary

Nested Classes

Modifier and Type	Interface	Description
static class	ApplyFunction.AllMatchFunction	Evaluates to true if all element of the array input Expr causes the LambdaExpr to evaluate to a 'truthy' value
static class	ApplyFunction.AnyMatchFunction	Evaluates to true if any element of the array input Expr causes the LambdaExpr to evaluate to a 'truthy' value
static class	ApplyFunction.BaseFoldFunction	Base class for family of ApplyFunction which aggregate a scalar or array value given one or more array input Expr arguments and an array or scalar "accumulator" argument with an initial value
static class	ApplyFunction.BaseMapFunction	Base class for "map" functions, which are a class of ApplyFunction which take a lambda function that is mapped to the values of an ApplyFunction.IndexableMapLambdaObjectBinding which is created from the outer Expr.ObjectBinding and the values of the array Expr argument(s)
static class	ApplyFunction.CartesianFoldFunction	Accumulate a value for the cartesian product of 'n' array inputs arguments with an 'n + 1' argument LambdaExpr.
static class	ApplyFunction.CartesianFoldLambdaBinding	ApplyFunction.IndexableFoldLambdaBinding for a ApplyFunction.CartesianFoldFunction.
static class	ApplyFunction.CartesianMapFunction	Map the cartesian product of 'n' array input arguments to an 'n' argument LambdaExpr
static class	ApplyFunction.CartesianMapLambdaBinding	ApplyFunction.IndexableMapLambdaObjectBinding for a ApplyFunction.CartesianMapFunction.
static class	ApplyFunction.FilterFunction	Filter an array to all elements that evaluate to a 'truthy' value for a LambdaExpr
static class	ApplyFunction.FoldFunction	Accumulate a value for a single array input with a 2 argument LambdaExpr.
static class	ApplyFunction.FoldLambdaBinding	ApplyFunction.IndexableFoldLambdaBinding for a ApplyFunction.FoldFunction.
static interface	ApplyFunction.IndexableFoldLambdaBinding	Expr.ObjectBinding which can be iterated by an integer index position for ApplyFunction.BaseFoldFunction.
static interface	ApplyFunction.IndexableMapLambdaObjectBinding	Expr.ObjectBinding which can be iterated by an integer index position for ApplyFunction.BaseMapFunction.
static class	ApplyFunction.LambdaInputBindingInspector	Helper that can wrap another Expr.InputBindingInspector to use to supply the type information of a LambdaExpr when evaluating Expr.getOutputType(org.apache.druid.math.expr.Expr.InputBindingInspector).
static class	ApplyFunction.MapFunction	Map the scalar values of a single array input Expr to a single argument LambdaExpr
static class	ApplyFunction.MapLambdaBinding	ApplyFunction.IndexableMapLambdaObjectBinding for a ApplyFunction.MapFunction.
static class	ApplyFunction.MatchFunction	Base class for family of ApplyFunction which evaluate elements elements of a single array input against a LambdaExpr to evaluate to a final 'truthy' value
static class	ApplyFunction.SettableLambdaBinding	Simple, mutable, Expr.ObjectBinding for a LambdaExpr which provides a Map for storing arbitrary values to use as values for IdentifierExpr in the body of the lambda that are arguments to the lambda

Method Summary

Modifier and Type	Method	Description
ExprEval	apply(org.apache.druid.math.expr.LambdaExpr lambdaExpr, List<Expr> argsExpr, Expr.ObjectBinding bindings)	Apply LambdaExpr to argument list of Expr given a set of outer Expr.ObjectBinding.
default <T> ExprVectorProcessor<T>	asVectorProcessor(Expr.VectorInputBindingInspector inspector, Expr lambda, List<Expr> args)	Builds a 'vectorized' function expression processor, that can build vectorized processors for its input values using Expr.asVectorProcessor(org.apache.druid.math.expr.Expr.VectorInputBindingInspector), for use in vectorized query engines.
default boolean	canVectorize(Expr.InputBindingInspector inspector, Expr lambda, List<Expr> args)	Check if an apply function can be 'vectorized', for a given LambdaExpr and set of Expr inputs.
Set<Expr>	getArrayInputs(List<Expr> args)	Get list of input arguments which must evaluate to an array ExprType
ExpressionType	getOutputType(Expr.InputBindingInspector inspector, org.apache.druid.math.expr.LambdaExpr expr, List<Expr> args)	Compute the output type of this function for a given lambda and the argument expressions which will be applied as its inputs.
default boolean	hasArrayOutput(org.apache.druid.math.expr.LambdaExpr lambdaExpr)	Returns true if apply function produces an array output.
void	validateArguments(org.apache.druid.math.expr.LambdaExpr lambdaExpr, List<Expr> args)	Validate function arguments.

Methods inherited from interface org.apache.druid.math.expr.NamedFunction

name, processingFailed, validationFailed, validationFailed, validationHelperCheckAnyOfArgumentCount, validationHelperCheckArgIsLiteral, validationHelperCheckArgumentCount, validationHelperCheckArgumentCount, validationHelperCheckArgumentRange, validationHelperCheckLambaArgumentCount, validationHelperCheckMinArgumentCount, validationHelperCheckMinArgumentCount

Method Detail

canVectorize

default boolean canVectorize(Expr.InputBindingInspector inspector,
                             Expr lambda,
                             List<Expr> args)

Check if an apply function can be 'vectorized', for a given LambdaExpr and set of Expr inputs. If this method returns true, asVectorProcessor(org.apache.druid.math.expr.Expr.VectorInputBindingInspector, org.apache.druid.math.expr.Expr, java.util.List<org.apache.druid.math.expr.Expr>) is expected to produce a ExprVectorProcessor which can evaluate values in batches to use with vectorized query engines.

See Also:

Expr.canVectorize(Expr.InputBindingInspector), Function.canVectorize(Expr.InputBindingInspector, List)

asVectorProcessor

default <T> ExprVectorProcessor<T> asVectorProcessor(Expr.VectorInputBindingInspector inspector,
                                                     Expr lambda,
                                                     List<Expr> args)

Builds a 'vectorized' function expression processor, that can build vectorized processors for its input values using Expr.asVectorProcessor(org.apache.druid.math.expr.Expr.VectorInputBindingInspector), for use in vectorized query engines.

See Also:

Expr.asVectorProcessor(Expr.VectorInputBindingInspector), Function.asVectorProcessor(Expr.VectorInputBindingInspector, List)

apply

ExprEval apply(org.apache.druid.math.expr.LambdaExpr lambdaExpr,
               List<Expr> argsExpr,
               Expr.ObjectBinding bindings)

Apply LambdaExpr to argument list of Expr given a set of outer Expr.ObjectBinding. These outer bindings will be used to form the scope for the bindings used to evaluate the LambdaExpr, which use the array inputs to supply scalar values to use as bindings for IdentifierExpr in the lambda body.

getArrayInputs

Set<Expr> getArrayInputs(List<Expr> args)

Get list of input arguments which must evaluate to an array ExprType

hasArrayOutput

default boolean hasArrayOutput(org.apache.druid.math.expr.LambdaExpr lambdaExpr)

Returns true if apply function produces an array output. All ApplyFunction implementations are expected to exclusively produce either scalar or array values.

validateArguments

void validateArguments(org.apache.druid.math.expr.LambdaExpr lambdaExpr,
                       List<Expr> args)

Validate function arguments. This method is called whenever a ApplyFunctionExpr is created, and should validate everything that is feasible up front. Note that input type information is typically unavailable at the time Expr are parsed, and so this method is incapable of performing complete validation.

getOutputType

@Nullable
ExpressionType getOutputType(Expr.InputBindingInspector inspector,
                             org.apache.druid.math.expr.LambdaExpr expr,
                             List<Expr> args)

Compute the output type of this function for a given lambda and the argument expressions which will be applied as its inputs.

See Also:

Expr.getOutputType(org.apache.druid.math.expr.Expr.InputBindingInspector)