Struct SelectStatement 

pub struct SelectStatement {

    pub distinct: bool,
    pub columns: Vec<String>,
    pub select_items: Vec<SelectItem>,
    pub from_source: Option<TableSource>,
    pub from_table: Option<String>,
    pub from_subquery: Option<Box<SelectStatement>>,
    pub from_function: Option<TableFunction>,
    pub from_alias: Option<String>,
    pub joins: Vec<JoinClause>,
    pub where_clause: Option<WhereClause>,
    pub order_by: Option<Vec<OrderByItem>>,
    pub group_by: Option<Vec<SqlExpression>>,
    pub having: Option<SqlExpression>,
    pub qualify: Option<SqlExpression>,
    pub limit: Option<usize>,
    pub offset: Option<usize>,
    pub ctes: Vec<CTE>,
    pub into_table: Option<IntoTable>,
    pub set_operations: Vec<(SetOperation, Box<SelectStatement>)>,
    pub leading_comments: Vec<Comment>,
    pub trailing_comment: Option<Comment>,
}

Fields

distinct: bool

columns: Vec<String>

select_items: Vec<SelectItem>

from_source: Option<TableSource>

from_table: Option<String>

👎Deprecated:

Use from_source instead

from_subquery: Option<Box<SelectStatement>>

👎Deprecated:

Use from_source instead

from_function: Option<TableFunction>

👎Deprecated:

Use from_source instead

from_alias: Option<String>

👎Deprecated:

Use from_source instead

joins: Vec<JoinClause>

where_clause: Option<WhereClause>

order_by: Option<Vec<OrderByItem>>

group_by: Option<Vec<SqlExpression>>

having: Option<SqlExpression>

qualify: Option<SqlExpression>

limit: Option<usize>

offset: Option<usize>

ctes: Vec<CTE>

into_table: Option<IntoTable>

set_operations: Vec<(SetOperation, Box<SelectStatement>)>

leading_comments: Vec<Comment>

trailing_comment: Option<Comment>

Implementations

impl SelectStatement

pub fn set_from_table(&mut self, table: String)

Point the FROM clause at a named table, updating from_source and the legacy fields together.

Both representations must move in lockstep: the executor (query_engine.rs) reads from_source first and only falls back to from_table, so a rewrite that touches just the legacy field is silently discarded whenever from_source is populated.

pub fn set_from_subquery(&mut self, query: Box<SelectStatement>)

Replace the derived table (subquery) in the FROM clause, updating from_source and the legacy field together.

The parser populates from_subquery and from_source::DerivedTable with clones of the same subquery, so rewriting only the former leaves a stale copy in from_source — which is the one the executor reads. The existing derived-table alias is preserved.

pub fn map_from_subquery( &mut self, f: impl FnOnce(SelectStatement) -> SelectStatement, )

Rewrite the derived table (subquery) in the FROM clause in place, if there is one, keeping from_source and the legacy field in sync.

Prefer this over taking from_subquery and reassigning it: the take-then-restore pattern leaves the from_source copy stale in between, and the alias is easy to drop on the way through.

Trait Implementations

impl Clone for SelectStatement

fn clone(&self) -> SelectStatement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SelectStatement

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

Formats the value using the given formatter.

impl Default for SelectStatement

fn default() -> Self

Returns the “default value” for a type.