Struct QueryBuilder

Source

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

Expand description

Main query builder for PostgreSQL

The S type parameter represents the schema type, which is used to ensure type safety when building queries.

Fields§

§sql: SQL<'a, PostgresValue<'a>>

Implementations§

Source §

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

Source

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

Adds a WHERE condition to the query

Source

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, PostgresValue<'a>> + IntoSelectTarget, Columns::Marker: ResolveRow<T>,

Adds a RETURNING clause to the query

Source §

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

Source

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, PostgresValue<'a>> + IntoSelectTarget, Columns::Marker: ResolveRow<T>,

Adds a RETURNING clause after WHERE

Source §

impl<'a, Schema, Table> QueryBuilder<'a, Schema, InsertInitial, Table>
where Table: PostgresTable<'a>,

Source

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

Specifies a single row to insert. Shorthand for .values([row]).

Source

pub fn values<I, T>( self, values: I, ) -> InsertBuilder<'a, Schema, InsertValuesSet, Table>
where I: IntoIterator<Item = Table::Insert<T>>,

Specifies multiple rows to insert.

Source

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

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

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

Source §

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

Source

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

Begins a typed ON CONFLICT clause targeting specific columns.

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::postgres::prelude::*;
use drizzle::postgres::builder::QueryBuilder;

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

#[PostgresIndex(unique)]
struct UserEmailIdx(User::email);

#[derive(PostgresSchema)]
struct Schema {
    user: User,
    user_email_idx: UserEmailIdx,
}

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

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

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

// Target a unique index
builder.insert(user).values([InsertUser::new("Alice")])
    .on_conflict(schema.user_email_idx).do_nothing();
}

Source

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

Begins a typed ON CONFLICT ON CONSTRAINT clause (PostgreSQL-only).

The target must implement NamedConstraint<T>, which is auto-generated for unique indexes.

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

§Examples

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

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

#[PostgresIndex(unique)]
struct UserEmailIdx(User::email);

#[derive(PostgresSchema)]
struct Schema {
    user: User,
    user_email_idx: UserEmailIdx,
}

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

builder.insert(schema.user).values([InsertUser::new("Alice")])
    .on_conflict_on_constraint(schema.user_email_idx).do_nothing();
}

Source

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.

Source

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, PostgresValue<'a>> + IntoSelectTarget, Columns::Marker: ResolveRow<T>,

Adds a RETURNING clause and transitions to ReturningSet state

Source §

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

Source

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, PostgresValue<'a>> + IntoSelectTarget, Columns::Marker: ResolveRow<T>,

Adds a RETURNING clause after ON CONFLICT

Source §

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

Source

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

Adds a WHERE clause to the DO UPDATE SET clause.

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

Source

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, PostgresValue<'a>> + IntoSelectTarget, Columns::Marker: ResolveRow<T>,

Adds a RETURNING clause after DO UPDATE SET

Source §

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

Source

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, PostgresValue<'a>>, M: ResolveRow<T>,

Specifies the table to select FROM and transitions state.

Source §

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

Source

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.

Source

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>,

JOIN with ON clause

Source

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>,

JOIN with ON clause

Source

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>,

JOIN with ON clause

Source

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>,

JOIN with ON clause

Source

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>,

JOIN with ON clause

Source

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>,

JOIN with ON clause

Source

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>,

JOIN with ON clause

Source

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>,

JOIN with ON clause

Source

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>,

JOIN with ON clause

Source

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>,

JOIN with ON clause

Source

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>,

JOIN with ON clause

Source

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>,

JOIN with ON clause

Source

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>,

JOIN with ON clause

Source

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>,

JOIN with ON clause

Source