OperandTypes (Apache Calcite API)

java.lang.Object
- org.apache.calcite.sql.type.OperandTypes

```
public abstract class OperandTypes
extends Object
```
Strategies for checking operand types.
This class defines singleton instances of strategy objects for operand type-checking. ReturnTypes and InferTypes provide similar strategies for operand type inference and operator return type inference.
Note to developers: avoid anonymous inner classes here except for unique, non-generalizable strategies; anything else belongs in a reusable top-level class. If you find yourself copying and pasting an existing strategy's anonymous inner class, you're making a mistake.

See Also:

SqlOperandTypeChecker, ReturnTypes, InferTypes

Field Summary

Fields
Modifier and Type	Field and Description
`static SqlSingleOperandTypeChecker`	`ANY`
`static SqlSingleOperandTypeChecker`	`ANY_ANY`
`static SqlSingleOperandTypeChecker`	`ANY_IGNORE`
`static SqlSingleOperandTypeChecker`	`ANY_NUMERIC`
`static SqlSingleOperandTypeChecker`	`ARRAY`
`static SqlOperandTypeChecker`	`AT_LEAST_ONE_SAME_VARIADIC` Operand type-checking strategy where any positive number of operands must all be in the same type family.
`static SqlSingleOperandTypeChecker`	`BINARY`
`static SqlSingleOperandTypeChecker`	`BOOLEAN`
`static SqlSingleOperandTypeChecker`	`BOOLEAN_BOOLEAN`
`static SqlSingleOperandTypeChecker`	`CBSTRING_INTEGER` Operand type-checking strategy where the first operand is a character or binary string (CHAR, VARCHAR, BINARY or VARBINARY), and the second operand is INTEGER.
`static SqlSingleOperandTypeChecker`	`CHARACTER`
`static SqlSingleOperandTypeChecker`	`CHARACTER_CHARACTER_DATETIME`
`static SqlSingleOperandTypeChecker`	`COLLECTION` Checks that returns whether a value is a multiset or an array.
`static SqlSingleOperandTypeChecker`	`COLLECTION_OR_MAP`
`static SqlOperandTypeChecker`	`COMPARABLE_ORDERED` Operand type-checking strategy where operand type must allow ordered comparisons.
`static SqlOperandTypeChecker`	`COMPARABLE_ORDERED_COMPARABLE_ORDERED` Operand type-checking strategy where operand types must allow ordered comparisons.
`static SqlOperandTypeChecker`	`COMPARABLE_UNORDERED_COMPARABLE_UNORDERED` Operand type-checking strategy where operand types must allow unordered comparisons.
`static SqlSingleOperandTypeChecker`	`CURSOR`
`static SqlSingleOperandTypeChecker`	`DATE`
`static SqlSingleOperandTypeChecker`	`DATETIME`
`static SqlSingleOperandTypeChecker`	`DATETIME_INTERVAL`
`static SqlSingleOperandTypeChecker`	`DATETIME_INTERVAL_INTERVAL`
`static SqlSingleOperandTypeChecker`	`DATETIME_INTERVAL_INTERVAL_TIME`
`static SqlSingleOperandTypeChecker`	`DATETIME_INTERVAL_TIME`
`static SqlSingleOperandTypeChecker`	`DIVISION_OPERATOR` Type-checking strategy for the "/" operator.
`static SqlSingleOperandTypeChecker`	`EXACT_NUMERIC`
`static SqlSingleOperandTypeChecker`	`EXACT_NUMERIC_EXACT_NUMERIC`
`static SqlSingleOperandTypeChecker`	`IGNORE_ANY`
`static SqlSingleOperandTypeChecker`	`INTEGER`
`static SqlSingleOperandTypeChecker`	`INTERVAL`
`static SqlSingleOperandTypeChecker`	`INTERVAL_DATETIME`
`static FamilyOperandTypeChecker`	`INTERVAL_INTERVAL`
`static SqlSingleOperandTypeChecker`	`INTERVAL_NUMERIC`
`static SqlSingleOperandTypeChecker`	`INTERVAL_SAME_SAME` Parameter type-checking strategy where type must a nullable time interval, nullable time interval.
`static SqlSingleOperandTypeChecker`	`INTERVALINTERVAL_INTERVALDATETIME`
`static SqlSingleOperandTypeChecker`	`LITERAL` Operand type-checking strategy type must be a non-NULL literal.
`static FamilyOperandTypeChecker`	`MINUS_DATE_OPERATOR`
`static SqlSingleOperandTypeChecker`	`MINUS_OPERATOR`
`static SqlSingleOperandTypeChecker`	`MULTIPLY_OPERATOR` Type-checking strategy for the "*" operator.
`static SqlSingleOperandTypeChecker`	`MULTISET`
`static SqlOperandTypeChecker`	`MULTISET_MULTISET`
`static SqlSingleOperandTypeChecker`	`NILADIC` Operand type-checking strategy for an operator which takes no operands.
`static SqlSingleOperandTypeChecker`	`NULLABLE_LITERAL` Operand type-checking strategy where type must be a literal or NULL.
`static SqlSingleOperandTypeChecker`	`NUMERIC`
`static SqlSingleOperandTypeChecker`	`NUMERIC_INTEGER`
`static SqlSingleOperandTypeChecker`	`NUMERIC_INTERVAL`
`static SqlSingleOperandTypeChecker`	`NUMERIC_NUMERIC`
`static SqlSingleOperandTypeChecker`	`NUMERIC_OPTIONAL_INTEGER`
`static SqlSingleOperandTypeChecker`	`NUMERIC_OR_INTERVAL`
`static SqlSingleOperandTypeChecker`	`NUMERIC_OR_STRING`
`static SqlOperandTypeChecker`	`ONE_OR_MORE` Operand type-checking strategy that allows one or more operands.
`static SqlSingleOperandTypeChecker`	`PERIOD`
`static SqlSingleOperandTypeChecker`	`PERIOD_OR_DATETIME`
`static SqlSingleOperandTypeChecker`	`PLUS_OPERATOR`
`static SqlSingleOperandTypeChecker`	`POSITIVE_INTEGER_LITERAL` Operand type-checking strategy type must be a positive integer non-NULL literal.
`static SqlSingleOperandTypeChecker`	`RECORD_COLLECTION` Checker that returns whether a value is a multiset of records or an array of records.
`static SqlOperandTypeChecker`	`RECORD_TO_SCALAR`
`static SqlSingleOperandTypeChecker`	`SAME_SAME` Operand type-checking strategy where two operands must both be in the same type family.
`static SqlSingleOperandTypeChecker`	`SAME_SAME_INTEGER`
`static SqlSingleOperandTypeChecker`	`SAME_SAME_SAME` Operand type-checking strategy where three operands must all be in the same type family.
`static SqlOperandTypeChecker`	`SAME_VARIADIC` Operand type-checking strategy where any number of operands must all be in the same type family.
`static SqlSingleOperandTypeChecker`	`SCALAR_OR_RECORD_COLLECTION` Checker that returns whether a value is a collection (multiset or array) of scalar or record values.
`static SqlSingleOperandTypeChecker`	`SCALAR_OR_RECORD_COLLECTION_OR_MAP`
`static SqlOperandTypeChecker`	`SET_OP` Operand type-checking strategy for a set operator (UNION, INTERSECT, EXCEPT).
`static SqlSingleOperandTypeChecker`	`STRING`
`static SqlSingleOperandTypeChecker`	`STRING_INTEGER`
`static SqlSingleOperandTypeChecker`	`STRING_INTEGER_INTEGER`
`static SqlSingleOperandTypeChecker`	`STRING_INTEGER_OPTIONAL_INTEGER`
`static SqlSingleOperandTypeChecker`	`STRING_SAME_SAME` Operand type-checking strategy where two operands must both be in the same string type family.
`static SqlSingleOperandTypeChecker`	`STRING_SAME_SAME_INTEGER` Operand type-checking strategy where two operands must both be in the same string type family and last type is INTEGER.
`static SqlSingleOperandTypeChecker`	`STRING_SAME_SAME_OR_ARRAY_SAME_SAME`
`static SqlSingleOperandTypeChecker`	`STRING_SAME_SAME_SAME` Operand type-checking strategy where three operands must all be in the same string type family.
`static FamilyOperandTypeChecker`	`STRING_STRING`
`static SqlSingleOperandTypeChecker`	`STRING_STRING_INTEGER`
`static SqlSingleOperandTypeChecker`	`STRING_STRING_INTEGER_INTEGER`
`static FamilyOperandTypeChecker`	`STRING_STRING_OPTIONAL_STRING`
`static FamilyOperandTypeChecker`	`STRING_STRING_STRING`
`static SqlSingleOperandTypeChecker`	`TIMESTAMP`
`static SqlSingleOperandTypeChecker`	`UNIT_INTERVAL_NUMERIC_LITERAL` Operand type-checking strategy type must be a numeric non-NULL literal in the range 0 and 1 inclusive.
`static SqlOperandTypeChecker`	`VARIADIC` Operand type-checking strategy for an operator with no restrictions on number or type of operands.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static SqlOperandTypeChecker`	`and(SqlOperandTypeChecker... rules)` Creates a checker that passes if all of the rules pass.
`static SqlSingleOperandTypeChecker`	`and(SqlSingleOperandTypeChecker... rules)` Creates a single-operand checker that passes if all of the rules pass.
`static FamilyOperandTypeChecker`	`family(List<SqlTypeFamily> families)` Creates a checker that passes if each operand is a member of a corresponding family.
`static FamilyOperandTypeChecker`	`family(List<SqlTypeFamily> families, Predicate<Integer> optional)` Creates a checker that passes if each operand is a member of a corresponding family, and allows specified parameters to be optional.
`static FamilyOperandTypeChecker`	`family(SqlTypeFamily... families)` Creates a checker that passes if each operand is a member of a corresponding family.
`static SqlOperandMetadata`	`operandMetadata(List<SqlTypeFamily> families, Function<RelDataTypeFactory,List<RelDataType>> typesFactory, IntFunction<String> operandName, Predicate<Integer> optional)` Creates a checker for user-defined functions (including user-defined aggregate functions, table functions, and table macros).
`static SqlOperandTypeChecker`	`or(SqlOperandTypeChecker... rules)` Creates a checker that passes if any one of the rules passes.
`static SqlSingleOperandTypeChecker`	`or(SqlSingleOperandTypeChecker... rules)` Creates a single-operand checker that passes if any one of the rules passes.
`static SqlOperandTypeChecker`	`repeat(SqlOperandCountRange range, SqlSingleOperandTypeChecker... rules)` Creates a checker that passes if all of the rules pass for each operand, using a given operand count strategy.
`static SqlOperandTypeChecker`	`sequence(String allowedSignatures, SqlSingleOperandTypeChecker... rules)` Creates an operand checker from a sequence of single-operand checkers.
`static SqlOperandTypeChecker`	`variadic(SqlOperandCountRange range)`

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

Field Detail

NILADIC
```
public static final SqlSingleOperandTypeChecker NILADIC
```
Operand type-checking strategy for an operator which takes no operands.

VARIADIC
```
public static final SqlOperandTypeChecker VARIADIC
```
Operand type-checking strategy for an operator with no restrictions on number or type of operands.

ONE_OR_MORE
```
public static final SqlOperandTypeChecker ONE_OR_MORE
```
Operand type-checking strategy that allows one or more operands.

BOOLEAN

public static final SqlSingleOperandTypeChecker BOOLEAN

BOOLEAN_BOOLEAN

public static final SqlSingleOperandTypeChecker BOOLEAN_BOOLEAN

NUMERIC

public static final SqlSingleOperandTypeChecker NUMERIC

INTEGER

public static final SqlSingleOperandTypeChecker INTEGER

NUMERIC_OPTIONAL_INTEGER

public static final SqlSingleOperandTypeChecker NUMERIC_OPTIONAL_INTEGER

NUMERIC_INTEGER

public static final SqlSingleOperandTypeChecker NUMERIC_INTEGER

NUMERIC_NUMERIC

public static final SqlSingleOperandTypeChecker NUMERIC_NUMERIC

EXACT_NUMERIC

public static final SqlSingleOperandTypeChecker EXACT_NUMERIC

EXACT_NUMERIC_EXACT_NUMERIC

public static final SqlSingleOperandTypeChecker EXACT_NUMERIC_EXACT_NUMERIC

BINARY

public static final SqlSingleOperandTypeChecker BINARY

STRING

public static final SqlSingleOperandTypeChecker STRING

STRING_STRING

public static final FamilyOperandTypeChecker STRING_STRING

STRING_STRING_STRING

public static final FamilyOperandTypeChecker STRING_STRING_STRING

STRING_STRING_OPTIONAL_STRING

public static final FamilyOperandTypeChecker STRING_STRING_OPTIONAL_STRING

CHARACTER

public static final SqlSingleOperandTypeChecker CHARACTER

DATETIME

public static final SqlSingleOperandTypeChecker DATETIME

DATE

public static final SqlSingleOperandTypeChecker DATE

TIMESTAMP

public static final SqlSingleOperandTypeChecker TIMESTAMP

INTERVAL

public static final SqlSingleOperandTypeChecker INTERVAL

CHARACTER_CHARACTER_DATETIME

public static final SqlSingleOperandTypeChecker CHARACTER_CHARACTER_DATETIME

PERIOD

public static final SqlSingleOperandTypeChecker PERIOD

PERIOD_OR_DATETIME

public static final SqlSingleOperandTypeChecker PERIOD_OR_DATETIME

INTERVAL_INTERVAL

public static final FamilyOperandTypeChecker INTERVAL_INTERVAL

MULTISET

public static final SqlSingleOperandTypeChecker MULTISET

ARRAY

public static final SqlSingleOperandTypeChecker ARRAY

COLLECTION
```
public static final SqlSingleOperandTypeChecker COLLECTION
```
Checks that returns whether a value is a multiset or an array. Cf Java, where list and set are collections but a map is not.

COLLECTION_OR_MAP

public static final SqlSingleOperandTypeChecker COLLECTION_OR_MAP

NULLABLE_LITERAL
```
public static final SqlSingleOperandTypeChecker NULLABLE_LITERAL
```
Operand type-checking strategy where type must be a literal or NULL.

LITERAL
```
public static final SqlSingleOperandTypeChecker LITERAL
```
Operand type-checking strategy type must be a non-NULL literal.

POSITIVE_INTEGER_LITERAL
```
public static final SqlSingleOperandTypeChecker POSITIVE_INTEGER_LITERAL
```
Operand type-checking strategy type must be a positive integer non-NULL literal.

UNIT_INTERVAL_NUMERIC_LITERAL
```
public static final SqlSingleOperandTypeChecker UNIT_INTERVAL_NUMERIC_LITERAL
```
Operand type-checking strategy type must be a numeric non-NULL literal in the range 0 and 1 inclusive.

SAME_SAME
```
public static final SqlSingleOperandTypeChecker SAME_SAME
```
Operand type-checking strategy where two operands must both be in the same type family.

SAME_SAME_INTEGER

public static final SqlSingleOperandTypeChecker SAME_SAME_INTEGER

SAME_SAME_SAME
```
public static final SqlSingleOperandTypeChecker SAME_SAME_SAME
```
Operand type-checking strategy where three operands must all be in the same type family.

SAME_VARIADIC
```
public static final SqlOperandTypeChecker SAME_VARIADIC
```
Operand type-checking strategy where any number of operands must all be in the same type family.

AT_LEAST_ONE_SAME_VARIADIC
```
public static final SqlOperandTypeChecker AT_LEAST_ONE_SAME_VARIADIC
```
Operand type-checking strategy where any positive number of operands must all be in the same type family.

COMPARABLE_ORDERED_COMPARABLE_ORDERED
```
public static final SqlOperandTypeChecker COMPARABLE_ORDERED_COMPARABLE_ORDERED
```
Operand type-checking strategy where operand types must allow ordered comparisons.

COMPARABLE_ORDERED
```
public static final SqlOperandTypeChecker COMPARABLE_ORDERED
```
Operand type-checking strategy where operand type must allow ordered comparisons. Used when instance comparisons are made on single operand functions

COMPARABLE_UNORDERED_COMPARABLE_UNORDERED
```
public static final SqlOperandTypeChecker COMPARABLE_UNORDERED_COMPARABLE_UNORDERED
```
Operand type-checking strategy where operand types must allow unordered comparisons.

STRING_SAME_SAME
```
public static final SqlSingleOperandTypeChecker STRING_SAME_SAME
```
Operand type-checking strategy where two operands must both be in the same string type family.

STRING_SAME_SAME_SAME
```
public static final SqlSingleOperandTypeChecker STRING_SAME_SAME_SAME
```
Operand type-checking strategy where three operands must all be in the same string type family.

STRING_STRING_INTEGER

public static final SqlSingleOperandTypeChecker STRING_STRING_INTEGER

STRING_STRING_INTEGER_INTEGER

public static final SqlSingleOperandTypeChecker STRING_STRING_INTEGER_INTEGER

STRING_INTEGER

public static final SqlSingleOperandTypeChecker STRING_INTEGER

STRING_INTEGER_INTEGER

public static final SqlSingleOperandTypeChecker STRING_INTEGER_INTEGER

STRING_INTEGER_OPTIONAL_INTEGER

public static final SqlSingleOperandTypeChecker STRING_INTEGER_OPTIONAL_INTEGER

CBSTRING_INTEGER
```
public static final SqlSingleOperandTypeChecker CBSTRING_INTEGER
```
Operand type-checking strategy where the first operand is a character or binary string (CHAR, VARCHAR, BINARY or VARBINARY), and the second operand is INTEGER.

STRING_SAME_SAME_INTEGER
```
public static final SqlSingleOperandTypeChecker STRING_SAME_SAME_INTEGER
```
Operand type-checking strategy where two operands must both be in the same string type family and last type is INTEGER.

STRING_SAME_SAME_OR_ARRAY_SAME_SAME

public static final SqlSingleOperandTypeChecker STRING_SAME_SAME_OR_ARRAY_SAME_SAME

ANY

public static final SqlSingleOperandTypeChecker ANY

ANY_ANY

public static final SqlSingleOperandTypeChecker ANY_ANY

ANY_IGNORE

public static final SqlSingleOperandTypeChecker ANY_IGNORE

IGNORE_ANY

public static final SqlSingleOperandTypeChecker IGNORE_ANY

ANY_NUMERIC

public static final SqlSingleOperandTypeChecker ANY_NUMERIC

CURSOR

public static final SqlSingleOperandTypeChecker CURSOR

INTERVAL_SAME_SAME
```
public static final SqlSingleOperandTypeChecker INTERVAL_SAME_SAME
```
Parameter type-checking strategy where type must a nullable time interval, nullable time interval.

NUMERIC_INTERVAL

public static final SqlSingleOperandTypeChecker NUMERIC_INTERVAL

INTERVAL_NUMERIC

public static final SqlSingleOperandTypeChecker INTERVAL_NUMERIC

DATETIME_INTERVAL

public static final SqlSingleOperandTypeChecker DATETIME_INTERVAL

DATETIME_INTERVAL_INTERVAL

public static final SqlSingleOperandTypeChecker DATETIME_INTERVAL_INTERVAL

DATETIME_INTERVAL_INTERVAL_TIME

public static final SqlSingleOperandTypeChecker DATETIME_INTERVAL_INTERVAL_TIME

DATETIME_INTERVAL_TIME

public static final SqlSingleOperandTypeChecker DATETIME_INTERVAL_TIME

INTERVAL_DATETIME

public static final SqlSingleOperandTypeChecker INTERVAL_DATETIME

INTERVALINTERVAL_INTERVALDATETIME

public static final SqlSingleOperandTypeChecker INTERVALINTERVAL_INTERVALDATETIME

PLUS_OPERATOR

public static final SqlSingleOperandTypeChecker PLUS_OPERATOR

MULTIPLY_OPERATOR

public static final SqlSingleOperandTypeChecker MULTIPLY_OPERATOR

Type-checking strategy for the "*" operator.

DIVISION_OPERATOR

public static final SqlSingleOperandTypeChecker DIVISION_OPERATOR

Type-checking strategy for the "/" operator.

MINUS_OPERATOR

public static final SqlSingleOperandTypeChecker MINUS_OPERATOR

MINUS_DATE_OPERATOR

public static final FamilyOperandTypeChecker MINUS_DATE_OPERATOR

NUMERIC_OR_INTERVAL

public static final SqlSingleOperandTypeChecker NUMERIC_OR_INTERVAL

NUMERIC_OR_STRING

public static final SqlSingleOperandTypeChecker NUMERIC_OR_STRING

RECORD_COLLECTION
```
public static final SqlSingleOperandTypeChecker RECORD_COLLECTION
```
Checker that returns whether a value is a multiset of records or an array of records.

See Also:

COLLECTION

SCALAR_OR_RECORD_COLLECTION
```
public static final SqlSingleOperandTypeChecker SCALAR_OR_RECORD_COLLECTION
```
Checker that returns whether a value is a collection (multiset or array) of scalar or record values.

SCALAR_OR_RECORD_COLLECTION_OR_MAP

public static final SqlSingleOperandTypeChecker SCALAR_OR_RECORD_COLLECTION_OR_MAP

MULTISET_MULTISET

public static final SqlOperandTypeChecker MULTISET_MULTISET

SET_OP
```
public static final SqlOperandTypeChecker SET_OP
```
Operand type-checking strategy for a set operator (UNION, INTERSECT, EXCEPT).

RECORD_TO_SCALAR

public static final SqlOperandTypeChecker RECORD_TO_SCALAR

Method Detail

family
```
public static FamilyOperandTypeChecker family(SqlTypeFamily... families)
```
Creates a checker that passes if each operand is a member of a corresponding family.

family

public static FamilyOperandTypeChecker family(List<SqlTypeFamily> families,
                                              Predicate<Integer> optional)

Creates a checker that passes if each operand is a member of a corresponding family, and allows specified parameters to be optional.

family
```
public static FamilyOperandTypeChecker family(List<SqlTypeFamily> families)
```
Creates a checker that passes if each operand is a member of a corresponding family.

operandMetadata

public static SqlOperandMetadata operandMetadata(List<SqlTypeFamily> families,
                                                 Function<RelDataTypeFactory,List<RelDataType>> typesFactory,
                                                 IntFunction<String> operandName,
                                                 Predicate<Integer> optional)

Creates a checker for user-defined functions (including user-defined aggregate functions, table functions, and table macros).

Unlike built-in functions, there is a fixed number of parameters, and the parameters have names. You can ask for the type of a parameter without providing a particular call (and with it actual arguments) but you do need to provide a type factory, and therefore the types are only good for the duration of the current statement.

or

public static SqlOperandTypeChecker or(SqlOperandTypeChecker... rules)

Creates a checker that passes if any one of the rules passes.

and

public static SqlOperandTypeChecker and(SqlOperandTypeChecker... rules)

Creates a checker that passes if all of the rules pass.

or

public static SqlSingleOperandTypeChecker or(SqlSingleOperandTypeChecker... rules)

Creates a single-operand checker that passes if any one of the rules passes.

and

public static SqlSingleOperandTypeChecker and(SqlSingleOperandTypeChecker... rules)

Creates a single-operand checker that passes if all of the rules pass.

sequence

public static SqlOperandTypeChecker sequence(String allowedSignatures,
                                             SqlSingleOperandTypeChecker... rules)

Creates an operand checker from a sequence of single-operand checkers.

repeat

public static SqlOperandTypeChecker repeat(SqlOperandCountRange range,
                                           SqlSingleOperandTypeChecker... rules)

Creates a checker that passes if all of the rules pass for each operand, using a given operand count strategy.

variadic

public static SqlOperandTypeChecker variadic(SqlOperandCountRange range)

Class OperandTypes