Struct SelectQuery 

pub struct SelectQuery {

    pub with: With,
    pub distinct: bool,
    pub select_list: SelectList,
    pub values: Values,
    pub from: TableRef,
    pub extra_from: Vec<TableRef>,
    pub where_: Where,
    pub group_by: GroupBy,
    pub having: Having,
    pub windows: Windows,
    pub compounds: Compounds,
    pub order_by: OrderBy,
    pub limit: Limit,
    pub offset: Offset,
}

A SQLite SELECT.

The field order is the clause order of https://www.sqlite.org/lang_select.html:

[ WITH [ RECURSIVE ] common-table-expression [, ...] ]
select-core [ compound-operator select-core ]*
[ ORDER BY ordering-term [, ...] ]
[ LIMIT expr [ ( OFFSET | , ) expr ] ]

select-core:
    SELECT [ DISTINCT | ALL ] result-column [, ...]
        [ FROM table-or-subquery [, ...] | join-clause ]
        [ WHERE expr ]
        [ GROUP BY expr [, ...] [ HAVING expr ] ]
        [ WINDOW window-name AS window-defn [, ...] ]
  | VALUES ( expr [, ...] ) [, ...]

Three things in that grammar are unlike PostgreSQL’s, and all three are visible in this type.

A compound operand is a bare select-core. There are no parentheses around it and none may be added — a parenthesised select is a table-or-subquery in SQLite, never a compound operand. So the ORDER BY and LIMIT after the last operand are the only ones there can be, they always apply to the whole compound, and this type therefore has one set of them rather than PostgreSQL’s two. See Compound.

OFFSET lives inside the LIMIT production. SELECT … OFFSET 5 with no LIMIT is a syntax error, so an offset without a limit is a recorded Error::Incomplete rather than SQL that will be rejected later.

VALUES (…), (…) is a select-core in its own right. values is that alternative: when it is non-empty the statement is a VALUES statement, and the clauses that only a SELECT core can carry are a recorded failure rather than silently dropped. A real SQLite additionally refuses ORDER BY/LIMIT when the last core is a VALUES, which its own parser accepts; that one is left to the engine, since whether it holds depends on what is compounded after the VALUES.

Fields

with: With

WITH ….

distinct: bool

SELECT DISTINCT. false is ALL, the default, which adds nothing.

select_list: SelectList

The result columns. Empty renders *.

values: Values

The VALUES (…), (…) alternative to the whole SELECT core.

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 ….

compounds: Compounds

The compound operands, applied left to right.

order_by: OrderBy

ORDER BY …, which belongs to the whole compound when there is one.

limit: Limit

LIMIT ….

offset: Offset

OFFSET …, which cannot stand without a limit.

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 HasCompounds for SelectQuery

fn compounds_mut(&mut self) -> &mut Compounds

The compound operands to modify.

impl HasExtraTables for SelectQuery

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

The additional from-items 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 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 HasValues for SelectQuery

fn values_mut(&mut self) -> &mut Values

The row source 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.