Enum Expr 

pub enum Expr {
    Column(Column),
    Value(Value),
    Binary {
        op: BinaryOp,
        lhs: Box<Expr>,
        rhs: Box<Expr>,
    },
    Unary {
        op: UnaryOp,
        expr: Box<Expr>,
    },
    And(Vec<Expr>),
    Or(Vec<Expr>),
    Lookup {
        expr: Box<Expr>,
        lookup: Lookup,
    },
    Exists(Box<QueryPlan>),
    Subquery(Box<QueryPlan>),
    Func {
        func: Function,
        args: Vec<Expr>,
    },
    Cast {
        expr: Box<Expr>,
        ty: SqlType,
    },
    Case {
        branches: Vec<(Expr, Expr)>,
        otherwise: Option<Box<Expr>>,
    },
    Aggregate(Aggregate),
    Window(Box<Window>),
    DatePart {
        part: DatePart,
        expr: Box<Expr>,
    },
    OuterRef(Column),
    Related(RelatedColumn),
}

Expression tree node.

Variants

Column(Column)

Column reference (Django F).

Value(Value)

Literal, always bound as a parameter.

Binary

Binary operation.

Fields

op: BinaryOp

Operator.

lhs: Box<Expr>

Left operand.

rhs: Box<Expr>

Right operand.

Unary

Unary operation.

Fields

op: UnaryOp

Operator.

expr: Box<Expr>

Operand.

And(Vec<Expr>)

Conjunction of all children (empty = TRUE).

Or(Vec<Expr>)

Disjunction of all children (empty = FALSE).

Lookup

Lookup applied to an expression.

Fields

expr: Box<Expr>

Target expression.

lookup: Lookup

Lookup.

Exists(Box<QueryPlan>)

EXISTS (subquery).

Subquery(Box<QueryPlan>)

Scalar subquery.

Func

Scalar function call.

Fields

func: Function

Function.

args: Vec<Expr>

Arguments.

Cast

CAST(expr AS type).

Fields

expr: Box<Expr>

Operand.

ty: SqlType

Target type family.

Case

Searched CASE WHEN .. THEN .. [ELSE ..] END.

Fields

branches: Vec<(Expr, Expr)>

(condition, result) branches, tried in order.

otherwise: Option<Box<Expr>>

ELSE result (NULL when absent).

Aggregate(Aggregate)

Aggregate function (COUNT, SUM, …).

Window(Box<Window>)

Window function with its OVER (..) clause.

DatePart

Date or time component of a temporal expression.

Fields

part: DatePart

Component to extract.

expr: Box<Expr>

Temporal operand.

OuterRef(Column)

Column of the enclosing query, used inside a correlated subquery.

Related(RelatedColumn)

Column reached through foreign keys; resolved into joins by QueryPlan::resolve_relations.

Implementations

impl Expr

pub fn year(self) -> Expr

The Year component of a temporal expression.

pub fn month(self) -> Expr

The Month component of a temporal expression.

pub fn day(self) -> Expr

The Day component of a temporal expression.

pub fn week(self) -> Expr

The Week component of a temporal expression.

pub fn quarter(self) -> Expr

The Quarter component of a temporal expression.

pub fn hour(self) -> Expr

The Hour component of a temporal expression.

pub fn minute(self) -> Expr

The Minute component of a temporal expression.

pub fn second(self) -> Expr

The Second component of a temporal expression.

pub fn date(self) -> Expr

The Date component of a temporal expression.

impl Expr

pub fn col(name: impl Into<Ident>) -> Self

Column expression on the root source.

pub fn val(v: impl Into<Value>) -> Self

Literal value expression.

pub fn outer(name: impl Into<Ident>) -> Self

Reference to a column of the enclosing query (Django OuterRef).

pub fn exists(plan: QueryPlan) -> Self

EXISTS (plan).

pub fn subquery(plan: QueryPlan) -> Self

Scalar subquery: plan must select exactly one column and one row.

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

self = rhs. A NULL right-hand side compiles to IS NULL.

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

self <> rhs. A NULL right-hand side compiles to IS NOT NULL.

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

self < rhs.

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

self <= rhs.

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

self > rhs.

pub fn ge(self, rhs: impl Into<Expr>) -> Self

self >= rhs.

pub fn and(self, rhs: Expr) -> Self

Logical AND; flattens nested ANDs.

pub fn or(self, rhs: Expr) -> Self

Logical OR; flattens nested ORs.

pub fn is_in<I, V>(self, values: I) -> Self

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

Membership test.

pub fn in_subquery(self, plan: QueryPlan) -> Self

Membership in the single column selected by plan.

pub fn range(self, lo: impl Into<Value>, hi: impl Into<Value>) -> Self

Inclusive range.

pub fn is_null(self, yes: bool) -> Self

IS NULL / IS NOT NULL.

pub fn iexact(self, v: impl Into<Value>) -> Self

Case-insensitive equality (text).

pub fn regex(self, pattern: impl Into<String>) -> Self

Regex match (requires Feature::Regex).

pub fn cast(self, ty: SqlType) -> Self

CAST(self AS ty).

pub fn date_part(self, part: DatePart) -> Self

Extract a date or time component.

pub fn asc(self) -> OrderExpr

Ascending ordering term.

pub fn desc(self) -> OrderExpr

Descending ordering term.

pub fn children(&self) -> Vec<&Expr>

Direct sub-expressions (subquery plans are reached through subplan instead).

pub fn children_mut(&mut self) -> Vec<&mut Expr>

Mutable counterpart of children.

pub fn subplan(&self) -> Option<&QueryPlan>

The nested query of EXISTS, a scalar subquery or IN (subquery).

pub fn subplan_mut(&mut self) -> Option<&mut QueryPlan>

Mutable counterpart of subplan.

pub fn contains_aggregate(&self) -> bool

Whether this expression computes an aggregate over the query’s rows (so a filter on it belongs in HAVING). Aggregates inside window functions and subqueries do not count.

pub fn contains_window(&self) -> bool

Whether this expression contains a window function.

impl Expr

pub fn has_foreign_origin(&self, origin: PlanOrigin) -> bool

Whether a subquery inside this expression was built against a database other than origin.

pub fn required_features(&self) -> Vec<Feature>

Features this expression (including nested subqueries) needs.

Trait Implementations

impl<R: Into<Expr>> Add<R> for Expr

type Output = Expr

The resulting type after applying the + operator.

fn add(self, rhs: R) -> Expr

Performs the + operation.

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<R: Into<Expr>> Div<R> for Expr

type Output = Expr

The resulting type after applying the / operator.

fn div(self, rhs: R) -> Expr

Performs the / operation.

impl From<Aggregate> for Expr

fn from(agg: Aggregate) -> Self

Converts to this type from the input type.

impl<M, T> From<Calc<M, T>> for Expr

fn from(c: Calc<M, T>) -> Self

Converts to this type from the input type.

impl<M, T> From<Field<M, T>> for Expr

fn from(f: Field<M, T>) -> Self

Converts to this type from the input type.

impl<M, T> From<Joined<M, T>> for Expr

fn from(j: Joined<M, T>) -> Self

Converts to this type from the input type.

impl<T: Into<Value>> From<T> for Expr

fn from(v: T) -> Self

Converts to this type from the input type.

impl From<Window> for Expr

fn from(window: Window) -> Self

Converts to this type from the input type.

impl<R: Into<Expr>> Mul<R> for Expr

type Output = Expr

The resulting type after applying the * operator.

fn mul(self, rhs: R) -> Expr

Performs the * operation.

impl Neg for Expr

type Output = Expr

The resulting type after applying the - operator.

fn neg(self) -> Expr

Performs the unary - operation.

impl Not for Expr

type Output = Expr

The resulting type after applying the ! operator.

fn not(self) -> Expr

Performs the unary ! operation.

impl PartialEq for Expr

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

Equality operator ==.

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

Inequality operator !=.

impl<R: Into<Expr>> Rem<R> for Expr

type Output = Expr

The resulting type after applying the % operator.

fn rem(self, rhs: R) -> Expr

Performs the % operation.

impl StructuralPartialEq for Expr

impl<R: Into<Expr>> Sub<R> for Expr

type Output = Expr

The resulting type after applying the - operator.

fn sub(self, rhs: R) -> Expr

Performs the - operation.