Trait ExprTrait 

pub trait ExprTrait: Sized {
    // Required method
    fn into_simple_expr(self) -> SimpleExpr;

    // Provided methods
    fn eq<V>(self, v: V) -> SimpleExpr
       where V: Into<SimpleExpr> { ... }
    fn ne<V>(self, v: V) -> SimpleExpr
       where V: Into<SimpleExpr> { ... }
    fn lt<V>(self, v: V) -> SimpleExpr
       where V: Into<SimpleExpr> { ... }
    fn lte<V>(self, v: V) -> SimpleExpr
       where V: Into<SimpleExpr> { ... }
    fn gt<V>(self, v: V) -> SimpleExpr
       where V: Into<SimpleExpr> { ... }
    fn gte<V>(self, v: V) -> SimpleExpr
       where V: Into<SimpleExpr> { ... }
    fn is_null(self) -> SimpleExpr { ... }
    fn is_not_null(self) -> SimpleExpr { ... }
    fn between<A, B>(self, a: A, b: B) -> SimpleExpr
       where A: Into<SimpleExpr>,
             B: Into<SimpleExpr> { ... }
    fn not_between<A, B>(self, a: A, b: B) -> SimpleExpr
       where A: Into<SimpleExpr>,
             B: Into<SimpleExpr> { ... }
    fn is_in<I, V>(self, values: I) -> SimpleExpr
       where I: IntoIterator<Item = V>,
             V: Into<SimpleExpr> { ... }
    fn is_not_in<I, V>(self, values: I) -> SimpleExpr
       where I: IntoIterator<Item = V>,
             V: Into<SimpleExpr> { ... }
    fn like<V>(self, pattern: V) -> SimpleExpr
       where V: Into<SimpleExpr> { ... }
    fn not_like<V>(self, pattern: V) -> SimpleExpr
       where V: Into<SimpleExpr> { ... }
    fn ilike<V>(self, pattern: V) -> SimpleExpr
       where V: Into<SimpleExpr> { ... }
    fn not_ilike<V>(self, pattern: V) -> SimpleExpr
       where V: Into<SimpleExpr> { ... }
    fn starts_with<S>(self, prefix: S) -> SimpleExpr
       where S: Into<String> { ... }
    fn ends_with<S>(self, suffix: S) -> SimpleExpr
       where S: Into<String> { ... }
    fn contains<S>(self, substring: S) -> SimpleExpr
       where S: Into<String> { ... }
    fn and<E>(self, other: E) -> SimpleExpr
       where E: Into<SimpleExpr> { ... }
    fn or<E>(self, other: E) -> SimpleExpr
       where E: Into<SimpleExpr> { ... }
    fn not(self) -> SimpleExpr { ... }
    fn add<V>(self, v: V) -> SimpleExpr
       where V: Into<SimpleExpr> { ... }
    fn sub<V>(self, v: V) -> SimpleExpr
       where V: Into<SimpleExpr> { ... }
    fn mul<V>(self, v: V) -> SimpleExpr
       where V: Into<SimpleExpr> { ... }
    fn div<V>(self, v: V) -> SimpleExpr
       where V: Into<SimpleExpr> { ... }
    fn modulo<V>(self, v: V) -> SimpleExpr
       where V: Into<SimpleExpr> { ... }
    fn bit_and<V>(self, v: V) -> SimpleExpr
       where V: Into<SimpleExpr> { ... }
    fn bit_or<V>(self, v: V) -> SimpleExpr
       where V: Into<SimpleExpr> { ... }
    fn left_shift<V>(self, v: V) -> SimpleExpr
       where V: Into<SimpleExpr> { ... }
    fn right_shift<V>(self, v: V) -> SimpleExpr
       where V: Into<SimpleExpr> { ... }
    fn cast_as<T>(self, type_name: T) -> SimpleExpr
       where T: IntoIden { ... }
    fn as_enum<T>(self, type_name: T) -> SimpleExpr
       where T: IntoIden { ... }
}

Trait for expression operations.

This trait provides methods for building complex expressions through operator chaining. It is implemented for Expr and SimpleExpr.

Example

use reinhardt_query::{Expr, ExprTrait};

// Comparison
let expr = Expr::col("age").gte(18);

// Logical operations
let expr = Expr::col("active").eq(true).and(Expr::col("verified").eq(true));

// Arithmetic
let expr = Expr::col("price").mul(Expr::col("quantity"));

Required Methods

fn into_simple_expr(self) -> SimpleExpr

Build the final SimpleExpr.

Provided Methods

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

where V: Into<SimpleExpr>,

Equal (=).

Example

Expr::col("name").eq("Alice")
// Generates: "name" = 'Alice'

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.

Example

Expr::col("age").between(18, 65)
// Generates: "age" BETWEEN 18 AND 65

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.

Returns FALSE when the iterator is empty, since x IN () is invalid SQL.

Example

Expr::col("status").is_in(["active", "pending"])
// Generates: "status" IN ('active', 'pending')

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

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

NOT IN.

Returns TRUE when the iterator is empty, since x NOT IN () is invalid SQL and logically equivalent to TRUE.

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

where V: Into<SimpleExpr>,

LIKE.

Example

Expr::col("name").like("%john%")
// Generates: "name" LIKE '%john%'

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.

SQL wildcard characters (%, _) and the escape character (\) in user input are escaped before constructing the pattern. The generated SQL includes an explicit ESCAPE '\' clause so that the backslash escaping is portable across all backends (including SQLite, which does not treat \ as an escape character by default).

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

where S: Into<String>,

Helper for LIKE with suffix wildcard.

SQL wildcard characters (%, _) and the escape character (\) in user input are escaped before constructing the pattern. The generated SQL includes an explicit ESCAPE '\' clause for cross-backend portability.

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

where S: Into<String>,

Helper for LIKE with both wildcards.

SQL wildcard characters (%, _) and the escape character (\) in user input are escaped before constructing the pattern. The generated SQL includes an explicit ESCAPE '\' clause for cross-backend portability.

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.

Example

Expr::col("age").cast_as("TEXT")
// Generates: CAST("age" AS TEXT)

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

where T: IntoIden,

AS ENUM expression (PostgreSQL).

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl ExprTrait for Expr

impl ExprTrait for SimpleExpr