java.lang.Object
- org.apache.druid.math.expr.ExpressionTypeConversion

public class ExpressionTypeConversion
extends Object

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static ExpressionType`	`autoDetect(ExprEval eval, ExprEval otherEval)`	Given 2 'input' types, which might not be fully trustable, choose the most appropriate combined type for non-vectorized, per-row type detection.
`static ExpressionType`	`conditional(Expr.InputBindingInspector inspector, List<Expr> args)`	Infer the output type of a list of possible 'conditional' expression outputs (where any of these could be the output expression if the corresponding case matching expression evaluates to true)
`static ExpressionType`	`function(ExpressionType type, ExpressionType other)`	Given 2 'input' types, choose the most appropriate combined type, if possible arrays must be the same type if either type is `ExprType.STRING`, the output type will be preserved as string if both types are `ExprType.LONG`, the output type will be preserved as long, otherwise `ExprType.DOUBLE`
`static ExpressionType`	`integerMathFunction(ExpressionType type, ExpressionType other)`	Given 2 'input' types, choose the most appropriate combined type, if possible arrays must be the same type if either type is `ExprType.STRING`, the output type will be preserved as string any number will be coerced to `ExprType.LONG`
`static ExpressionType`	`leastRestrictiveType(ExpressionType type, ExpressionType other)`	`ColumnType.leastRestrictiveType(ColumnType, ColumnType)` but for expression types
`static ExpressionType`	`numeric(ExpressionType type, ExpressionType other)`	Default best effort numeric type conversion.
`static ExpressionType`	`operator(ExpressionType type, ExpressionType other)`	Given 2 'input' types, choose the most appropriate combined type, if possible arrays must be the same type if both types are `ExprType.STRING`, the output type will be preserved as string if both types are `ExprType.LONG`, the output type will be preserved as long otherwise, output is `ExprType.DOUBLE`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

conditional
```
public static ExpressionType conditional(Expr.InputBindingInspector inspector,
                                         List<Expr> args)
```
Infer the output type of a list of possible 'conditional' expression outputs (where any of these could be the output expression if the corresponding case matching expression evaluates to true)

autoDetect
```
public static ExpressionType autoDetect(ExprEval eval,
                                        ExprEval otherEval)
```
Given 2 'input' types, which might not be fully trustable, choose the most appropriate combined type for non-vectorized, per-row type detection. In this mode, null values are ExprType.STRING typed, despite potentially coming from an underlying numeric column, or when an underlying column was completely missing and so all values are null. This method is not well suited for array handling.

operator

@Nullable
public static ExpressionType operator(@Nullable
                                      ExpressionType type,
                                      @Nullable
                                      ExpressionType other)

Given 2 'input' types, choose the most appropriate combined type, if possible arrays must be the same type if both types are ExprType.STRING, the output type will be preserved as string if both types are ExprType.LONG, the output type will be preserved as long otherwise, output is ExprType.DOUBLE

function

@Nullable
public static ExpressionType function(@Nullable
                                      ExpressionType type,
                                      @Nullable
                                      ExpressionType other)

Given 2 'input' types, choose the most appropriate combined type, if possible arrays must be the same type if either type is ExprType.STRING, the output type will be preserved as string if both types are ExprType.LONG, the output type will be preserved as long, otherwise ExprType.DOUBLE

leastRestrictiveType

@Nullable
public static ExpressionType leastRestrictiveType(@Nullable
                                                  ExpressionType type,
                                                  @Nullable
                                                  ExpressionType other)
                                           throws Types.IncompatibleTypeException

ColumnType.leastRestrictiveType(ColumnType, ColumnType) but for expression types

Throws:: Types.IncompatibleTypeException

integerMathFunction

@Nullable
public static ExpressionType integerMathFunction(@Nullable
                                                 ExpressionType type,
                                                 @Nullable
                                                 ExpressionType other)

Given 2 'input' types, choose the most appropriate combined type, if possible arrays must be the same type if either type is ExprType.STRING, the output type will be preserved as string any number will be coerced to ExprType.LONG

numeric

public static ExpressionType numeric(@Nullable
                                     ExpressionType type,
                                     @Nullable
                                     ExpressionType other)

Default best effort numeric type conversion. If both types are ExprType.LONG, returns ExprType.LONG, else ExprType.DOUBLE

Class ExpressionTypeConversion