Type Alias SelectBuilder 

pub type SelectBuilder<'a, Schema, State, Table = (), Marker = (), Row = (), Grouped = ()> = QueryBuilder<'a, Schema, State, Table, Marker, Row, Grouped>;

Builds a SELECT query specifically for PostgreSQL

Aliased Type

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

Fields

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

Implementations

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

Specifies the table to select FROM and transitions state.

impl<'a, S, State, T, M, R, G> SelectBuilder<'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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

JOIN with ON clause

pub fn left_join_using<U: PostgresTable<'a>>( self, table: U, columns: impl ToSQL<'a, PostgresValue<'a>>, ) -> SelectBuilder<'a, S, SelectJoinSet, U, <M as ScopePush<U>>::Out, <M as AfterLeftJoin<R, U>>::NewRow, G>

where M: AfterLeftJoin<R, U> + ScopePush<U>,

JOIN with USING clause (PostgreSQL-specific)

pub fn left_outer_join_using<U: PostgresTable<'a>>( self, table: U, columns: impl ToSQL<'a, PostgresValue<'a>>, ) -> SelectBuilder<'a, S, SelectJoinSet, U, <M as ScopePush<U>>::Out, <M as AfterLeftJoin<R, U>>::NewRow, G>

where M: AfterLeftJoin<R, U> + ScopePush<U>,

JOIN with USING clause (PostgreSQL-specific)

pub fn right_join_using<U: PostgresTable<'a>>( self, table: U, columns: impl ToSQL<'a, PostgresValue<'a>>, ) -> SelectBuilder<'a, S, SelectJoinSet, U, <M as ScopePush<U>>::Out, <M as AfterRightJoin<R, U>>::NewRow, G>

where M: AfterRightJoin<R, U> + ScopePush<U>,

JOIN with USING clause (PostgreSQL-specific)

pub fn right_outer_join_using<U: PostgresTable<'a>>( self, table: U, columns: impl ToSQL<'a, PostgresValue<'a>>, ) -> SelectBuilder<'a, S, SelectJoinSet, U, <M as ScopePush<U>>::Out, <M as AfterRightJoin<R, U>>::NewRow, G>

where M: AfterRightJoin<R, U> + ScopePush<U>,

JOIN with USING clause (PostgreSQL-specific)

pub fn full_join_using<U: PostgresTable<'a>>( self, table: U, columns: impl ToSQL<'a, PostgresValue<'a>>, ) -> SelectBuilder<'a, S, SelectJoinSet, U, <M as ScopePush<U>>::Out, <M as AfterFullJoin<R, U>>::NewRow, G>

where M: AfterFullJoin<R, U> + ScopePush<U>,

JOIN with USING clause (PostgreSQL-specific)

pub fn full_outer_join_using<U: PostgresTable<'a>>( self, table: U, columns: impl ToSQL<'a, PostgresValue<'a>>, ) -> SelectBuilder<'a, S, SelectJoinSet, U, <M as ScopePush<U>>::Out, <M as AfterFullJoin<R, U>>::NewRow, G>

where M: AfterFullJoin<R, U> + ScopePush<U>,

JOIN with USING clause (PostgreSQL-specific)

pub fn inner_join_using<U: PostgresTable<'a>>( self, table: U, columns: impl ToSQL<'a, PostgresValue<'a>>, ) -> SelectBuilder<'a, S, SelectJoinSet, U, <M as ScopePush<U>>::Out, <M as AfterJoin<R, U>>::NewRow, G>

where M: AfterJoin<R, U> + ScopePush<U>,

JOIN with USING clause (PostgreSQL-specific)

pub fn join_using<U: PostgresTable<'a>>( self, table: U, columns: impl ToSQL<'a, PostgresValue<'a>>, ) -> SelectBuilder<'a, S, SelectJoinSet, U, <M as ScopePush<U>>::Out, <M as AfterJoin<R, U>>::NewRow, G>

where M: AfterJoin<R, U> + ScopePush<U>,

JOIN with USING clause (PostgreSQL-specific)

impl<'a, S, State, T, M, R, G> SelectBuilder<'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, PostgresValue<'a>>, E::SQLType: BooleanLike,

Adds a WHERE clause to filter query results.

impl<'a, S, State, T, M, R, G> SelectBuilder<'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, PostgresValue<'a>>,

Adds a GROUP BY clause to the query.

impl<'a, S, State, T, M, R, G> SelectBuilder<'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, PostgresValue<'a>>, E::SQLType: BooleanLike,

Adds a HAVING clause after GROUP BY.

impl<'a, S, State, T, M, R, G> SelectBuilder<'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, PostgresValue<'a>>,

Sorts the query results.

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

where State: LimitAllowed,

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

Limits the number of rows returned.

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

where State: OffsetAllowed,

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

Sets the offset for the query results.

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

where State: AsCteState, T: SQLTable<'a, PostgresSchemaType, PostgresValue<'a>>,

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

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

impl<'a, S, State, T, M, R, G> SelectBuilder<'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, S, State, T, M, R, G> SelectBuilder<'a, S, State, T, M, R, G>

where State: ForLockableState,

pub fn for_update(self) -> SelectBuilder<'a, S, SelectForSet, T, M, R, G>

Adds FOR UPDATE clause to lock selected rows for update.

pub fn for_share(self) -> SelectBuilder<'a, S, SelectForSet, T, M, R, G>

Adds FOR SHARE clause to lock selected rows for shared access.

pub fn for_no_key_update(self) -> SelectBuilder<'a, S, SelectForSet, T, M, R, G>

Adds FOR NO KEY UPDATE clause.

pub fn for_key_share(self) -> SelectBuilder<'a, S, SelectForSet, T, M, R, G>

Adds FOR KEY SHARE clause.

pub fn for_update_of<U: PostgresTable<'a>>( self, table: U, ) -> SelectBuilder<'a, S, SelectForSet, T, M, R, G>

Adds FOR UPDATE OF table clause.

pub fn for_share_of<U: PostgresTable<'a>>( self, table: U, ) -> SelectBuilder<'a, S, SelectForSet, T, M, R, G>

Adds FOR SHARE OF table clause.

impl<S, T, M, R, G> SelectBuilder<'_, S, SelectForSet, T, M, R, G>

pub fn nowait(self) -> Self

Adds NOWAIT option to fail immediately if rows are locked.

pub fn skip_locked(self) -> Self

Adds SKIP LOCKED option to skip over locked rows.

Trait Implementations

impl<'a, S, State, T, M, R, G> Expr<'a, PostgresValue<'a>> for SelectBuilder<'a, S, State, T, M, R, G>

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

type SQLType = <M as SubqueryType<'a, PostgresValue<'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.

impl<'a, S, State: ExecutableState, T, M, R, G> IntoSelect<'a, S, M, R> for SelectBuilder<'a, S, State, T, M, R, G>

type State = State

type Table = T

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