Enum Expr

pub enum Expr {
Show 24 variants
    And(ExprAnd),
    Any(ExprAny),
    Arg(ExprArg),
    BinaryOp(ExprBinaryOp),
    Cast(ExprCast),
    Default,
    Error(ExprError),
    Exists(ExprExists),
    Func(ExprFunc),
    InList(ExprInList),
    InSubquery(ExprInSubquery),
    IsNull(ExprIsNull),
    IsVariant(ExprIsVariant),
    Let(ExprLet),
    Map(ExprMap),
    Match(ExprMatch),
    Not(ExprNot),
    Or(ExprOr),
    Project(ExprProject),
    Record(ExprRecord),
    Reference(ExprReference),
    List(ExprList),
    Stmt(ExprStmt),
    Value(Value),
}

Expand description

An expression.

Variants§

§

Any(ExprAny)

ANY - returns true if any of the items evaluate to true

§

Arg(ExprArg)

An argument when the expression is a function body

§

Default

Suggests that the database should use its default value. Useful for auto-increment fields and other columns with default values.

§

Error(ExprError)

An error expression that fails evaluation with a message.

§

Exists(ExprExists)

An exists expression [ NOT ] EXISTS(SELECT ...), used in expressions like WHERE [ NOT ] EXISTS (SELECT ...).

§

InSubquery(ExprInSubquery)

The expression is contained by the given subquery

§

IsNull(ExprIsNull)

Whether an expression is (or is not) null. This is different from a binary expression because of how databases treat null comparisons.

§

IsVariant(ExprIsVariant)

Whether an expression evaluates to a specific enum variant.

§

Let(ExprLet)

A scoped binding expression (transient — inlined before planning)

§

Map(ExprMap)

Apply an expression to each item in a list

§

Match(ExprMatch)

A match expression that dispatches on a subject expression

§

Reference(ExprReference)

Reference a value from within the statement itself.

§

Value(Value)

Evaluates to a constant value reference

Implementations§

§

impl Expr

pub fn eval(&self, input: impl Input) -> Result<Value, Error>

pub fn eval_bool(&self, input: impl Input) -> Result<bool, Error>

pub fn eval_const(&self) -> Result<Value, Error>

§

impl Expr

pub const TRUE: Expr

pub const FALSE: Expr

pub const DEFAULT: Expr = Expr::Default

pub fn null() -> Expr

pub fn is_value_null(&self) -> bool

Is a value that evaluates to null

pub fn is_true(&self) -> bool

Returns true if the expression is the true boolean expression

pub fn is_false(&self) -> bool

Returns true if the expression is the false boolean expression

pub fn is_unsatisfiable(&self) -> bool

Returns true if the expression can never evaluate to true.

In SQL’s three-valued logic, both false and null are unsatisfiable: a filter producing either value will never match any rows.

pub fn is_default(&self) -> bool

Returns true if the expression is the default expression

pub fn is_value(&self) -> bool

Returns true if the expression is a constant value.

pub fn is_stmt(&self) -> bool

pub fn is_binary_op(&self) -> bool

Returns true if the expression is a binary operation

pub fn is_arg(&self) -> bool

pub fn is_always_non_nullable(&self) -> bool

Returns true if the expression is always non-nullable.

This method is conservative and only returns true for expressions we can prove are non-nullable.

pub fn into_value(self) -> Value

pub fn into_stmt(self) -> ExprStmt

pub fn is_stable(&self) -> bool

Returns true if the expression is stable

An expression is stable if it yields the same value each time it is evaluated

pub fn is_const(&self) -> bool

Returns true if the expression is a constant expression.

A constant expression is one that does not reference any external data. This means it contains no Reference, Stmt, or Arg expressions that reference external inputs.

Arg expressions inside Map bodies with nesting less than the current map depth are local bindings (bound to the mapped element), not external inputs, and are therefore considered const in that context.

pub fn is_eval(&self) -> bool

Returns true if the expression can be evaluated.

An expression can be evaluated if it doesn’t contain references to external data sources like subqueries or references. Args are allowed since they represent function parameters that can be bound at evaluation time.

pub fn map_projections(&self, f: impl FnMut(&Projection) -> Projection) -> Expr

pub fn entry(&self, path: impl EntryPath) -> Option<Entry<'_>>

pub fn entry_mut(&mut self, path: impl EntryPath) -> EntryMut<'_>

pub fn take(&mut self) -> Expr

pub fn substitute(&mut self, input: impl Input)

§

impl Expr

pub fn and(lhs: impl Into<Expr>, rhs: impl Into<Expr>) -> Expr

pub fn and_from_vec(operands: Vec<Expr>) -> Expr

§

impl Expr

pub fn any(expr: impl Into<Expr>) -> Expr

Creates an Any expression that returns true if any item in the list evaluates to true.

Returns false if the list is empty (matching Rust’s [].iter().any() semantics).

pub fn is_any(&self) -> bool

Returns true if this is an Any expression

§

impl Expr

pub fn arg(expr_arg: impl Into<ExprArg>) -> Expr

§

impl Expr

pub fn binary_op( lhs: impl Into<Expr>, op: BinaryOp, rhs: impl Into<Expr>, ) -> Expr

pub fn eq(lhs: impl Into<Expr>, rhs: impl Into<Expr>) -> Expr

pub fn is_eq(&self) -> bool

Returns true if the expression is a binary expression with the equality operator

pub fn ge(lhs: impl Into<Expr>, rhs: impl Into<Expr>) -> Expr

pub fn gt(lhs: impl Into<Expr>, rhs: impl Into<Expr>) -> Expr

pub fn le(lhs: impl Into<Expr>, rhs: impl Into<Expr>) -> Expr

pub fn lt(lhs: impl Into<Expr>, rhs: impl Into<Expr>) -> Expr

pub fn ne(lhs: impl Into<Expr>, rhs: impl Into<Expr>) -> Expr

§

impl Expr

pub fn cast(expr: impl Into<Expr>, ty: impl Into<Type>) -> Expr

pub fn is_cast(&self) -> bool

§

impl Expr

pub fn error(message: impl Into<String>) -> Expr

§

impl Expr

pub fn exists(subquery: impl Into<Query>) -> Expr

pub fn not_exists(subquery: impl Into<Query>) -> Expr

§

impl Expr

pub fn in_list(lhs: impl Into<Expr>, rhs: impl Into<Expr>) -> Expr

§

impl Expr

pub fn in_subquery(lhs: impl Into<Expr>, rhs: impl Into<Query>) -> Expr

pub fn is_in_subquery(&self) -> bool

§

impl Expr

pub fn is_null(expr: impl Into<Expr>) -> Expr

pub fn is_not_null(expr: impl Into<Expr>) -> Expr

§

impl Expr

pub fn is_variant(expr: impl Into<Expr>, variant: VariantId) -> Expr

§

impl Expr

pub fn list<T>(items: impl IntoIterator<Item = T>) -> Expr
where T: Into<Expr>,

pub fn list_from_vec(items: Vec<Expr>) -> Expr

pub fn is_list(&self) -> bool

pub fn is_list_empty(&self) -> bool

pub fn expect_list(&self) -> &ExprList

pub fn expect_list_mut(&mut self) -> &mut ExprList

pub fn unwrap_list(self) -> ExprList

§

impl Expr

pub fn map(base: impl Into<Expr>, map: impl Into<Expr>) -> Expr

pub fn as_map(&self) -> &ExprMap

§

impl Expr

pub fn match_expr( subject: impl Into<Expr>, arms: Vec<MatchArm>, else_expr: impl Into<Expr>, ) -> Expr

Creates a Match expression that dispatches on subject.

§

impl Expr

pub fn not(expr: impl Into<Expr>) -> Expr

Creates a Not expression that negates the given expression.

pub fn is_not(&self) -> bool

Returns true if this is a Not expression.

§

impl Expr

pub fn or(lhs: impl Into<Expr>, rhs: impl Into<Expr>) -> Expr

pub fn or_from_vec(operands: Vec<Expr>) -> Expr

§

impl Expr

pub fn project(base: impl Into<Expr>, projection: impl Into<Projection>) -> Expr

pub fn arg_project( expr_arg: impl Into<ExprArg>, projection: impl Into<Projection>, ) -> Expr

pub fn is_project(&self) -> bool

pub fn as_project(&self) -> &ExprProject

§

impl Expr

pub fn record<T>(items: impl IntoIterator<Item = T>) -> Expr
where T: Into<Expr>,

pub fn record_from_vec(fields: Vec<Expr>) -> Expr

pub fn is_record(&self) -> bool

pub fn as_record(&self) -> Option<&ExprRecord>

pub fn as_record_unwrap(&self) -> &ExprRecord

pub fn as_record_mut(&mut self) -> &mut ExprRecord

pub fn into_record(self) -> ExprRecord

pub fn record_len(&self) -> Option<usize>

pub fn into_record_items(self) -> Option<impl Iterator<Item = Expr>>

§

impl Expr

pub fn is_expr_reference(&self) -> bool

pub fn ref_self_field(field: impl Into<FieldId>) -> Expr

Creates an expression that references a field in the current query.

This creates an ExprReference::Field with nesting = 0, meaning it references a field in the current query scope rather than an outer query.

§Arguments

field - A field identifier that can be converted into a FieldId

§Returns

An Expr::Reference containing an ExprReference::Field that points to the specified field in the current query’s relation.

pub fn ref_field(nesting: usize, field: impl Into<FieldId>) -> Expr

Create a reference to a field at a specified nesting level

pub fn ref_parent_field(field: impl Into<FieldId>) -> Expr

Create a reference to a field one level up

pub fn is_field(&self) -> bool

pub fn ref_parent_model() -> Expr

Create a model reference to the parent model

pub fn ref_ancestor_model(nesting: usize) -> Expr

Create a model reference to the specified nesting level

pub fn column(column: impl Into<ExprReference>) -> Expr

pub fn is_column(&self) -> bool

pub fn as_expr_reference(&self) -> Option<&ExprReference>

pub fn as_expr_reference_unwrap(&self) -> &ExprReference

pub fn as_expr_column(&self) -> Option<&ExprColumn>

pub fn as_expr_column_unwrap(&self) -> &ExprColumn

§

impl Expr

pub fn stmt(stmt: impl Into<Statement>) -> Expr

§

impl Expr

pub fn count_star() -> Expr

§

impl Expr

pub fn last_insert_id() -> Expr

Trait Implementations§

§

impl Clone for Expr

§

fn clone(&self) -> Expr

Returns a duplicate of the value. Read more

1.0.0 · Source§

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

Performs copy-assignment from source. Read more

§

impl Debug for Expr

§

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

Formats the value using the given formatter. Read more

§