Struct Join 

pub struct Join {
    pub this: Expression,
    pub on: Option<Expression>,
    pub using: Vec<Identifier>,
    pub kind: JoinKind,
    pub use_inner_keyword: bool,
    pub use_outer_keyword: bool,
    pub deferred_condition: bool,
    pub join_hint: Option<String>,
    pub match_condition: Option<Expression>,
    pub pivots: Vec<Expression>,
}

Represent a JOIN clause between two table sources.

The join condition can be specified via on (ON predicate) or using (USING column list), but not both. The kind field determines the join type (INNER, LEFT, CROSS, etc.).

Fields

this: Expression

The right-hand table expression being joined.

on: Option<Expression>

The ON condition (mutually exclusive with using).

using: Vec<Identifier>

The USING column list (mutually exclusive with on).

kind: JoinKind

The join type (INNER, LEFT, RIGHT, FULL, CROSS, etc.).

use_inner_keyword: bool

Whether INNER keyword was explicitly used (INNER JOIN vs JOIN)

use_outer_keyword: bool

Whether OUTER keyword was explicitly used (LEFT OUTER JOIN vs LEFT JOIN)

deferred_condition: bool

Whether the ON/USING condition was deferred (assigned right-to-left for chained JOINs)

join_hint: Option<String>

TSQL join hint: LOOP, HASH, MERGE (e.g., INNER LOOP JOIN)

match_condition: Option<Expression>

Snowflake ASOF JOIN match condition (MATCH_CONDITION clause)

pivots: Vec<Expression>

PIVOT/UNPIVOT operations that follow this join (Oracle/TSQL syntax)

Trait Implementations

impl Clone for Join

fn clone(&self) -> Join

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Join

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Join

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Join

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

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 Join