Struct Select 

pub struct Select {
    pub table: String,
    pub items: Vec<SelectItem>,
    pub joins: Vec<JoinClause>,
    pub filter: Option<Expr>,
    pub order_by: Vec<OrderBy>,
    pub take: Option<i32>,
    pub skip: Option<u32>,
    pub group_by: Vec<ColumnMarker>,
    pub distinct: Vec<String>,
    pub having: Option<Expr>,
    pub order_by_items: Vec<OrderByItem>,
    pub order_by_exprs: Vec<(Expr, OrderDir)>,
}

SELECT query AST node.

Fields

table: String

Table name.

items: Vec<SelectItem>

Select items (columns or computed expressions).

joins: Vec<JoinClause>

JOIN clauses.

filter: Option<Expr>

WHERE clause.

order_by: Vec<OrderBy>

ORDER BY clauses.

take: Option<i32>

Row count to return (maps to SQL LIMIT).

Positive values limit forward; negative values signal backward pagination (callers must negate and reverse ORDER BY in application code). The absolute value is used when building the SQL LIMIT clause.

skip: Option<u32>

Row offset to skip (maps to SQL OFFSET).

group_by: Vec<ColumnMarker>

GROUP BY columns.

distinct: Vec<String>

Columns to deduplicate on.

Non-empty activates deduplication:

• Postgres: SELECT DISTINCT ON (cols)
• SQLite / MySQL: plain SELECT DISTINCT

having: Option<Expr>

HAVING clause (post-GROUP BY filter).

order_by_items: Vec<OrderByItem>

ORDER BY items preserved in their original mixed column/expression order.

order_by_exprs: Vec<(Expr, OrderDir)>

ORDER BY expression items (for aggregate functions, e.g. COUNT(*) DESC).

Implementations

impl Select

pub fn from_table(table: impl Into<String>) -> SelectBuilder

Creates a new SELECT query builder for the given table.

Trait Implementations

impl Clone for Select

fn clone(&self) -> Select

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Select

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

Formats the value using the given formatter.

impl PartialEq for Select

fn eq(&self, other: &Select) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Select