Enum SetExpr 

pub enum SetExpr<X: Extension = NoExt> {
    Select {
        select: Box<Select<X>>,
        meta: Meta,
    },
    Values {
        values: Box<Values<X>>,
        meta: Meta,
    },
    Query {
        query: Box<Query<X>>,
        meta: Meta,
    },
    SetOperation {
        op: SetOperator,
        all: bool,
        by_name: bool,
        left: Box<SetExpr<X>>,
        right: Box<SetExpr<X>>,
        meta: Meta,
    },
    Pivot {
        pivot: Box<Pivot<X>>,
        meta: Meta,
    },
    Unpivot {
        unpivot: Box<Unpivot<X>>,
        meta: Meta,
    },
}

The SQL set expr forms represented by the AST.

Variants

Select

A SELECT query body.

Fields

select: Box<Select<X>>

The select body; see Select.

meta: Meta

Source location and node identity.

Values

A VALUES (...) row-constructor query body.

Fields

values: Box<Values<X>>

Values in source order.

meta: Meta

Source location and node identity.

Query

A parenthesized nested query body.

Fields

query: Box<Query<X>>

Query governed by this node.

meta: Meta

Source location and node identity.

SetOperation

A set operation combining two query bodies (UNION/INTERSECT/EXCEPT).

Fields

op: SetOperator

Operator applied by this expression.

all: bool

Whether the all form was present in the source.

by_name: bool

DuckDB’s UNION [ALL] BY NAME modifier: pair the two inputs’ columns by name (padding a side’s missing columns with NULL) instead of by position. A semantic modifier of the operation — it changes column correspondence — so it is a flag on this node, not a spelling tag or a new SetOperator variant (a semantic modifier is a shape field, a pure spelling would be a tag). Orthogonal to all, exactly as DuckDB models it — UNION [ALL] BY NAME serializes as setop_type: UNION_BY_NAME with a separate setop_all (probed on 1.5.4). DuckDB accepts BY NAME on UNION only (INTERSECT/EXCEPT BY NAME are syntax errors; probed on 1.5.4), so the parser sets this true only for SetOperator::Union. Gated by SelectSyntax::union_by_name; false for every ordinary (positional) set operation.

left: Box<SetExpr<X>>

Left-hand operand.

right: Box<SetExpr<X>>

Right-hand operand.

meta: Meta

Source location and node identity.

Pivot

DuckDB’s PIVOT operator standing as a query body — the CTE body, the CREATE VIEW/CREATE TABLE AS/CREATE MACRO … AS TABLE body, or any other query-body position (WITH p AS (PIVOT t ON x USING sum(y)) SELECT …, CREATE VIEW v AS PIVOT t ON x IN (…) USING sum(y); both probed on 1.5.4). DuckDB admits PIVOT/UNPIVOT at query-body position but not DESCRIBE/SHOW (a CTE body with those is Parser Error: A CTE needs a SELECT), so this is a query-body variant — reusing the shared Pivot core (tagged PivotSpelling::Statement) exactly as Statement::Pivot and TableFactor::Pivot do — rather than a general “statement in query position” carrier (which the canonical-shape rule bans as a vibe-union, and which the divergent composition of DESCRIBE/SHOW would misrepresent). Boxed to keep this hot enum within its size budget. Gated by TableFactorSyntax::pivot.

Fields

pivot: Box<Pivot<X>>

The pivot operation; see Pivot.

meta: Meta

Source location and node identity.

Unpivot

DuckDB’s UNPIVOT operator standing as a query body — the Pivot counterpart, sharing the Unpivot core with Statement::Unpivot and TableFactor::Unpivot. Gated by TableFactorSyntax::unpivot.

Fields

unpivot: Box<Unpivot<X>>

The unpivot operation; see Unpivot.

meta: Meta

Source location and node identity.

Trait Implementations

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

fn clone(&self) -> SetExpr<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 SetExpr<X>

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

Formats the value using the given formatter.

impl<'de, X> Deserialize<'de> for SetExpr<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 SetExpr<X>

impl<X: Hash + Extension> Hash for SetExpr<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 SetExpr<X>

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

Equality operator ==.

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

Inequality operator !=.

impl<X: Extension + Render> Render for SetExpr<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 SetExpr<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 SetExpr<X>

fn span(&self) -> Span

Return the span for this value.

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