Struct Expr 

pub struct Expr<Req, S: SqlType> { /* private fields */ }

A typed SQL expression. Req is the (possibly empty) flat list of tables this expression references — see the module docs and scope::Superset for how that’s checked against a query’s actual scope at the point the expression is used, not at the point it’s built. This is what lets orders::user_id.eq(users::id) be a plain, portable value with no dependency on which query it’ll eventually be used in.

Implementations

impl<Req, S: SqlType> Expr<Req, S>

pub fn decodes_as<S2: SqlType>(self) -> Declared<Req, S2>

States what this expression decodes to, which is what makes it selectable: S was inferred from whatever built the expression, and an inference can contradict the join the query actually has.

Trait Implementations

impl<Req, S: SqlType> Clone for Expr<Req, S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Req, S: SqlType> IntoExpr for Expr<Req, S>

type Sql = S

The SQL type this expression has. An associated type rather than a parameter because every implementor has exactly one — a column its declared type, a literal its leaf type — which is what lets a mismatch report itself as Comparable/AssignsTo rather than as an inference failure on a type nobody wrote.

type Req = Req

fn into_expr(self) -> Expr<Req, S>

impl IntoRowCount for Expr<Nil, Integer>

A prepare!{} placeholder, or any other scope-free Expr of an integer type: bound rather than written, so one prepared query serves every page. Only the two integer types — a page is a number.

fn into_row_count(self) -> RowCount

impl IntoRowCount for Expr<Nil, BigInt>

fn into_row_count(self) -> RowCount

impl<Req, S: SqlType> LabelExt for Expr<Req, S>

fn label<K: LabelKey>(self, _key: K) -> Labeled<K, Self>

impl<Req, S: BoolLike> Not for Expr<Req, S>

!condition, not condition.not(): the standard Not trait reads more naturally at call sites than a same-named inherent method. Implemented for all three spellings .filter takes, each keeping its own type — NOT of a Nullable<Bool> is still nullable, and a sql! fragment stays the same fragment.

type Output = Expr<Req, S>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.