Enum Expr 

#[non_exhaustive]
pub enum Expr {
    Column(ColumnRef),
    Value(Value),
    Tuple(Vec<Expr>),
    Binary(Box<Expr>, BinOp, Box<Expr>),
    Not(Box<Expr>),
    Neg(Box<Expr>),
    IsNull(Box<Expr>),
    IsNotNull(Box<Expr>),
    In(Box<Expr>, Box<Expr>),
    NotIn(Box<Expr>, Box<Expr>),
    Between(Box<Expr>, Box<Expr>, Box<Expr>),
    NotBetween(Box<Expr>, Box<Expr>, Box<Expr>),
    Like {
        expr: Box<Expr>,
        pattern: Box<Expr>,
        negated: bool,
        escape: Option<char>,
    },
    Func(Func),
    Subquery(Box<Select>),
    Exists(Box<Select>),
    Case(Vec<(Expr, Expr)>, Option<Box<Expr>>),
    Cast(Box<Expr>, &'static str),
    Alias(Box<Expr>, Ident),
    Raw(String, Vec<Value>),
    Paren(Box<Expr>),
}

A SQL expression.

The enum is #[non_exhaustive] so that new node kinds can be added without breaking downstream matches; construct nodes through the associated functions and methods rather than the variants directly.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Column(ColumnRef)

A column reference.

Value(Value)

A bound value.

Tuple(Vec<Expr>)

A parenthesised list of expressions, for example the right-hand side of IN.

Binary(Box<Expr>, BinOp, Box<Expr>)

A binary operation lhs op rhs.

Not(Box<Expr>)

A logical negation NOT expr.

Neg(Box<Expr>)

An arithmetic negation -expr.

IsNull(Box<Expr>)

The expr IS NULL test.

IsNotNull(Box<Expr>)

The expr IS NOT NULL test.

In(Box<Expr>, Box<Expr>)

The expr IN (...) membership test.

NotIn(Box<Expr>, Box<Expr>)

The expr NOT IN (...) membership test.

Between(Box<Expr>, Box<Expr>, Box<Expr>)

The expr BETWEEN a AND b range test.

NotBetween(Box<Expr>, Box<Expr>, Box<Expr>)

The expr NOT BETWEEN a AND b range test.

Like

A pattern test expr [NOT] LIKE pattern [ESCAPE 'c'].

The escape character is carried on the node because SQLite treats a backslash in a pattern literally unless the statement says otherwise; the contains family sets it so that % and _ in user input match themselves.

Fields

expr: Box<Expr>

The tested expression.

pattern: Box<Expr>

The pattern, normally a bound value.

negated: bool

Whether the test is NOT LIKE.

escape: Option<char>

The ESCAPE character, when the pattern uses one.

Func(Func)

A function call name(args).

Subquery(Box<Select>)

A scalar subquery (SELECT ...).

Exists(Box<Select>)

An existence test EXISTS (SELECT ...).

Case(Vec<(Expr, Expr)>, Option<Box<Expr>>)

A CASE WHEN ... THEN ... ELSE ... END expression.

Cast(Box<Expr>, &'static str)

A type conversion CAST(expr AS type).

Alias(Box<Expr>, Ident)

An aliased expression expr AS alias, only meaningful in select lists.

Raw(String, Vec<Value>)

Raw SQL inserted verbatim, with ? placeholders for the values carried in .1.

Paren(Box<Expr>)

An explicitly parenthesised expression (expr).

Implementations

impl Expr

pub fn col(column: impl Into<ColumnRef>) -> Expr

A column reference, from "name" or ("table", "name").

pub fn val(value: impl Into<Value>) -> Expr

A bound value.

pub fn tuple<V>(values: impl IntoIterator<Item = V>) -> Expr

where V: Into<Value>,

A tuple of bound values.

pub fn subquery(select: Select) -> Expr

A scalar subquery.

pub fn exists(select: Select) -> Expr

An EXISTS (subquery) test.

pub fn cust(sql: impl Into<String>) -> Expr

Raw SQL with ? placeholders and no values.

pub fn cust_with_values<V>( sql: impl Into<String>, values: impl IntoIterator<Item = V>, ) -> Expr

where V: Into<Value>,

Raw SQL with ? placeholders and the values that fill them, in order.

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

Builds self = rhs.

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

Builds self <> rhs.

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

Builds self < rhs.

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

Builds self <= rhs.

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

Builds self > rhs.

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

Builds self >= rhs.

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

Builds self AND rhs.

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

Builds self OR rhs.

pub fn not(self) -> Expr

Builds NOT self.

pub fn neg(self) -> Expr

Builds -self.

pub fn is_null(self) -> Expr

Builds self IS NULL.

pub fn is_not_null(self) -> Expr

Builds self IS NOT NULL.

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

Builds self IS rhs, the null-safe equality.

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

Builds self IS NOT rhs.

pub fn like(self, pattern: impl Into<Value>) -> Expr

Builds self LIKE pattern, binding the pattern as a parameter.

The pattern is taken as written: % and _ are wildcards and no ESCAPE clause is emitted. See like_escaped for a pattern that needs one.

pub fn not_like(self, pattern: impl Into<Value>) -> Expr

Builds self NOT LIKE pattern, binding the pattern as a parameter.

pub fn like_escaped(self, pattern: impl Into<Value>, escape: char) -> Expr

Builds self LIKE pattern ESCAPE 'escape', for a pattern in which escape precedes every wildcard that must match literally.

pub fn matches(self, query: impl Into<Value>) -> Expr

Builds self MATCH query for full-text search, binding the query as a parameter.

pub fn is_in<V>(self, values: impl IntoIterator<Item = V>) -> Expr

where V: Into<Value>,

Builds self IN (values).

An empty list renders as IN (NULL), which matches nothing, so a filter built from an empty collection behaves as expected instead of producing a syntax error.

pub fn is_not_in<V>(self, values: impl IntoIterator<Item = V>) -> Expr

where V: Into<Value>,

Builds self NOT IN (values).

pub fn in_subquery(self, select: Select) -> Expr

Builds self IN (subquery).

pub fn not_in_subquery(self, select: Select) -> Expr

Builds self NOT IN (subquery).

pub fn between(self, a: impl Into<Expr>, b: impl Into<Expr>) -> Expr

Builds self BETWEEN a AND b.

pub fn not_between(self, a: impl Into<Expr>, b: impl Into<Expr>) -> Expr

Builds self NOT BETWEEN a AND b.

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

Builds self + rhs.

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

Builds self - rhs.

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

Builds self * rhs.

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

Builds self / rhs.

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

Builds self % rhs.

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

Builds self || rhs.

pub fn json_get(self, path: impl Into<Value>) -> Expr

Builds self -> path, JSON extraction keeping the JSON representation.

pub fn json_get_text(self, path: impl Into<Value>) -> Expr

Builds self ->> path, JSON extraction yielding a SQL value.

pub fn cast_as(self, ty: &'static str) -> Expr

Builds CAST(self AS type).

pub fn alias(self, alias: impl IntoIden) -> Expr

Builds self AS alias.

pub fn paren(self) -> Expr

Builds (self).

pub fn case(whens: Vec<(Expr, Expr)>, otherwise: Option<Expr>) -> Expr

Builds CASE WHEN ... THEN ... ELSE ... END.

pub fn contains(self, s: &str) -> Expr

Builds self LIKE '%s%' ESCAPE '\\', with %, _ and \\ escaped in s so that the fragment matches literally.

pub fn starts_with(self, s: &str) -> Expr

Builds self LIKE 's%' ESCAPE '\\', with %, _ and \\ escaped in s so that the fragment matches literally.

pub fn ends_with(self, s: &str) -> Expr

Builds self LIKE '%s' ESCAPE '\\', with %, _ and \\ escaped in s so that the fragment matches literally.

Trait Implementations

impl Build for Expr

fn to_statement(&self) -> Statement

Renders into a Statement.

fn build(&self) -> (String, Vec<Value>)

Renders to the SQL text and the values to bind.

fn to_string_inlined(&self) -> String

Renders with literals inlined, for logs and tests only.

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<(), Error>

Formats the value using the given formatter.

impl<T> From<T> for Expr

where T: Into<Value>,

fn from(value: T) -> Expr

Converts to this type from the input type.

impl IntoCondition for Expr

fn into_condition(self) -> Condition

Converts into a condition.

impl PartialEq for Expr

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Expr