Struct SQLExpr 

pub struct SQLExpr<'a, V: SQLParam, T: DataType, N: Nullability = NonNull, A: AggregateKind = Scalar> { /* private fields */ }

A SQL expression that carries type information.

This wrapper preserves the SQL type through operations, enabling compile-time type checking of SQL expressions.

Type Parameters

• 'a: Lifetime of borrowed data
• V: The dialect’s value type (SQLiteValue, PostgresValue)
• T: The SQL data type marker (Int, Text, etc.)
• N: The nullability marker (NonNull or Null)
• A: The aggregation marker (Scalar or Agg)

Example

use drizzle_core::expr::{SQLExpr, NonNull, Scalar};
use drizzle_core::types::Int;

let expr: SQLExpr<'_, SQLiteValue, Int, NonNull, Scalar> = ...;

Implementations

impl<'a, V: SQLParam, T: DataType, N: Nullability, A: AggregateKind> SQLExpr<'a, V, T, N, A>

pub const fn new(sql: SQL<'a, V>) -> Self

Create a new typed expression from raw SQL.

pub fn into_sql(self) -> SQL<'a, V>

Consume the wrapper and return the inner SQL.

pub fn nullable(self) -> SQLExpr<'a, V, T, Null, A>

Mark this expression as nullable while preserving its SQL type and aggregate kind.

impl<'a, V, T, N> SQLExpr<'a, V, T, N, Agg>

where V: SQLParam + 'a, T: DataType, N: Nullability,

pub fn over(self, spec: WindowSpec<'a, V>) -> SQLExpr<'a, V, T, N, Scalar>

Apply a window specification to this aggregate expression.

Converts the expression from Agg to Scalar, generating <expr> OVER (...).

Example

sum(orders.amount).over(
    window()
        .partition_by([orders.customer_id])
        .order_by([asc(orders.date)])
)

pub fn filter<C>(self, condition: C) -> Self

where C: Expr<'a, V>, C::SQLType: BooleanLike,

Apply a FILTER clause to this aggregate (PostgreSQL extension).

Generates <agg> FILTER (WHERE <condition>).

Methods from Deref<Target = SQL<'a, V>>

pub fn is_subquery(&self) -> bool

Check if this SQL fragment is a subquery (starts with SELECT/WITH).

pub fn sql(&self) -> String

Returns the SQL string with dialect-appropriate placeholders. Uses $1, $2, ... for PostgreSQL, :name or ? for SQLite, ? for MySQL.

pub fn build(&self) -> (String, SmallVec<[&V; 8]>)

Generates the SQL string and collects parameter references in a single pass.

This is the preferred method for driver execution paths since it avoids iterating the chunk list twice (once for sql(), once for params()).

pub fn build_with(&self, style: ParamStyle) -> (String, SmallVec<[&V; 8]>)

Same as build but lets the caller override the placeholder style. Drivers that speak the dialect but bind parameters differently (e.g. AWS Data API on Postgres) use this to emit :1, :2, ... instead of $1, $2, ... without any post-hoc rewriting.

pub fn write_to(&self, buf: &mut impl Write)

Write SQL to a buffer with dialect-appropriate placeholders. Uses $1, $2, ... for PostgreSQL, ? or :name for SQLite, ? for MySQL.

pub fn write_to_with(&self, buf: &mut impl Write, style: ParamStyle)

Same as write_to but with a caller-chosen placeholder style.

pub fn write_chunk_to( &self, buf: &mut impl Write, chunk: &SQLChunk<'a, V>, index: usize, )

Write a single chunk with pattern detection

pub fn params(&self) -> impl Iterator<Item = &V> + use<'_, V>

Returns an iterator over references to parameter values (avoids allocating a Vec - callers can collect if needed)

Trait Implementations

impl<'a, V, T, N, A, Rhs> Add<Rhs> for SQLExpr<'a, V, T, N, A>

where V: SQLParam + 'a, T: ArithmeticOutput<Rhs::SQLType>, N: Nullability + NullOr<Rhs::Nullable>, A: AggOr<Rhs::Aggregate>, Rhs: Expr<'a, V>, Rhs::SQLType: Numeric, Rhs::Nullable: Nullability,

type Output = SQLExpr<'a, V, <T as ArithmeticOutput<<Rhs as Expr<'a, V>>::SQLType>>::Output, <N as NullOr<<Rhs as Expr<'a, V>>::Nullable>>::Output, <A as AggOr<<Rhs as Expr<'a, V>>::Aggregate>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: Rhs) -> Self::Output

Performs the + operation.

impl<'a, V, T, N, A> AsRef<SQL<'a, V>> for SQLExpr<'a, V, T, N, A>

where V: SQLParam, T: DataType, N: Nullability, A: AggregateKind,

Provides reference conversion to inner SQL.

Example

fn takes_sql_ref<'a, V>(sql: &SQL<'a, V>) { ... }
let expr = eq(users.id, 42);
takes_sql_ref(expr.as_ref());

fn as_ref(&self) -> &SQL<'a, V>

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a, V, T, N, A, Rhs> BitAnd<Rhs> for SQLExpr<'a, V, T, N, A>

where V: SQLParam + 'a, T: BooleanLike, N: Nullability + NullOr<Rhs::Nullable>, A: AggOr<Rhs::Aggregate>, Rhs: Expr<'a, V>, Rhs::SQLType: BooleanLike, Rhs::Nullable: Nullability,

Implements expr1 & expr2 for boolean expressions (SQL AND).

Example

let condition = eq(users.active, true) & gt(users.age, 18);
// ("users"."active" = TRUE AND "users"."age" > 18)

type Output = SQLExpr<'a, V, <<V as SQLParam>::DialectMarker as DialectTypes>::Bool, <N as NullOr<<Rhs as Expr<'a, V>>::Nullable>>::Output, <A as AggOr<<Rhs as Expr<'a, V>>::Aggregate>>::Output>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<'a, V, T, N, A, Rhs> BitOr<Rhs> for SQLExpr<'a, V, T, N, A>

where V: SQLParam + 'a, T: BooleanLike, N: Nullability + NullOr<Rhs::Nullable>, A: AggOr<Rhs::Aggregate>, Rhs: Expr<'a, V>, Rhs::SQLType: BooleanLike, Rhs::Nullable: Nullability,

Implements expr1 | expr2 for boolean expressions (SQL OR).

Example

let condition = eq(users.role, "admin") | eq(users.role, "moderator");
// ("users"."role" = 'admin' OR "users"."role" = 'moderator')

type Output = SQLExpr<'a, V, <<V as SQLParam>::DialectMarker as DialectTypes>::Bool, <N as NullOr<<Rhs as Expr<'a, V>>::Nullable>>::Output, <A as AggOr<<Rhs as Expr<'a, V>>::Aggregate>>::Output>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<'a, V: Clone + SQLParam, T: Clone + DataType, N: Clone + Nullability, A: Clone + AggregateKind> Clone for SQLExpr<'a, V, T, N, A>

fn clone(&self) -> SQLExpr<'a, V, T, N, A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, V: Debug + SQLParam, T: Debug + DataType, N: Debug + Nullability, A: Debug + AggregateKind> Debug for SQLExpr<'a, V, T, N, A>

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

Formats the value using the given formatter.

impl<'a, V, T, N, A> Deref for SQLExpr<'a, V, T, N, A>

where V: SQLParam, T: DataType, N: Nullability, A: AggregateKind,

Provides transparent access to inner SQL methods via Deref coercion.

Example

let expr = eq(users.id, 42);
// Access SQL methods directly:
let sql_str = expr.to_string();

type Target = SQL<'a, V>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<V, T, N, A> Display for SQLExpr<'_, V, T, N, A>

where V: SQLParam + Display, T: DataType, N: Nullability, A: AggregateKind,

Display the SQL expression as a string.

Delegates to the inner SQL type’s Display implementation.

Example

let expr = eq(users.id, 42);
println!("{}", expr);  // "users"."id" = 42

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

Formats the value using the given formatter.

impl<'a, V, T, N, A, Rhs> Div<Rhs> for SQLExpr<'a, V, T, N, A>

where V: SQLParam + 'a, T: ArithmeticOutput<Rhs::SQLType>, N: Nullability + NullOr<Rhs::Nullable>, A: AggOr<Rhs::Aggregate>, Rhs: Expr<'a, V>, Rhs::SQLType: Numeric, Rhs::Nullable: Nullability,

type Output = SQLExpr<'a, V, <T as ArithmeticOutput<<Rhs as Expr<'a, V>>::SQLType>>::Output, <N as NullOr<<Rhs as Expr<'a, V>>::Nullable>>::Output, <A as AggOr<<Rhs as Expr<'a, V>>::Aggregate>>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: Rhs) -> Self::Output

Performs the / operation.

impl<'a, V: SQLParam, T: DataType, N: Nullability, A: AggregateKind> Expr<'a, V> for SQLExpr<'a, V, T, N, A>

type SQLType = T

The SQL data type this expression evaluates to.

type Nullable = N

Whether this expression can be NULL.

type Aggregate = A

Whether this is an aggregate (COUNT, SUM) or scalar expression.

fn to_expr_sql(&self) -> SQL<'a, V>

Render this value as a scalar expression by reference.

fn into_expr_sql(self) -> SQL<'a, V>

where Self: Sized,

Render this value as a scalar expression, consuming it when useful.

impl<V: SQLParam, T, N, A> ExprValueType for SQLExpr<'_, V, T, N, A>

where T: DataType + SQLTypeToRust<V::DialectMarker>, N: Nullability + WrapNullable<<T as SQLTypeToRust<V::DialectMarker>>::RustType>, A: AggregateKind,

type ValueType = <N as WrapNullable<<T as SQLTypeToRust<<V as SQLParam>::DialectMarker>>::RustType>>::Output

impl<'a, V: SQLParam, T: DataType, N: Nullability, A: AggregateKind> From<SQLExpr<'a, V, T, N, A>> for SQL<'a, V>

fn from(expr: SQLExpr<'a, V, T, N, A>) -> Self

Converts to this type from the input type.

impl<V: SQLParam, T, N, A> GroupByIdentity for SQLExpr<'_, V, T, N, A>

where T: DataType, N: Nullability, A: AggregateKind,

type Identity = SQLExpr<'_, V, T, N, A>

impl<V, T, N, A> HasAggStatus for SQLExpr<'_, V, T, N, A>

where V: SQLParam, T: DataType, N: Nullability, A: AggToStatus,

type Status = <A as AggToStatus>::Status

impl<V: SQLParam, T, N, A> IntoSelectTarget for SQLExpr<'_, V, T, N, A>

where T: DataType, N: Nullability, A: AggregateKind,

select(typed_expr) → SelectCols<(Expr,)> — single typed expression.

type Marker = SelectCols<(SQLExpr<'_, V, T, N, A>,)>

impl<'a, V, T, N, A, Rhs> Mul<Rhs> for SQLExpr<'a, V, T, N, A>

where V: SQLParam + 'a, T: ArithmeticOutput<Rhs::SQLType>, N: Nullability + NullOr<Rhs::Nullable>, A: AggOr<Rhs::Aggregate>, Rhs: Expr<'a, V>, Rhs::SQLType: Numeric, Rhs::Nullable: Nullability,

type Output = SQLExpr<'a, V, <T as ArithmeticOutput<<Rhs as Expr<'a, V>>::SQLType>>::Output, <N as NullOr<<Rhs as Expr<'a, V>>::Nullable>>::Output, <A as AggOr<<Rhs as Expr<'a, V>>::Aggregate>>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: Rhs) -> Self::Output

Performs the * operation.

impl<'a, V, T, N, A> Neg for SQLExpr<'a, V, T, N, A>

where V: SQLParam + 'a, T: Numeric, N: Nullability, A: AggregateKind,

type Output = SQLExpr<'a, V, T, N, A>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a, V, T, N, A> Not for SQLExpr<'a, V, T, N, A>

where V: SQLParam + 'a, T: BooleanLike, N: Nullability, A: AggregateKind,

Implements !expr for boolean expressions (SQL NOT).

Example

let condition = eq(users.active, true);
let negated = !condition;  // NOT "users"."active" = TRUE

type Output = SQLExpr<'a, V, <<V as SQLParam>::DialectMarker as DialectTypes>::Bool, N, A>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<'a, V, T, N, A, Rhs> Rem<Rhs> for SQLExpr<'a, V, T, N, A>

where V: SQLParam + 'a, T: ArithmeticOutput<Rhs::SQLType>, N: Nullability + NullOr<Rhs::Nullable>, A: AggOr<Rhs::Aggregate>, Rhs: Expr<'a, V>, Rhs::SQLType: Numeric, Rhs::Nullable: Nullability,

type Output = SQLExpr<'a, V, <T as ArithmeticOutput<<Rhs as Expr<'a, V>>::SQLType>>::Output, <N as NullOr<<Rhs as Expr<'a, V>>::Nullable>>::Output, <A as AggOr<<Rhs as Expr<'a, V>>::Aggregate>>::Output>

The resulting type after applying the % operator.

fn rem(self, rhs: Rhs) -> Self::Output

Performs the % operation.

impl<'a, V, T, N, A, Rhs> Sub<Rhs> for SQLExpr<'a, V, T, N, A>

where V: SQLParam + 'a, T: ArithmeticOutput<Rhs::SQLType>, N: Nullability + NullOr<Rhs::Nullable>, A: AggOr<Rhs::Aggregate>, Rhs: Expr<'a, V>, Rhs::SQLType: Numeric, Rhs::Nullable: Nullability,

type Output = SQLExpr<'a, V, <T as ArithmeticOutput<<Rhs as Expr<'a, V>>::SQLType>>::Output, <N as NullOr<<Rhs as Expr<'a, V>>::Nullable>>::Output, <A as AggOr<<Rhs as Expr<'a, V>>::Aggregate>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: Rhs) -> Self::Output

Performs the - operation.

impl<'a, V: SQLParam, T: DataType, N: Nullability, A: AggregateKind> ToSQL<'a, V> for SQLExpr<'a, V, T, N, A>

fn to_sql(&self) -> SQL<'a, V>

fn into_sql(self) -> SQL<'a, V>

Consume self and return SQL without cloning. Default delegates to to_sql() (which clones). Types that own their SQL (like SQL and SQLExpr) override this to avoid the clone.