Enum SimpleExpr 

pub enum SimpleExpr {
    Column(ColumnRef),
    TableColumn(DynIden, DynIden),
    Value(Value),
    Unary(UnOper, Box<SimpleExpr>),
    Binary(Box<SimpleExpr>, BinOper, Box<SimpleExpr>),
    FunctionCall(DynIden, Vec<SimpleExpr>),
    SubQuery(Option<SubQueryOper>, Box<SelectStatement>),
    Tuple(Vec<SimpleExpr>),
    Custom(String),
    CustomWithExpr(String, Vec<SimpleExpr>),
    Constant(Keyword),
    Asterisk,
    Case(Box<CaseStatement>),
    AsEnum(DynIden, Box<SimpleExpr>),
    Cast(Box<SimpleExpr>, DynIden),
    Window {
        func: Box<SimpleExpr>,
        window: WindowStatement,
    },
    WindowNamed {
        func: Box<SimpleExpr>,
        name: DynIden,
    },
}

A simple SQL expression.

This enum represents the AST for SQL expressions. Each variant corresponds to a type of SQL expression that can appear in queries.

Example

use reinhardt_query::SimpleExpr;

// Column reference
let col = SimpleExpr::Column(ColumnRef::column("name"));

// Value literal
let val = SimpleExpr::Value(Value::Int(Some(42)));

// Binary operation (column = 42)
let eq = SimpleExpr::Binary(
    Box::new(col),
    BinOper::Equal,
    Box::new(val),
);

Variants

Column(ColumnRef)

A column reference (e.g., name, users.name, public.users.name)

TableColumn(DynIden, DynIden)

A table-qualified column (legacy format)

Value(Value)

A literal value (e.g., 42, 'hello', TRUE)

Unary(UnOper, Box<SimpleExpr>)

A unary operation (e.g., NOT x)

Binary(Box<SimpleExpr>, BinOper, Box<SimpleExpr>)

A binary operation (e.g., x = y, a AND b, x + y)

FunctionCall(DynIden, Vec<SimpleExpr>)

A function call (e.g., MAX(x), LOWER(name))

SubQuery(Option<SubQueryOper>, Box<SelectStatement>)

A subquery (e.g., (SELECT ...))

The optional operator indicates how the subquery is used:

• None: Standalone subquery (e.g., in FROM clause or SELECT list)
• Some(SubQueryOper): Subquery with operator (e.g., IN, EXISTS, ALL)

Tuple(Vec<SimpleExpr>)

A tuple of expressions (e.g., (1, 2, 3))

Custom(String)

A custom SQL expression (e.g., NOW())

Security Warning

This variant embeds raw SQL directly into the query. Only use with trusted input or static SQL strings. For dynamic values, use CustomWithExpr instead.

CustomWithExpr(String, Vec<SimpleExpr>)

A custom SQL expression with parameter placeholders

Constant(Keyword)

A constant (database-specific constant like TRUE, FALSE, NULL)

Asterisk

An asterisk (*)

Case(Box<CaseStatement>)

A CASE WHEN expression

AsEnum(DynIden, Box<SimpleExpr>)

An AS expression with alias (e.g., expr AS alias)

Cast(Box<SimpleExpr>, DynIden)

A CAST expression (e.g., CAST(x AS INTEGER))

Window

A window function with inline window specification

Represents expressions like:

ROW_NUMBER() OVER (PARTITION BY department_id ORDER BY salary DESC)

Fields

func: Box<SimpleExpr>

The function expression

window: WindowStatement

The window specification

WindowNamed

A window function with named window reference

Represents expressions like:

ROW_NUMBER() OVER window_name

where window_name is defined in the WINDOW clause.

Fields

func: Box<SimpleExpr>

The function expression

name: DynIden

The window name

Implementations

impl SimpleExpr

pub fn binary(self, op: BinOper, right: SimpleExpr) -> Self

Create a binary operation expression.

Trait Implementations

impl Clone for SimpleExpr

fn clone(&self) -> SimpleExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SimpleExpr

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

Formats the value using the given formatter.

impl ExprTrait for SimpleExpr

fn into_simple_expr(self) -> SimpleExpr

Build the final SimpleExpr.

fn eq<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Equal (=).

fn ne<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Not equal (<>).

fn lt<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Less than (<).

fn lte<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Less than or equal (<=).

fn gt<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Greater than (>).

fn gte<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Greater than or equal (>=).

fn is_null(self) -> SimpleExpr

IS NULL.

fn is_not_null(self) -> SimpleExpr

IS NOT NULL.

fn between<A, B>(self, a: A, b: B) -> SimpleExpr

where A: Into<SimpleExpr>, B: Into<SimpleExpr>,

BETWEEN.

fn not_between<A, B>(self, a: A, b: B) -> SimpleExpr

where A: Into<SimpleExpr>, B: Into<SimpleExpr>,

NOT BETWEEN.

fn is_in<I, V>(self, values: I) -> SimpleExpr

where I: IntoIterator<Item = V>, V: Into<SimpleExpr>,

IN.

fn is_not_in<I, V>(self, values: I) -> SimpleExpr

where I: IntoIterator<Item = V>, V: Into<SimpleExpr>,

NOT IN.

fn like<V>(self, pattern: V) -> SimpleExpr

where V: Into<SimpleExpr>,

LIKE.

fn not_like<V>(self, pattern: V) -> SimpleExpr

where V: Into<SimpleExpr>,

NOT LIKE.

fn ilike<V>(self, pattern: V) -> SimpleExpr

where V: Into<SimpleExpr>,

ILIKE (case-insensitive LIKE, PostgreSQL).

fn not_ilike<V>(self, pattern: V) -> SimpleExpr

where V: Into<SimpleExpr>,

NOT ILIKE (PostgreSQL).

fn starts_with<S>(self, prefix: S) -> SimpleExpr

where S: Into<String>,

Helper for LIKE with prefix wildcard.

fn ends_with<S>(self, suffix: S) -> SimpleExpr

where S: Into<String>,

Helper for LIKE with suffix wildcard.

fn contains<S>(self, substring: S) -> SimpleExpr

where S: Into<String>,

Helper for LIKE with both wildcards.

fn and<E>(self, other: E) -> SimpleExpr

where E: Into<SimpleExpr>,

AND.

fn or<E>(self, other: E) -> SimpleExpr

where E: Into<SimpleExpr>,

OR.

fn not(self) -> SimpleExpr

NOT (unary).

fn add<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Addition (+).

fn sub<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Subtraction (-).

fn mul<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Multiplication (*).

fn div<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Division (/).

fn modulo<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Modulo (%).

fn bit_and<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Bitwise AND (&).

fn bit_or<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Bitwise OR (|).

fn left_shift<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Left shift (<<).

fn right_shift<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Right shift (>>).

fn cast_as<T>(self, type_name: T) -> SimpleExpr

where T: IntoIden,

CAST expression.

fn as_enum<T>(self, type_name: T) -> SimpleExpr

where T: IntoIden,

AS ENUM expression (PostgreSQL).

impl From<&str> for SimpleExpr

fn from(s: &str) -> Self

Converts to this type from the input type.

impl From<CaseStatement> for SimpleExpr

fn from(case: CaseStatement) -> Self

Converts to this type from the input type.

impl From<ColumnRef> for SimpleExpr

fn from(c: ColumnRef) -> Self

Converts to this type from the input type.

impl From<Expr> for SimpleExpr

fn from(e: Expr) -> Self

Converts to this type from the input type.

impl From<Keyword> for SimpleExpr

fn from(k: Keyword) -> Self

Converts to this type from the input type.

impl From<SimpleExpr> for Expr

fn from(e: SimpleExpr) -> Self

Converts to this type from the input type.

impl From<String> for SimpleExpr

fn from(s: String) -> Self

Converts to this type from the input type.

impl From<Value> for SimpleExpr

fn from(v: Value) -> Self

Converts to this type from the input type.

impl From<bool> for SimpleExpr

fn from(b: bool) -> Self

Converts to this type from the input type.

impl From<f32> for SimpleExpr

fn from(f: f32) -> Self

Converts to this type from the input type.

impl From<f64> for SimpleExpr

fn from(f: f64) -> Self

Converts to this type from the input type.

impl From<i32> for SimpleExpr

fn from(i: i32) -> Self

Converts to this type from the input type.

impl From<i64> for SimpleExpr

fn from(i: i64) -> Self

Converts to this type from the input type.

impl IntoCondition for SimpleExpr

fn into_condition_expression(self) -> ConditionExpression

Convert into a ConditionExpression.

fn into_condition(self) -> Condition

where Self: Sized,

Convert into a Condition (wrapping if necessary).