Struct Expression 

pub struct Expression<T> {
    pub template: String,
    pub parameters: Vec<ExpressiveEnum<T>>,
}

Owned expression contains template and Vec of IntoExpressive parameters

Fields

template: String

parameters: Vec<ExpressiveEnum<T>>

Implementations

impl<T> Expression<T>

pub fn new( template: impl Into<String>, parameters: Vec<ExpressiveEnum<T>>, ) -> Expression<T>

Create a new owned expression with template and parameters

pub fn empty() -> Expression<T>

Create an empty expression that renders as “”.

pub fn from_vec(vec: Vec<Expression<T>>, delimiter: &str) -> Expression<T>

Create expression from vector of expressions and a delimiter

See the module-level documentation for examples.

impl<T> Expression<T>

pub fn as_type<U>(self) -> Expression<U>

where T: Into<U> + Send + Clone + 'static, U: Send + 'static,

Explicitly convert this expression to a different type.

Maps all scalar parameters via Into<U>. Useful for crossing type boundaries — e.g. converting Expression<i64> from a typed column operation into Expression<AnySqliteType> so it can be chained with operations on other types.

let price = Column::<i64>::new("price");
price.gt(10)                          // Expression<i64>
    .as_type::<AnySqliteType>()       // Expression<AnySqliteType>
    .eq(false)                        // now bool is accepted

impl<T> Expression<T>

where T: Display + Debug,

pub fn preview(&self) -> String

Trait Implementations

impl<T> Add for Expression<T>

type Output = Expression<T>

The resulting type after applying the + operator.

fn add(self, rhs: Expression<T>) -> <Expression<T> as Add>::Output

Performs the + operation.

impl<T> Clone for Expression<T>

where T: Clone,

fn clone(&self) -> Expression<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Expression<T>

where T: Debug + Display,

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

Formats the value using the given formatter.

impl<T> Div for Expression<T>

type Output = Expression<T>

The resulting type after applying the / operator.

fn div(self, rhs: Expression<T>) -> <Expression<T> as Div>::Output

Performs the / operation.

impl<From> ExpressionMap<From> for Expression<From>

fn map<To>(self) -> Expression<To>

where From: Into<To> + Send + Clone + 'static, To: Send + 'static,

Map this expression to a different type

impl<From, To> ExpressionMapper<From, To> for Expression<From>

fn map_expression(expr: Expression<From>) -> Expression<To>

where From: Into<To> + Send + Clone + 'static, To: Send + 'static,

Convert Expression<From> to Expression<To>

impl<T> Expressive<T> for Expression<T>

where T: Clone,

fn expr(&self) -> Expression<T>

Convert this construct into an Expression<T>.

fn preview(&self) -> String

where T: Debug + Display,

Preview the expression as a formatted string.

impl From<MockSelect> for Expression<Value>

fn from(val: MockSelect) -> Expression<Value>

Converts to this type from the input type.

impl<T> Mul for Expression<T>

type Output = Expression<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Expression<T>) -> <Expression<T> as Mul>::Output

Performs the * operation.

impl<T> OrderByExt<Expression<T>> for Expression<T>

where T: Clone + Send + Sync + 'static,

fn ascending(&self) -> OrderBy<Expression<T>>

Create an ascending order specification

fn descending(&self) -> OrderBy<Expression<T>>

Create a descending order specification

impl<T> Sub for Expression<T>

type Output = Expression<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Expression<T>) -> <Expression<T> as Sub>::Output

Performs the - operation.