Struct SelectQuery 

pub struct SelectQuery {

    pub with: With,
    pub distinct: Option<Distinct>,
    pub select_list: SelectList,
    pub from: TableRef,
    pub extra_from: Vec<TableRef>,
    pub where_: Where,
    pub group_by: GroupBy,
    pub having: Having,
    pub windows: Windows,
    pub order_by: OrderBy,
    pub limit: Limit,
    pub offset: Offset,
    pub fetch: Fetch,
    pub locks: Locks,
    pub combines: Combines,
}

A PostgreSQL SELECT.

The field order is the clause order of https://www.postgresql.org/docs/17/sql-select.html:

[ WITH [ RECURSIVE ] with_query [, ...] ]
SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
    [ * | expression [ [ AS ] output_name ] [, ...] ]
    [ FROM from_item [, ...] ]
    [ WHERE condition ]
    [ GROUP BY [ ALL | DISTINCT ] grouping_element [, ...] ]
    [ HAVING condition ]
    [ WINDOW window_name AS ( window_definition ) [, ...] ]
    [ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select ]
    [ ORDER BY expression [ ASC | DESC | USING operator ] [ NULLS { FIRST | LAST } ] [, ...] ]
    [ LIMIT { count | ALL } ]
    [ OFFSET start [ ROW | ROWS ] ]
    [ FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } { ONLY | WITH TIES } ]
    [ FOR { UPDATE | NO KEY UPDATE | SHARE | KEY SHARE } [ OF table_name [, ...] ]
      [ NOWAIT | SKIP LOCKED ] [...] ]

The set-operation line is the one the layout does not mirror, and deliberately: the trailing clauses after it belong to the combination, not to this query, and PostgreSQL says so —

Without parentheses, these clauses will be taken to apply to the result of the UNION, not to its right-hand input expression.

— so this query’s own ORDER BY/LIMIT/OFFSET/FETCH/FOR render where the fields sit and the whole thing is parenthesised when something is combined onto it, while the combination’s live inside Combines.

Fields

with: With

WITH ….

distinct: Option<Distinct>

DISTINCT / DISTINCT ON (…). None is ALL, the default.

select_list: SelectList

The projection. Empty renders *.

from: TableRef

The first FROM item, with its joins.

extra_from: Vec<TableRef>

Further comma-separated FROM items.

where_: Where

WHERE ….

group_by: GroupBy

GROUP BY ….

having: Having

HAVING ….

windows: Windows

WINDOW ….

order_by: OrderBy

ORDER BY … — this query’s own.

limit: Limit

LIMIT … — this query’s own.

offset: Offset

OFFSET … — this query’s own.

fetch: Fetch

FETCH … — this query’s own.

locks: Locks

FOR UPDATE ….

combines: Combines

The set operations, and the trailing clauses that belong to their result.

Implementations

impl SelectQuery

pub fn new() -> SelectQuery

An empty SELECT, which renders SELECT *.

pub fn apply(&mut self, mods: impl Mod<SelectQuery>)

Apply more mods to an existing query.

Trait Implementations

impl Clone for SelectQuery

fn clone(&self) -> SelectQuery

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SelectQuery

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

Formats the value using the given formatter.

impl Default for SelectQuery

fn default() -> SelectQuery

Returns the “default value” for a type.

impl Expression for SelectQuery

fn write_sql(&self, w: &mut SqlWriter<'_>)

Append this fragment to w.

impl HasCombines for SelectQuery

fn combines_mut(&mut self) -> &mut Combines

The set operations to modify.

impl HasExtraTables for SelectQuery

fn extra_tables_mut(&mut self) -> &mut Vec<TableRef>

The additional from-items to modify.

impl HasFetch for SelectQuery

fn fetch_mut(&mut self) -> &mut Fetch

The FETCH clause to modify.

impl HasGroupBy for SelectQuery

fn group_by_mut(&mut self) -> &mut GroupBy

The GROUP BY clause to modify.

impl HasHaving for SelectQuery

fn having_mut(&mut self) -> &mut Having

The HAVING clause to modify.

impl HasJoins for SelectQuery

fn joins_mut(&mut self) -> &mut Vec<Join>

The join list to modify.

impl HasLimit for SelectQuery

fn limit_mut(&mut self) -> &mut Limit

The LIMIT clause to modify.

impl HasLocks for SelectQuery

fn locks_mut(&mut self) -> &mut Locks

The locking clauses to modify.

impl HasOffset for SelectQuery

fn offset_mut(&mut self) -> &mut Offset

The OFFSET clause to modify.

impl HasOrderBy for SelectQuery

fn order_by_mut(&mut self) -> &mut OrderBy

The ORDER BY clause to modify.

impl HasSelectList for SelectQuery

fn select_list_mut(&mut self) -> &mut SelectList

The projection to modify.

impl HasTableRef for SelectQuery

fn table_ref_mut(&mut self) -> &mut TableRef

The table reference to modify.

impl HasWhere for SelectQuery

fn where_mut(&mut self) -> &mut Where

The WHERE clause to modify.

impl HasWindows for SelectQuery

fn windows_mut(&mut self) -> &mut Windows

The WINDOW clause to modify.

impl HasWith for SelectQuery

fn with_mut(&mut self) -> &mut With

The WITH clause to modify.

impl IntoExpr for SelectQuery

fn into_expr(self) -> Expr

Perform the conversion.

impl IntoExprList for SelectQuery

fn into_expr_list(self) -> Vec<Expr>

Perform the conversion.

impl Query for SelectQuery

fn query_type(&self) -> QueryType

Which statement this renders.

fn dialect(&self) -> &dyn Dialect

The dialect this query renders itself in.

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

Render to SQL and arguments, numbering placeholders from 1.

fn build_from(&self, start: usize) -> Result<(String, Vec<Value>), Error>

build with a different first placeholder position, for splicing into a statement that already has arguments — bob’s BuildN.

impl<H, L, M> QueryExtensions<H, L, M> for SelectQuery

fn hooks(&self) -> &[Hook]

Hooks to run before this query executes.

fn loaders(&self) -> &[Loader]

Loaders to run after this query executes, for eagerly loaded relations.

fn mapper_mods(&self) -> &[MapperMod]

Adjustments to the row mapper, for relations loaded in the same query.