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>,
    },
    Case {
        operand: Option<Box<TypedExpr>>,
        branches: Vec<TypedCaseWhen>,
        else_expr: Option<Box<TypedExpr>>,
    },
    FunctionCall {
        name: String,
        args: Vec<TypedExpr>,
        distinct: bool,
        star: bool,
        filter: Option<Box<TypedExpr>>,
        order_by: Vec<SortExpr>,
        over: Option<TypedWindowSpec>,
    },
    Cast {
        expr: Box<TypedExpr>,
        target_type: ResolvedType,
    },
    TryCast {
        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,
        kind: PatternMatchKind,
    },
    InList {
        expr: Box<TypedExpr>,
        list: Vec<TypedExpr>,
        negated: bool,
    },
    IsNull {
        expr: Box<TypedExpr>,
        negated: bool,
    },
    VectorLiteral(Vec<f64>),
    ScalarSubquery(Box<LogicalPlan>),
    InSubquery {
        expr: Box<TypedExpr>,
        subquery: Box<LogicalPlan>,
        negated: bool,
    },
    Exists {
        subquery: Box<LogicalPlan>,
        negated: bool,
    },
    Quantified {
        expr: Box<TypedExpr>,
        op: BinaryOp,
        quantifier: Quantifier,
        subquery: Box<LogicalPlan>,
    },
}

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.

Case

A searched or simple CASE expression.

Fields

operand: Option<Box<TypedExpr>>

The simple CASE operand, or None for searched CASE.

branches: Vec<TypedCaseWhen>

WHEN/THEN branches in source order.

else_expr: Option<Box<TypedExpr>>

The ELSE expression, or None for the implicit NULL result.

FunctionCall

A function call.

Fields

name: String

Function name.

args: Vec<TypedExpr>

Function arguments.

distinct: bool

DISTINCT modifier for aggregate functions.

star: bool

STAR modifier for COUNT(*).

filter: Option<Box<TypedExpr>>

Aggregate row filter from FILTER (WHERE predicate) (issue #148).

order_by: Vec<SortExpr>

Aggregate-local ordering. WITHIN GROUP (ORDER BY ...) is normalized into this list by the type checker.

over: Option<TypedWindowSpec>

Optional typed OVER (...) specification.

Cast

An explicit type cast.

Fields

expr: Box<TypedExpr>

Expression to cast.

target_type: ResolvedType

Target type.

TryCast

An explicit type cast that returns NULL on conversion failure.

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).

kind: PatternMatchKind

Pattern operator variant.

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.

ScalarSubquery(Box<LogicalPlan>)

A scalar subquery.

InSubquery

An IN subquery.

Fields

expr: Box<TypedExpr>

Expression to test.

subquery: Box<LogicalPlan>

Planned subquery.

negated: bool

Whether this is NOT IN.

Exists

An EXISTS subquery.

Fields

subquery: Box<LogicalPlan>

Planned subquery.

negated: bool

Whether this is NOT EXISTS.

Quantified

A quantified comparison subquery.

Fields

expr: Box<TypedExpr>

Expression to compare.

op: BinaryOp

Comparison operator.

quantifier: Quantifier

ANY/ALL quantifier.

subquery: Box<LogicalPlan>

Planned subquery.

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.