Enum Expr 

pub enum Expr {
    Column(String),
    CompositeField {
        table: String,
        column: String,
        field: String,
        json_key: String,
        json_cast: JsonPathCast,
    },
    Param(Value),
    Binary {
        left: Box<Expr>,
        op: BinaryOp,
        right: Box<Expr>,
    },
    Not(Box<Expr>),
    FunctionCall {
        name: String,
        args: Vec<Expr>,
    },
    Filter {
        expr: Box<Expr>,
        predicate: Box<Expr>,
    },
    Exists(Box<Select>),
    NotExists(Box<Select>),
    Relation {
        op: RelationFilterOp,
        relation: Box<RelationFilter>,
    },
    ScalarSubquery(Box<Select>),
    IsNull(Box<Expr>),
    IsNotNull(Box<Expr>),
    Literal(LiteralSql),
    List(Vec<Expr>),
    CaseWhen {
        condition: Box<Expr>,
        then: Box<Expr>,
    },
    Star,
}

Expression node for WHERE clauses and filters.

Variants

Column(String)

Column reference.

CompositeField

Field inside a composite value.

Rendered as a native composite attribute on PostgreSQL and as JSON-path extraction on JSON-backed providers.

Fields

table: String

Database table name.

column: String

Database column name containing the composite/JSON value.

field: String

Database field name inside the PostgreSQL composite type.

json_key: String

JSON object key used by JSON-backed composite storage.

json_cast: JsonPathCast

Optional cast hint for JSON-backed providers.

Param(Value)

Parameter placeholder.

Binary

Binary operation.

Fields

left: Box<Expr>

Left operand.

op: BinaryOp

Operator.

right: Box<Expr>

Right operand.

Not(Box<Expr>)

Logical NOT.

FunctionCall

Function call (e.g., json_agg, COALESCE).

Fields

name: String

Function name.

args: Vec<Expr>

Function arguments.

Filter

SQL FILTER clause for aggregate functions (PostgreSQL).

Fields

expr: Box<Expr>

The aggregation expression.

predicate: Box<Expr>

The filter predicate.

Exists(Box<Select>)

EXISTS subquery predicate — compiles to EXISTS (SELECT ...).

NotExists(Box<Select>)

NOT EXISTS subquery predicate — compiles to NOT EXISTS (SELECT ...).

Relation

Relation predicate (some / none / every) with explicit relation metadata.

Fields

op: RelationFilterOp

Which relation operator to apply.

relation: Box<RelationFilter>

Relation metadata and nested child filter.

ScalarSubquery(Box<Select>)

Scalar subquery — compiles to (SELECT ...).

The inner SELECT must return exactly one row and one column. Used for correlated aggregate sub‑queries (e.g. relation includes) that must not produce a cartesian product when two or more relations are joined.

IsNull(Box<Expr>)

IS NULL check — compiles to expr IS NULL.

IsNotNull(Box<Expr>)

IS NOT NULL check — compiles to expr IS NOT NULL.

Literal(LiteralSql)

A raw SQL string literal emitted verbatim (no parameter binding).

Use this sparingly — only for values that must appear as SQL literals rather than positional parameters (e.g. keys in json_build_object). The LiteralSql newtype enforces that the text is trusted, never raw user input.

List(Vec<Expr>)

An ordered list of expressions for use in IN / NOT IN clauses.

Rendered as a comma-separated sequence; the surrounding parentheses are added by the IN/NOT IN rendering path in each dialect.

CaseWhen

CASE WHEN … THEN … ELSE NULL END.

Fields

condition: Box<Expr>

The condition.

then: Box<Expr>

The THEN result.

Star

SQL wildcard * — used inside aggregate functions like COUNT(*).

Implementations

impl Expr

pub fn column(name: impl Into<String>) -> Self

Creates a column reference.

pub fn composite_field( table: impl Into<String>, column: impl Into<String>, field: impl Into<String>, json_key: impl Into<String>, json_cast: JsonPathCast, ) -> Self

Creates a reference to a field inside a composite column.

pub fn param(value: impl Into<Value>) -> Self

Creates a parameter placeholder.

pub fn eq(self, other: Expr) -> Self

Creates an equality comparison (=).

pub fn ne(self, other: Expr) -> Self

Creates a not-equal comparison (!=).

pub fn lt(self, other: Expr) -> Self

Creates a less-than comparison (<).

pub fn le(self, other: Expr) -> Self

Creates a less-than-or-equal comparison (<=).

pub fn gt(self, other: Expr) -> Self

Creates a greater-than comparison (>).

pub fn ge(self, other: Expr) -> Self

Creates a greater-than-or-equal comparison (>=).

pub fn and(self, other: Expr) -> Self

Creates a logical AND.

pub fn or(self, other: Expr) -> Self

Creates a logical OR.

pub fn like(self, pattern: Expr) -> Self

Creates a LIKE pattern match.

pub fn in_list(self, exprs: Vec<Expr>) -> Self

Creates an IN list membership check.

pub fn not_in_list(self, exprs: Vec<Expr>) -> Self

Creates a NOT IN list membership check.

pub fn function_call(name: impl Into<String>, args: Vec<Expr>) -> Self

Creates a function call expression.

pub fn vector_distance(metric: VectorMetric, left: Expr, right: Expr) -> Self

Creates an internal vector-distance expression for pgvector ordering.

pub fn json_agg(expr: Expr) -> Self

Creates a json_agg() aggregate function.

pub fn json_build_object(pairs: Vec<(String, Expr)>) -> Self

Creates a json_build_object() function with key-value pairs.

Keys are emitted as SQL string literals (not bound parameters) because json_build_object requires literal key names in all supported dialects.

Safety

Keys must be static/compile-time strings. Never pass untrusted input as a key — use Expr::param for that and handle it in application logic.

pub fn coalesce(exprs: Vec<Expr>) -> Self

Creates a COALESCE() function to return first non-NULL value.

pub fn is_not_null(self) -> Self

Creates an IS NOT NULL check — compiles to expr IS NOT NULL.

pub fn is_null(self) -> Self

Creates an IS NULL check — compiles to expr IS NULL.

pub fn filter(self, predicate: Expr) -> Self

Adds a FILTER clause to an aggregate expression (PostgreSQL).

pub fn exists(subquery: Select) -> Self

Creates an EXISTS subquery predicate.

pub fn not_exists(subquery: Select) -> Self

Creates a NOT EXISTS subquery predicate.

pub fn relation_some( field: impl Into<String>, parent_table: impl Into<String>, target_table: impl Into<String>, fk_db: impl Into<String>, pk_db: impl Into<String>, filter: Expr, ) -> Self

Creates a relation some predicate.

pub fn relation_none( field: impl Into<String>, parent_table: impl Into<String>, target_table: impl Into<String>, fk_db: impl Into<String>, pk_db: impl Into<String>, filter: Expr, ) -> Self

Creates a relation none predicate.

pub fn relation_every( field: impl Into<String>, parent_table: impl Into<String>, target_table: impl Into<String>, fk_db: impl Into<String>, pk_db: impl Into<String>, filter: Expr, ) -> Self

Creates a relation every predicate.

pub fn scalar_subquery(subquery: Select) -> Self

Creates a scalar subquery expression (SELECT ...).

The inner SELECT must return exactly one column and at most one row.

pub fn case_when(condition: Expr, then: Expr) -> Self

Creates a CASE WHEN condition THEN result ELSE NULL END expression.

pub fn star() -> Self

Creates the SQL wildcard * (for use in COUNT(*)).

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl<T> From<Column<T>> for Expr

fn from(col: Column<T>) -> Expr

Converts a typed column into an expression.

Examples

use nautilus_core::{Column, Expr};

let id: Column<i64> = Column::new("users", "id");
let expr: Expr = id.into();

impl Not for Expr

Implements the ! operator for expressions, producing a SQL NOT clause.

type Output = Expr

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq for Expr

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Expr