Struct QueryBuilder 

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

Available on crate feature sqlite only.

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) -> QueryBuilder<'a, S, DeleteWhereSet, T>

where E: Expr<'a, SQLiteValue<'a>>, <E as Expr<'a, SQLiteValue<'a>>>::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, ) -> QueryBuilder<'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 as IntoSelectTarget>::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, ) -> QueryBuilder<'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 as IntoSelectTarget>::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 as SQLTable<'a, SQLiteSchemaType, SQLiteValue<'a>>>::Insert<T>, ) -> QueryBuilder<'a, Schema, InsertValuesSet, Table>

where <Table as SQLTable<'a, SQLiteSchemaType, SQLiteValue<'a>>>::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, ) -> QueryBuilder<'a, Schema, InsertValuesSet, Table>

where I: IntoIterator<Item = <Table as SQLTable<'a, SQLiteSchemaType, SQLiteValue<'a>>>::Insert<T>>, <Table as SQLTable<'a, SQLiteSchemaType, SQLiteValue<'a>>>::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 columns<Columns>( self, columns: Columns, ) -> QueryBuilder<'a, Schema, InsertColumnsSet<<Columns as InsertTargetColumns<'a, SQLiteValue<'a>, Table>>::Columns>, Table>

where Columns: InsertTargetColumns<'a, SQLiteValue<'a>, Table>,

Chooses an explicit ordered target-column list for an INSERT SELECT.

pub fn select<Q, R, ScopeProof, AggProof>( self, query: Q, ) -> QueryBuilder<'a, Schema, InsertValuesSet, Table>

where Table: InsertSelectTable, Q: IntoSelectQuery<'a, Schema, R>, <Q as IntoSelectQuery<'a, Schema, R>>::Marker: InsertSelectCompatible<'a, SQLiteValue<'a>, Table, R> + InsertSourceInScope<ScopeProof> + MarkerAggValidFor<<Q as IntoSelectQuery<'a, Schema, R>>::Grouped, AggProof>,

Inserts a checked SELECT into every insertable table column.

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

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

Inserts an unchecked raw SELECT without a target list.

This opts out of projection shape, type, nullability, source-scope, and aggregate validation.

impl<'a, Schema, Table, Targets> QueryBuilder<'a, Schema, InsertColumnsSet<Targets>, Table>

where Table: SQLiteTable<'a> + InsertSelectTable,

pub fn select<Q, R, RequiredProof, ScopeProof, AggProof>( self, query: Q, ) -> QueryBuilder<'a, Schema, InsertValuesSet, Table>

where Targets: IncludesRequired<<Table as InsertSelectTable>::RequiredColumns, RequiredProof>, Q: IntoSelectQuery<'a, Schema, R>, <Q as IntoSelectQuery<'a, Schema, R>>::Marker: PartialInsertSelectCompatible<'a, SQLiteValue<'a>, Targets> + InsertSourceInScope<ScopeProof> + MarkerAggValidFor<<Q as IntoSelectQuery<'a, Schema, R>>::Grouped, AggProof>,

Inserts a checked SELECT into the chosen target columns.

pub fn select_raw<Q, RequiredProof>( self, query: Q, ) -> QueryBuilder<'a, Schema, InsertValuesSet, Table>

where Targets: IncludesRequired<<Table as InsertSelectTable>::RequiredColumns, RequiredProof>, Q: ToSQL<'a, SQLiteValue<'a>>,

Inserts an unchecked raw SELECT into the chosen target columns.

This opts out of projection shape, type, nullability, source-scope, and aggregate validation.

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

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

where C: ConflictTarget<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, ) -> QueryBuilder<'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, ) -> QueryBuilder<'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 as IntoSelectTarget>::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, ) -> QueryBuilder<'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 as IntoSelectTarget>::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, ) -> QueryBuilder<'a, S, InsertOnConflictSet, T>

where E: Expr<'a, SQLiteValue<'a>>, <E as Expr<'a, SQLiteValue<'a>>>::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, ) -> QueryBuilder<'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 as IntoSelectTarget>::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, ) -> QueryBuilder<'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>( self, arg: J, ) -> QueryBuilder<'a, S, SelectJoinSet, <J as JoinArg<'a, T>>::JoinedTable, <M as ScopePush<<J as JoinArg<'a, T>>::JoinedTable>>::Out, <M as AfterJoin<R, <J as JoinArg<'a, T>>::JoinedTable>>::NewRow, G>

where J: JoinArg<'a, T>, M: AfterJoin<R, <J as JoinArg<'a, T>>::JoinedTable> + ScopePush<<J as JoinArg<'a, T>>::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>( self, source: J, ) -> QueryBuilder<'a, S, SelectJoinSet, <J as JoinSource<'a>>::JoinedTable, <M as ScopePush<<J as JoinSource<'a>>::JoinedTable>>::Out, <M as AfterJoin<R, <J as JoinSource<'a>>::JoinedTable>>::NewRow, G>

where J: JoinSource<'a>, M: AfterJoin<R, <J as JoinSource<'a>>::JoinedTable> + ScopePush<<J as JoinSource<'a>>::JoinedTable>,

Adds a NATURAL join. The database matches the columns both sides share by name, so it takes a source and no ON condition.

pub fn natural_left_join<J>( self, source: J, ) -> QueryBuilder<'a, S, SelectJoinSet, <J as JoinSource<'a>>::JoinedTable, <M as ScopePush<<J as JoinSource<'a>>::JoinedTable>>::Out, <M as AfterLeftJoin<R, <J as JoinSource<'a>>::JoinedTable>>::NewRow, G>

where J: JoinSource<'a>, M: AfterLeftJoin<R, <J as JoinSource<'a>>::JoinedTable> + ScopePush<<J as JoinSource<'a>>::JoinedTable>,

Adds a NATURAL join. The database matches the columns both sides share by name, so it takes a source and no ON condition.

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

where J: JoinArg<'a, T>, M: AfterLeftJoin<R, <J as JoinArg<'a, T>>::JoinedTable> + ScopePush<<J as JoinArg<'a, T>>::JoinedTable>,

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

where J: JoinArg<'a, T>, M: AfterLeftJoin<R, <J as JoinArg<'a, T>>::JoinedTable> + ScopePush<<J as JoinArg<'a, T>>::JoinedTable>,

pub fn natural_left_outer_join<J>( self, source: J, ) -> QueryBuilder<'a, S, SelectJoinSet, <J as JoinSource<'a>>::JoinedTable, <M as ScopePush<<J as JoinSource<'a>>::JoinedTable>>::Out, <M as AfterLeftJoin<R, <J as JoinSource<'a>>::JoinedTable>>::NewRow, G>

where J: JoinSource<'a>, M: AfterLeftJoin<R, <J as JoinSource<'a>>::JoinedTable> + ScopePush<<J as JoinSource<'a>>::JoinedTable>,

Adds a NATURAL join. The database matches the columns both sides share by name, so it takes a source and no ON condition.

pub fn natural_right_join<J>( self, source: J, ) -> QueryBuilder<'a, S, SelectJoinSet, <J as JoinSource<'a>>::JoinedTable, <M as ScopePush<<J as JoinSource<'a>>::JoinedTable>>::Out, <M as AfterRightJoin<R, <J as JoinSource<'a>>::JoinedTable>>::NewRow, G>

where J: JoinSource<'a>, M: AfterRightJoin<R, <J as JoinSource<'a>>::JoinedTable> + ScopePush<<J as JoinSource<'a>>::JoinedTable>,

Adds a NATURAL join. The database matches the columns both sides share by name, so it takes a source and no ON condition.

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

where J: JoinArg<'a, T>, M: AfterRightJoin<R, <J as JoinArg<'a, T>>::JoinedTable> + ScopePush<<J as JoinArg<'a, T>>::JoinedTable>,

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

where J: JoinArg<'a, T>, M: AfterRightJoin<R, <J as JoinArg<'a, T>>::JoinedTable> + ScopePush<<J as JoinArg<'a, T>>::JoinedTable>,

pub fn natural_right_outer_join<J>( self, source: J, ) -> QueryBuilder<'a, S, SelectJoinSet, <J as JoinSource<'a>>::JoinedTable, <M as ScopePush<<J as JoinSource<'a>>::JoinedTable>>::Out, <M as AfterRightJoin<R, <J as JoinSource<'a>>::JoinedTable>>::NewRow, G>

where J: JoinSource<'a>, M: AfterRightJoin<R, <J as JoinSource<'a>>::JoinedTable> + ScopePush<<J as JoinSource<'a>>::JoinedTable>,

Adds a NATURAL join. The database matches the columns both sides share by name, so it takes a source and no ON condition.

pub fn natural_full_join<J>( self, source: J, ) -> QueryBuilder<'a, S, SelectJoinSet, <J as JoinSource<'a>>::JoinedTable, <M as ScopePush<<J as JoinSource<'a>>::JoinedTable>>::Out, <M as AfterFullJoin<R, <J as JoinSource<'a>>::JoinedTable>>::NewRow, G>

where J: JoinSource<'a>, M: AfterFullJoin<R, <J as JoinSource<'a>>::JoinedTable> + ScopePush<<J as JoinSource<'a>>::JoinedTable>,

Adds a NATURAL join. The database matches the columns both sides share by name, so it takes a source and no ON condition.

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

where J: JoinArg<'a, T>, M: AfterFullJoin<R, <J as JoinArg<'a, T>>::JoinedTable> + ScopePush<<J as JoinArg<'a, T>>::JoinedTable>,

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

where J: JoinArg<'a, T>, M: AfterFullJoin<R, <J as JoinArg<'a, T>>::JoinedTable> + ScopePush<<J as JoinArg<'a, T>>::JoinedTable>,

pub fn natural_full_outer_join<J>( self, source: J, ) -> QueryBuilder<'a, S, SelectJoinSet, <J as JoinSource<'a>>::JoinedTable, <M as ScopePush<<J as JoinSource<'a>>::JoinedTable>>::Out, <M as AfterFullJoin<R, <J as JoinSource<'a>>::JoinedTable>>::NewRow, G>

where J: JoinSource<'a>, M: AfterFullJoin<R, <J as JoinSource<'a>>::JoinedTable> + ScopePush<<J as JoinSource<'a>>::JoinedTable>,

Adds a NATURAL join. The database matches the columns both sides share by name, so it takes a source and no ON condition.

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

where J: JoinArg<'a, T>, M: AfterJoin<R, <J as JoinArg<'a, T>>::JoinedTable> + ScopePush<<J as JoinArg<'a, T>>::JoinedTable>,

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

where Arg: CrossJoinArg<'a, T>, M: AfterJoin<R, <Arg as CrossJoinArg<'a, T>>::JoinedTable> + ScopePush<<Arg as CrossJoinArg<'a, T>>::JoinedTable>,

Adds a cross join.

A bare source renders CROSS JOIN. For backwards compatibility, (source, predicate) renders the equivalent INNER JOIN ... ON ....

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

where State: SelectWhereAllowed,

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

where E: Expr<'a, SQLiteValue<'a>>, <E as Expr<'a, SQLiteValue<'a>>>::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, ) -> QueryBuilder<'a, S, SelectGroupSet, T, M, R, <Gr as IntoGroupBy<'a, SQLiteValue<'a>>>::Columns>

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

Adds a GROUP BY clause to the query.

Non-aggregate columns in SELECT must appear in the GROUP BY list, with one exception: grouping by a table’s single-column primary key functionally determines the whole row (SQL:1999), so any scalar column of that table may be selected. Prefer .group_by(table.pk) over listing every selected column — it also lets SQLite stream groups in key order instead of sorting through a temp B-tree.

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, ) -> QueryBuilder<'a, S, SelectGroupSet, T, M, R, G>

where E: Expr<'a, SQLiteValue<'a>>, <E as Expr<'a, SQLiteValue<'a>>>::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: SelectOrderAllowed,

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

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

Sorts the query results.

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

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

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

Sorts a compound (UNION / INTERSECT / EXCEPT) result by its output columns. Column references are rendered unqualified, which is the only spelling PostgreSQL and turso accept here.

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, ) -> QueryBuilder<'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: SelectStandaloneOffsetAllowed,

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

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

Sets the offset for the query results.

SQLite only accepts OFFSET after a LIMIT, so this renders LIMIT -1 OFFSET n; a negative limit means no limit.

Panics

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

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

pub fn offset<P>( self, offset: P, ) -> QueryBuilder<'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: ExecutableState, M: DerivedSelection<'a, SQLiteValue<'a>, SQLiteSchemaType, T>,

pub fn alias<Name, ScopeProof, AggProof>( self, _name: Name, ) -> Derived<'a, SQLiteValue<'a>, Name, <M as DerivedSelection<'a, SQLiteValue<'a>, SQLiteSchemaType, T>>::Projection, QueryBuilder<'a, S, State, T, M, R, G>>

where Name: Tag, <M as DerivedSelection<'a, SQLiteValue<'a>, SQLiteSchemaType, T>>::Projection: DerivedProjection<Name>, M: MarkerScopeValidFor<ScopeProof> + MarkerAggValidFor<G, AggProof>,

Names this completed query so it can be used as a derived source.

Panics

Panics when the projection contains duplicate output names. Name a computed expression with drizzle_core::expr::NamedExt::named to make each output unique.

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>( self, ) -> CTEView<'a, SQLiteValue<'a>, <T as SQLTable<'a, SQLiteSchemaType, SQLiteValue<'a>>>::Aliased<Tag>, QueryBuilder<'a, S, State, T, M, R, G>>

where Tag: Tag + 'static,

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>, ) -> QueryBuilder<'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>, ) -> QueryBuilder<'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>, ) -> QueryBuilder<'a, S, SelectSetOpSet, T, M, R, G>

Combines this query with another using INTERSECT.

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

Combines this query with another using EXCEPT.

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

where Table: SQLiteTable<'a>,

pub fn set( self, values: <Table as SQLTable<'a, SQLiteSchemaType, SQLiteValue<'a>>>::Update, ) -> QueryBuilder<'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) -> QueryBuilder<'a, S, UpdateWhereSet, T>

where E: Expr<'a, SQLiteValue<'a>>, <E as Expr<'a, SQLiteValue<'a>>>::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, ) -> QueryBuilder<'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 as IntoSelectTarget>::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, ) -> QueryBuilder<'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 as IntoSelectTarget>::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>, ) -> QueryBuilder<'a, Schema, State, Table, Marker, Row, Grouped>

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, ) -> QueryBuilder<'a, Schema, State, Table, Marker, Row, Grouped>

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, ) -> QueryBuilder<'a, Schema, SelectInitial, (), <T as IntoSelectTarget>::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, ) -> QueryBuilder<'a, Schema, SelectInitial, (), <T as IntoSelectTarget>::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, ) -> QueryBuilder<'a, Schema, SelectInitial, (), <T as IntoSelectTarget>::Marker>

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

pub fn select_distinct<T>( &self, columns: T, ) -> QueryBuilder<'a, Schema, SelectInitial, (), <T as IntoSelectTarget>::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, ) -> QueryBuilder<'a, Schema, InsertInitial, Table>

where Table: SQLiteTable<'a>,

Begins an INSERT query after a CTE.

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

where Table: SQLiteTable<'a>,

Begins an UPDATE query after a CTE.

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

where Table: SQLiteTable<'a>,

Begins a DELETE query after a CTE.

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

where C: CTEDefinition<'a>,

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

pub fn insert<Table>( &self, table: Table, ) -> QueryBuilder<'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, ) -> QueryBuilder<'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, ) -> QueryBuilder<'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, State, Table, Marker, Row, Grouped> Clone for QueryBuilder<'a, Schema, State, Table, Marker, Row, Grouped>

where Schema: Clone, State: Clone, Table: Clone, Marker: Clone, Row: Clone, Grouped: Clone,

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, State, Table, Marker, Row, Grouped> Debug for QueryBuilder<'a, Schema, State, Table, Marker, Row, Grouped>

where Schema: Debug, State: Debug, Table: Debug, Marker: Debug, Row: Debug, Grouped: Debug,

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

Formats the value using the given formatter.

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

where Schema: Default, State: Default, Table: Default, Marker: Default, Row: Default, Grouped: Default,

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

Returns the “default value” for a type.

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

where State: ExecutableState, M: SubqueryType<'a, SQLiteValue<'a>>,

type SQLType = <M as SubqueryType<'a, SQLiteValue<'a>>>::SQLType

The SQL data type this expression evaluates to.

type Nullable = Null

Whether this expression can be NULL.

type Aggregate = Scalar

Whether this is an aggregate (COUNT, SUM) or scalar expression.

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

Render this value as a scalar expression by reference.

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

where Self: Sized,

Render this value as a scalar expression, consuming it when useful.

fn to_condition_sql(&self) -> Option<SQL<'a, V>>

Render this value as one element of a ConditionList.

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

where Self: Sized,

Consuming counterpart of Expr::to_condition_sql.

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

where State: ExecutableState,

type State = State

type Table = T

fn into_select(self) -> QueryBuilder<'a, S, State, T, M, R>

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.