Struct SelectBuilder 

pub struct SelectBuilder { /* private fields */ }

A typed, fluent SELECT query builder with parameterized conditions.

use framework::db::{SelectBuilder, Order};

let users: Vec<User> = SelectBuilder::table("users")
    .columns("id, name, email, created_at")
    .where_eq("active", true)
    .where_like("name", "%alice%")
    .where_gt("age", 18)
    .where_in("role", &["admin", "editor"])
    .where_null("deleted_at")
    .order_by("created_at", Order::Desc)
    .limit(20)
    .offset(0)
    .fetch_all(&pool)
    .await?;

let count = SelectBuilder::table("users")
    .where_eq("active", true)
    .count(&pool)
    .await?;

let user: Option<User> = SelectBuilder::table("users")
    .where_eq("email", "alice@example.com")
    .fetch_one(&pool)
    .await?;

Implementations

impl SelectBuilder

pub fn table(table: &str) -> Self

pub fn columns(self, cols: &str) -> Self

pub fn join(self, join_clause: &str) -> Self

Add a JOIN clause. Must not contain SQL injection vectors (;, quotes, comments).

pub fn where_eq<V: IntoBindValue>(self, column: &str, value: V) -> Self

pub fn where_ne<V: IntoBindValue>(self, column: &str, value: V) -> Self

pub fn where_gt<V: IntoBindValue>(self, column: &str, value: V) -> Self

pub fn where_gte<V: IntoBindValue>(self, column: &str, value: V) -> Self

pub fn where_lt<V: IntoBindValue>(self, column: &str, value: V) -> Self

pub fn where_lte<V: IntoBindValue>(self, column: &str, value: V) -> Self

pub fn where_like<V: IntoBindValue>(self, column: &str, pattern: V) -> Self

pub fn where_null(self, column: &str) -> Self

pub fn where_not_null(self, column: &str) -> Self

pub fn where_in<V>(self, column: &str, values: &[V]) -> Self

where V: Clone + IntoBindValue,

pub fn where_raw(self, raw: &str) -> Self

Add a raw WHERE clause. WARNING: This is NOT parameterized. Only use with hardcoded strings, NEVER with user input.

pub fn order_by(self, column: &str, direction: Order) -> Self

pub fn limit(self, limit: u32) -> Self

pub fn offset(self, offset: u32) -> Self

pub fn group_by(self, clause: &str) -> Self

pub async fn fetch_all<T>(self, pool: &DbPool) -> Result<Vec<T>, Error>

where T: for<'r> FromRow<'r, DbRow> + Send + Unpin,

Execute and return all matching rows

pub async fn fetch_one<T>(self, pool: &DbPool) -> Result<Option<T>, Error>

where T: for<'r> FromRow<'r, DbRow> + Send + Unpin,

Execute and return the first matching row

pub async fn count(self, pool: &DbPool) -> Result<i64, Error>

Execute a COUNT(*) query with the same conditions