Enum Expr 

pub enum Expr {
    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),
}

An expression.

Variants

And(ExprAnd)

AND a set of binary expressions

Any(ExprAny)

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

Arg(ExprArg)

An argument when the expression is a function body

BinaryOp(ExprBinaryOp)

Binary expression

Cast(ExprCast)

Cast an expression to a different type

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 ...).

Func(ExprFunc)

Function call

InList(ExprInList)

In list

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

Not(ExprNot)

Negates a boolean expression

Or(ExprOr)

OR a set of binary expressions

Project(ExprProject)

Project an expression

Record(ExprRecord)

Evaluates to a tuple value

Reference(ExprReference)

Reference a value from within the statement itself.

List(ExprList)

A list of expressions of the same type

Stmt(ExprStmt)

Evaluate a sub-statement

Value(Value)

Evaluates to a constant value reference

Implementations

impl Expr

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

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

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

impl Expr

pub const TRUE: Expr

pub const FALSE: Expr

pub const DEFAULT: Expr = Expr::Default

pub fn null() -> Self

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) -> Self

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

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

pub fn take(&mut self) -> Self

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

impl Expr

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

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

impl Expr

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

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>) -> Self

impl Expr

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

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

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<Self>, rhs: impl Into<Self>) -> Self

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

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

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

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

impl Expr

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

pub fn is_cast(&self) -> bool

impl Expr

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

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<Self>, rhs: impl Into<Self>) -> Self

impl Expr

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

pub fn is_in_subquery(&self) -> bool

impl Expr

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

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

impl Expr

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

impl Expr

pub fn list<T>(items: impl IntoIterator<Item = T>) -> Self

where T: Into<Self>,

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

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<Self>, map: impl Into<Self>) -> Self

pub fn as_map(&self) -> &ExprMap

impl Expr

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

Creates a Match expression that dispatches on subject.

impl Expr

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

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<Self>, rhs: impl Into<Self>) -> Self

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

impl Expr

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

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

pub fn is_project(&self) -> bool

pub fn as_project(&self) -> &ExprProject

impl Expr

pub fn record<T>(items: impl IntoIterator<Item = T>) -> Self

where T: Into<Self>,

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

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>) -> Self

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>) -> Self

Create a reference to a field at a specified nesting level

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

Create a reference to a field one level up

pub fn is_field(&self) -> bool

pub fn ref_parent_model() -> Self

Create a model reference to the parent model

pub fn ref_ancestor_model(nesting: usize) -> Self

Create a model reference to the specified nesting level

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

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>) -> Self

impl Expr

pub fn count_star() -> Self

impl Expr

pub fn last_insert_id() -> Self

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl<'a> From<&'a Expr> for Entry<'a>

fn from(value: &'a Expr) -> Self

Converts to this type from the input type.

impl From<&ExprColumn> for Expr

fn from(value: &ExprColumn) -> Self

Converts to this type from the input type.

impl From<&ExprReference> for Expr

fn from(value: &ExprReference) -> Self

Converts to this type from the input type.

impl From<&String> for Expr

fn from(value: &String) -> Self

Converts to this type from the input type.

impl From<&i64> for Expr

fn from(value: &i64) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut Expr> for EntryMut<'a>

fn from(value: &'a mut Expr) -> Self

Converts to this type from the input type.

impl From<&str> for Expr

fn from(value: &str) -> Self

Converts to this type from the input type.

impl<E1, E2> From<(E1, E2)> for Expr

where E1: Into<Self>, E2: Into<Self>,

fn from(value: (E1, E2)) -> Self

Converts to this type from the input type.

impl<'a> From<Entry<'a>> for Expr

fn from(value: Entry<'a>) -> Self

Converts to this type from the input type.

impl From<Expr> for Returning

fn from(value: Expr) -> Self

Converts to this type from the input type.

impl From<Expr> for Values

fn from(value: Expr) -> Self

Converts to this type from the input type.

impl From<ExprAnd> for Expr

fn from(value: ExprAnd) -> Self

Converts to this type from the input type.

impl From<ExprAny> for Expr

fn from(value: ExprAny) -> Self

Converts to this type from the input type.

impl From<ExprArg> for Expr

fn from(value: ExprArg) -> Self

Converts to this type from the input type.

impl From<ExprBinaryOp> for Expr

fn from(value: ExprBinaryOp) -> Self

Converts to this type from the input type.

impl From<ExprCast> for Expr

fn from(value: ExprCast) -> Self

Converts to this type from the input type.

impl From<ExprColumn> for Expr

fn from(value: ExprColumn) -> Self

Converts to this type from the input type.

impl From<ExprError> for Expr

fn from(value: ExprError) -> Self

Converts to this type from the input type.

impl From<ExprExists> for Expr

fn from(value: ExprExists) -> Self

Converts to this type from the input type.

impl From<ExprFunc> for Expr

fn from(value: ExprFunc) -> Self

Converts to this type from the input type.

impl From<ExprInList> for Expr

fn from(value: ExprInList) -> Self

Converts to this type from the input type.

impl From<ExprInSubquery> for Expr

fn from(value: ExprInSubquery) -> Self

Converts to this type from the input type.

impl From<ExprIsNull> for Expr

fn from(value: ExprIsNull) -> Self

Converts to this type from the input type.

impl From<ExprIsVariant> for Expr

fn from(value: ExprIsVariant) -> Self

Converts to this type from the input type.

impl From<ExprLet> for Expr

fn from(value: ExprLet) -> Self

Converts to this type from the input type.

impl From<ExprList> for Expr

fn from(value: ExprList) -> Self

Converts to this type from the input type.

impl From<ExprMap> for Expr

fn from(value: ExprMap) -> Self

Converts to this type from the input type.

impl From<ExprMatch> for Expr

fn from(value: ExprMatch) -> Self

Converts to this type from the input type.

impl From<ExprNot> for Expr

fn from(value: ExprNot) -> Self

Converts to this type from the input type.

impl From<ExprOr> for Expr

fn from(value: ExprOr) -> Self

Converts to this type from the input type.

impl From<ExprProject> for Expr

fn from(value: ExprProject) -> Self

Converts to this type from the input type.

impl From<ExprRecord> for Expr

fn from(value: ExprRecord) -> Self

Converts to this type from the input type.

impl From<ExprReference> for Expr

fn from(value: ExprReference) -> Self

Converts to this type from the input type.

impl From<ExprStmt> for Expr

fn from(value: ExprStmt) -> Self

Converts to this type from the input type.

impl From<FuncCount> for Expr

fn from(value: FuncCount) -> Self

Converts to this type from the input type.

impl From<FuncLastInsertId> for Expr

fn from(value: FuncLastInsertId) -> Self

Converts to this type from the input type.

impl From<Insert> for Expr

fn from(value: Insert) -> Self

Converts to this type from the input type.

impl From<String> for Expr

fn from(value: String) -> Self

Converts to this type from the input type.

impl From<Value> for Expr

fn from(value: Value) -> Self

Converts to this type from the input type.

impl From<Vec<Expr>> for Expr

fn from(value: Vec<Self>) -> Self

Converts to this type from the input type.

impl From<bool> for Expr

fn from(value: bool) -> Self

Converts to this type from the input type.

impl From<i64> for Expr

fn from(value: i64) -> Self

Converts to this type from the input type.

impl Like<&[Value]> for Expr

fn like(&self, other: &&[Value]) -> bool

Returns true if self matches the pattern other.

impl Like<&[u8]> for Expr

fn like(&self, pattern: &&[u8]) -> bool

Returns true if self matches the pattern other.

impl<const N: usize> Like<&[u8; N]> for Expr

fn like(&self, other: &&[u8; N]) -> bool

Returns true if self matches the pattern other.

impl Like<&String> for Expr

fn like(&self, pattern: &&String) -> bool

Returns true if self matches the pattern other.

impl Like<&str> for Expr

fn like(&self, pattern: &&str) -> bool

Returns true if self matches the pattern other.

impl<const N: usize> Like<[&str; N]> for Expr

fn like(&self, other: &[&str; N]) -> bool

Returns true if self matches the pattern other.

impl<const N: usize> Like<[Value; N]> for Expr

Like implementation for expressions against arrays of Values

fn like(&self, pattern: &[Value; N]) -> bool

Returns true if self matches the pattern other.

impl<T1> Like<(T1,)> for Expr

where Expr: Like<T1>,

fn like(&self, pattern: &(T1,)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2> Like<(T1, T2)> for Expr

where Expr: Like<T1> + Like<T2>,

fn like(&self, pattern: &(T1, T2)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3> Like<(T1, T2, T3)> for Expr

where Expr: Like<T1> + Like<T2> + Like<T3>,

fn like(&self, pattern: &(T1, T2, T3)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4> Like<(T1, T2, T3, T4)> for Expr

where Expr: Like<T1> + Like<T2> + Like<T3> + Like<T4>,

fn like(&self, pattern: &(T1, T2, T3, T4)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5> Like<(T1, T2, T3, T4, T5)> for Expr

where Expr: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5>,

fn like(&self, pattern: &(T1, T2, T3, T4, T5)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5, T6> Like<(T1, T2, T3, T4, T5, T6)> for Expr

where Expr: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5> + Like<T6>,

fn like(&self, pattern: &(T1, T2, T3, T4, T5, T6)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5, T6, T7> Like<(T1, T2, T3, T4, T5, T6, T7)> for Expr

where Expr: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5> + Like<T6> + Like<T7>,

fn like(&self, pattern: &(T1, T2, T3, T4, T5, T6, T7)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5, T6, T7, T8> Like<(T1, T2, T3, T4, T5, T6, T7, T8)> for Expr

where Expr: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5> + Like<T6> + Like<T7> + Like<T8>,

fn like(&self, pattern: &(T1, T2, T3, T4, T5, T6, T7, T8)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9> Like<(T1, T2, T3, T4, T5, T6, T7, T8, T9)> for Expr

where Expr: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5> + Like<T6> + Like<T7> + Like<T8> + Like<T9>,

fn like(&self, pattern: &(T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Like<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> for Expr

where Expr: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5> + Like<T6> + Like<T7> + Like<T8> + Like<T9> + Like<T10>,

fn like(&self, pattern: &(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Like<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> for Expr

where Expr: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5> + Like<T6> + Like<T7> + Like<T8> + Like<T9> + Like<T10> + Like<T11>,

fn like(&self, pattern: &(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Like<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> for Expr

where Expr: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5> + Like<T6> + Like<T7> + Like<T8> + Like<T9> + Like<T10> + Like<T11> + Like<T12>,

fn like( &self, pattern: &(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), ) -> bool

Returns true if self matches the pattern other.

impl Like<String> for Expr

Like implementation for Expr and String (delegates to PartialEq)

fn like(&self, pattern: &String) -> bool

Returns true if self matches the pattern other.

impl Like<Uuid> for Expr

fn like(&self, other: &Uuid) -> bool

Returns true if self matches the pattern other.

impl Like<Value> for Expr

fn like(&self, other: &Value) -> bool

Returns true if self matches the pattern other.

impl Like<Vec<Value>> for Expr

Like implementation for expressions against Vec patterns

fn like(&self, pattern: &Vec<Value>) -> bool

Returns true if self matches the pattern other.

impl Like<i16> for Expr

Available on crate feature assert-struct only.

fn like(&self, pattern: &i16) -> bool

Returns true if self matches the pattern other.

impl Like<i32> for Expr

Available on crate feature assert-struct only.

fn like(&self, pattern: &i32) -> bool

Returns true if self matches the pattern other.

impl Like<i64> for Expr

Available on crate feature assert-struct only.

fn like(&self, pattern: &i64) -> bool

Returns true if self matches the pattern other.

impl Like<i8> for Expr

Available on crate feature assert-struct only.

fn like(&self, pattern: &i8) -> bool

Returns true if self matches the pattern other.

impl Like<isize> for Expr

Available on crate feature assert-struct only.

fn like(&self, pattern: &isize) -> bool

Returns true if self matches the pattern other.

impl Like<u16> for Expr

Available on crate feature assert-struct only.

fn like(&self, pattern: &u16) -> bool

Returns true if self matches the pattern other.

impl Like<u32> for Expr

Available on crate feature assert-struct only.

fn like(&self, pattern: &u32) -> bool

Returns true if self matches the pattern other.

impl Like<u64> for Expr

Available on crate feature assert-struct only.

fn like(&self, pattern: &u64) -> bool

Returns true if self matches the pattern other.

impl Like<u8> for Expr

Available on crate feature assert-struct only.

fn like(&self, pattern: &u8) -> bool

Returns true if self matches the pattern other.

impl Like<usize> for Expr

Available on crate feature assert-struct only.

fn like(&self, pattern: &usize) -> bool

Returns true if self matches the pattern other.

impl Node for Expr

fn visit<V: Visit>(&self, visit: V)

fn visit_mut<V: VisitMut>(&mut self, visit: V)

impl PartialEq<&str> for Expr

PartialEq<&str> for Expr

fn eq(&self, other: &&str) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0> PartialEq<(T0,)> for Expr

where Expr: PartialEq<T0>, Value: PartialEq<T0>,

fn eq(&self, other: &(T0,)) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0, T1> PartialEq<(T0, T1)> for Expr

where Expr: PartialEq<T0> + PartialEq<T1>, Value: PartialEq<T0> + PartialEq<T1>,

fn eq(&self, other: &(T0, T1)) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0, T1, T2> PartialEq<(T0, T1, T2)> for Expr

where Expr: PartialEq<T0> + PartialEq<T1> + PartialEq<T2>, Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2>,

fn eq(&self, other: &(T0, T1, T2)) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0, T1, T2, T3> PartialEq<(T0, T1, T2, T3)> for Expr

where Expr: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3>, Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3>,

fn eq(&self, other: &(T0, T1, T2, T3)) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0, T1, T2, T3, T4> PartialEq<(T0, T1, T2, T3, T4)> for Expr

where Expr: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4>, Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4>,

fn eq(&self, other: &(T0, T1, T2, T3, T4)) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0, T1, T2, T3, T4, T5> PartialEq<(T0, T1, T2, T3, T4, T5)> for Expr

where Expr: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5>, Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5>,

fn eq(&self, other: &(T0, T1, T2, T3, T4, T5)) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0, T1, T2, T3, T4, T5, T6> PartialEq<(T0, T1, T2, T3, T4, T5, T6)> for Expr

where Expr: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6>, Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6>,

fn eq(&self, other: &(T0, T1, T2, T3, T4, T5, T6)) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0, T1, T2, T3, T4, T5, T6, T7> PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7)> for Expr

where Expr: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7>, Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7>,

fn eq(&self, other: &(T0, T1, T2, T3, T4, T5, T6, T7)) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> for Expr

where Expr: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7> + PartialEq<T8>, Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7> + PartialEq<T8>,

fn eq(&self, other: &(T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> for Expr

where Expr: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7> + PartialEq<T8> + PartialEq<T9>, Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7> + PartialEq<T8> + PartialEq<T9>,

fn eq(&self, other: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> for Expr

where Expr: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7> + PartialEq<T8> + PartialEq<T9> + PartialEq<T10>, Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7> + PartialEq<T8> + PartialEq<T9> + PartialEq<T10>,

fn eq(&self, other: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> for Expr

where Expr: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7> + PartialEq<T8> + PartialEq<T9> + PartialEq<T10> + PartialEq<T11>, Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7> + PartialEq<T8> + PartialEq<T9> + PartialEq<T10> + PartialEq<T11>,

fn eq(&self, other: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0> PartialEq<Expr> for (T0,)

where Expr: PartialEq<(T0,)>,

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0, T1> PartialEq<Expr> for (T0, T1)

where Expr: PartialEq<(T0, T1)>,

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0, T1, T2> PartialEq<Expr> for (T0, T1, T2)

where Expr: PartialEq<(T0, T1, T2)>,

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0, T1, T2, T3> PartialEq<Expr> for (T0, T1, T2, T3)

where Expr: PartialEq<(T0, T1, T2, T3)>,

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0, T1, T2, T3, T4> PartialEq<Expr> for (T0, T1, T2, T3, T4)

where Expr: PartialEq<(T0, T1, T2, T3, T4)>,

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0, T1, T2, T3, T4, T5> PartialEq<Expr> for (T0, T1, T2, T3, T4, T5)

where Expr: PartialEq<(T0, T1, T2, T3, T4, T5)>,

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0, T1, T2, T3, T4, T5, T6> PartialEq<Expr> for (T0, T1, T2, T3, T4, T5, T6)

where Expr: PartialEq<(T0, T1, T2, T3, T4, T5, T6)>,

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0, T1, T2, T3, T4, T5, T6, T7> PartialEq<Expr> for (T0, T1, T2, T3, T4, T5, T6, T7)

where Expr: PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7)>,

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> PartialEq<Expr> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

where Expr: PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>,

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> PartialEq<Expr> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

where Expr: PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>,

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> PartialEq<Expr> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where Expr: PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>,

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> PartialEq<Expr> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where Expr: PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>,

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Expr> for i16

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Expr> for i32

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Expr> for i64

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Expr> for i8

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Expr> for u16

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Expr> for u32

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Expr> for u64

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Expr> for u8

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<String> for Expr

PartialEq for Expr

fn eq(&self, other: &String) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<bool> for Expr

PartialEq implementation for Expr and primitive type

fn eq(&self, other: &bool) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i16> for Expr

fn eq(&self, other: &i16) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i32> for Expr

fn eq(&self, other: &i32) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i64> for Expr

fn eq(&self, other: &i64) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i8> for Expr

fn eq(&self, other: &i8) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<str> for Expr

PartialEq for Expr

fn eq(&self, other: &str) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u16> for Expr

fn eq(&self, other: &u16) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u32> for Expr

fn eq(&self, other: &u32) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u64> for Expr

fn eq(&self, other: &u64) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u8> for Expr

fn eq(&self, other: &u8) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for Expr

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Project for &Expr

fn project(self, projection: &Projection) -> Option<Expr>

impl Project for Expr

fn project(self, projection: &Projection) -> Option<Expr>

impl StructuralPartialEq for Expr