Struct SelectStatement 

pub struct SelectStatement {

    pub comments: Vec<String>,
    pub ctes: Vec<Cte>,
    pub distinct: bool,
    pub top: Option<Box<Expr>>,
    pub columns: Vec<SelectItem>,
    pub from: Option<FromClause>,
    pub joins: Vec<JoinClause>,
    pub where_clause: Option<Expr>,
    pub group_by: Vec<Expr>,
    pub having: Option<Expr>,
    pub order_by: Vec<OrderByItem>,
    pub limit: Option<Expr>,
    pub offset: Option<Expr>,
    pub fetch_first: Option<Expr>,
    pub qualify: Option<Expr>,
    pub window_definitions: Vec<WindowDefinition>,
}

A SELECT statement, including CTEs.

Aligned with sqlglot’s Select expression which wraps With, From, Where, Group, Having, Order, Limit, Offset, Window.

Fields

comments: Vec<String>

Comments attached to this statement.

ctes: Vec<Cte>

Common Table Expressions (WITH clause)

distinct: bool

top: Option<Box<Expr>>

TOP N (TSQL-style)

columns: Vec<SelectItem>

from: Option<FromClause>

joins: Vec<JoinClause>

where_clause: Option<Expr>

group_by: Vec<Expr>

having: Option<Expr>

order_by: Vec<OrderByItem>

limit: Option<Expr>

offset: Option<Expr>

fetch_first: Option<Expr>

Oracle-style FETCH FIRST n ROWS ONLY

qualify: Option<Expr>

QUALIFY clause (BigQuery, Snowflake)

window_definitions: Vec<WindowDefinition>

Named WINDOW definitions

Implementations

impl SelectStatement

pub fn add_select(&mut self, expr_str: &str)

Add a column to the SELECT list.

Examples

use sqlglot_rust::builder::select;

let mut stmt = select(&["a"]).from("t").build_select();
stmt.add_select("b");

pub fn add_select_dialect(&mut self, expr_str: &str, dialect: Dialect)

Add a column with dialect-specific parsing.

pub fn add_select_expr(&mut self, expr: Expr, alias: Option<&str>)

Add an expression to the SELECT list.

pub fn add_where(&mut self, condition: &str)

Add a condition to the WHERE clause (AND).

Examples

use sqlglot_rust::builder::select;

let mut stmt = select(&["a"]).from("t").build_select();
stmt.add_where("x > 1");
stmt.add_where("y < 10");

pub fn add_where_dialect(&mut self, condition: &str, dialect: Dialect)

Add a WHERE condition with dialect-specific parsing.

pub fn add_where_expr(&mut self, expr: Expr)

Add an expression to the WHERE clause (AND).

pub fn add_join(&mut self, table_name: &str, on: &str, join_type: JoinType)

Add a JOIN clause.

Examples

use sqlglot_rust::builder::select;
use sqlglot_rust::ast::JoinType;

let mut stmt = select(&["*"]).from("users").build_select();
stmt.add_join("orders", "users.id = orders.user_id", JoinType::Left);

pub fn add_join_dialect( &mut self, table_name: &str, on: &str, join_type: JoinType, dialect: Dialect, )

Add a JOIN with dialect-specific parsing.

pub fn add_join_subquery( &mut self, query: Statement, alias: &str, on: &str, join_type: JoinType, )

Add a JOIN with a subquery.

pub fn add_join_subquery_dialect( &mut self, query: Statement, alias: &str, on: &str, join_type: JoinType, dialect: Dialect, )

Add a JOIN with a subquery and dialect-specific parsing.

pub fn as_subquery(self, alias: &str) -> TableSource

Wrap this SELECT as a subquery with an alias.

Examples

use sqlglot_rust::builder::select;

let inner = select(&["id", "name"]).from("users").build_select();
let subq = inner.as_subquery("u");

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<'de> Deserialize<'de> for SelectStatement

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SelectStatement

fn eq(&self, other: &SelectStatement) -> 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 Serialize for SelectStatement

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SelectStatement