Struct Except 

pub struct Except {

    pub left: Expression,
    pub right: Expression,
    pub all: bool,
    pub distinct: bool,
    pub with: Option<With>,
    pub order_by: Option<OrderBy>,
    pub limit: Option<Box<Expression>>,
    pub offset: Option<Box<Expression>>,
    pub distribute_by: Option<DistributeBy>,
    pub sort_by: Option<SortBy>,
    pub cluster_by: Option<ClusterBy>,
    pub by_name: bool,
    pub side: Option<String>,
    pub kind: Option<String>,
    pub corresponding: bool,
    pub strict: bool,
    pub on_columns: Vec<Expression>,
}

Represent an EXCEPT (MINUS) set operation between two query expressions.

Returns rows from the left operand that do not appear in the right operand. When all is true, duplicates are subtracted according to their multiplicity.

Fields

left: Expression

The left-hand query operand.

right: Expression

The right-hand query operand (rows to subtract).

all: bool

Whether EXCEPT ALL (true) or EXCEPT (false, which deduplicates).

distinct: bool

Whether DISTINCT was explicitly specified

with: Option<With>

Optional WITH clause

order_by: Option<OrderBy>

ORDER BY applied to entire EXCEPT result

limit: Option<Box<Expression>>

LIMIT applied to entire EXCEPT result

offset: Option<Box<Expression>>

OFFSET applied to entire EXCEPT result

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)

by_name: bool

DuckDB BY NAME modifier

side: Option<String>

BigQuery: Set operation side (LEFT, RIGHT, FULL)

kind: Option<String>

BigQuery: Set operation kind (INNER)

corresponding: bool

BigQuery: CORRESPONDING modifier

strict: bool

BigQuery: STRICT modifier (before CORRESPONDING)

on_columns: Vec<Expression>

BigQuery: BY (columns) after CORRESPONDING

Trait Implementations

impl Clone for Except

fn clone(&self) -> Except

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Except

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Except

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Except

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

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 Except