Struct Query 

pub struct Query<X: Extension = NoExt> {
    pub with: Option<With<X>>,
    pub body: SetExpr<X>,
    pub order_by: ThinVec<OrderByExpr<X>>,
    pub order_by_all: Option<Box<OrderByAll>>,
    pub limit_by: Option<Box<LimitBy<X>>>,
    pub limit: Option<Limit<X>>,
    pub settings: ThinVec<Setting<X>>,
    pub format: Option<Box<FormatClause>>,
    pub locking: ThinVec<LockingClause>,
    pub pipe_operators: ThinVec<PipeOperator<X>>,
    pub for_clause: Option<Box<ForClause>>,
    pub meta: Meta,
}

An SQL query.

Fields

with: Option<With<X>>

Common table expressions visible to this statement.

body: SetExpr<X>

Statement or query body governed by this node.

order_by: ThinVec<OrderByExpr<X>>

Ordering terms in source order.

order_by_all: Option<Box<OrderByAll>>

DuckDB’s ORDER BY ALL mode — sort by every projection column, left to right — with its optional direction/nulls modifiers; None for an ordinary (or absent) ORDER BY. Mutually exclusive with a non-empty order_by: DuckDB rejects mixing ALL with explicit sort keys (ORDER BY ALL, x / ORDER BY x, ALL are syntax errors; probed on 1.5.4), so ALL is a mode of the whole clause, never a sort-key expression — the column set is unknowable at parse time, so a synthetic key list would be a lie (the shape is anchored on the semantics). Boxed because the clause is rare while Query is a hot node (the Select::into precedent). Gated by GroupingSyntax::order_by_all; only the query-level clause admits ALL — DuckDB rejects it in window ORDER BY (“Cannot ORDER BY ALL in a window expression”) and has no DML sort tails.

limit_by: Option<Box<LimitBy<X>>>

ClickHouse LIMIT n [OFFSET m] BY expr, … — per-group row limiting, written after ORDER BY and before the ordinary limit tail. Its own field because it coexists with limit and means something different (see LimitBy); None for the common query that writes no LIMIT BY. Gated by QueryTailSyntax::limit_by_clause — off for every shipped preset but Lenient, so it stays None elsewhere. Boxed because the clause is rare while Query is a hot node (the order_by_all precedent) — keeping the 104-byte LimitBy off the inline Query footprint.

limit: Option<Limit<X>>

Row limit applied to the result.

settings: ThinVec<Setting<X>>

ClickHouse SETTINGS name = value, … — query-level setting overrides written after the ordinary limit tail (SELECT … LIMIT 10 SETTINGS max_threads = 8). Empty for the common query that writes none — a bare ThinVec costing one null pointer when unused, following the locking/pipe_operators list-tail precedent rather than a boxed option (a list’s own rarity optimization is the empty vector, so Query’s hot footprint grows by only that one pointer). Gated by QueryTailSyntax::settings_clause — on for Lenient only, so it stays empty under every oracle-compared preset.

format: Option<Box<FormatClause>>

ClickHouse FORMAT <name> — the output-format clause that closes the query, the last tail of all (after settings); None for the common query that names no format. The format name is a bare identifier (JSON, CSV, TabSeparated, Null), see FormatClause. Gated by QueryTailSyntax::format_clause — off for every shipped preset but Lenient, so it stays None elsewhere. Boxed because the clause is rare while Query is a hot node (the order_by_all/limit_by precedent), keeping the clause off the inline Query footprint at one pointer’s cost.

locking: ThinVec<LockingClause>

The row-locking clauses (FOR UPDATE/FOR SHARE/…) written after LIMIT. PostgreSQL admits several stacked clauses (FOR UPDATE OF a FOR SHARE OF b), MySQL exactly one, so this is a list; empty when the query writes none. Gated by QueryTailSyntax::locking_clauses. Not generic over X: a LockingClause carries only names and surface tags, no expression.

pipe_operators: ThinVec<PipeOperator<X>>

BigQuery/ZetaSQL |> pipe operators applied to this query’s result, left to right (FROM t |> WHERE x |> SELECT a). Empty for an ordinary query — the common case, so a bare ThinVec that costs one null pointer when unused, like locking. Each element is one PipeOperator step. Gated by QueryTailSyntax::pipe_syntax; off for every shipped preset, so the field stays empty there and the |> token never even lexes.

for_clause: Option<Box<ForClause>>

MSSQL FOR XML … / FOR JSON … result-shaping tail — the last clause of all, serializing the result as XML/JSON instead of a rowset; None for the common query that writes no FOR XML/FOR JSON. See ForClause. Gated by QueryTailSyntax::for_xml_json_clause — on for MSSQL and Lenient, so it stays None elsewhere. Boxed because the clause is rare while Query is a hot node (the order_by_all/format precedent), keeping the 92-byte ForClause off the inline Query footprint at one pointer’s cost. Not generic over X: a ForClause carries only mode tags and quoted names, no expression.

meta: Meta

Source location and node identity.

Trait Implementations

impl<X: Clone + Extension> Clone for Query<X>

fn clone(&self) -> Query<X>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<X: Debug + Extension> Debug for Query<X>

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

Formats the value using the given formatter.

impl<'de, X> Deserialize<'de> for Query<X>

where X: Deserialize<'de> + Extension,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<X: Eq + Extension> Eq for Query<X>

impl<X: Extension + Render> FragmentRender for Query<X>

impl<X: Hash + Extension> Hash for Query<X>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<X: PartialEq + Extension> PartialEq for Query<X>

fn eq(&self, other: &Query<X>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<X: Extension + Render> Render for Query<X>

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

Return the render for this value.

fn operand_binding_power(&self) -> Option<BindingPower>

The binding power this node contributes when it appears as an operand, or None (the default) for a self-delimiting node — an atom, call, or constructor — that never needs parentheses.

impl<X> Serialize for Query<X>

where X: Serialize + Extension,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<X: Extension> Spanned for Query<X>

fn span(&self) -> Span

Return the span for this value.

impl<X: PartialEq + Extension> StructuralPartialEq for Query<X>