RexLiteral (Calcite Core 1.16.0 API)

java.lang.Object
- org.apache.calcite.rex.RexNode
- - org.apache.calcite.rex.RexLiteral

public class RexLiteral
extends RexNode

Constant value in a row-expression.

There are several methods for creating literals in RexBuilder: RexBuilder.makeLiteral(boolean) and so forth.

How is the value stored? In that respect, the class is somewhat of a black box. There is a getValue() method which returns the value as an object, but the type of that value is implementation detail, and it is best that your code does not depend upon that knowledge. It is better to use task-oriented methods such as getValue2() and toJavaString(java.lang.Comparable, org.apache.calcite.sql.type.SqlTypeName).

The allowable types and combinations are:

Allowable types for RexLiteral instances
TypeName	Meaning	Value type
`SqlTypeName.NULL`	The null value. It has its own special type.	null
`SqlTypeName.BOOLEAN`	Boolean, namely `TRUE`, `FALSE` or `UNKNOWN`.	`Boolean`, or null represents the UNKNOWN value
`SqlTypeName.DECIMAL`	Exact number, for example `0`, `-.5`, `12345`.	`BigDecimal`
`SqlTypeName.DOUBLE`	Approximate number, for example `6.023E-23`.	`BigDecimal`
`SqlTypeName.DATE`	Date, for example `DATE '1969-04'29'`	`Calendar`; also `Calendar` (UTC time zone) and `Integer` (days since POSIX epoch)
`SqlTypeName.TIME`	Time, for example `TIME '18:37:42.567'`	`Calendar`; also `Calendar` (UTC time zone) and `Integer` (milliseconds since midnight)
`SqlTypeName.TIMESTAMP`	Timestamp, for example `TIMESTAMP '1969-04-29 18:37:42.567'`	`TimestampString`; also `Calendar` (UTC time zone) and `Long` (milliseconds since POSIX epoch)
`SqlTypeName.INTERVAL_DAY`, `SqlTypeName.INTERVAL_DAY_HOUR`, `SqlTypeName.INTERVAL_DAY_MINUTE`, `SqlTypeName.INTERVAL_DAY_SECOND`, `SqlTypeName.INTERVAL_HOUR`, `SqlTypeName.INTERVAL_HOUR_MINUTE`, `SqlTypeName.INTERVAL_HOUR_SECOND`, `SqlTypeName.INTERVAL_MINUTE`, `SqlTypeName.INTERVAL_MINUTE_SECOND`, `SqlTypeName.INTERVAL_SECOND`	Interval, for example `INTERVAL '4:3:2' HOUR TO SECOND`	`BigDecimal`; also `Long` (milliseconds)
`SqlTypeName.INTERVAL_YEAR`, `SqlTypeName.INTERVAL_YEAR_MONTH`, `SqlTypeName.INTERVAL_MONTH`	Interval, for example `INTERVAL '2-3' YEAR TO MONTH`	`BigDecimal`; also `Integer` (months)
`SqlTypeName.CHAR`	Character constant, for example `'Hello, world!'`, `''`, `_N'Bonjour'`, `_ISO-8859-1'It''s superman!' COLLATE SHIFT_JIS$ja_JP$2`. These are always CHAR, never VARCHAR.	`NlsString`; also `String`
`SqlTypeName.BINARY`	Binary constant, for example `X'7F34'`. (The number of hexits must be even; see above.) These constants are always BINARY, never VARBINARY.	`ByteBuffer`; also `byte[]`
`SqlTypeName.SYMBOL`	A symbol is a special type used to make parsing easier; it is not part of the SQL standard, and is not exposed to end-users. It is used to hold a flag, such as the LEADING flag in a call to the function `TRIM([LEADING\|TRAILING\|BOTH] chars FROM string)`.	An enum class

Field Summary

Fields
Modifier and Type	Field and Description
`private static com.google.common.collect.ImmutableList<org.apache.calcite.avatica.util.TimeUnit>`	`TIME_UNITS`
`private RelDataType`	`type` The real type of this literal, as reported by `getType()`.
`private SqlTypeName`	`typeName` An indication of the broad type of this literal -- even if its type isn't a SQL type.
`private Comparable`	`value` The value of this literal.

Fields inherited from class org.apache.calcite.rex.RexNode
digest

Constructor Summary

Constructors
Constructor and Description

RexLiteral(Comparable value, RelDataType type, SqlTypeName typeName)
Creates a RexLiteral.

Constructors
Constructor and Description
`RexLiteral(Comparable value, RelDataType type, SqlTypeName typeName)` Creates a `RexLiteral`.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<R,P> R`	`accept(RexBiVisitor<R,P> visitor, P arg)` Accepts a visitor with a payload, dispatching to the right overloaded `RexBiVisitor.visitInputRef(RexInputRef, Object)` visitXxx} method.
`<R> R`	`accept(RexVisitor<R> visitor)` Accepts a visitor, dispatching to the right overloaded `visitXxx` method.
`static boolean`	`booleanValue(RexNode node)`
`boolean`	`equals(Object obj)`
`private static boolean`	`equals(Object o1, Object o2)`
`private static Comparable`	`findValue(RexNode node)`
`static RexLiteral`	`fromJdbcString(RelDataType type, SqlTypeName typeName, String literal)` Converts a Jdbc string into a RexLiteral.
`private static String`	`getCalendarFormat(SqlTypeName typeName)`
`SqlKind`	`getKind()` Returns the kind of node this is.
`private static List<org.apache.calcite.avatica.util.TimeUnit>`	`getTimeUnits(SqlTypeName typeName)` Returns a list of the time units covered by an interval type such as HOUR TO SECOND.
`RelDataType`	`getType()`
`SqlTypeName`	`getTypeName()`
`Comparable`	`getValue()` Returns the value of this literal.
`Object`	`getValue2()` Returns the value of this literal, in the form that the calculator program builder wants it.
`Object`	`getValue3()` Returns the value of this literal, in the form that the rex-to-lix translator wants it.
`<T> T`	`getValueAs(Class<T> clazz)` Returns the value of this literal as an instance of the specified class.
`int`	`hashCode()`
`private String`	`intervalString(BigDecimal v)`
`static int`	`intValue(RexNode node)`
`boolean`	`isAlwaysFalse()` Returns whether this expression always returns false.
`boolean`	`isAlwaysTrue()` Returns whether this expression always returns true.
`boolean`	`isNull()` Returns whether this literal's value is null.
`static boolean`	`isNullLiteral(RexNode node)`
`private static void`	`pad(StringBuilder b, String s, int width)`
`private static void`	`printAsJava(Comparable value, PrintWriter pw, SqlTypeName typeName, boolean java)` Prints a value as a Java string.
`void`	`printAsJava(PrintWriter pw)` Prints the value this literal as a Java string constant.
`static String`	`stringValue(RexNode node)`
`private static String`	`toJavaString(Comparable value, SqlTypeName typeName)`
`static boolean`	`validConstant(Object o, Litmus litmus)` Returns whether a value is valid as a constant value, using the same criteria as `valueMatchesType(java.lang.Comparable, org.apache.calcite.sql.type.SqlTypeName, boolean)`.
`static Comparable`	`value(RexNode node)`
`static boolean`	`valueMatchesType(Comparable value, SqlTypeName typeName, boolean strict)`
`private static int`	`width(org.apache.calcite.avatica.util.TimeUnit timeUnit)`

Methods inherited from class org.apache.calcite.rex.RexNode
isA, isA, toString

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

- Field Detail
  - value
```
private final Comparable value
```
    The value of this literal. Must be consistent with its type, as per valueMatchesType(java.lang.Comparable, org.apache.calcite.sql.type.SqlTypeName, boolean). For example, you can't store an Integer value here just because you feel like it -- all numbers are represented by a BigDecimal. But since this field is private, it doesn't really matter how the values are stored.
  - type
```
private final RelDataType type
```
    The real type of this literal, as reported by getType().
  - typeName
```
private final SqlTypeName typeName
```
    An indication of the broad type of this literal -- even if its type isn't a SQL type. Sometimes this will be different than the SQL type; for example, all exact numbers, including integers have typeName SqlTypeName.DECIMAL. See valueMatchesType(java.lang.Comparable, org.apache.calcite.sql.type.SqlTypeName, boolean) for the definitive story.
  - TIME_UNITS
```
private static final com.google.common.collect.ImmutableList<org.apache.calcite.avatica.util.TimeUnit> TIME_UNITS
```
- Constructor Detail
  - RexLiteral
```
RexLiteral(Comparable value,
           RelDataType type,
           SqlTypeName typeName)
```
    Creates a RexLiteral.
- Method Detail
  - valueMatchesType
```
public static boolean valueMatchesType(Comparable value,
                                       SqlTypeName typeName,
                                       boolean strict)
```
    Returns:
    
    whether value is appropriate for its type (we have rules about these things)
  - toJavaString
```
private static String toJavaString(Comparable value,
                                   SqlTypeName typeName)
```
  - validConstant
```
public static boolean validConstant(Object o,
                                    Litmus litmus)
```
    Returns whether a value is valid as a constant value, using the same criteria as valueMatchesType(java.lang.Comparable, org.apache.calcite.sql.type.SqlTypeName, boolean).
  - getTimeUnits
```
private static List<org.apache.calcite.avatica.util.TimeUnit> getTimeUnits(SqlTypeName typeName)
```
    Returns a list of the time units covered by an interval type such as HOUR TO SECOND. Adds MILLISECOND if the end is SECOND, to deal with fractional seconds.
  - intervalString
```
private String intervalString(BigDecimal v)
```
  - pad
```
private static void pad(StringBuilder b,
                        String s,
                        int width)
```
  - width
```
private static int width(org.apache.calcite.avatica.util.TimeUnit timeUnit)
```
  - printAsJava
```
public void printAsJava(PrintWriter pw)
```
    Prints the value this literal as a Java string constant.
  - printAsJava
```
private static void printAsJava(Comparable value,
                                PrintWriter pw,
                                SqlTypeName typeName,
                                boolean java)
```
    Prints a value as a Java string. The value must be consistent with the type, as per valueMatchesType(java.lang.Comparable, org.apache.calcite.sql.type.SqlTypeName, boolean).
    Typical return values:
    - true
    - null
    - "Hello, world!"
    - 1.25
    - 1234ABCD
    Parameters:
    
    value - Value
    
    pw - Writer to write to
    
    typeName - Type family
  - fromJdbcString
```
public static RexLiteral fromJdbcString(RelDataType type,
                                        SqlTypeName typeName,
                                        String literal)
```
    Converts a Jdbc string into a RexLiteral. This method accepts a string, as returned by the Jdbc method ResultSet.getString(), and restores the string into an equivalent RexLiteral. It allows one to use Jdbc strings as a common format for data.
    If a null literal is provided, then a null pointer will be returned.
    
    Parameters:
    
    type - data type of literal to be read
    
    typeName - type family of literal
    
    literal - the (non-SQL encoded) string representation, as returned by the Jdbc call to return a column as a string
    
    Returns:
    
    a typed RexLiteral, or null
  - getCalendarFormat
```
private static String getCalendarFormat(SqlTypeName typeName)
```
  - getTypeName
```
public SqlTypeName getTypeName()
```
  - getType
```
public RelDataType getType()
```
    Specified by:
    
    getType in class RexNode
  - getKind
```
public SqlKind getKind()
```
    Description copied from class: RexNode
    
    Returns the kind of node this is.
    
    Overrides:
    
    getKind in class RexNode
    
    Returns:
    
    Node kind, never null
  - isNull
```
public boolean isNull()
```
    Returns whether this literal's value is null.
  - getValue
```
public Comparable getValue()
```
    Returns the value of this literal.
    For backwards compatibility, returns DATE. TIME and TIMESTAMP as a Calendar value in UTC time zone.
  - getValue2
```
public Object getValue2()
```
    Returns the value of this literal, in the form that the calculator program builder wants it.
  - getValue3
```
public Object getValue3()
```
    Returns the value of this literal, in the form that the rex-to-lix translator wants it.
  - getValueAs
```
public <T> T getValueAs(Class<T> clazz)
```
    Returns the value of this literal as an instance of the specified class.
    The following SQL types allow more than one form:
    - CHAR as NlsString or String
    - TIME as TimeString, Integer (milliseconds since midnight), Calendar (in UTC)
    - DATE as DateString, Integer (days since 1970-01-01), Calendar
    - TIMESTAMP as TimestampString, Long (milliseconds since 1970-01-01 00:00:00), Calendar
    - DECIMAL as BigDecimal or Long
    Called with clazz = Comparable, returns the value in its native form.
    Type Parameters:
    
    T - Return type
    
    Parameters:
    
    clazz - Desired return type
    
    Returns:
    
    Value of this literal in the desired type
  - booleanValue
```
public static boolean booleanValue(RexNode node)
```
  - isAlwaysTrue
```
public boolean isAlwaysTrue()
```
    Description copied from class: RexNode
    
    Returns whether this expression always returns true. (Such as if this expression is equal to the literal TRUE.)
    
    Overrides:
    
    isAlwaysTrue in class RexNode
  - isAlwaysFalse
```
public boolean isAlwaysFalse()
```
    Description copied from class: RexNode
    
    Returns whether this expression always returns false. (Such as if this expression is equal to the literal FALSE.)
    
    Overrides:
    
    isAlwaysFalse in class RexNode
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - value
```
public static Comparable value(RexNode node)
```
  - intValue
```
public static int intValue(RexNode node)
```
  - stringValue
```
public static String stringValue(RexNode node)
```
  - findValue
```
private static Comparable findValue(RexNode node)
```
  - isNullLiteral
```
public static boolean isNullLiteral(RexNode node)
```
  - equals
```
private static boolean equals(Object o1,
                              Object o2)
```
  - accept
```
public <R> R accept(RexVisitor<R> visitor)
```
    Description copied from class: RexNode
    
    Accepts a visitor, dispatching to the right overloaded visitXxx method.
    Also see RexUtil.apply(RexVisitor, java.util.List, RexNode), which applies a visitor to several expressions simultaneously.
    
    Specified by:
    
    accept in class RexNode
  - accept
```
public <R,P> R accept(RexBiVisitor<R,P> visitor,
                      P arg)
```
    Description copied from class: RexNode
    
    Accepts a visitor with a payload, dispatching to the right overloaded RexBiVisitor.visitInputRef(RexInputRef, Object) visitXxx} method.
    
    Specified by:
    
    accept in class RexNode

Class RexLiteral

Field Summary

Fields inherited from class org.apache.calcite.rex.RexNode

Constructor Summary

Method Summary

Methods inherited from class org.apache.calcite.rex.RexNode

Methods inherited from class java.lang.Object

Field Detail

value

type

typeName

TIME_UNITS

Constructor Detail

RexLiteral

Method Detail

valueMatchesType

toJavaString

validConstant

getTimeUnits

intervalString

pad

width

printAsJava

printAsJava

fromJdbcString

getCalendarFormat

getTypeName

getType

getKind

isNull

getValue

getValue2

getValue3

getValueAs

booleanValue

isAlwaysTrue

isAlwaysFalse

equals

hashCode

value

intValue

stringValue

findValue

isNullLiteral

equals

accept

accept