Struct QueryBuilder

pub struct QueryBuilder { /* private fields */ }

Query builder for SELECT operations

Implementations

impl QueryBuilder

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

Select specific columns

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

Add an equality filter

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

Add a not equal filter

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

Add a greater than filter

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

Add a greater than or equal filter

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

Add a less than filter

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

Add a less than or equal filter

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

Add a LIKE filter

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

Add an ILIKE filter (case-insensitive)

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

Add an IS filter (for null checks)

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

Add an IN filter

pub fn order(self, column: &str, direction: OrderDirection) -> Self

Add ordering

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

Set limit

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

Set offset

pub fn single(self) -> Self

Return single row

pub fn and<F>(self, builder_fn: F) -> Self

where F: FnOnce(QueryBuilder) -> QueryBuilder,

Group filters with AND logic

Examples

let client = Client::new("http://localhost:54321", "test-key").unwrap();

// Find users where age >= 18 AND status = "active" AND city = "NYC"
let adults_in_nyc: Vec<Value> = client.database()
    .from("users")
    .select("*")
    .and(|query| {
        query
            .gte("age", "18")
            .eq("status", "active")
            .eq("city", "NYC")
    })
    .execute()
    .await
    .unwrap();

pub fn or<F>(self, builder_fn: F) -> Self

where F: FnOnce(QueryBuilder) -> QueryBuilder,

Group filters with OR logic

Examples

let client = Client::new("http://localhost:54321", "test-key").unwrap();

// Find users where status = "online" OR status = "away"
let active_users: Vec<Value> = client.database()
    .from("users")
    .select("*")
    .or(|query| {
        query
            .eq("status", "online")
            .eq("status", "away")
    })
    .execute()
    .await
    .unwrap();

pub fn not<F>(self, builder_fn: F) -> Self

where F: FnOnce(QueryBuilder) -> QueryBuilder,

Apply NOT logic to a filter

Examples

let client = Client::new("http://localhost:54321", "test-key").unwrap();

// Find users where NOT (status = "banned")
let active_users: Vec<Value> = client.database()
    .from("users")
    .select("*")
    .not(|query| query.eq("status", "banned"))
    .execute()
    .await
    .unwrap();

pub fn inner_join(self, foreign_table: &str, foreign_columns: &str) -> Self

Add an INNER JOIN to another table

Examples

let client = Client::new("http://localhost:54321", "test-key").unwrap();

// Join posts with authors: SELECT posts.*, authors.name, authors.email
let posts_with_authors: Vec<Value> = client.database()
    .from("posts")
    .select("*")
    .inner_join("authors", "name,email")
    .execute()
    .await
    .unwrap();

pub fn left_join(self, foreign_table: &str, foreign_columns: &str) -> Self

Add a LEFT JOIN to another table

Examples

let client = Client::new("http://localhost:54321", "test-key").unwrap();

// Left join posts with optional authors
let posts_with_optional_authors: Vec<Value> = client.database()
    .from("posts")
    .select("*")
    .left_join("authors", "name,email")
    .execute()
    .await
    .unwrap();

pub fn inner_join_as( self, foreign_table: &str, foreign_columns: &str, alias: &str, ) -> Self

Add an INNER JOIN with a custom alias

Examples

let client = Client::new("http://localhost:54321", "test-key").unwrap();

// Join with alias: SELECT posts.*, author:authors!inner(name,email)
let posts: Vec<Value> = client.database()
    .from("posts")
    .select("*")
    .inner_join_as("authors", "name,email", "author")
    .execute()
    .await
    .unwrap();

pub fn left_join_as( self, foreign_table: &str, foreign_columns: &str, alias: &str, ) -> Self

Add a LEFT JOIN with a custom alias

Examples

let client = Client::new("http://localhost:54321", "test-key").unwrap();

// Left join with alias: SELECT posts.*, author:authors(name,email)
let posts: Vec<Value> = client.database()
    .from("posts")
    .select("*")
    .left_join_as("authors", "name,email", "author")
    .execute()
    .await
    .unwrap();

pub async fn execute<T>(&self) -> Result<Vec<T>>

where T: for<'de> Deserialize<'de>,

Execute the query

pub async fn single_execute<T>(&self) -> Result<Option<T>>

where T: for<'de> Deserialize<'de>,

Execute the query and return a single row

Trait Implementations

impl Clone for QueryBuilder

fn clone(&self) -> QueryBuilder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QueryBuilder

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

Formats the value using the given formatter.