Struct Join 

pub struct Join {
    pub join_type: JoinType,
    pub table: String,
    pub alias: Option<String>,
    pub on: Expr,
    pub lateral: bool,
    pub is_subquery: bool,
    pub subquery_params: Vec<Value>,
    pub subquery: Option<Box<SelectQuery>>,
}

A JOIN clause.

Fields

join_type: JoinType

Type of join

table: String

Table to join (table name or subquery SQL)

alias: Option<String>

Optional table alias

on: Expr

ON condition

lateral: bool

Whether this is a LATERAL join (subquery can reference outer query columns).

Supported by PostgreSQL and MySQL 8.0+. Not supported by SQLite.

is_subquery: bool

Whether the table field contains a subquery (wrapped in parentheses).

subquery_params: Vec<Value>

Parameters from a subquery table expression.

subquery: Option<Box<SelectQuery>>

Deferred subquery builder (dialect-aware).

Implementations

impl Join

pub fn inner(table: impl Into<String>, on: Expr) -> Self

Create an INNER JOIN.

pub fn left(table: impl Into<String>, on: Expr) -> Self

Create a LEFT JOIN.

pub fn right(table: impl Into<String>, on: Expr) -> Self

Create a RIGHT JOIN.

pub fn full(table: impl Into<String>, on: Expr) -> Self

Create a FULL OUTER JOIN.

pub fn cross(table: impl Into<String>) -> Self

Create a CROSS JOIN (no ON condition needed, but we require one for uniformity).

pub fn lateral( join_type: JoinType, subquery_sql: impl Into<String>, alias: impl Into<String>, on: Expr, params: Vec<Value>, ) -> Self

Create a LATERAL JOIN with a subquery.

A LATERAL subquery can reference columns from preceding FROM items. Supported by PostgreSQL (9.3+) and MySQL (8.0.14+). Not supported by SQLite.

Arguments

• join_type - The join type (typically JoinType::Inner or JoinType::Left)
• subquery_sql - The subquery SQL (without parentheses)
• alias - Required alias for the lateral subquery
• on - ON condition (use Expr::raw("TRUE") for implicit join)
• params - Parameters for the subquery

pub fn lateral_query( join_type: JoinType, subquery: SelectQuery, alias: impl Into<String>, on: Expr, ) -> Self

Create a LATERAL JOIN with a deferred subquery builder.

pub fn left_lateral( subquery_sql: impl Into<String>, alias: impl Into<String>, on: Expr, params: Vec<Value>, ) -> Self

Create a LEFT JOIN LATERAL (most common form).

Shorthand for Join::lateral(JoinType::Left, ...).

pub fn inner_lateral( subquery_sql: impl Into<String>, alias: impl Into<String>, on: Expr, params: Vec<Value>, ) -> Self

Create an INNER JOIN LATERAL.

pub fn cross_lateral( subquery_sql: impl Into<String>, alias: impl Into<String>, params: Vec<Value>, ) -> Self

Create a CROSS JOIN LATERAL (no ON condition).

pub fn alias(self, alias: impl Into<String>) -> Self

Set an alias for the joined table.

pub fn set_lateral(self) -> Self

Mark this join as LATERAL.

pub fn to_sql(&self) -> (String, Vec<Value>)

Generate SQL for this JOIN clause and collect parameters.

Returns a tuple of (sql, params) since the ON condition may contain literal values that need to be bound as parameters.

pub fn to_sql_with_dialect(&self, dialect: Dialect) -> (String, Vec<Value>)

Generate SQL for this JOIN clause with a specific dialect.

pub fn build(&self, params: &mut Vec<Value>, offset: usize) -> String

Generate SQL and collect parameters.

pub fn build_with_dialect( &self, dialect: Dialect, params: &mut Vec<Value>, offset: usize, ) -> String

Generate SQL and collect parameters with a specific dialect.

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.