RexBuilder (Calcite Core 1.2.0-incubating API)

java.lang.Object
- org.apache.calcite.rex.RexBuilder

```
public class RexBuilder
extends Object
```
Factory for row expressions.
Some common literal values (NULL, TRUE, FALSE, 0, 1, '') are cached.

Field Summary

Fields
Modifier and Type	Field and Description
`static SqlSpecialOperator`	`GET_OPERATOR` Special operator that accesses an unadvertised field of an input record.
`static com.google.common.base.Function<RelDataTypeField,RexInputRef>`	`TO_INPUT_REF`
`protected RelDataTypeFactory`	`typeFactory`

Constructor Summary

Constructors
Constructor and Description

RexBuilder(RelDataTypeFactory typeFactory)
Creates a RexBuilder.

Constructors
Constructor and Description
`RexBuilder(RelDataTypeFactory typeFactory)` Creates a RexBuilder.

Method Summary

Methods
Modifier and Type	Method and Description
`RexNode`	`addAggCall(AggregateCall aggCall, int groupCount, boolean indicator, List<AggregateCall> aggCalls, Map<AggregateCall,RexNode> aggCallMapping, List<RelDataType> aggArgTypes)` Creates a reference to an aggregate call, checking for repeated calls.
`RexLiteral`	`constantNull()` Creates a constant for the SQL `NULL` value.
`RexNode`	`copy(RexNode expr)` Creates a copy of an expression, which may have been created using a different RexBuilder and/or `RelDataTypeFactory`, using this RexBuilder.
`RexNode`	`decodeIntervalOrDecimal(RexNode node)` Retrieves an interval or decimal node's integer representation
`RelDataType`	`deriveReturnType(SqlOperator op, List<? extends RexNode> exprs)` Derives the return type of a call to an operator.
`RexNode`	`encodeIntervalOrDecimal(RexNode value, RelDataType type, boolean checkOverflow)` Casts a decimal's integer representation to a decimal node.
`RexNode`	`ensureType(RelDataType type, RexNode node, boolean matchNullability)` Ensures expression is interpreted as a specified type.
`SqlStdOperatorTable`	`getOpTab()` Returns this RexBuilder's operator table
`RelDataTypeFactory`	`getTypeFactory()` Returns this RexBuilder's type factory
`List<RexInputRef>`	`identityProjects(RelDataType rowType)` Creates a list of `RexInputRef` expressions, projecting the fields of a given record type.
`RexNode`	`makeAbstractCast(RelDataType type, RexNode exp)` Creates a call to the CAST operator.
`RexLiteral`	`makeApproxLiteral(BigDecimal bd)` Creates a double-precision literal.
`RexLiteral`	`makeApproxLiteral(BigDecimal bd, RelDataType type)` Creates an approximate numeric literal (double or float).
`RexLiteral`	`makeBigintLiteral(BigDecimal bd)` Creates a BIGINT literal.
`RexLiteral`	`makeBinaryLiteral(ByteString byteString)` Creates a byte array literal.
`RexNode`	`makeCall(RelDataType returnType, SqlOperator op, List<RexNode> exprs)` Creates a call with a list of arguments and a predetermined type.
`RexNode`	`makeCall(SqlOperator op, List<? extends RexNode> exprs)` Creates a call with an array of arguments.
`RexNode`	`makeCall(SqlOperator op, RexNode... exprs)` Creates a call with a list of arguments.
`RexNode`	`makeCast(RelDataType type, RexNode exp)` Creates a call to the CAST operator, expanding if possible.
`RexLiteral`	`makeCharLiteral(NlsString str)` Creates a character string literal from an `NlsString`.
`RexNode`	`makeCorrel(RelDataType type, String name)` Creates an expression referencing a correlation variable.
`RexLiteral`	`makeDateLiteral(Calendar date)` Creates a Date literal.
`RexDynamicParam`	`makeDynamicParam(RelDataType type, int index)` Creates a reference to a dynamic parameter
`RexLiteral`	`makeExactLiteral(BigDecimal bd)` Creates a numeric literal.
`RexLiteral`	`makeExactLiteral(BigDecimal bd, RelDataType type)` Creates a numeric literal.
`RexNode`	`makeFieldAccess(RexNode expr, int i)` Creates an expression accessing a field with a given ordinal from a record.
`RexNode`	`makeFieldAccess(RexNode expr, String fieldName, boolean caseSensitive)` Creates an expression accessing a given named field from a record.
`RexLiteral`	`makeFlag(Enum flag)` Creates a literal representing a flag.
`RexInputRef`	`makeInputRef(RelDataType type, int i)` Creates a reference to a given field of the input record.
`RexInputRef`	`makeInputRef(RelNode input, int i)` Creates a reference to a given field of the input relational expression.
`RexLiteral`	`makeIntervalLiteral(BigDecimal v, SqlIntervalQualifier intervalQualifier)` Creates an interval literal.
`RexLiteral`	`makeIntervalLiteral(SqlIntervalQualifier intervalQualifier)` Creates an interval literal.
`RexLiteral`	`makeLiteral(boolean b)` Creates a boolean literal.
`protected RexLiteral`	`makeLiteral(Comparable o, RelDataType type, SqlTypeName typeName)` Internal method to create a call to a literal.
`RexNode`	`makeLiteral(Object value, RelDataType type, boolean allowCast)` Creates a literal of a given type.
`RexLiteral`	`makeLiteral(String s)` Creates a character string literal.
`RexNode`	`makeNewInvocation(RelDataType type, List<RexNode> exprs)` Creates an invocation of the NEW operator.
`RexNode`	`makeNotNullCast(RexNode expr)` Makes an expression which converts a value of type T to a value of type T NOT NULL, or throws if the value is NULL.
`RexNode`	`makeNullLiteral(SqlTypeName typeName)` Creates a literal whose value is NULL, with a particular type.
`RexNode`	`makeNullLiteral(SqlTypeName typeName, int precision)` Creates an expression corresponding to a null literal, cast to a specific type and precision
`RexNode`	`makeOver(RelDataType type, SqlAggFunction operator, List<RexNode> exprs, List<RexNode> partitionKeys, com.google.common.collect.ImmutableList<RexFieldCollation> orderKeys, RexWindowBound lowerBound, RexWindowBound upperBound, boolean physical, boolean allowPartial, boolean nullWhenCountZero)` Creates a call to a windowed agg.
`protected RexLiteral`	`makePreciseStringLiteral(String s)` Creates a character string literal with type CHAR and default charset and collation.
`RexRangeRef`	`makeRangeReference(RelDataType type, int offset, boolean nullable)` Creates a reference to all the fields in the row.
`RexNode`	`makeRangeReference(RelNode input)` Creates a reference to all the fields in the row.
`RexNode`	`makeReinterpretCast(RelDataType type, RexNode exp, RexNode checkOverflow)` Makes a reinterpret cast.
`RexLiteral`	`makeTimeLiteral(Calendar time, int precision)` Creates a Time literal.
`RexLiteral`	`makeTimestampLiteral(Calendar timestamp, int precision)` Creates a Timestamp literal.
`RexWindow`	`makeWindow(List<RexNode> partitionKeys, com.google.common.collect.ImmutableList<RexFieldCollation> orderKeys, RexWindowBound lowerBound, RexWindowBound upperBound, boolean isRows)` Creates a window specification.
`RexNode`	`makeZeroLiteral(RelDataType type)` Creates a literal of the default value for the given type.
`RelDataType`	`matchNullability(RelDataType type, RexNode value)` Ensures that a type's nullability matches a value's nullability.

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

- Field Detail
  - GET_OPERATOR
```
public static final SqlSpecialOperator GET_OPERATOR
```
    Special operator that accesses an unadvertised field of an input record. This operator cannot be used in SQL queries; it is introduced temporarily during sql-to-rel translation, then replaced during the process that trims unwanted fields.
  - TO_INPUT_REF
```
public static final com.google.common.base.Function<RelDataTypeField,RexInputRef> TO_INPUT_REF
```
  - typeFactory
```
protected final RelDataTypeFactory typeFactory
```
- Constructor Detail
  - RexBuilder
```
public RexBuilder(RelDataTypeFactory typeFactory)
```
    Creates a RexBuilder.
    
    Parameters:
    typeFactory - Type factory
- Method Detail
  - identityProjects
```
public List<RexInputRef> identityProjects(RelDataType rowType)
```
    Creates a list of RexInputRef expressions, projecting the fields of a given record type.
  - getTypeFactory
```
public RelDataTypeFactory getTypeFactory()
```
    Returns this RexBuilder's type factory
    
    Returns:
    type factory
  - getOpTab
```
public SqlStdOperatorTable getOpTab()
```
    Returns this RexBuilder's operator table
    
    Returns:
    operator table
  - makeFieldAccess
```
public RexNode makeFieldAccess(RexNode expr,
                      String fieldName,
                      boolean caseSensitive)
```
    Creates an expression accessing a given named field from a record.
    NOTE: Be careful choosing the value of caseSensitive. If the field name was supplied by an end-user (e.g. as a column alias in SQL), use your session's case-sensitivity setting. Only hard-code true if you are sure that the field name is internally generated. Hard-coding false is almost certainly wrong.
    
    Parameters:
    expr - Expression yielding a record
    fieldName - Name of field in record
    caseSensitive - Whether match is case-sensitive
    
    Returns:
    Expression accessing a given named field
  - makeFieldAccess
```
public RexNode makeFieldAccess(RexNode expr,
                      int i)
```
    Creates an expression accessing a field with a given ordinal from a record.
    
    Parameters:
    expr - Expression yielding a record
    i - Ordinal of field
    
    Returns:
    Expression accessing given field
  - makeCall
```
public RexNode makeCall(RelDataType returnType,
               SqlOperator op,
               List<RexNode> exprs)
```
    Creates a call with a list of arguments and a predetermined type.
  - makeCall
```
public RexNode makeCall(SqlOperator op,
               List<? extends RexNode> exprs)
```
    Creates a call with an array of arguments.
    If you already know the return type of the call, then makeCall(org.apache.calcite.rel.type.RelDataType, org.apache.calcite.sql.SqlOperator, java.util.List) is preferred.
  - makeCall
```
public final RexNode makeCall(SqlOperator op,
               RexNode... exprs)
```
    Creates a call with a list of arguments.
    Equivalent to makeCall(op, exprList.toArray(new RexNode[exprList.size()])).
  - deriveReturnType
```
public RelDataType deriveReturnType(SqlOperator op,
                           List<? extends RexNode> exprs)
```
    Derives the return type of a call to an operator.
    
    Parameters:
    op - the operator being called
    exprs - actual operands
    
    Returns:
    derived type
  - addAggCall
```
public RexNode addAggCall(AggregateCall aggCall,
                 int groupCount,
                 boolean indicator,
                 List<AggregateCall> aggCalls,
                 Map<AggregateCall,RexNode> aggCallMapping,
                 List<RelDataType> aggArgTypes)
```
    Creates a reference to an aggregate call, checking for repeated calls.
    Argument types help to optimize for repeated aggregates. For instance count(42) is equivalent to count(*).
    
    Parameters:
    aggCall - aggregate call to be added
    groupCount - number of groups in the aggregate relation
    indicator - Whether the Aggregate has indicator (GROUPING) columns
    aggCalls - destination list of aggregate calls
    aggCallMapping - the dictionary of already added calls
    aggArgTypes - Argument types, not null
    
    Returns:
    Rex expression for the given aggregate call
  - makeOver
```
public RexNode makeOver(RelDataType type,
               SqlAggFunction operator,
               List<RexNode> exprs,
               List<RexNode> partitionKeys,
               com.google.common.collect.ImmutableList<RexFieldCollation> orderKeys,
               RexWindowBound lowerBound,
               RexWindowBound upperBound,
               boolean physical,
               boolean allowPartial,
               boolean nullWhenCountZero)
```
    Creates a call to a windowed agg.
  - makeWindow
```
public RexWindow makeWindow(List<RexNode> partitionKeys,
                   com.google.common.collect.ImmutableList<RexFieldCollation> orderKeys,
                   RexWindowBound lowerBound,
                   RexWindowBound upperBound,
                   boolean isRows)
```
    Creates a window specification.
    
    Parameters:
    partitionKeys - Partition keys
    orderKeys - Order keys
    lowerBound - Lower bound
    upperBound - Upper bound
    isRows - Whether physical. True if row-based, false if range-based
    
    Returns:
    window specification
  - constantNull
```
public RexLiteral constantNull()
```
    Creates a constant for the SQL NULL value.
  - makeCorrel
```
public RexNode makeCorrel(RelDataType type,
                 String name)
```
    Creates an expression referencing a correlation variable.
    
    Parameters:
    type - Type of variable
    name - Name of variable
    
    Returns:
    Correlation variable
  - makeNewInvocation
```
public RexNode makeNewInvocation(RelDataType type,
                        List<RexNode> exprs)
```
    Creates an invocation of the NEW operator.
    
    Parameters:
    type - Type to be instantiated
    exprs - Arguments to NEW operator
    
    Returns:
    Expression invoking NEW operator
  - makeCast
```
public RexNode makeCast(RelDataType type,
               RexNode exp)
```
    Creates a call to the CAST operator, expanding if possible.
    
    Parameters:
    type - Type to cast to
    exp - Expression being cast
    
    Returns:
    Call to CAST operator
  - encodeIntervalOrDecimal
```
public RexNode encodeIntervalOrDecimal(RexNode value,
                              RelDataType type,
                              boolean checkOverflow)
```
    Casts a decimal's integer representation to a decimal node. If the expression is not the expected integer type, then it is casted first.
    An overflow check may be requested to ensure the internal value does not exceed the maximum value of the decimal type.
    
    Parameters:
    value - integer representation of decimal
    type - type integer will be reinterpreted as
    checkOverflow - indicates whether an overflow check is required when reinterpreting this particular value as the decimal type. A check usually not required for arithmetic, but is often required for rounding and explicit casts.
    
    Returns:
    the integer reinterpreted as an opaque decimal type
  - decodeIntervalOrDecimal
```
public RexNode decodeIntervalOrDecimal(RexNode node)
```
    Retrieves an interval or decimal node's integer representation
    
    Parameters:
    node - the interval or decimal value as an opaque type
    
    Returns:
    an integer representation of the decimal value
  - makeAbstractCast
```
public RexNode makeAbstractCast(RelDataType type,
                       RexNode exp)
```
    Creates a call to the CAST operator.
    
    Parameters:
    type - Type to cast to
    exp - Expression being cast
    
    Returns:
    Call to CAST operator
  - makeReinterpretCast
```
public RexNode makeReinterpretCast(RelDataType type,
                          RexNode exp,
                          RexNode checkOverflow)
```
    Makes a reinterpret cast.
    
    Parameters:
    type - type returned by the cast
    exp - expression to be casted
    checkOverflow - whether an overflow check is required
    
    Returns:
    a RexCall with two operands and a special return type
  - makeNotNullCast
```
public RexNode makeNotNullCast(RexNode expr)
```
    Makes an expression which converts a value of type T to a value of type T NOT NULL, or throws if the value is NULL. If the expression is already NOT NULL, does nothing.
  - makeRangeReference
```
public RexNode makeRangeReference(RelNode input)
```
    Creates a reference to all the fields in the row. That is, the whole row as a single record object.
    
    Parameters:
    input - Input relational expression
  - makeRangeReference
```
public RexRangeRef makeRangeReference(RelDataType type,
                             int offset,
                             boolean nullable)
```
    Creates a reference to all the fields in the row.
    For example, if the input row has type T{f0,f1,f2,f3,f4} then makeRangeReference(T{f0,f1,f2,f3,f4}, S{f3,f4}, 3) is an expression which yields the last 2 fields.
    
    Parameters:
    type - Type of the resulting range record.
    offset - Index of first field.
    nullable - Whether the record is nullable.
  - makeInputRef
```
public RexInputRef makeInputRef(RelDataType type,
                       int i)
```
    Creates a reference to a given field of the input record.
    
    Parameters:
    type - Type of field
    i - Ordinal of field
    
    Returns:
    Reference to field
  - makeInputRef
```
public RexInputRef makeInputRef(RelNode input,
                       int i)
```
    Creates a reference to a given field of the input relational expression.
    
    Parameters:
    input - Input relational expression
    i - Ordinal of field
    
    Returns:
    Reference to field
  - makeFlag
```
public RexLiteral makeFlag(Enum flag)
```
    Creates a literal representing a flag.
    
    Parameters:
    flag - Flag value
  - makeLiteral
```
protected RexLiteral makeLiteral(Comparable o,
                     RelDataType type,
                     SqlTypeName typeName)
```
    Internal method to create a call to a literal. Code outside this package should call one of the type-specific methods such as makeDateLiteral(Calendar), makeLiteral(boolean), makeLiteral(String).
    
    Parameters:
    o - Value of literal, must be appropriate for the type
    type - Type of literal
    typeName - SQL type of literal
    
    Returns:
    Literal
  - makeLiteral
```
public RexLiteral makeLiteral(boolean b)
```
    Creates a boolean literal.
  - makeExactLiteral
```
public RexLiteral makeExactLiteral(BigDecimal bd)
```
    Creates a numeric literal.
  - makeBigintLiteral
```
public RexLiteral makeBigintLiteral(BigDecimal bd)
```
    Creates a BIGINT literal.
  - makeExactLiteral
```
public RexLiteral makeExactLiteral(BigDecimal bd,
                          RelDataType type)
```
    Creates a numeric literal.
  - makeBinaryLiteral
```
public RexLiteral makeBinaryLiteral(ByteString byteString)
```
    Creates a byte array literal.
  - makeApproxLiteral
```
public RexLiteral makeApproxLiteral(BigDecimal bd)
```
    Creates a double-precision literal.
  - makeApproxLiteral
```
public RexLiteral makeApproxLiteral(BigDecimal bd,
                           RelDataType type)
```
    Creates an approximate numeric literal (double or float).
    
    Parameters:
    bd - literal value
    type - approximate numeric type
    
    Returns:
    new literal
  - makeLiteral
```
public RexLiteral makeLiteral(String s)
```
    Creates a character string literal.
  - makePreciseStringLiteral
```
protected RexLiteral makePreciseStringLiteral(String s)
```
    Creates a character string literal with type CHAR and default charset and collation.
    
    Parameters:
    s - String value
    
    Returns:
    Character string literal
  - ensureType
```
public RexNode ensureType(RelDataType type,
                 RexNode node,
                 boolean matchNullability)
```
    Ensures expression is interpreted as a specified type. The returned expression may be wrapped with a cast.
    
    Parameters:
    type - desired type
    node - expression
    matchNullability - whether to correct nullability of specified type to match the expression; this usually should be true, except for explicit casts which can override default nullability
    
    Returns:
    a casted expression or the original expression
  - matchNullability
```
public RelDataType matchNullability(RelDataType type,
                           RexNode value)
```
    Ensures that a type's nullability matches a value's nullability.
  - makeCharLiteral
```
public RexLiteral makeCharLiteral(NlsString str)
```
    Creates a character string literal from an NlsString.
    If the string's charset and collation are not set, uses the system defaults.
  - makeDateLiteral
```
public RexLiteral makeDateLiteral(Calendar date)
```
    Creates a Date literal.
  - makeTimeLiteral
```
public RexLiteral makeTimeLiteral(Calendar time,
                         int precision)
```
    Creates a Time literal.
  - makeTimestampLiteral
```
public RexLiteral makeTimestampLiteral(Calendar timestamp,
                              int precision)
```
    Creates a Timestamp literal.
  - makeIntervalLiteral
```
public RexLiteral makeIntervalLiteral(SqlIntervalQualifier intervalQualifier)
```
    Creates an interval literal.
  - makeIntervalLiteral
```
public RexLiteral makeIntervalLiteral(BigDecimal v,
                             SqlIntervalQualifier intervalQualifier)
```
    Creates an interval literal.
  - makeDynamicParam
```
public RexDynamicParam makeDynamicParam(RelDataType type,
                               int index)
```
    Creates a reference to a dynamic parameter
    
    Parameters:
    type - Type of dynamic parameter
    index - Index of dynamic parameter
    
    Returns:
    Expression referencing dynamic parameter
  - makeNullLiteral
```
public RexNode makeNullLiteral(SqlTypeName typeName,
                      int precision)
```
    Creates an expression corresponding to a null literal, cast to a specific type and precision
    
    Parameters:
    typeName - name of the type that the null will be cast to
    precision - precision of the type
    
    Returns:
    created expression
  - makeNullLiteral
```
public RexNode makeNullLiteral(SqlTypeName typeName)
```
    Creates a literal whose value is NULL, with a particular type.
    The typing is necessary because RexNodes are strictly typed. For example, in the Rex world the NULL parameter to SUBSTRING(NULL FROM 2 FOR 4) must have a valid VARCHAR type so that the result type can be determined.
    
    Parameters:
    typeName - Type to cast NULL to
    
    Returns:
    NULL literal of given type
  - copy
```
public RexNode copy(RexNode expr)
```
    Creates a copy of an expression, which may have been created using a different RexBuilder and/or RelDataTypeFactory, using this RexBuilder.
    
    Parameters:
    expr - Expression
    
    Returns:
    Copy of expression
    See Also:
    RelDataTypeFactory.copyType(RelDataType)
  - makeZeroLiteral
```
public RexNode makeZeroLiteral(RelDataType type)
```
    Creates a literal of the default value for the given type.
    This value is:
    - 0 for numeric types;
    - FALSE for BOOLEAN;
    - The epoch for TIMESTAMP and DATE;
    - Midnight for TIME;
    - The empty string for string types (CHAR, BINARY, VARCHAR, VARBINARY).
    Parameters:
    type - Type
    
    Returns:
    Simple literal, or cast simple literal
  - makeLiteral
```
public RexNode makeLiteral(Object value,
                  RelDataType type,
                  boolean allowCast)
```
    Creates a literal of a given type. The value is assumed to be compatible with the type.
    
    Parameters:
    value - Value
    type - Type
    allowCast - Whether to allow a cast. If false, value is always a RexLiteral but may not be the exact type
    
    Returns:
    Simple literal, or cast simple literal

Class RexBuilder

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

GET_OPERATOR

TO_INPUT_REF

typeFactory

Constructor Detail

RexBuilder

Method Detail

identityProjects

getTypeFactory

getOpTab

makeFieldAccess

makeFieldAccess

makeCall

makeCall

makeCall

deriveReturnType

addAggCall

makeOver

makeWindow

constantNull

makeCorrel

makeNewInvocation

makeCast

encodeIntervalOrDecimal

decodeIntervalOrDecimal

makeAbstractCast

makeReinterpretCast

makeNotNullCast

makeRangeReference

makeRangeReference

makeInputRef

makeInputRef

makeFlag

makeLiteral

makeLiteral

makeExactLiteral

makeBigintLiteral

makeExactLiteral

makeBinaryLiteral

makeApproxLiteral

makeApproxLiteral

makeLiteral

makePreciseStringLiteral

ensureType

matchNullability

makeCharLiteral

makeDateLiteral

makeTimeLiteral

makeTimestampLiteral

makeIntervalLiteral

makeIntervalLiteral

makeDynamicParam

makeNullLiteral

makeNullLiteral

copy

makeZeroLiteral

makeLiteral