Struct QueryBuilder

pub struct QueryBuilder { /* private fields */ }

SQL query builder for complex queries

Provides a fluent interface for building SQL queries with support for:

• Column selection and table joins
• WHERE clauses with complex filtering
• GROUP BY and HAVING clauses
• ORDER BY with multiple sort criteria
• LIMIT and OFFSET for pagination
• Aggregate functions (COUNT, SUM, AVG, etc.)
• DISTINCT queries

Examples

use libsql_orm::{QueryBuilder, FilterOperator, Sort, SortOrder, JoinType};

// Basic query
let query = QueryBuilder::new("users")
    .select(vec!["id", "name", "email"])
    .r#where(FilterOperator::Eq("is_active".to_string(), Value::Boolean(true)))
    .order_by(Sort::new("name", SortOrder::Asc))
    .limit(10);

// Query with joins
let joined_query = QueryBuilder::new("posts")
    .select(vec!["posts.title", "users.name"])
    .join(JoinType::Inner, "users", "users.id = posts.user_id")
    .r#where(FilterOperator::Eq("posts.published".to_string(), Value::Boolean(true)));

// Aggregate query
let agg_query = QueryBuilder::new("orders")
    .aggregate(Aggregate::Sum, "amount", Some("total_amount"))
    .group_by(vec!["user_id"])
    .having(FilterOperator::Gt("total_amount".to_string(), Value::Real(1000.0)));

Implementations

impl QueryBuilder

pub fn new(table: impl Into<String>) -> Self

Create a new query builder

pub fn select(self, columns: Vec<impl Into<String>>) -> Self

Select specific columns

pub fn join( self, join_type: JoinType, table: impl Into<String>, condition: impl Into<String>, ) -> Self

Add a join clause

pub fn join_as( self, join_type: JoinType, table: impl Into<String>, alias: impl Into<String>, condition: impl Into<String>, ) -> Self

Add a join clause with alias

pub fn where(self, filter: FilterOperator) -> Self

Add a where clause

pub fn group_by(self, columns: Vec<impl Into<String>>) -> Self

Add a group by clause

pub fn having(self, filter: FilterOperator) -> Self

Add a having clause

pub fn order_by(self, sort: Sort) -> Self

Add an order by clause

pub fn order_by_multiple(self, sorts: Vec<Sort>) -> Self

Add multiple order by clauses

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

Set limit

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

Set offset

pub fn distinct(self, distinct: bool) -> Self

Set distinct

pub fn aggregate( self, function: Aggregate, column: impl Into<String>, alias: Option<impl Into<String>>, ) -> Self

Set aggregate function

pub fn select_all(self) -> Self

Select all columns

pub fn select_columns(self, columns: &[&str]) -> Self

Select specific columns

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

Select a single column

pub fn select_count(self) -> Self

Select count

pub fn select_aggregate(self, aggregate: &str) -> Self

Select aggregate

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

Select distinct

pub fn where_condition( self, condition: &str, _params: impl Into<Vec<Value>>, ) -> Self

Add where condition

pub fn search(self, field: &str, query: &str) -> Self

Add search

pub fn with_filter(self, filter: Filter) -> Self

Add filter

pub fn with_filters(self, filters: Vec<Filter>) -> Self

Add filters

pub fn with_sorts(self, sorts: Vec<Sort>) -> Self

Add sorts

pub fn having_condition( self, condition: &str, _params: impl Into<Vec<Value>>, ) -> Self

Add having condition

pub fn where_in(self, field: &str, subquery: QueryBuilder) -> Self

Add where in clause

pub async fn execute_count(&self, db: &Database) -> Result<u64>

Execute count query

pub async fn execute_aggregate(&self, db: &Database) -> Result<Vec<Row>>

Execute aggregate query

pub fn build(&self) -> Result<(String, Vec<Value>)>

Build the SQL query

pub fn build_count(&self) -> Result<(String, Vec<Value>)>

Build a count query

pub async fn execute<T>(&self, db: &Database) -> Result<Vec<T>>

where T: DeserializeOwned,

Execute the query

pub async fn execute_paginated<T>( &self, db: &Database, pagination: &Pagination, ) -> Result<PaginatedResult<T>>

where T: DeserializeOwned,

Execute the query with pagination

Trait Implementations

impl Clone for QueryBuilder

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.