Enum TypedExprKind 

pub enum TypedExprKind {
    Literal(Literal),
    ColumnRef {
        table: String,
        column: String,
        column_index: usize,
    },
    BinaryOp {
        left: Box<TypedExpr>,
        op: BinaryOp,
        right: Box<TypedExpr>,
    },
    UnaryOp {
        op: UnaryOp,
        operand: Box<TypedExpr>,
    },
    FunctionCall {
        name: String,
        args: Vec<TypedExpr>,
    },
    Cast {
        expr: Box<TypedExpr>,
        target_type: ResolvedType,
    },
    Between {
        expr: Box<TypedExpr>,
        low: Box<TypedExpr>,
        high: Box<TypedExpr>,
        negated: bool,
    },
    Like {
        expr: Box<TypedExpr>,
        pattern: Box<TypedExpr>,
        escape: Option<Box<TypedExpr>>,
        negated: bool,
    },
    InList {
        expr: Box<TypedExpr>,
        list: Vec<TypedExpr>,
        negated: bool,
    },
    IsNull {
        expr: Box<TypedExpr>,
        negated: bool,
    },
    VectorLiteral(Vec<f64>),
}

The kind of a typed expression.

Each variant corresponds to a different expression type that has been type-checked. Unlike ExprKind, column references include the resolved column index for efficient access.

Variants

Literal(Literal)

A literal value.

ColumnRef

A column reference with resolved table and column index.

Fields

table: String

The table name (resolved, never None after name resolution).

column: String

The column name.

column_index: usize

The column index in the table’s column list (0-based). This allows efficient column access during execution.

BinaryOp

A binary operation.

Fields

left: Box<TypedExpr>

Left operand.

op: BinaryOp

The operator.

right: Box<TypedExpr>

Right operand.

UnaryOp

A unary operation.

Fields

op: UnaryOp

The operator.

operand: Box<TypedExpr>

The operand.

FunctionCall

A function call.

Fields

name: String

Function name.

args: Vec<TypedExpr>

Function arguments.

Cast

An explicit type cast.

Fields

expr: Box<TypedExpr>

Expression to cast.

target_type: ResolvedType

Target type.

Between

A BETWEEN expression.

Fields

expr: Box<TypedExpr>

Expression to test.

low: Box<TypedExpr>

Lower bound.

high: Box<TypedExpr>

Upper bound.

negated: bool

Whether the expression is negated (NOT BETWEEN).

Like

A LIKE pattern match expression.

Fields

expr: Box<TypedExpr>

Expression to match.

pattern: Box<TypedExpr>

Pattern to match against.

escape: Option<Box<TypedExpr>>

Optional escape character.

negated: bool

Whether the expression is negated (NOT LIKE).

InList

An IN list expression.

Fields

expr: Box<TypedExpr>

Expression to test.

list: Vec<TypedExpr>

List of values to check against.

negated: bool

Whether the expression is negated (NOT IN).

IsNull

An IS NULL expression.

Fields

expr: Box<TypedExpr>

Expression to test.

negated: bool

Whether the expression is negated (IS NOT NULL).

VectorLiteral(Vec<f64>)

A vector literal.

Trait Implementations

impl Clone for TypedExprKind

fn clone(&self) -> TypedExprKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TypedExprKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.