Struct SelectStatement 

pub struct SelectStatement { /* private fields */ }

SELECT statement builder

This struct provides a fluent API for constructing SELECT queries.

Examples

use reinhardt_query::prelude::*;

let query = Query::select()
    .column(Expr::col("id"))
    .column(Expr::col("name"))
    .from("users")
    .and_where(Expr::col("active").eq(true))
    .order_by("name", Order::Asc)
    .limit(10);

Implementations

impl SelectStatement

pub fn new() -> Self

Create a new SELECT statement

pub fn take(&mut self) -> Self

Take the ownership of data in the current SelectStatement

pub fn column<C>(&mut self, col: C) -> &mut Self

where C: IntoColumnRef,

Add a column to the SELECT clause

Examples

use reinhardt_query::prelude::*;

let query = Query::select()
    .column("id")
    .column("name")
    .from("users");

pub fn columns<I, C>(&mut self, cols: I) -> &mut Self

where I: IntoIterator<Item = C>, C: IntoColumnRef,

Add multiple columns to the SELECT clause

Examples

use reinhardt_query::prelude::*;

let query = Query::select()
    .columns(["id", "name", "email"])
    .from("users");

pub fn expr<E>(&mut self, expr: E) -> &mut Self

where E: Into<SimpleExpr>,

Add an expression to the SELECT clause

Examples

use reinhardt_query::prelude::*;

let query = Query::select()
    .expr(Expr::col("price").mul(Expr::col("quantity")))
    .from("orders");

pub fn expr_as<E, A>(&mut self, expr: E, alias: A) -> &mut Self

where E: Into<SimpleExpr>, A: IntoIden,

Add an expression with an alias to the SELECT clause

Examples

use reinhardt_query::prelude::*;

let query = Query::select()
    .expr_as(Expr::col("price").mul(Expr::col("quantity")), "total")
    .from("orders");

pub fn from<T>(&mut self, tbl: T) -> &mut Self

where T: IntoTableRef,

Add a table to the FROM clause

Examples

use reinhardt_query::prelude::*;

let query = Query::select()
    .column("id")
    .from("users");

pub fn from_as<T, A>(&mut self, tbl: T, alias: A) -> &mut Self

where T: IntoIden, A: IntoIden,

Add a table with alias to the FROM clause

Equivalent to FROM table AS alias.

pub fn from_subquery( &mut self, query: SelectStatement, alias: impl IntoIden, ) -> &mut Self

Add a subquery to the FROM clause

Equivalent to FROM (SELECT ...) AS alias.

pub fn clear_selects(&mut self) -> &mut Self

Clear all column selections

pub fn join<T, C>(&mut self, join: JoinType, tbl: T, condition: C) -> &mut Self

where T: IntoTableRef, C: IntoCondition,

Add a JOIN clause

Examples

use reinhardt_query::prelude::*;

let query = Query::select()
    .from("users")
    .join(
        JoinType::InnerJoin,
        "orders",
        Expr::col(("users", "id")).equals(("orders", "user_id"))
    );

pub fn left_join<T, C>(&mut self, tbl: T, condition: C) -> &mut Self

where T: IntoTableRef, C: IntoCondition,

Add a LEFT JOIN clause

Examples

use reinhardt_query::prelude::*;

let query = Query::select()
    .from("users")
    .left_join(
        "orders",
        Expr::col(("users", "id")).equals(("orders", "user_id"))
    );

pub fn right_join<T, C>(&mut self, tbl: T, condition: C) -> &mut Self

where T: IntoTableRef, C: IntoCondition,

Add a RIGHT JOIN clause

pub fn full_outer_join<T, C>(&mut self, tbl: T, condition: C) -> &mut Self

where T: IntoTableRef, C: IntoCondition,

Add a FULL OUTER JOIN clause

pub fn inner_join<T, C>(&mut self, tbl: T, condition: C) -> &mut Self

where T: IntoTableRef, C: IntoCondition,

Add an INNER JOIN clause

pub fn cross_join<T>(&mut self, tbl: T) -> &mut Self

where T: IntoTableRef,

Add a CROSS JOIN clause

pub fn and_where<C>(&mut self, condition: C) -> &mut Self

where C: IntoCondition,

Add a condition to the WHERE clause

Examples

use reinhardt_query::prelude::*;

let query = Query::select()
    .from("users")
    .and_where(Expr::col("active").eq(true));

pub fn cond_where(&mut self, condition: Condition) -> &mut Self

Add a condition to the WHERE clause using Condition

pub fn group_by<C>(&mut self, col: C) -> &mut Self

where C: IntoColumnRef,

Add a GROUP BY clause

Examples

use reinhardt_query::prelude::*;

let query = Query::select()
    .column("category")
    .expr_as(Expr::count("*"), "count")
    .from("products")
    .group_by("category");

pub fn group_by_col<C>(&mut self, col: C) -> &mut Self

where C: IntoColumnRef,

Add a column to the GROUP BY clause (alias for group_by)

pub fn group_by_columns<I, C>(&mut self, cols: I) -> &mut Self

where I: IntoIterator<Item = C>, C: IntoColumnRef,

Add multiple GROUP BY columns

pub fn and_having<C>(&mut self, condition: C) -> &mut Self

where C: IntoCondition,

Add a condition to the HAVING clause

Examples

use reinhardt_query::prelude::*;

let query = Query::select()
    .column("category")
    .expr_as(Expr::count("*"), "count")
    .from("products")
    .group_by("category")
    .and_having(Expr::count("*").gt(5));

pub fn cond_having(&mut self, condition: Condition) -> &mut Self

Add a condition to the HAVING clause using Condition

pub fn order_by<C>(&mut self, col: C, order: Order) -> &mut Self

where C: IntoColumnRef,

Add an ORDER BY clause

Examples

use reinhardt_query::prelude::*;

let query = Query::select()
    .from("users")
    .order_by("name", Order::Asc)
    .order_by("created_at", Order::Desc);

pub fn order_by_expr<E>(&mut self, expr: E, order: Order) -> &mut Self

where E: Into<SimpleExpr>,

Add an ORDER BY clause with expression

pub fn limit<V>(&mut self, limit: V) -> &mut Self

where V: IntoValue,

Set the LIMIT clause

Examples

use reinhardt_query::prelude::*;

let query = Query::select()
    .from("users")
    .limit(10);

pub fn offset<V>(&mut self, offset: V) -> &mut Self

where V: IntoValue,

Set the OFFSET clause

Examples

use reinhardt_query::prelude::*;

let query = Query::select()
    .from("users")
    .limit(10)
    .offset(20);

pub fn distinct(&mut self) -> &mut Self

Set DISTINCT

Examples

use reinhardt_query::prelude::*;

let query = Query::select()
    .distinct()
    .column("category")
    .from("products");

pub fn distinct_on<I, C>(&mut self, cols: I) -> &mut Self

where I: IntoIterator<Item = C>, C: IntoColumnRef,

Set DISTINCT ON (PostgreSQL only)

pub fn union(&mut self, query: SelectStatement) -> &mut Self

Add a UNION clause

pub fn union_all(&mut self, query: SelectStatement) -> &mut Self

Add a UNION ALL clause

pub fn intersect(&mut self, query: SelectStatement) -> &mut Self

Add an INTERSECT clause

pub fn except(&mut self, query: SelectStatement) -> &mut Self

Add an EXCEPT clause

pub fn with_cte<N>(&mut self, name: N, query: SelectStatement) -> &mut Self

where N: IntoIden,

Add a Common Table Expression (CTE) to the WITH clause

Examples

use reinhardt_query::prelude::*;

let cte = Query::select()
    .column("id")
    .column("name")
    .from("users")
    .and_where(Expr::col("active").eq(true));

let query = Query::select()
    .with_cte("active_users", cte)
    .column("*")
    .from("active_users");

pub fn with_recursive_cte<N>( &mut self, name: N, query: SelectStatement, ) -> &mut Self

where N: IntoIden,

Add a RECURSIVE Common Table Expression (CTE) to the WITH clause

Examples

use reinhardt_query::prelude::*;

// Recursive CTE for hierarchical data
let cte = Query::select()
    .column("id")
    .column("parent_id")
    .column("name")
    .from("categories")
    .and_where(Expr::col("parent_id").is_null())
    .union_all(
        Query::select()
            .column(Expr::col(("c", "id")))
            .column(Expr::col(("c", "parent_id")))
            .column(Expr::col(("c", "name")))
            .from_as("categories", "c")
            .join(
                JoinType::InnerJoin,
                "category_tree",
                Expr::col(("c", "parent_id")).eq(Expr::col(("category_tree", "id")))
            )
    );

let query = Query::select()
    .with_recursive_cte("category_tree", cte)
    .column("*")
    .from("category_tree");

pub fn window_as<T>(&mut self, name: T, window: WindowStatement) -> &mut Self

where T: IntoIden,

Add a named window specification to the WINDOW clause

Named windows can be referenced by window functions using OVER window_name.

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![OrderExpr {
        expr: Expr::col("salary").into_simple_expr(),
        order: Order::Desc,
        nulls: None,
    }],
    frame: None,
};

let query = Query::select()
    .column("name")
    .expr_as(Expr::row_number().over_named("w"), "rank")
    .from("employees")
    .window_as("w", window);

pub fn lock(&mut self, lock_type: LockType) -> &mut Self

Set FOR UPDATE lock

pub fn lock_exclusive(&mut self) -> &mut Self

Set FOR UPDATE lock

pub fn lock_shared(&mut self) -> &mut Self

Set FOR SHARE lock

pub fn apply_if<T, F>(&mut self, val: Option<T>, func: F) -> &mut Self

where F: FnOnce(&mut Self, T),

Apply a function conditionally

pub fn conditions<T, F>( &mut self, b: bool, if_true: T, if_false: F, ) -> &mut Self

where T: FnOnce(&mut Self), F: FnOnce(&mut Self),

Conditional execution

Trait Implementations

impl Clone for SelectStatement

fn clone(&self) -> SelectStatement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SelectStatement

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

Formats the value using the given formatter.

impl Default for SelectStatement

fn default() -> SelectStatement

Returns the “default value” for a type.

impl QueryStatementBuilder for SelectStatement

fn build_any(&self, query_builder: &dyn QueryBuilderTrait) -> (String, Values)

Build SQL statement for a database backend and collect query parameters

fn to_string<T: QueryBuilderTrait>(&self, query_builder: T) -> String

Build SQL statement for a database backend and return SQL string with values inlined as SQL literals.

fn build<T: QueryBuilderTrait>(&self, query_builder: T) -> (String, Values)

Build SQL statement with parameter collection

impl QueryStatementWriter for SelectStatement