RexLiteral (Calcite Core 1.2.0-incubating 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	Meaing	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`
`SqlTypeName.TIME`	Time, for example `TIME '18:37:42.567'`	`Calendar`
`SqlTypeName.TIMESTAMP`	Timestamp, for example `TIMESTAMP '1969-04-29 18:37:42.567'`	`Calendar`
`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`
`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`
`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 inherited from class org.apache.calcite.rex.RexNode
  digest

Method Summary

Methods
Modifier and Type	Method and Description
`<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)`
`static RexLiteral`	`fromJdbcString(RelDataType type, SqlTypeName typeName, String literal)` Converts a Jdbc string into a RexLiteral.
`SqlKind`	`getKind()` Returns the kind of node this is.
`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.
`int`	`hashCode()`
`static int`	`intValue(RexNode node)`
`boolean`	`isAlwaysFalse()` Returns whether this expression always returns false.
`boolean`	`isAlwaysTrue()` Returns whether this expression always returns true.
`static boolean`	`isNullLiteral(RexNode node)`
`void`	`printAsJava(PrintWriter pw)` Prints the value this literal as a Java string constant.
`static String`	`stringValue(RexNode node)`
`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 boolean`	`valueMatchesType(Comparable value, SqlTypeName typeName, boolean strict)`

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

- 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)
  - 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).
  - printAsJava
```
public void printAsJava(PrintWriter pw)
```
    Prints the value this literal as a Java string constant.
  - 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
  - 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
  - getValue
```
public Comparable getValue()
```
    Returns the value of this literal.
  - 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.
  - 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
  - intValue
```
public static int intValue(RexNode node)
```
  - stringValue
```
public static String stringValue(RexNode node)
```
  - isNullLiteral
```
public static boolean isNullLiteral(RexNode node)
```
  - 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

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

valueMatchesType

validConstant

printAsJava

fromJdbcString

getTypeName

getType

getKind

getValue

getValue2

getValue3

booleanValue

isAlwaysTrue

isAlwaysFalse

equals

hashCode

intValue

stringValue

isNullLiteral

accept