Enum FromClause 

pub enum FromClause {
    Table {
        name: String,
        qualifier: String,
        alias: Option<String>,
    },
    Join {
        left: Box<FromClause>,
        right: Box<FromClause>,
        kind: JoinKind,
        on: Option<Expr>,
        using: Option<JoinUsing>,
        natural: bool,
        lateral: bool,
    },
    Values {
        rows: Vec<Vec<Expr>>,
        alias: Option<String>,
        column_aliases: Vec<String>,
    },
    Function {
        name: String,
        output_name: String,
        relation: Option<String>,
        args: Vec<Expr>,
        alias: Option<String>,
        column_aliases: Vec<String>,
        column_types: Vec<String>,
    },
    Subquery {
        body: Box<SelectStmt>,
        alias: Option<String>,
        column_aliases: Vec<String>,
    },
}

Variants

Table

FROM <table> [AS <alias>].

Fields

name: String

Durable catalog identity, including an explicit schema when present.

qualifier: String

Relation name visible to SQL column binding before an alias is applied.

alias: Option<String>

Join

FROM left <kind> right ON predicate. lateral is true when the right side is a LATERAL subquery / function – the engine re-evaluates it for every left row.

Fields

left: Box<FromClause>

right: Box<FromClause>

kind: JoinKind

on: Option<Expr>

Boolean qualification supplied by ON. This is mutually exclusive with using and natural in parser-produced trees.

using: Option<JoinUsing>

PostgreSQL USING (column, ...) [AS alias] metadata. The column list must remain explicit until both input row types are known so binding can validate each side and construct the merged output.

natural: bool

NATURAL derives its USING list from the visible columns of both input row types at binding time.

lateral: bool

Values

FROM (VALUES (...)...) [AS <alias>(<col_aliases>)].

Fields

rows: Vec<Vec<Expr>>

alias: Option<String>

column_aliases: Vec<String>

Function

FROM <fn>(<args>) [AS <alias>(<col_aliases>)] – e.g. generate_series(1, 5), unnest(arr), regexp_split_to_table, json_each(...), cypher(...) AS (col agtype, ...). The engine dispatches by name.

Fields

name: String

output_name: String

Local function identifier used as PostgreSQL’s default output column label. Kept separate from the catalog-qualified lookup name so quoted identifiers containing . remain indivisible.

relation: Option<String>

Catalog relation bound to a relation-aware table function. Kept separate from scalar arguments so name resolution, dependency tracking, and planning never treat it as text data.

args: Vec<Expr>

alias: Option<String>

column_aliases: Vec<String>

column_types: Vec<String>

Declared column types when the alias used a column definition list (AS (col agtype, n int)); empty when the alias only renamed columns. Type names are lowercased PostgreSQL internal names (agtype, int4, text, …).

Subquery

FROM (SELECT ...) AS <alias> – subquery as a relation. The body re-runs as if a CTE; the alias renames the result columns when supplied.

Fields

body: Box<SelectStmt>

alias: Option<String>

column_aliases: Vec<String>

Implementations

impl FromClause

pub fn collect_tables(&self, out: &mut Vec<(String, Option<String>)>)

All table names referenced under this clause, in declaration order. Used by the compiler to resolve unqualified column refs.

Trait Implementations

impl Clone for FromClause

fn clone(&self) -> FromClause

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FromClause

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FromClause

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for FromClause

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.