Struct Subquery 

pub struct Subquery {
    pub this: Expression,
    pub alias: Option<Identifier>,
    pub column_aliases: Vec<Identifier>,
    pub order_by: Option<OrderBy>,
    pub limit: Option<Limit>,
    pub offset: Option<Offset>,
    pub distribute_by: Option<DistributeBy>,
    pub sort_by: Option<SortBy>,
    pub cluster_by: Option<ClusterBy>,
    pub lateral: bool,
    pub modifiers_inside: bool,
    pub trailing_comments: Vec<String>,
}

Represent a parenthesized subquery expression.

A subquery wraps an inner query (typically a SELECT, UNION, etc.) in parentheses and optionally applies an alias, column aliases, ORDER BY, LIMIT, and OFFSET. The modifiers_inside flag controls whether the modifiers are rendered inside or outside the parentheses.

Subqueries appear in many SQL contexts: FROM clauses, WHERE IN/EXISTS, scalar subqueries in select-lists, and derived tables.

Fields

this: Expression

The inner query expression.

alias: Option<Identifier>

Optional alias for the derived table.

column_aliases: Vec<Identifier>

Optional column aliases: AS t(c1, c2)

order_by: Option<OrderBy>

ORDER BY clause (for parenthesized queries)

limit: Option<Limit>

LIMIT clause

offset: Option<Offset>

OFFSET clause

distribute_by: Option<DistributeBy>

DISTRIBUTE BY clause (Hive/Spark)

sort_by: Option<SortBy>

SORT BY clause (Hive/Spark)

cluster_by: Option<ClusterBy>

CLUSTER BY clause (Hive/Spark)

lateral: bool

Whether this is a LATERAL subquery (can reference earlier tables in FROM)

modifiers_inside: bool

Whether modifiers (ORDER BY, LIMIT, OFFSET) should be generated inside the parentheses true: (SELECT 1 LIMIT 1) - modifiers inside false: (SELECT 1) LIMIT 1 - modifiers outside

trailing_comments: Vec<String>

Trailing comments after the closing paren

Trait Implementations

impl Clone for Subquery

fn clone(&self) -> Subquery

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Subquery

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Subquery

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Subquery

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

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 Subquery