Struct Expr 

pub struct Expr(/* private fields */);

Available on native and crate feature database only.

Expression builder for creating SQL expressions.

Expr provides static methods to create expressions and instance methods to chain operations on them.

Example

use reinhardt_query::Expr;

// Simple column reference
let col = Expr::col("name");

// Value expression
let val = Expr::val(42);

// Build complex expressions
let expr = Expr::col("age").gte(18).and(Expr::col("active").eq(true));

Implementations

impl Expr

pub fn col<C>(col: C) -> Expr

where C: IntoColumnRef,

Create an expression from a column reference.

Example

use reinhardt_query::expr::Expr;

let expr = Expr::col("name");

pub fn tbl<T, C>(table: T, col: C) -> Expr

where T: IntoIden, C: IntoIden,

Create a table-qualified column expression.

Example

use reinhardt_query::expr::Expr;

let expr = Expr::tbl("users", "name");

pub fn val<V>(val: V) -> Expr

where V: IntoValue,

Create a value expression.

Example

use reinhardt_query::expr::Expr;

let expr = Expr::val(42);
let expr2 = Expr::val("hello");

pub fn cust<S>(sql: S) -> Expr

where S: Into<String>,

Create a custom SQL expression.

Security Warning

DO NOT pass user input directly to this method. This method embeds the SQL string directly into the query without parameterization, which can lead to SQL injection vulnerabilities.

Use Expr::cust_with_values() for dynamic values instead.

Examples

use reinhardt_query::expr::Expr;

// ✅ SAFE: Static SQL expression
let expr = Expr::cust("NOW()");

// ❌ UNSAFE: User input
// let expr = Expr::cust(&user_input);

// ✅ SAFE: Parameterized custom expression
// let expr = Expr::cust_with_values("? + ?", [user_input, other_value]);

pub fn cust_with_values<S, I, V>(sql: S, values: I) -> Expr

where S: Into<String>, I: IntoIterator<Item = V>, V: Into<SimpleExpr>,

Create a custom SQL expression with value placeholders.

Use ? as placeholders for the values.

Example

use reinhardt_query::expr::Expr;

let expr = Expr::cust_with_values("? + ?", [1, 2]);

pub fn tuple<I>(exprs: I) -> Expr

where I: IntoIterator<Item = Expr>,

Create a tuple expression.

Example

use reinhardt_query::expr::Expr;

let expr = Expr::tuple([Expr::val(1), Expr::val(2), Expr::val(3)]);

pub fn asterisk() -> Expr

Create an asterisk expression (*).

Example

use reinhardt_query::expr::Expr;

let expr = Expr::asterisk();

pub fn subquery(select: SelectStatement) -> Expr

Create a subquery expression.

This creates a standalone subquery that can be used in FROM or SELECT clauses.

Example

use reinhardt_query::prelude::*;

let subquery = Query::select().column("id").from("users");
let expr = Expr::subquery(subquery);

pub fn exists(select: SelectStatement) -> Expr

Create an EXISTS subquery expression.

Example

use reinhardt_query::prelude::*;

let subquery = Query::select().column("id").from("orders").and_where(
    Expr::col(("orders", "user_id")).eq(Expr::col(("users", "id")))
);
let exists = Expr::exists(subquery);

pub fn not_exists(select: SelectStatement) -> Expr

Create a NOT EXISTS subquery expression.

Example

use reinhardt_query::prelude::*;

let subquery = Query::select().column("id").from("banned_users").and_where(
    Expr::col(("banned_users", "id")).eq(Expr::col(("users", "id")))
);
let not_exists = Expr::not_exists(subquery);

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

Create an IN subquery expression.

Example

use reinhardt_query::prelude::*;

let subquery = Query::select().column("user_id").from("premium_users");
let in_expr = Expr::col("id").in_subquery(subquery);

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

Create a NOT IN subquery expression.

Example

use reinhardt_query::prelude::*;

let subquery = Query::select().column("user_id").from("banned_users");
let not_in_expr = Expr::col("id").not_in_subquery(subquery);

pub fn case() -> CaseExprBuilder

Create a CASE expression.

Example

use reinhardt_query::expr::{Expr, ExprTrait};

let case = Expr::case()
    .when(Expr::col("status").eq("active"), "Active")
    .when(Expr::col("status").eq("pending"), "Pending")
    .else_result("Unknown");

pub fn value<V>(val: V) -> Expr

where V: IntoValue,

Create a value expression (alias for Expr::val).

pub fn expr_col(col: Arc<dyn Iden>) -> Expr

Create an expression from a DynIden column.

pub fn null() -> Expr

Create a NULL constant expression.

pub fn constant_true() -> Expr

Create a TRUE constant expression.

pub fn constant_false() -> Expr

Create a FALSE constant expression.

pub fn default() -> Expr

Create a DEFAULT constant expression.

pub fn current_timestamp() -> Expr

Create a CURRENT_TIMESTAMP expression.

pub fn current_date() -> Expr

Create a CURRENT_DATE expression.

pub fn current_time() -> Expr

Create a CURRENT_TIME expression.

pub fn over(self, window: WindowStatement) -> SimpleExpr

Apply a window specification to this expression.

This creates a window function call with an inline window specification.

Examples

use reinhardt_query::prelude::*;
use reinhardt_query::types::window::WindowStatement;

let window = WindowStatement {
    partition_by: vec![Expr::col("department_id").into_simple_expr()],
    order_by: vec![],
    frame: None,
};

let expr = Expr::row_number().over(window);

pub fn over_named<T>(self, name: T) -> SimpleExpr

where T: IntoIden,

Apply a named window to this expression.

This creates a window function call that references a named window defined in the WINDOW clause.

Examples

use reinhardt_query::prelude::*;

let expr = Expr::row_number().over_named("w");

pub fn row_number() -> Expr

Create a ROW_NUMBER() window function.

Returns a sequential number for each row within a partition.

Examples

use reinhardt_query::prelude::*;
use reinhardt_query::types::window::WindowStatement;

let window = WindowStatement {
    partition_by: vec![],
    order_by: vec![],
    frame: None,
};

let expr = Expr::row_number().over(window);

pub fn rank() -> Expr

Create a RANK() window function.

Returns the rank of each row within a partition, with gaps in ranking for tied values.

Examples

use reinhardt_query::prelude::*;
use reinhardt_query::types::window::WindowStatement;

let window = WindowStatement {
    partition_by: vec![],
    order_by: vec![],
    frame: None,
};

let expr = Expr::rank().over(window);

pub fn dense_rank() -> Expr

Create a DENSE_RANK() window function.

Returns the rank of each row within a partition, without gaps in ranking for tied values.

Examples

use reinhardt_query::prelude::*;
use reinhardt_query::types::window::WindowStatement;

let window = WindowStatement {
    partition_by: vec![],
    order_by: vec![],
    frame: None,
};

let expr = Expr::dense_rank().over(window);

pub fn ntile(buckets: i64) -> Expr

Create an NTILE(n) window function.

Divides the rows in a partition into buckets number of groups.

Examples

use reinhardt_query::prelude::*;
use reinhardt_query::types::window::WindowStatement;

let window = WindowStatement {
    partition_by: vec![],
    order_by: vec![],
    frame: None,
};

let expr = Expr::ntile(4).over(window); // Divide into quartiles

pub fn lead( expr: SimpleExpr, offset: Option<i64>, default: Option<Value>, ) -> Expr

Create a LEAD() window function.

Returns the value of the expression evaluated at the row that is offset rows after the current row within the partition.

Arguments

• expr - The expression to evaluate
• offset - Number of rows after the current row (default is 1 if None)
• default - Default value if the lead row doesn’t exist (default is NULL if None)

Examples

use reinhardt_query::prelude::*;
use reinhardt_query::types::window::WindowStatement;

let window = WindowStatement {
    partition_by: vec![],
    order_by: vec![],
    frame: None,
};

// Get next salary value
let expr = Expr::lead(Expr::col("salary").into_simple_expr(), Some(1), None).over(window);

pub fn lag( expr: SimpleExpr, offset: Option<i64>, default: Option<Value>, ) -> Expr

Create a LAG() window function.

Returns the value of the expression evaluated at the row that is offset rows before the current row within the partition.

Arguments

• expr - The expression to evaluate
• offset - Number of rows before the current row (default is 1 if None)
• default - Default value if the lag row doesn’t exist (default is NULL if None)

Examples

use reinhardt_query::prelude::*;
use reinhardt_query::types::window::WindowStatement;

let window = WindowStatement {
    partition_by: vec![],
    order_by: vec![],
    frame: None,
};

// Get previous salary value
let expr = Expr::lag(Expr::col("salary").into_simple_expr(), Some(1), None).over(window);

pub fn first_value(expr: SimpleExpr) -> Expr

Create a FIRST_VALUE() window function.

Returns the first value in a window frame.

Examples

use reinhardt_query::prelude::*;
use reinhardt_query::types::window::WindowStatement;

let window = WindowStatement {
    partition_by: vec![],
    order_by: vec![],
    frame: None,
};

let expr = Expr::first_value(Expr::col("salary").into_simple_expr()).over(window);

pub fn last_value(expr: SimpleExpr) -> Expr

Create a LAST_VALUE() window function.

Returns the last value in a window frame.

Examples

use reinhardt_query::prelude::*;
use reinhardt_query::types::window::WindowStatement;

let window = WindowStatement {
    partition_by: vec![],
    order_by: vec![],
    frame: None,
};

let expr = Expr::last_value(Expr::col("salary").into_simple_expr()).over(window);

pub fn nth_value(expr: SimpleExpr, n: i64) -> Expr

Create an NTH_VALUE() window function.

Returns the value of the expression at the nth row of the window frame.

Arguments

• expr - The expression to evaluate
• n - The row number (1-based) within the frame

Examples

use reinhardt_query::prelude::*;
use reinhardt_query::types::window::WindowStatement;

let window = WindowStatement {
    partition_by: vec![],
    order_by: vec![],
    frame: None,
};

// Get the 3rd salary value in the frame
let expr = Expr::nth_value(Expr::col("salary").into_simple_expr(), 3).over(window);

pub fn into_simple_expr(self) -> SimpleExpr

Convert this Expr into a SimpleExpr.

pub fn as_simple_expr(&self) -> &SimpleExpr

Get a reference to the underlying SimpleExpr.

pub fn binary<R>(self, op: BinOper, right: R) -> SimpleExpr

where R: Into<SimpleExpr>,

Create a binary operation expression.

Example

use reinhardt_query::prelude::*;

let expr = Expr::col("age").binary(BinOper::GreaterThan, Expr::val(18).into_simple_expr());

pub fn equals<C>(self, col: C) -> SimpleExpr

where C: IntoColumnRef,

Create an equality expression between two columns.

This is equivalent to self.eq(Expr::col(col)).

Example

use reinhardt_query::prelude::*;

let expr = Expr::col(("orders", "user_id")).equals(("users", "id"));

pub fn expr_as<T>(self, alias: T) -> SimpleExpr

where T: IntoIden,

Create an aliased expression (AS).

Example

use reinhardt_query::expr::Expr;

let expr = Expr::col("name").expr_as("alias_name");

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

Formats the value using the given formatter.

impl ExprTrait for Expr

fn into_simple_expr(self) -> SimpleExpr

Build the final SimpleExpr.

fn eq<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Equal (=).

fn ne<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Not equal (<>).

fn lt<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Less than (<).

fn lte<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Less than or equal (<=).

fn gt<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Greater than (>).

fn gte<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Greater than or equal (>=).

fn is_null(self) -> SimpleExpr

IS NULL.

fn is_not_null(self) -> SimpleExpr

IS NOT NULL.

fn between<A, B>(self, a: A, b: B) -> SimpleExpr

where A: Into<SimpleExpr>, B: Into<SimpleExpr>,

BETWEEN.

fn not_between<A, B>(self, a: A, b: B) -> SimpleExpr

where A: Into<SimpleExpr>, B: Into<SimpleExpr>,

NOT BETWEEN.

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

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

IN.

fn is_not_in<I, V>(self, values: I) -> SimpleExpr

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

NOT IN.

fn like<V>(self, pattern: V) -> SimpleExpr

where V: Into<SimpleExpr>,

LIKE.

fn not_like<V>(self, pattern: V) -> SimpleExpr

where V: Into<SimpleExpr>,

NOT LIKE.

fn ilike<V>(self, pattern: V) -> SimpleExpr

where V: Into<SimpleExpr>,

ILIKE (case-insensitive LIKE, PostgreSQL).

fn not_ilike<V>(self, pattern: V) -> SimpleExpr

where V: Into<SimpleExpr>,

NOT ILIKE (PostgreSQL).

fn starts_with<S>(self, prefix: S) -> SimpleExpr

where S: Into<String>,

Helper for LIKE with prefix wildcard.

fn ends_with<S>(self, suffix: S) -> SimpleExpr

where S: Into<String>,

Helper for LIKE with suffix wildcard.

fn contains<S>(self, substring: S) -> SimpleExpr

where S: Into<String>,

Helper for LIKE with both wildcards.

fn and<E>(self, other: E) -> SimpleExpr

where E: Into<SimpleExpr>,

AND.

fn or<E>(self, other: E) -> SimpleExpr

where E: Into<SimpleExpr>,

OR.

fn not(self) -> SimpleExpr

NOT (unary).

fn add<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Addition (+).

fn sub<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Subtraction (-).

fn mul<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Multiplication (*).

fn div<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Division (/).

fn modulo<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Modulo (%).

fn bit_and<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Bitwise AND (&).

fn bit_or<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Bitwise OR (|).

fn left_shift<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Left shift (<<).

fn right_shift<V>(self, v: V) -> SimpleExpr

where V: Into<SimpleExpr>,

Right shift (>>).

fn cast_as<T>(self, type_name: T) -> SimpleExpr

where T: IntoIden,

CAST expression.

fn as_enum<T>(self, type_name: T) -> SimpleExpr

where T: IntoIden,

AS ENUM expression (PostgreSQL).

impl From<&str> for Expr

fn from(s: &str) -> Expr

Converts to this type from the input type.

impl From<Expr> for SimpleExpr

fn from(e: Expr) -> SimpleExpr

Converts to this type from the input type.

impl From<SimpleExpr> for Expr

fn from(e: SimpleExpr) -> Expr

Converts to this type from the input type.

impl IntoCondition for Expr

fn into_condition_expression(self) -> ConditionExpression

Convert into a ConditionExpression.

fn into_condition(self) -> Condition

where Self: Sized,

Convert into a Condition (wrapping if necessary).

impl IntoValue for Expr

fn into_value(self) -> Value

Converts this value into a Value.