Struct QueryBuilder 

pub struct QueryBuilder<'a, Schema = (), State = (), Table = (), Marker = (), Row = (), Grouped = ()> {
    pub sql: SQL<'a, SQLiteValue<'a>>,
    /* private fields */
}

Main query builder for SQLite operations.

QueryBuilder provides a type-safe, fluent API for building SQL queries. It uses compile-time type checking to ensure queries are valid and properly structured.

Type Parameters

• Schema: The database schema type, ensuring queries only reference valid tables
• State: The current builder state, enforcing proper query construction order
• Table: The table type being operated on (for single-table operations)

Basic Usage

use drizzle::sqlite::prelude::*;
use drizzle::sqlite::builder::QueryBuilder;

#[SQLiteTable(name = "users")]
struct User {
    #[column(primary)]
    id: i32,
    name: String,
}

#[derive(SQLiteSchema)]
struct Schema {
    user: User,
}

// Create a query builder for your schema
let builder = QueryBuilder::new::<Schema>();
let Schema { user } = Schema::new();

// Build queries using the fluent API
let query = builder
    .select(user.name)
    .from(user);
assert_eq!(query.to_sql().sql(), r#"SELECT "users"."name" FROM "users""#);

Query Types

The builder supports all major SQL operations:

SELECT Queries

let query = builder.select(user.name).from(user);
let query = builder.select((user.id, user.name)).from(user).r#where(gt(user.id, 10));

INSERT Queries

let query = builder
    .insert(user)
    .values([InsertUser::new("Alice")]);

UPDATE Queries

let query = builder
    .update(user)
    .set(UpdateUser::default().with_name("Bob"))
    .r#where(eq(user.id, 1));

DELETE Queries

let query = builder
    .delete(user)
    .r#where(lt(user.id, 10));

Common Table Expressions (CTEs)

The builder supports WITH clauses for complex queries with typed field access:

// Create a CTE with typed field access using .into_cte::<Tag>()
let active_users = builder
    .select((user.id, user.name))
    .from(user)
    .into_cte::<ActiveUsersTag>();

// Use the CTE with typed column access via Deref
let query = builder
    .with(&active_users)
    .select(active_users.name)  // Typed field access!
    .from(&active_users);
assert_eq!(
    query.to_sql().sql(),
    r#"WITH active_users AS (SELECT "users"."id", "users"."name" FROM "users") SELECT "active_users"."name" FROM "active_users""#
);

Fields

sql: SQL<'a, SQLiteValue<'a>>

Implementations

impl<'a, S, T> QueryBuilder<'a, S, DeleteInitial, T>

pub fn where<E>(self, condition: E) -> DeleteBuilder<'a, S, DeleteWhereSet, T>

where E: Expr<'a, SQLiteValue<'a>>, E::SQLType: BooleanLike,

Adds a WHERE clause to specify which rows to delete.

Warning: Without a WHERE clause, ALL rows in the table will be deleted! Always use this method unless you specifically intend to truncate the entire table.

Examples

// Delete specific row by ID
let query = builder
    .delete(user)
    .r#where(eq(user.id, 1));
assert_eq!(query.to_sql().sql(), r#"DELETE FROM "users" WHERE "users"."id" = ?"#);

// Delete with complex conditions
let query = builder
    .delete(user)
    .r#where(and(
        gt(user.id, 100),
        or(eq(user.name, "test"), eq(user.age, 0))
    ));

pub fn returning<Columns>( self, columns: Columns, ) -> DeleteBuilder<'a, S, DeleteReturningSet, T, Scoped<<Columns as IntoSelectTarget>::Marker, Cons<T, Nil>>, <<Columns as IntoSelectTarget>::Marker as ResolveRow<T>>::Row>

where Columns: ToSQL<'a, SQLiteValue<'a>> + IntoSelectTarget, Columns::Marker: ResolveRow<T>,

Adds a RETURNING clause to the query

impl<'a, S, T> QueryBuilder<'a, S, DeleteWhereSet, T>

pub fn returning<Columns>( self, columns: Columns, ) -> DeleteBuilder<'a, S, DeleteReturningSet, T, Scoped<<Columns as IntoSelectTarget>::Marker, Cons<T, Nil>>, <<Columns as IntoSelectTarget>::Marker as ResolveRow<T>>::Row>

where Columns: ToSQL<'a, SQLiteValue<'a>> + IntoSelectTarget, Columns::Marker: ResolveRow<T>,

Adds a RETURNING clause after WHERE

impl<'a, Schema, Table> QueryBuilder<'a, Schema, InsertInitial, Table>

where Table: SQLiteTable<'a>,

pub fn value<T>( self, value: Table::Insert<T>, ) -> InsertBuilder<'a, Schema, InsertValuesSet, Table>

where Table::Insert<T>: SQLModel<'a, SQLiteValue<'a>>,

Specifies a single row to insert into the table.

Accepts an insert value object generated by the SQLiteTable macro (e.g., InsertUser).

pub fn values<I, T>( self, values: I, ) -> InsertBuilder<'a, Schema, InsertValuesSet, Table>

where I: IntoIterator<Item = Table::Insert<T>>, Table::Insert<T>: SQLModel<'a, SQLiteValue<'a>>,

Specifies the values to insert into the table.

Accepts an iterable of insert value objects generated by the SQLiteTable macro (e.g., InsertUser).

pub fn select<Q>( self, query: Q, ) -> InsertBuilder<'a, Schema, InsertValuesSet, Table>

where Q: ToSQL<'a, SQLiteValue<'a>>,

Inserts rows produced by a SELECT query without an explicit column list.

The SELECT output must provide every table column in declaration order.

impl<'a, S, T> QueryBuilder<'a, S, InsertValuesSet, T>

pub fn on_conflict<C: ConflictTarget<T>>( self, target: C, ) -> OnConflictBuilder<'a, S, T>

Begins a typed ON CONFLICT clause targeting a specific constraint.

The target must implement ConflictTarget<T>, which is auto-generated for primary key columns, unique columns, and unique indexes.

Returns an OnConflictBuilder to specify do_nothing() or do_update().

Examples

fn main() {
use drizzle::sqlite::prelude::*;
use drizzle::sqlite::builder::QueryBuilder;

#[SQLiteTable(name = "users")]
struct User {
    #[column(primary)]
    id: i32,
    name: String,
    #[column(unique)]
    email: Option<String>,
}

#[derive(SQLiteSchema)]
struct Schema {
    user: User,
}

let builder = QueryBuilder::new::<Schema>();
let schema = Schema::new();
let user = schema.user;

// Target a specific column (requires PK or unique constraint)
builder.insert(user).values([InsertUser::new("Alice")])
    .on_conflict(user.id).do_nothing();

// Target with DO UPDATE
builder.insert(user).values([InsertUser::new("Alice")])
    .on_conflict(user.email).do_update(UpdateUser::default().with_name("updated"));
}

pub fn on_conflict_do_nothing( self, ) -> InsertBuilder<'a, S, InsertOnConflictSet, T>

Shorthand for ON CONFLICT DO NOTHING without specifying a target.

This matches any constraint violation.

pub fn returning<Columns>( self, columns: Columns, ) -> InsertBuilder<'a, S, InsertReturningSet, T, Scoped<<Columns as IntoSelectTarget>::Marker, Cons<T, Nil>>, <<Columns as IntoSelectTarget>::Marker as ResolveRow<T>>::Row>

where Columns: ToSQL<'a, SQLiteValue<'a>> + IntoSelectTarget, Columns::Marker: ResolveRow<T>,

Adds a RETURNING clause and transitions to ReturningSet state

impl<'a, S, T> QueryBuilder<'a, S, InsertOnConflictSet, T>

pub fn returning<Columns>( self, columns: Columns, ) -> InsertBuilder<'a, S, InsertReturningSet, T, Scoped<<Columns as IntoSelectTarget>::Marker, Cons<T, Nil>>, <<Columns as IntoSelectTarget>::Marker as ResolveRow<T>>::Row>

where Columns: ToSQL<'a, SQLiteValue<'a>> + IntoSelectTarget, Columns::Marker: ResolveRow<T>,

Adds a RETURNING clause after ON CONFLICT

impl<'a, S, T> QueryBuilder<'a, S, InsertDoUpdateSet, T>

pub fn where<E>( self, condition: E, ) -> InsertBuilder<'a, S, InsertOnConflictSet, T>

where E: Expr<'a, SQLiteValue<'a>>, E::SQLType: BooleanLike,

Adds a WHERE clause to the DO UPDATE SET clause.

Generates: ON CONFLICT (col) DO UPDATE SET ... WHERE condition

pub fn returning<Columns>( self, columns: Columns, ) -> InsertBuilder<'a, S, InsertReturningSet, T, Scoped<<Columns as IntoSelectTarget>::Marker, Cons<T, Nil>>, <<Columns as IntoSelectTarget>::Marker as ResolveRow<T>>::Row>

where Columns: ToSQL<'a, SQLiteValue<'a>> + IntoSelectTarget, Columns::Marker: ResolveRow<T>,

Adds a RETURNING clause after DO UPDATE SET

impl<'a, S, M> QueryBuilder<'a, S, SelectInitial, (), M>

pub fn from<T>( self, query: T, ) -> SelectBuilder<'a, S, SelectFromSet, T, Scoped<M, Cons<T, Nil>>, <M as ResolveRow<T>>::Row>

where T: ToSQL<'a, SQLiteValue<'a>>, M: ResolveRow<T>,

Specifies the table or subquery to select FROM.

This method transitions the builder from the initial state to the FROM state, enabling subsequent WHERE, JOIN, ORDER BY, and other clauses.

The row type R is resolved from the select marker M and the table T via the ResolveRow trait.

Examples

// Select from a table
let query = builder.select(user.name).from(user);
assert_eq!(query.to_sql().sql(), r#"SELECT "users"."name" FROM "users""#);

impl<'a, S, State, T, M, R, G> QueryBuilder<'a, S, State, T, M, R, G>

where State: JoinAllowed,

pub fn join<J: JoinArg<'a, T>>( self, arg: J, ) -> SelectBuilder<'a, S, SelectJoinSet, J::JoinedTable, <M as ScopePush<J::JoinedTable>>::Out, <M as AfterJoin<R, J::JoinedTable>>::NewRow, G>

where M: AfterJoin<R, J::JoinedTable> + ScopePush<J::JoinedTable>,

Adds an INNER JOIN clause to the query.

Joins another table to the current query using the specified condition. The joined table must be part of the schema and the condition should relate columns from both tables.

let query = builder
    .select((user.name, post.title))
    .from(user)
    .join((post, eq(user.id, post.user_id)));
assert_eq!(
    query.to_sql().sql(),
    r#"SELECT "users"."name", "posts"."title" FROM "users" JOIN "posts" ON "users"."id" = "posts"."user_id""#
);

pub fn natural_join<J: JoinArg<'a, T>>( self, arg: J, ) -> SelectBuilder<'a, S, SelectJoinSet, J::JoinedTable, <M as ScopePush<J::JoinedTable>>::Out, <M as AfterJoin<R, J::JoinedTable>>::NewRow, G>

where M: AfterJoin<R, J::JoinedTable> + ScopePush<J::JoinedTable>,

pub fn natural_left_join<J: JoinArg<'a, T>>( self, arg: J, ) -> SelectBuilder<'a, S, SelectJoinSet, J::JoinedTable, <M as ScopePush<J::JoinedTable>>::Out, <M as AfterLeftJoin<R, J::JoinedTable>>::NewRow, G>

where M: AfterLeftJoin<R, J::JoinedTable> + ScopePush<J::JoinedTable>,

pub fn left_join<J: JoinArg<'a, T>>( self, arg: J, ) -> SelectBuilder<'a, S, SelectJoinSet, J::JoinedTable, <M as ScopePush<J::JoinedTable>>::Out, <M as AfterLeftJoin<R, J::JoinedTable>>::NewRow, G>

where M: AfterLeftJoin<R, J::JoinedTable> + ScopePush<J::JoinedTable>,

pub fn left_outer_join<J: JoinArg<'a, T>>( self, arg: J, ) -> SelectBuilder<'a, S, SelectJoinSet, J::JoinedTable, <M as ScopePush<J::JoinedTable>>::Out, <M as AfterLeftJoin<R, J::JoinedTable>>::NewRow, G>

where M: AfterLeftJoin<R, J::JoinedTable> + ScopePush<J::JoinedTable>,

pub fn natural_left_outer_join<J: JoinArg<'a, T>>( self, arg: J, ) -> SelectBuilder<'a, S, SelectJoinSet, J::JoinedTable, <M as ScopePush<J::JoinedTable>>::Out, <M as AfterLeftJoin<R, J::JoinedTable>>::NewRow, G>

where M: AfterLeftJoin<R, J::JoinedTable> + ScopePush<J::JoinedTable>,

pub fn natural_right_join<J: JoinArg<'a, T>>( self, arg: J, ) -> SelectBuilder<'a, S, SelectJoinSet, J::JoinedTable, <M as ScopePush<J::JoinedTable>>::Out, <M as AfterRightJoin<R, J::JoinedTable>>::NewRow, G>

where M: AfterRightJoin<R, J::JoinedTable> + ScopePush<J::JoinedTable>,

pub fn right_join<J: JoinArg<'a, T>>( self, arg: J, ) -> SelectBuilder<'a, S, SelectJoinSet, J::JoinedTable, <M as ScopePush<J::JoinedTable>>::Out, <M as AfterRightJoin<R, J::JoinedTable>>::NewRow, G>

where M: AfterRightJoin<R, J::JoinedTable> + ScopePush<J::JoinedTable>,

pub fn right_outer_join<J: JoinArg<'a, T>>( self, arg: J, ) -> SelectBuilder<'a, S, SelectJoinSet, J::JoinedTable, <M as ScopePush<J::JoinedTable>>::Out, <M as AfterRightJoin<R, J::JoinedTable>>::NewRow, G>

where M: AfterRightJoin<R, J::JoinedTable> + ScopePush<J::JoinedTable>,

pub fn natural_right_outer_join<J: JoinArg<'a, T>>( self, arg: J, ) -> SelectBuilder<'a, S, SelectJoinSet, J::JoinedTable, <M as ScopePush<J::JoinedTable>>::Out, <M as AfterRightJoin<R, J::JoinedTable>>::NewRow, G>

where M: AfterRightJoin<R, J::JoinedTable> + ScopePush<J::JoinedTable>,

pub fn natural_full_join<J: JoinArg<'a, T>>( self, arg: J, ) -> SelectBuilder<'a, S, SelectJoinSet, J::JoinedTable, <M as ScopePush<J::JoinedTable>>::Out, <M as AfterFullJoin<R, J::JoinedTable>>::NewRow, G>

where M: AfterFullJoin<R, J::JoinedTable> + ScopePush<J::JoinedTable>,

pub fn full_join<J: JoinArg<'a, T>>( self, arg: J, ) -> SelectBuilder<'a, S, SelectJoinSet, J::JoinedTable, <M as ScopePush<J::JoinedTable>>::Out, <M as AfterFullJoin<R, J::JoinedTable>>::NewRow, G>

where M: AfterFullJoin<R, J::JoinedTable> + ScopePush<J::JoinedTable>,

pub fn full_outer_join<J: JoinArg<'a, T>>( self, arg: J, ) -> SelectBuilder<'a, S, SelectJoinSet, J::JoinedTable, <M as ScopePush<J::JoinedTable>>::Out, <M as AfterFullJoin<R, J::JoinedTable>>::NewRow, G>

where M: AfterFullJoin<R, J::JoinedTable> + ScopePush<J::JoinedTable>,

pub fn natural_full_outer_join<J: JoinArg<'a, T>>( self, arg: J, ) -> SelectBuilder<'a, S, SelectJoinSet, J::JoinedTable, <M as ScopePush<J::JoinedTable>>::Out, <M as AfterFullJoin<R, J::JoinedTable>>::NewRow, G>

where M: AfterFullJoin<R, J::JoinedTable> + ScopePush<J::JoinedTable>,

pub fn inner_join<J: JoinArg<'a, T>>( self, arg: J, ) -> SelectBuilder<'a, S, SelectJoinSet, J::JoinedTable, <M as ScopePush<J::JoinedTable>>::Out, <M as AfterJoin<R, J::JoinedTable>>::NewRow, G>

where M: AfterJoin<R, J::JoinedTable> + ScopePush<J::JoinedTable>,

pub fn cross_join<J: JoinArg<'a, T>>( self, arg: J, ) -> SelectBuilder<'a, S, SelectJoinSet, J::JoinedTable, <M as ScopePush<J::JoinedTable>>::Out, <M as AfterJoin<R, J::JoinedTable>>::NewRow, G>

where M: AfterJoin<R, J::JoinedTable> + ScopePush<J::JoinedTable>,

impl<'a, S, State, T, M, R, G> QueryBuilder<'a, S, State, T, M, R, G>

where State: WhereAllowed,

pub fn where<E>( self, condition: E, ) -> SelectBuilder<'a, S, SelectWhereSet, T, M, R, G>

where E: Expr<'a, SQLiteValue<'a>>, E::SQLType: BooleanLike,

Adds a WHERE clause to filter query results.

// Single condition
let query = builder
    .select(user.name)
    .from(user)
    .r#where(gt(user.id, 10));
assert_eq!(
    query.to_sql().sql(),
    r#"SELECT "users"."name" FROM "users" WHERE "users"."id" > ?"#
);

// Multiple conditions
let query = builder
    .select(user.name)
    .from(user)
    .r#where(and(gt(user.id, 10), eq(user.name, "Alice")));

impl<'a, S, State, T, M, R, G> QueryBuilder<'a, S, State, T, M, R, G>

where State: GroupByAllowed,

pub fn group_by<Gr>( self, columns: Gr, ) -> SelectBuilder<'a, S, SelectGroupSet, T, M, R, Gr::Columns>

where Gr: IntoGroupBy<'a, SQLiteValue<'a>>,

Adds a GROUP BY clause to the query.

impl<'a, S, State, T, M, R, G> QueryBuilder<'a, S, State, T, M, R, G>

where State: HavingAllowed,

pub fn having<E>( self, condition: E, ) -> SelectBuilder<'a, S, SelectGroupSet, T, M, R, G>

where E: Expr<'a, SQLiteValue<'a>>, E::SQLType: BooleanLike,

Adds a HAVING clause after GROUP BY.

impl<'a, S, State, T, M, R, G> QueryBuilder<'a, S, State, T, M, R, G>

where State: OrderByAllowed,

pub fn order_by<TOrderBy>( self, expressions: TOrderBy, ) -> SelectBuilder<'a, S, SelectOrderSet, T, M, R, G>

where TOrderBy: ToSQL<'a, SQLiteValue<'a>>,

Sorts the query results.

impl<'a, S, State, T, M, R, G> QueryBuilder<'a, S, State, T, M, R, G>

where State: LimitAllowed,

pub fn limit<P>( self, limit: P, ) -> SelectBuilder<'a, S, SelectLimitSet, T, M, R, G>

where P: PaginationArg<'a, SQLiteValue<'a>>,

Limits the number of rows returned.

Panics

Panics when a signed numeric argument is negative or a numeric value does not fit in usize.

impl<'a, S, State, T, M, R, G> QueryBuilder<'a, S, State, T, M, R, G>

where State: OffsetAllowed,

pub fn offset<P>( self, offset: P, ) -> SelectBuilder<'a, S, SelectOffsetSet, T, M, R, G>

where P: PaginationArg<'a, SQLiteValue<'a>>,

Sets the offset for the query results.

Panics

Panics when a signed numeric argument is negative or a numeric value does not fit in usize.

impl<'a, S, State, T, M, R, G> QueryBuilder<'a, S, State, T, M, R, G>

where State: AsCteState, T: SQLTable<'a, SQLiteSchemaType, SQLiteValue<'a>>,

pub fn into_cte<Tag: Tag + 'static>( self, ) -> CTEView<'a, <T as SQLTable<'a, SQLiteSchemaType, SQLiteValue<'a>>>::Aliased<Tag>, Self>

Converts this SELECT query into a typed CTE using alias tag name.

impl<'a, S, State, T, M, R, G> QueryBuilder<'a, S, State, T, M, R, G>

where State: ExecutableState,

pub fn union( self, other: impl IntoSelect<'a, S, M, R>, ) -> SelectBuilder<'a, S, SelectSetOpSet, T, M, R, G>

Combines this query with another using UNION.

pub fn union_all( self, other: impl IntoSelect<'a, S, M, R>, ) -> SelectBuilder<'a, S, SelectSetOpSet, T, M, R, G>

Combines this query with another using UNION ALL.

pub fn intersect( self, other: impl IntoSelect<'a, S, M, R>, ) -> SelectBuilder<'a, S, SelectSetOpSet, T, M, R, G>

Combines this query with another using INTERSECT.

pub fn intersect_all( self, other: impl IntoSelect<'a, S, M, R>, ) -> SelectBuilder<'a, S, SelectSetOpSet, T, M, R, G>

Combines this query with another using INTERSECT ALL.

pub fn except( self, other: impl IntoSelect<'a, S, M, R>, ) -> SelectBuilder<'a, S, SelectSetOpSet, T, M, R, G>

Combines this query with another using EXCEPT.

pub fn except_all( self, other: impl IntoSelect<'a, S, M, R>, ) -> SelectBuilder<'a, S, SelectSetOpSet, T, M, R, G>

Combines this query with another using EXCEPT ALL.

impl<'a, Schema, Table> QueryBuilder<'a, Schema, UpdateInitial, Table>

where Table: SQLiteTable<'a>,

pub fn set( self, values: Table::Update, ) -> UpdateBuilder<'a, Schema, UpdateSetClauseSet, Table>

Specifies which columns to update and their new values.

This method accepts update expressions that specify which columns should be modified. You can update single or multiple columns using the generated update model’s with_* setters.

Examples

// Update single column
let query = builder
    .update(user)
    .set(UpdateUser::default().with_name("New Name"));
assert_eq!(query.to_sql().sql(), r#"UPDATE "users" SET "name" = ?"#);

// Update multiple columns
let query = builder
    .update(user)
    .set(UpdateUser::default().with_name("New Name").with_email("new@example.com"));

impl<'a, S, T> QueryBuilder<'a, S, UpdateSetClauseSet, T>

pub fn where<E>(self, condition: E) -> UpdateBuilder<'a, S, UpdateWhereSet, T>

where E: Expr<'a, SQLiteValue<'a>>, E::SQLType: BooleanLike,

Adds a WHERE clause to specify which rows to update.

Without a WHERE clause, all rows in the table would be updated. This method allows you to specify conditions to limit which rows are affected by the update.

Examples

// Update specific row by ID
let query = builder
    .update(user)
    .set(UpdateUser::default().with_name("Updated Name"))
    .r#where(eq(user.id, 1));
assert_eq!(
    query.to_sql().sql(),
    r#"UPDATE "users" SET "name" = ? WHERE "users"."id" = ?"#
);

// Update multiple rows with complex condition
let query = builder
    .update(user)
    .set(UpdateUser::default().with_name("Updated"))
    .r#where(and(gt(user.id, 10), eq(user.age, 25)));

pub fn returning<Columns>( self, columns: Columns, ) -> UpdateBuilder<'a, S, UpdateReturningSet, T, Scoped<<Columns as IntoSelectTarget>::Marker, Cons<T, Nil>>, <<Columns as IntoSelectTarget>::Marker as ResolveRow<T>>::Row>

where Columns: ToSQL<'a, SQLiteValue<'a>> + IntoSelectTarget, Columns::Marker: ResolveRow<T>,

Adds a RETURNING clause and transitions to the ReturningSet state

impl<'a, S, T> QueryBuilder<'a, S, UpdateWhereSet, T>

pub fn returning<Columns>( self, columns: Columns, ) -> UpdateBuilder<'a, S, UpdateReturningSet, T, Scoped<<Columns as IntoSelectTarget>::Marker, Cons<T, Nil>>, <<Columns as IntoSelectTarget>::Marker as ResolveRow<T>>::Row>

where Columns: ToSQL<'a, SQLiteValue<'a>> + IntoSelectTarget, Columns::Marker: ResolveRow<T>,

Adds a RETURNING clause after WHERE

impl<'a, Schema, State, Table, Marker, Row, Grouped> QueryBuilder<'a, Schema, State, Table, Marker, Row, Grouped>

where State: ExecutableState,

pub fn comment(self, text: impl AsRef<str>) -> Self

Attaches a sqlcommenter comment to the query.

The comment is prepended to the generated SQL and wrapped in /* ... */. Any /* or */ sequences in the input are sanitised so they can’t terminate the surrounding comment.

pub fn comment_tags<I, K, V>(self, pairs: I) -> Self

where I: IntoIterator<Item = (K, V)>, K: AsRef<str>, V: AsRef<str>,

Attaches a tag-style sqlcommenter comment to the query.

Each (key, value) pair is URL-encoded, sorted alphabetically, joined with ,, and wrapped in /* ... */. Pairs with empty values are skipped; an all-empty input is a no-op.

impl<'a> QueryBuilder<'a>

pub const fn new<S>() -> QueryBuilder<'a, S, BuilderInit>

Creates a new query builder for the given schema type.

This is the entry point for building SQL queries. The schema type parameter ensures that only valid tables from your schema can be used in queries.

Examples

use drizzle::sqlite::prelude::*;
use drizzle::sqlite::builder::QueryBuilder;

#[SQLiteTable(name = "users")]
struct User {
    #[column(primary)]
    id: i32,
    name: String,
}

#[derive(SQLiteSchema)]
struct MySchema {
    user: User,
}

let builder = QueryBuilder::new::<MySchema>();

impl<'a, Schema> QueryBuilder<'a, Schema, BuilderInit>

pub fn select<T>( &self, columns: T, ) -> SelectBuilder<'a, Schema, SelectInitial, (), T::Marker>

where T: ToSQL<'a, SQLiteValue<'a>> + IntoSelectTarget,

Begins a SELECT query with the specified columns.

This method starts building a SELECT statement. You can select individual columns, multiple columns as a tuple, or use () to select all columns.

Examples

// Select a single column
let query = builder.select(user.name).from(user);
assert_eq!(query.to_sql().sql(), r#"SELECT "users"."name" FROM "users""#);

// Select multiple columns
let query = builder.select((user.id, user.name)).from(user);
assert_eq!(query.to_sql().sql(), r#"SELECT "users"."id", "users"."name" FROM "users""#);

pub fn select_distinct<T>( &self, columns: T, ) -> SelectBuilder<'a, Schema, SelectInitial, (), T::Marker>

where T: ToSQL<'a, SQLiteValue<'a>> + IntoSelectTarget,

Begins a SELECT DISTINCT query with the specified columns.

SELECT DISTINCT removes duplicate rows from the result set.

Examples

let query = builder.select_distinct(user.name).from(user);
assert_eq!(query.to_sql().sql(), r#"SELECT DISTINCT "users"."name" FROM "users""#);

impl<'a, Schema> QueryBuilder<'a, Schema, CTEInit>

pub fn select<T>( &self, columns: T, ) -> SelectBuilder<'a, Schema, SelectInitial, (), T::Marker>

where T: ToSQL<'a, SQLiteValue<'a>> + IntoSelectTarget,

pub fn select_distinct<T>( &self, columns: T, ) -> SelectBuilder<'a, Schema, SelectInitial, (), T::Marker>

where T: ToSQL<'a, SQLiteValue<'a>> + IntoSelectTarget,

Begins a SELECT DISTINCT query with the specified columns after a CTE.

pub fn insert<Table>( &self, table: Table, ) -> InsertBuilder<'a, Schema, InsertInitial, Table>

where Table: SQLiteTable<'a>,

Begins an INSERT query after a CTE.

pub fn update<Table>( &self, table: Table, ) -> UpdateBuilder<'a, Schema, UpdateInitial, Table>

where Table: SQLiteTable<'a>,

Begins an UPDATE query after a CTE.

pub fn delete<Table>( &self, table: Table, ) -> DeleteBuilder<'a, Schema, DeleteInitial, Table>

where Table: SQLiteTable<'a>,

Begins a DELETE query after a CTE.

pub fn with<C>(&self, cte: &C) -> Self

where C: CTEDefinition<'a>,

impl<'a, Schema> QueryBuilder<'a, Schema, BuilderInit>

pub fn insert<Table>( &self, table: Table, ) -> InsertBuilder<'a, Schema, InsertInitial, Table>

where Table: SQLiteTable<'a>,

Begins an INSERT query for the specified table.

This method starts building an INSERT statement. The table must be part of the schema and will be type-checked at compile time.

Examples

let query = builder
    .insert(user)
    .values([InsertUser::new("Alice")]);
assert_eq!(query.to_sql().sql(), r#"INSERT INTO "users" ("name") VALUES (?)"#);

pub fn update<Table>( &self, table: Table, ) -> UpdateBuilder<'a, Schema, UpdateInitial, Table>

where Table: SQLiteTable<'a>,

Begins an UPDATE query for the specified table.

This method starts building an UPDATE statement. The table must be part of the schema and will be type-checked at compile time.

Examples

let query = builder
    .update(user)
    .set(UpdateUser::default().with_name("Bob"))
    .r#where(eq(user.id, 1));
assert_eq!(query.to_sql().sql(), r#"UPDATE "users" SET "name" = ? WHERE "users"."id" = ?"#);

pub fn delete<Table>( &self, table: Table, ) -> DeleteBuilder<'a, Schema, DeleteInitial, Table>

where Table: SQLiteTable<'a>,

Begins a DELETE query for the specified table.

This method starts building a DELETE statement. The table must be part of the schema and will be type-checked at compile time.

Examples

let query = builder
    .delete(user)
    .r#where(lt(user.id, 10));
assert_eq!(query.to_sql().sql(), r#"DELETE FROM "users" WHERE "users"."id" < ?"#);

pub fn with<C>(&self, cte: &C) -> QueryBuilder<'a, Schema, CTEInit>

where C: CTEDefinition<'a>,

Trait Implementations

impl<'a, Schema: Clone, State: Clone, Table: Clone, Marker: Clone, Row: Clone, Grouped: Clone> Clone for QueryBuilder<'a, Schema, State, Table, Marker, Row, Grouped>

fn clone(&self) -> QueryBuilder<'a, Schema, State, Table, Marker, Row, Grouped>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, Schema: Debug, State: Debug, Table: Debug, Marker: Debug, Row: Debug, Grouped: Debug> Debug for QueryBuilder<'a, Schema, State, Table, Marker, Row, Grouped>

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

Formats the value using the given formatter.

impl<'a, Schema: Default, State: Default, Table: Default, Marker: Default, Row: Default, Grouped: Default> Default for QueryBuilder<'a, Schema, State, Table, Marker, Row, Grouped>

fn default() -> QueryBuilder<'a, Schema, State, Table, Marker, Row, Grouped>

Returns the “default value” for a type.

impl<'a, Schema, State, Table, Marker, Row, Grouped> ToSQL<'a, SQLiteValue<'a>> for QueryBuilder<'a, Schema, State, Table, Marker, Row, Grouped>

fn to_sql(&self) -> SQL<'a, SQLiteValue<'a>>

fn into_sql(self) -> SQL<'a, V>

where Self: Sized,

Consume self and return SQL without cloning. Default delegates to to_sql() (which clones). Types that own their SQL (like SQL and SQLExpr) override this to avoid the clone.