RexLiteral (Flink : 1.12-SNAPSHOT API)

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

public class RexLiteral
extends org.apache.calcite.rex.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, org.apache.calcite.rel.type.RelDataType, org.apache.calcite.rex.RexDigestIncludeType).

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

Line 374 ~ 376: fix FLINK-20942, the file should be removed when upgrade to CALCITE 1.27.0 release.

Field Summary
- Fields inherited from class org.apache.calcite.rex.RexNode
  digest

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<R,P> R`	`accept(org.apache.calcite.rex.RexBiVisitor<R,P> visitor, P arg)`
`<R> R`	`accept(org.apache.calcite.rex.RexVisitor<R> visitor)`
`static boolean`	`booleanValue(org.apache.calcite.rex.RexNode node)`
`String`	`computeDigest(org.apache.calcite.rex.RexDigestIncludeType includeType)` Returns a string which concisely describes the definition of this rex literal.
`boolean`	`equals(Object obj)`
`static RexLiteral`	`fromJdbcString(org.apache.calcite.rel.type.RelDataType type, org.apache.calcite.sql.type.SqlTypeName typeName, String literal)` Converts a Jdbc string into a RexLiteral.
`org.apache.calcite.sql.SqlKind`	`getKind()`
`org.apache.calcite.rel.type.RelDataType`	`getType()`
`org.apache.calcite.sql.type.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.
`Comparable`	`getValue4()` Returns the value of this literal, in the form that `RexInterpreter` wants it.
`<T> T`	`getValueAs(Class<T> clazz)` Returns the value of this literal as an instance of the specified class.
`int`	`hashCode()`
`static int`	`intValue(org.apache.calcite.rex.RexNode node)`
`boolean`	`isAlwaysFalse()`
`boolean`	`isAlwaysTrue()`
`boolean`	`isNull()` Returns whether this literal's value is null.
`static boolean`	`isNullLiteral(org.apache.calcite.rex.RexNode node)`
`void`	`printAsJava(PrintWriter pw)` Prints the value this literal as a Java string constant.
`static org.apache.calcite.sql.type.SqlTypeName`	`strictTypeName(org.apache.calcite.rel.type.RelDataType type)` Returns the strict literal type for a given type.
`static String`	`stringValue(org.apache.calcite.rex.RexNode node)`
`static boolean`	`validConstant(Object o, org.apache.calcite.util.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(org.apache.calcite.rex.RexNode node)`
`static boolean`	`valueMatchesType(Comparable value, org.apache.calcite.sql.type.SqlTypeName typeName, boolean strict)` Returns whether a value is appropriate for its type.

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

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

- Method Detail
  - computeDigest
```
public final String computeDigest(org.apache.calcite.rex.RexDigestIncludeType includeType)
```
    Returns a string which concisely describes the definition of this rex literal. Two literals are equivalent if and only if their digests are the same.
    The digest does not contain the expression's identity, but does include the identity of children.
    Technically speaking 1:INT differs from 1:FLOAT, so we need data type in the literal's digest, however we want to avoid extra verbosity of the RelNode.getDigest() for readability purposes, so we omit type info in certain cases. For instance, 1:INT becomes 1 (INT is implied by default), however 1:BIGINT always holds the type
    Here's a non-exhaustive list of the "well known cases":
    - Hide "NOT NULL" for not null literals
    - Hide INTEGER, BOOLEAN, SYMBOL, TIME(0), TIMESTAMP(0), DATE(0) types
    - Hide collation when it matches IMPLICIT/COERCIBLE
    - Hide charset when it matches default
    - Hide CHAR(xx) when literal length is equal to the precision of the type. In other words, use 'Bob' instead of 'Bob':CHAR(3)
    - Hide BOOL for AND/OR arguments. In other words, AND(true, null) means null is BOOL.
    - Hide types for literals in simple binary operations (e.g. +, -, *, /, comparison) when type of the other argument is clear. See RexCall.computeDigest(boolean) For instance: =(true. null) means null is BOOL. =($0, null) means the type of null matches the type of $0.
    Parameters:
    
    includeType - whether the digest should include type or not
    
    Returns:
    
    digest
  - valueMatchesType
```
public static boolean valueMatchesType(Comparable value,
                                       org.apache.calcite.sql.type.SqlTypeName typeName,
                                       boolean strict)
```
    Returns whether a value is appropriate for its type. (We have rules about these things!)
  - strictTypeName
```
public static org.apache.calcite.sql.type.SqlTypeName strictTypeName(org.apache.calcite.rel.type.RelDataType type)
```
    Returns the strict literal type for a given type.
  - validConstant
```
public static boolean validConstant(Object o,
                                    org.apache.calcite.util.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).
  - printAsJava
```
public void printAsJava(PrintWriter pw)
```
    Prints the value this literal as a Java string constant.
  - fromJdbcString
```
public static RexLiteral fromJdbcString(org.apache.calcite.rel.type.RelDataType type,
                                        org.apache.calcite.sql.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
  - getTypeName
```
public org.apache.calcite.sql.type.SqlTypeName getTypeName()
```
  - getType
```
public org.apache.calcite.rel.type.RelDataType getType()
```
    Specified by:
    
    getType in class org.apache.calcite.rex.RexNode
  - getKind
```
public org.apache.calcite.sql.SqlKind getKind()
```
    Overrides:
    
    getKind in class org.apache.calcite.rex.RexNode
  - 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.
  - getValue4
```
public Comparable getValue4()
```
    Returns the value of this literal, in the form that RexInterpreter 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(org.apache.calcite.rex.RexNode node)
```
  - isAlwaysTrue
```
public boolean isAlwaysTrue()
```
    Overrides:
    
    isAlwaysTrue in class org.apache.calcite.rex.RexNode
  - isAlwaysFalse
```
public boolean isAlwaysFalse()
```
    Overrides:
    
    isAlwaysFalse in class org.apache.calcite.rex.RexNode
  - equals
```
public boolean equals(Object obj)
```
    Specified by:
    
    equals in class org.apache.calcite.rex.RexNode
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in class org.apache.calcite.rex.RexNode
  - value
```
public static Comparable value(org.apache.calcite.rex.RexNode node)
```
  - intValue
```
public static int intValue(org.apache.calcite.rex.RexNode node)
```
  - stringValue
```
public static String stringValue(org.apache.calcite.rex.RexNode node)
```
  - isNullLiteral
```
public static boolean isNullLiteral(org.apache.calcite.rex.RexNode node)
```
  - accept
```
public <R> R accept(org.apache.calcite.rex.RexVisitor<R> visitor)
```
    Specified by:
    
    accept in class org.apache.calcite.rex.RexNode
  - accept
```
public <R,P> R accept(org.apache.calcite.rex.RexBiVisitor<R,P> visitor,
                      P arg)
```
    Specified by:
    
    accept in class org.apache.calcite.rex.RexNode

Back to Flink Website

Class RexLiteral

Field Summary

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

Method Summary

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

Methods inherited from class java.lang.Object

Method Detail

computeDigest

valueMatchesType

strictTypeName

validConstant

printAsJava

fromJdbcString

getTypeName

getType

getKind

isNull

getValue

getValue2

getValue3

getValue4

getValueAs

booleanValue

isAlwaysTrue

isAlwaysFalse

equals

hashCode

value

intValue

stringValue

isNullLiteral

accept

accept