@PublicEvolving public abstract class ScalarFunction extends UserDefinedFunction
The behavior of a ScalarFunction can be defined by implementing a custom evaluation
method. An evaluation method must be declared publicly and named eval. Evaluation
methods can also be overloaded by implementing multiple methods named eval.
By default, input and output data types are automatically extracted using reflection. If the
reflective information is not sufficient, it can be supported and enriched with DataTypeHint and FunctionHint annotations.
The following examples show how to specify a scalar function:
// a function that accepts two INT arguments and computes a sum
class SumFunction extends ScalarFunction {
public Integer eval(Integer a, Integer b) {
return a + b;
}
}
// a function that accepts either INT NOT NULL or BOOLEAN NOT NULL and computes a STRING
class StringifyFunction extends ScalarFunction {
public String eval(int i) {
return String.valueOf(i);
}
public String eval(boolean b) {
return String.valueOf(b);
}
}
// a function that accepts either INT or BOOLEAN and computes a STRING using function hints| Constructor and Description |
|---|
ScalarFunction() |
| Modifier and Type | Method and Description |
|---|---|
FunctionKind |
getKind()
Returns the kind of function this definition describes.
|
TypeInformation<?>[] |
getParameterTypes(Class<?>[] signature)
Deprecated.
This method uses the old type system and is based on the old reflective
extraction logic. The method will be removed in future versions and is only called when
using the deprecated
TableEnvironment.registerFunction(...) method. The new
reflective extraction logic (possibly enriched with DataTypeHint and FunctionHint) should be powerful enough to cover most use cases. For advanced users, it
is possible to override UserDefinedFunction.getTypeInference(DataTypeFactory). |
TypeInformation<?> |
getResultType(Class<?>[] signature)
Deprecated.
This method uses the old type system and is based on the old reflective
extraction logic. The method will be removed in future versions and is only called when
using the deprecated
TableEnvironment.registerFunction(...) method. The new
reflective extraction logic (possibly enriched with DataTypeHint and FunctionHint) should be powerful enough to cover most use cases. For advanced users, it
is possible to override UserDefinedFunction.getTypeInference(DataTypeFactory). |
TypeInference |
getTypeInference(DataTypeFactory typeFactory)
Returns the logic for performing type inference of a call to this function definition.
|
close, functionIdentifier, open, toStringclone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, waitgetRequirements, isDeterministic, supportsConstantFolding@Deprecated public TypeInformation<?> getResultType(Class<?>[] signature)
TableEnvironment.registerFunction(...) method. The new
reflective extraction logic (possibly enriched with DataTypeHint and FunctionHint) should be powerful enough to cover most use cases. For advanced users, it
is possible to override UserDefinedFunction.getTypeInference(DataTypeFactory).@Deprecated public TypeInformation<?>[] getParameterTypes(Class<?>[] signature)
TableEnvironment.registerFunction(...) method. The new
reflective extraction logic (possibly enriched with DataTypeHint and FunctionHint) should be powerful enough to cover most use cases. For advanced users, it
is possible to override UserDefinedFunction.getTypeInference(DataTypeFactory).TypeInformation about the operands of the evaluation method with a given
signature.public final FunctionKind getKind()
FunctionDefinitionpublic TypeInference getTypeInference(DataTypeFactory typeFactory)
UserDefinedFunctionThe type inference process is responsible for inferring unknown types of input arguments, validating input arguments, and producing result types. The type inference process happens independent of a function body. The output of the type inference is used to search for a corresponding runtime implementation.
Instances of type inference can be created by using TypeInference.newBuilder().
See BuiltInFunctionDefinitions for concrete usage examples.
The type inference for user-defined functions is automatically extracted using reflection.
It does this by analyzing implementation methods such as eval() or accumulate() and
the generic parameters of a function class if present. If the reflective information is not
sufficient, it can be supported and enriched with DataTypeHint and FunctionHint annotations.
Note: Overriding this method is only recommended for advanced users. If a custom type inference is specified, it is the responsibility of the implementer to make sure that the output of the type inference process matches with the implementation method:
The implementation method must comply with each DataType.getConversionClass()
returned by the type inference. For example, if DataTypes.TIMESTAMP(3).bridgedTo(java.sql.Timestamp.class) is an expected argument type, the
method must accept a call eval(java.sql.Timestamp).
Regular Java calling semantics (including type widening and autoboxing) are applied when
calling an implementation method which means that the signature can be eval(java.lang.Object).
The runtime will take care of converting the data to the data format specified by the
DataType.getConversionClass() coming from the type inference logic.
getTypeInference in interface FunctionDefinitiongetTypeInference in class UserDefinedFunctionCopyright © 2014–2024 The Apache Software Foundation. All rights reserved.