java.lang.Object
- java.lang.Enum<ExpressionType>
- - org.apache.calcite.linq4j.tree.ExpressionType

All Implemented Interfaces:

java.io.Serializable, java.lang.Comparable<ExpressionType>
```
public enum ExpressionType
extends java.lang.Enum<ExpressionType>
```
Analogous to LINQ's System.Linq.Expressions.ExpressionType.

Enum Constant Summary

Enum Constants
Enum Constant	Description
`Add`	An addition operation, such as a + b, without overflow checking, for numeric operands.
`AddAssign`	An addition compound assignment operation, such as (a += b), without overflow checking, for numeric operands.
`AddAssignChecked`	An addition compound assignment operation, such as (a += b), with overflow checking, for numeric operands.
`AddChecked`	An addition operation, such as (a + b), with overflow checking, for numeric operands.
`And`	A bitwise or logical AND operation, such as `a & b` in Java.
`AndAlso`	A conditional AND operation that evaluates the second operand only if the first operand evaluates to true.
`AndAssign`	A bitwise or logical AND compound assignment operation, such as (a &= b) in C#.
`ArrayIndex`	An indexing operation in a one-dimensional array, such as `array[index]` in Java.
`ArrayLength`	An operation that obtains the length of a one-dimensional array, such as array.Length.
`Assign`	An assignment operation, such as (a = b).
`Block`	A block of expressions.
`Call`	A method call, such as in the `obj.sampleMethod()` expression.
`Coalesce`	A node that represents a null coalescing operation, such as (a ?? b) in C# or If(a, b) in Visual Basic.
`Conditional`	A conditional operation, such as `a > b ? a : b` in Java.
`Constant`	A constant value.
`Convert`	A cast or conversion operation, such as `(SampleType) obj` in Java.
`ConvertChecked`	A cast or conversion operation, such as `(SampleType) obj` in Java.
`DebugInfo`	Debugging information.
`Declaration`	Declaration of a variable.
`Decrement`	A unary decrement operation, such as (a - 1) in C# and Visual Basic.
`Default`	A default value.
`Divide`	A division operation, such as (a / b), for numeric operands.
`DivideAssign`	An division compound assignment operation, such as (a /= b), for numeric operands.
`Dynamic`	A dynamic operation.
`Equal`	A node that represents an equality comparison, such as `a == b` in Java.
`ExclusiveOr`	A bitwise or logical XOR operation, such as `a ^ b` in Java.
`ExclusiveOrAssign`	A bitwise or logical XOR compound assignment operation, such as (a ^= b) in C#.
`Extension`	An extension expression.
`For`
`Goto`	A "go to" expression, such as goto Label in C# or GoTo Label in Visual Basic.
`GreaterThan`	A "greater than" comparison, such as (a > b).
`GreaterThanOrEqual`	A "greater than or equal to" comparison, such as (a >= b).
`Increment`	A unary increment operation, such as (a + 1) in C# and Visual Basic.
`Index`	An index operation or an operation that accesses a property that takes arguments.
`Invoke`	An operation that invokes a delegate or lambda expression, such as sampleDelegate.Invoke().
`IsFalse`	A false condition value.
`IsTrue`	A true condition value.
`Label`	A label.
`Lambda`	A lambda expression, such as `a -> a + a` in Java.
`LeftShift`	A bitwise left-shift operation, such as `a << b` in Java.
`LeftShiftAssign`	A bitwise left-shift compound assignment, such as (a <<= b).
`LessThan`	A "less than" comparison, such as (a < b).
`LessThanOrEqual`	A "less than or equal to" comparison, such as (a <= b).
`ListInit`	An operation that creates a new IEnumerable object and initializes it from a list of elements, such as new List<SampleType>(){ a, b, c } in C# or Dim sampleList = { a, b, c } in Visual Basic.
`Loop`	A loop, such as for or while.
`MemberAccess`	An operation that reads from a field or property, such as obj.SampleProperty.
`MemberInit`	An operation that creates a new object and initializes one or more of its members, such as new Point { X = 1, Y = 2 } in C# or New Point With {.X = 1, .Y = 2} in Visual Basic.
`Mod`	A percent remainder operation, such as (a % b), for numeric operands.
`Modulo`	An arithmetic remainder operation, such as (a % b) in C# or (a Mod b) in Visual Basic.
`ModuloAssign`	An arithmetic remainder compound assignment operation, such as (a %= b) in C#.
`Multiply`	A multiplication operation, such as (a * b), without overflow checking, for numeric operands.
`MultiplyAssign`	A multiplication compound assignment operation, such as (a *= b), without overflow checking, for numeric operands.
`MultiplyAssignChecked`	A multiplication compound assignment operation, such as (a *= b), that has overflow checking, for numeric operands.
`MultiplyChecked`	An multiplication operation, such as (a * b), that has overflow checking, for numeric operands.
`Negate`	An arithmetic negation operation, such as (-a).
`NegateChecked`	An arithmetic negation operation, such as (-a), that has overflow checking.
`New`	An operation that calls a constructor to create a new object, such as new SampleType().
`NewArrayBounds`	An operation that creates a new array, in which the bounds for each dimension are specified, such as new SampleType[dim1, dim2] in C# or New SampleType(dim1, dim2) in Visual Basic.
`NewArrayInit`	An operation that creates a new one-dimensional array and initializes it from a list of elements, such as new SampleType[]{a, b, c} in C# or New SampleType(){a, b, c} in Visual Basic.
`Not`	A bitwise complement or logical negation operation.
`NotEqual`	An inequality comparison, such as (a != b) in C# or (a <> b) in Visual Basic.
`OnesComplement`	A ones complement operation, such as (~a) in C#.
`Or`	A bitwise or logical OR operation, such as (a \| b) in C# or (a Or b) in Visual Basic.
`OrAssign`	A bitwise or logical OR compound assignment, such as (a \|= b) in C#.
`OrElse`	A short-circuiting conditional OR operation, such as (a \|\| b) in C# or (a OrElse b) in Visual Basic.
`Parameter`	A reference to a parameter or variable that is defined in the context of the expression.
`PostDecrementAssign`	A unary postfix decrement, such as (a--).
`PostIncrementAssign`	A unary postfix increment, such as (a++).
`Power`	A mathematical operation that raises a number to a power, such as (a ^ b) in Visual Basic.
`PowerAssign`	A compound assignment operation that raises a number to a power, such as (a ^= b) in Visual Basic.
`PreDecrementAssign`	A unary prefix decrement, such as (--a).
`PreIncrementAssign`	A unary prefix increment, such as (++a).
`Quote`	An expression that has a constant value of type Expression.
`RightShift`	A bitwise right-shift operation, such as (a >*gt; b).
`RightShiftAssign`	A bitwise right-shift compound assignment operation, such as (a >>= b).
`RuntimeVariables`	A list of run-time variables.
`Subtract`	A subtraction operation, such as (a - b), without overflow checking, for numeric operands.
`SubtractAssign`	A subtraction compound assignment operation, such as (a -= b), without overflow checking, for numeric operands.
`SubtractAssignChecked`	A subtraction compound assignment operation, such as (a -= b), that has overflow checking, for numeric operands.
`SubtractChecked`	An arithmetic subtraction operation, such as (a - b), that has overflow checking, for numeric operands.
`Switch`	A switch operation, such as switch in C# or Select Case in Visual Basic.
`Throw`	An operation that throws an exception, such as throw new Exception().
`Try`	A try-catch expression.
`TypeAs`	An explicit reference or boxing conversion in which null is supplied if the conversion fails, such as (obj as SampleType) in C# or TryCast(obj, SampleType) in Visual Basic.
`TypeEqual`	An exact type test.
`TypeIs`	A type test, such as obj is SampleType in C# or TypeOf obj is SampleType in Visual Basic.
`UnaryPlus`	A unary plus operation, such as (+a).
`Unbox`	An unbox value type operation, such as unbox and unbox.any instructions in MSIL.
`While`

Field Summary

Fields
Modifier and Type	Field	Description
`(package private) int`	`lprec`
`(package private) boolean`	`modifiesLvalue`
`(package private) java.lang.String`	`op`
`(package private) java.lang.String`	`op2`
`(package private) boolean`	`postfix`
`(package private) int`	`rprec`

Constructor Summary

Constructors
Modifier	Constructor	Description
`private`	`ExpressionType()`
`private`	`ExpressionType(java.lang.String op, boolean postfix, int prec, boolean right)`
`private`	`ExpressionType(java.lang.String op, java.lang.String op2, boolean postfix, int prec, boolean right)`
`private`	`ExpressionType(java.lang.String op, java.lang.String op2, boolean postfix, int prec, boolean right, boolean modifiesLvalue)`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static ExpressionType`	`valueOf(java.lang.String name)`	Returns the enum constant of this type with the specified name.
`static ExpressionType[]`	`values()`	Returns an array containing the constants of this enum type, in the order they are declared.

Methods inherited from class java.lang.Enum
clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf

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

- Enum Constant Detail
  - Add
```
public static final ExpressionType Add
```
    An addition operation, such as a + b, without overflow checking, for numeric operands.
  - AddChecked
```
public static final ExpressionType AddChecked
```
    An addition operation, such as (a + b), with overflow checking, for numeric operands.
  - And
```
public static final ExpressionType And
```
    A bitwise or logical AND operation, such as a & b in Java.
  - AndAlso
```
public static final ExpressionType AndAlso
```
    A conditional AND operation that evaluates the second operand only if the first operand evaluates to true. It corresponds to a && b in Java.
  - ArrayLength
```
public static final ExpressionType ArrayLength
```
    An operation that obtains the length of a one-dimensional array, such as array.Length.
  - ArrayIndex
```
public static final ExpressionType ArrayIndex
```
    An indexing operation in a one-dimensional array, such as array[index] in Java.
  - Call
```
public static final ExpressionType Call
```
    A method call, such as in the obj.sampleMethod() expression.
  - Coalesce
```
public static final ExpressionType Coalesce
```
    A node that represents a null coalescing operation, such as (a ?? b) in C# or If(a, b) in Visual Basic.
  - Conditional
```
public static final ExpressionType Conditional
```
    A conditional operation, such as a > b ? a : b in Java.
  - Constant
```
public static final ExpressionType Constant
```
    A constant value.
  - Convert
```
public static final ExpressionType Convert
```
    A cast or conversion operation, such as (SampleType) obj in Java. For a numeric conversion, if the converted value is too large for the destination type, no exception is thrown.
  - ConvertChecked
```
public static final ExpressionType ConvertChecked
```
    A cast or conversion operation, such as (SampleType) obj in Java. For a numeric conversion, if the converted value does not fit the destination type, an exception is thrown.
  - Divide
```
public static final ExpressionType Divide
```
    A division operation, such as (a / b), for numeric operands.
  - Mod
```
public static final ExpressionType Mod
```
    A percent remainder operation, such as (a % b), for numeric operands.
  - Equal
```
public static final ExpressionType Equal
```
    A node that represents an equality comparison, such as a == b in Java.
  - ExclusiveOr
```
public static final ExpressionType ExclusiveOr
```
    A bitwise or logical XOR operation, such as a ^ b in Java.
  - GreaterThan
```
public static final ExpressionType GreaterThan
```
    A "greater than" comparison, such as (a > b).
  - GreaterThanOrEqual
```
public static final ExpressionType GreaterThanOrEqual
```
    A "greater than or equal to" comparison, such as (a >= b).
  - Invoke
```
public static final ExpressionType Invoke
```
    An operation that invokes a delegate or lambda expression, such as sampleDelegate.Invoke().
  - Lambda
```
public static final ExpressionType Lambda
```
    A lambda expression, such as a -> a + a in Java.
  - LeftShift
```
public static final ExpressionType LeftShift
```
    A bitwise left-shift operation, such as a << b in Java.
  - LessThan
```
public static final ExpressionType LessThan
```
    A "less than" comparison, such as (a < b).
  - LessThanOrEqual
```
public static final ExpressionType LessThanOrEqual
```
    A "less than or equal to" comparison, such as (a <= b).
  - ListInit
```
public static final ExpressionType ListInit
```
    An operation that creates a new IEnumerable object and initializes it from a list of elements, such as new List<SampleType>(){ a, b, c } in C# or Dim sampleList = { a, b, c } in Visual Basic.
  - MemberAccess
```
public static final ExpressionType MemberAccess
```
    An operation that reads from a field or property, such as obj.SampleProperty.
  - MemberInit
```
public static final ExpressionType MemberInit
```
    An operation that creates a new object and initializes one or more of its members, such as new Point { X = 1, Y = 2 } in C# or New Point With {.X = 1, .Y = 2} in Visual Basic.
  - Modulo
```
public static final ExpressionType Modulo
```
    An arithmetic remainder operation, such as (a % b) in C# or (a Mod b) in Visual Basic.
  - Multiply
```
public static final ExpressionType Multiply
```
    A multiplication operation, such as (a * b), without overflow checking, for numeric operands.
  - MultiplyChecked
```
public static final ExpressionType MultiplyChecked
```
    An multiplication operation, such as (a * b), that has overflow checking, for numeric operands.
  - Negate
```
public static final ExpressionType Negate
```
    An arithmetic negation operation, such as (-a). The object a should not be modified in place.
  - UnaryPlus
```
public static final ExpressionType UnaryPlus
```
    A unary plus operation, such as (+a). The result of a predefined unary plus operation is the value of the operand, but user-defined implementations might have unusual results.
  - NegateChecked
```
public static final ExpressionType NegateChecked
```
    An arithmetic negation operation, such as (-a), that has overflow checking. The object a should not be modified in place.
  - New
```
public static final ExpressionType New
```
    An operation that calls a constructor to create a new object, such as new SampleType().
  - NewArrayInit
```
public static final ExpressionType NewArrayInit
```
    An operation that creates a new one-dimensional array and initializes it from a list of elements, such as new SampleType[]{a, b, c} in C# or New SampleType(){a, b, c} in Visual Basic.
  - NewArrayBounds
```
public static final ExpressionType NewArrayBounds
```
    An operation that creates a new array, in which the bounds for each dimension are specified, such as new SampleType[dim1, dim2] in C# or New SampleType(dim1, dim2) in Visual Basic.
  - Not
```
public static final ExpressionType Not
```
    A bitwise complement or logical negation operation. In C#, it is equivalent to (~a) for integral types and to (!a) for Boolean values. In Visual Basic, it is equivalent to (Not a). The object a should not be modified in place.
  - NotEqual
```
public static final ExpressionType NotEqual
```
    An inequality comparison, such as (a != b) in C# or (a <> b) in Visual Basic.
  - Or
```
public static final ExpressionType Or
```
    A bitwise or logical OR operation, such as (a | b) in C# or (a Or b) in Visual Basic.
  - OrElse
```
public static final ExpressionType OrElse
```
    A short-circuiting conditional OR operation, such as (a || b) in C# or (a OrElse b) in Visual Basic.
  - Parameter
```
public static final ExpressionType Parameter
```
    A reference to a parameter or variable that is defined in the context of the expression. For more information, see ParameterExpression.
  - Power
```
public static final ExpressionType Power
```
    A mathematical operation that raises a number to a power, such as (a ^ b) in Visual Basic.
  - Quote
```
public static final ExpressionType Quote
```
    An expression that has a constant value of type Expression. A Quote node can contain references to parameters that are defined in the context of the expression it represents.
  - RightShift
```
public static final ExpressionType RightShift
```
    A bitwise right-shift operation, such as (a >*gt; b).
  - Subtract
```
public static final ExpressionType Subtract
```
    A subtraction operation, such as (a - b), without overflow checking, for numeric operands.
  - SubtractChecked
```
public static final ExpressionType SubtractChecked
```
    An arithmetic subtraction operation, such as (a - b), that has overflow checking, for numeric operands.
  - TypeAs
```
public static final ExpressionType TypeAs
```
    An explicit reference or boxing conversion in which null is supplied if the conversion fails, such as (obj as SampleType) in C# or TryCast(obj, SampleType) in Visual Basic.
  - TypeIs
```
public static final ExpressionType TypeIs
```
    A type test, such as obj is SampleType in C# or TypeOf obj is SampleType in Visual Basic.
  - Assign
```
public static final ExpressionType Assign
```
    An assignment operation, such as (a = b).
  - Block
```
public static final ExpressionType Block
```
    A block of expressions.
  - DebugInfo
```
public static final ExpressionType DebugInfo
```
    Debugging information.
  - Decrement
```
public static final ExpressionType Decrement
```
    A unary decrement operation, such as (a - 1) in C# and Visual Basic. The object a should not be modified in place.
  - Dynamic
```
public static final ExpressionType Dynamic
```
    A dynamic operation.
  - Default
```
public static final ExpressionType Default
```
    A default value.
  - Extension
```
public static final ExpressionType Extension
```
    An extension expression.
  - Goto
```
public static final ExpressionType Goto
```
    A "go to" expression, such as goto Label in C# or GoTo Label in Visual Basic.
  - Increment
```
public static final ExpressionType Increment
```
    A unary increment operation, such as (a + 1) in C# and Visual Basic. The object a should not be modified in place.
  - Index
```
public static final ExpressionType Index
```
    An index operation or an operation that accesses a property that takes arguments.
  - Label
```
public static final ExpressionType Label
```
    A label.
  - RuntimeVariables
```
public static final ExpressionType RuntimeVariables
```
    A list of run-time variables. For more information, see RuntimeVariablesExpression.
  - Loop
```
public static final ExpressionType Loop
```
    A loop, such as for or while.
  - Switch
```
public static final ExpressionType Switch
```
    A switch operation, such as switch in C# or Select Case in Visual Basic.
  - Throw
```
public static final ExpressionType Throw
```
    An operation that throws an exception, such as throw new Exception().
  - Try
```
public static final ExpressionType Try
```
    A try-catch expression.
  - Unbox
```
public static final ExpressionType Unbox
```
    An unbox value type operation, such as unbox and unbox.any instructions in MSIL.
  - AddAssign
```
public static final ExpressionType AddAssign
```
    An addition compound assignment operation, such as (a += b), without overflow checking, for numeric operands.
  - AndAssign
```
public static final ExpressionType AndAssign
```
    A bitwise or logical AND compound assignment operation, such as (a &= b) in C#.
  - DivideAssign
```
public static final ExpressionType DivideAssign
```
    An division compound assignment operation, such as (a /= b), for numeric operands.
  - ExclusiveOrAssign
```
public static final ExpressionType ExclusiveOrAssign
```
    A bitwise or logical XOR compound assignment operation, such as (a ^= b) in C#.
  - LeftShiftAssign
```
public static final ExpressionType LeftShiftAssign
```
    A bitwise left-shift compound assignment, such as (a <<= b).
  - ModuloAssign
```
public static final ExpressionType ModuloAssign
```
    An arithmetic remainder compound assignment operation, such as (a %= b) in C#.
  - MultiplyAssign
```
public static final ExpressionType MultiplyAssign
```
    A multiplication compound assignment operation, such as (a *= b), without overflow checking, for numeric operands.
  - OrAssign
```
public static final ExpressionType OrAssign
```
    A bitwise or logical OR compound assignment, such as (a |= b) in C#.
  - PowerAssign
```
public static final ExpressionType PowerAssign
```
    A compound assignment operation that raises a number to a power, such as (a ^= b) in Visual Basic.
  - RightShiftAssign
```
public static final ExpressionType RightShiftAssign
```
    A bitwise right-shift compound assignment operation, such as (a >>= b).
  - SubtractAssign
```
public static final ExpressionType SubtractAssign
```
    A subtraction compound assignment operation, such as (a -= b), without overflow checking, for numeric operands.
  - AddAssignChecked
```
public static final ExpressionType AddAssignChecked
```
    An addition compound assignment operation, such as (a += b), with overflow checking, for numeric operands.
  - MultiplyAssignChecked
```
public static final ExpressionType MultiplyAssignChecked
```
    A multiplication compound assignment operation, such as (a *= b), that has overflow checking, for numeric operands.
  - SubtractAssignChecked
```
public static final ExpressionType SubtractAssignChecked
```
    A subtraction compound assignment operation, such as (a -= b), that has overflow checking, for numeric operands.
  - PreIncrementAssign
```
public static final ExpressionType PreIncrementAssign
```
    A unary prefix increment, such as (++a). The object a should be modified in place.
  - PreDecrementAssign
```
public static final ExpressionType PreDecrementAssign
```
    A unary prefix decrement, such as (--a). The object a should be modified in place.
  - PostIncrementAssign
```
public static final ExpressionType PostIncrementAssign
```
    A unary postfix increment, such as (a++). The object a should be modified in place.
  - PostDecrementAssign
```
public static final ExpressionType PostDecrementAssign
```
    A unary postfix decrement, such as (a--). The object a should be modified in place.
  - TypeEqual
```
public static final ExpressionType TypeEqual
```
    An exact type test.
  - OnesComplement
```
public static final ExpressionType OnesComplement
```
    A ones complement operation, such as (~a) in C#.
  - IsTrue
```
public static final ExpressionType IsTrue
```
    A true condition value.
  - IsFalse
```
public static final ExpressionType IsFalse
```
    A false condition value.
  - Declaration
```
public static final ExpressionType Declaration
```
    Declaration of a variable.
  - For
```
public static final ExpressionType For
```
  - While
```
public static final ExpressionType While
```
- Field Detail
  - op
```
final java.lang.String op
```
  - op2
```
final java.lang.String op2
```
  - postfix
```
final boolean postfix
```
  - lprec
```
final int lprec
```
  - rprec
```
final int rprec
```
  - modifiesLvalue
```
final boolean modifiesLvalue
```
- Constructor Detail
  - ExpressionType
```
private ExpressionType()
```
  - ExpressionType
```
private ExpressionType(java.lang.String op,
                       boolean postfix,
                       int prec,
                       boolean right)
```
  - ExpressionType
```
private ExpressionType(java.lang.String op,
                       java.lang.String op2,
                       boolean postfix,
                       int prec,
                       boolean right)
```
  - ExpressionType
```
private ExpressionType(java.lang.String op,
                       java.lang.String op2,
                       boolean postfix,
                       int prec,
                       boolean right,
                       boolean modifiesLvalue)
```
- Method Detail
  - values
```
public static ExpressionType[] values()
```
    Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows:
    for (ExpressionType c : ExpressionType.values()) System.out.println(c);
    Returns:
    
    an array containing the constants of this enum type, in the order they are declared
  - valueOf
```
public static ExpressionType valueOf(java.lang.String name)
```
    Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)
    
    Parameters:
    
    name - the name of the enum constant to be returned.
    
    Returns:
    
    the enum constant with the specified name
    
    Throws:
    
    java.lang.IllegalArgumentException - if this enum type has no constant with the specified name
    
    java.lang.NullPointerException - if the argument is null

Enum ExpressionType

Enum Constant Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Enum

Methods inherited from class java.lang.Object

Enum Constant Detail

Add

AddChecked

And

AndAlso

ArrayLength

ArrayIndex

Call

Coalesce

Conditional

Constant

Convert

ConvertChecked

Divide

Mod

Equal

ExclusiveOr

GreaterThan

GreaterThanOrEqual

Invoke

Lambda

LeftShift

LessThan

LessThanOrEqual

ListInit

MemberAccess

MemberInit

Modulo

Multiply

MultiplyChecked

Negate

UnaryPlus

NegateChecked

New

NewArrayInit

NewArrayBounds

Not

NotEqual

Or

OrElse

Parameter

Power

Quote

RightShift

Subtract

SubtractChecked

TypeAs

TypeIs

Assign

Block

DebugInfo

Decrement

Dynamic

Default

Extension

Goto

Increment

Index

Label

RuntimeVariables

Loop

Switch

Throw

Try

Unbox

AddAssign

AndAssign

DivideAssign

ExclusiveOrAssign

LeftShiftAssign

ModuloAssign

MultiplyAssign

OrAssign