Struct Join 

pub struct Join {
    pub left: Arc<LogicalPlan>,
    pub right: Arc<LogicalPlan>,
    pub on: Vec<(Expr, Expr)>,
    pub filter: Option<Expr>,
    pub join_type: JoinType,
    pub join_constraint: JoinConstraint,
    pub schema: DFSchemaRef,
    pub null_equality: NullEquality,
    pub null_aware: bool,
}

Join two logical plans on one or more join columns

Fields

left: Arc<LogicalPlan>

Left input

right: Arc<LogicalPlan>

Right input

on: Vec<(Expr, Expr)>

Equijoin clause expressed as pairs of (left, right) join expressions

filter: Option<Expr>

Filters applied during join (non-equi conditions)

join_type: JoinType

Join type

join_constraint: JoinConstraint

Join constraint

schema: DFSchemaRef

The output schema, containing fields from the left and right inputs

null_equality: NullEquality

Defines the null equality for the join.

null_aware: bool

Whether this is a null-aware anti join (for NOT IN semantics).

Only applies to LeftAnti joins. When true, implements SQL NOT IN semantics where:

• If the right side (subquery) contains any NULL in join keys, no rows are output
• Left side rows with NULL in join keys are not output

This is required for correct NOT IN subquery behavior with three-valued logic.

Implementations

impl Join

pub fn try_new( left: Arc<LogicalPlan>, right: Arc<LogicalPlan>, on: Vec<(Expr, Expr)>, filter: Option<Expr>, join_type: JoinType, join_constraint: JoinConstraint, null_equality: NullEquality, null_aware: bool, ) -> Result<Self>

Creates a new Join operator with automatically computed schema.

This constructor computes the schema based on the join type and inputs, removing the need to manually specify the schema or call recompute_schema.

Arguments

• left - Left input plan
• right - Right input plan
• on - Join condition as a vector of (left_expr, right_expr) pairs
• filter - Optional filter expression (for non-equijoin conditions)
• join_type - Type of join (Inner, Left, Right, etc.)
• join_constraint - Join constraint (On, Using)
• null_equality - How to handle nulls in join comparisons
• null_aware - Whether this is a null-aware anti join (for NOT IN semantics)

Returns

A new Join operator with the computed schema

pub fn try_new_with_project_input( original: &LogicalPlan, left: Arc<LogicalPlan>, right: Arc<LogicalPlan>, column_on: (Vec<Column>, Vec<Column>), ) -> Result<(Self, bool)>

Create Join with input which wrapped with projection, this method is used in physical planning only to help create the physical join.

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 Hash for Join

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 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 PartialOrd for Join

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Join

impl StructuralPartialEq for Join