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 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 as_sql(&self) -> &SQL<'a, V>

Get a reference to the inner SQL.

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

pub fn is_subquery(&self) -> bool

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

pub fn sql(&self) -> String

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

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 Named placeholders use :name syntax only for SQLite; PostgreSQL always uses $N

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 write_qualified_columns( &self, buf: &mut impl Write, table: &dyn SQLTableInfo, )

Write fully qualified columns

pub fn params(&self) -> impl Iterator<Item = &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: AggregateKind, 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>

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, N, A, Rhs> BitAnd<Rhs> for SQLExpr<'a, V, Bool, N, A>

where V: SQLParam + 'a, N: Nullability, A: AggregateKind, Rhs: Expr<'a, V>,

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, Bool>

The resulting type after applying the & operator.

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

Performs the & operation.

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

where V: SQLParam + 'a, N: Nullability, A: AggregateKind, Rhs: Expr<'a, V>,

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, Bool>

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<'a, V, T, N, A> Display for SQLExpr<'a, 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: AggregateKind, 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>

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.

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<'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: AggregateKind, 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>

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>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

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

where V: SQLParam + 'a, 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, Bool>

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: AggregateKind, 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>

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: AggregateKind, 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>

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 alias(&self, alias: &'static str) -> SQL<'a, V>