Enum TableFactor 

pub enum TableFactor {
    Table {
        name: ObjectName,
        alias: Option<TableAlias>,
        args: Option<TableFunctionArgs>,
        with_hints: Vec<Expr>,
        version: Option<TableVersion>,
        with_ordinality: bool,
        partitions: Vec<Ident>,
        json_path: Option<JsonPath>,
        sample: Option<TableSampleKind>,
        index_hints: Vec<TableIndexHints>,
    },
    Derived {
        lateral: bool,
        subquery: Box<Query>,
        alias: Option<TableAlias>,
        sample: Option<TableSampleKind>,
    },
    TableFunction {
        expr: Expr,
        alias: Option<TableAlias>,
    },
    Function {
        lateral: bool,
        name: ObjectName,
        args: Vec<FunctionArg>,
        with_ordinality: bool,
        alias: Option<TableAlias>,
    },
    UNNEST {
        alias: Option<TableAlias>,
        array_exprs: Vec<Expr>,
        with_offset: bool,
        with_offset_alias: Option<Ident>,
        with_ordinality: bool,
    },
    JsonTable {
        json_expr: Expr,
        json_path: ValueWithSpan,
        columns: Vec<JsonTableColumn>,
        alias: Option<TableAlias>,
    },
    OpenJsonTable {
        json_expr: Expr,
        json_path: Option<ValueWithSpan>,
        columns: Vec<OpenJsonTableColumn>,
        alias: Option<TableAlias>,
    },
    NestedJoin {
        table_with_joins: Box<TableWithJoins>,
        alias: Option<TableAlias>,
    },
    Pivot {
        table: Box<TableFactor>,
        aggregate_functions: Vec<ExprWithAlias>,
        value_column: Vec<Expr>,
        value_source: PivotValueSource,
        default_on_null: Option<Expr>,
        alias: Option<TableAlias>,
    },
    Unpivot {
        table: Box<TableFactor>,
        value: Expr,
        name: Ident,
        columns: Vec<ExprWithAlias>,
        null_inclusion: Option<NullInclusion>,
        alias: Option<TableAlias>,
    },
    MatchRecognize {
        table: Box<TableFactor>,
        partition_by: Vec<Expr>,
        order_by: Vec<OrderByExpr>,
        measures: Vec<Measure>,
        rows_per_match: Option<RowsPerMatch>,
        after_match_skip: Option<AfterMatchSkip>,
        pattern: MatchRecognizePattern,
        symbols: Vec<SymbolDefinition>,
        alias: Option<TableAlias>,
    },
    XmlTable {
        namespaces: Vec<XmlNamespaceDefinition>,
        row_expression: Expr,
        passing: XmlPassingClause,
        columns: Vec<XmlTableColumn>,
        alias: Option<TableAlias>,
    },
    SemanticView {
        name: ObjectName,
        dimensions: Vec<Expr>,
        metrics: Vec<Expr>,
        facts: Vec<Expr>,
        where_clause: Option<Expr>,
        alias: Option<TableAlias>,
    },
}

A table name or a parenthesized subquery with an optional alias

Variants

Table

A named table or relation, possibly with arguments, hints, or sampling.

Fields

name: ObjectName

Table or relation name.

alias: Option<TableAlias>

Optional alias for the table (e.g. table AS t).

args: Option<TableFunctionArgs>

Arguments of a table-valued function, as supported by Postgres and MSSQL. Note that deprecated MSSQL FROM foo (NOLOCK) syntax will also be parsed as args.

This field’s value is Some(v), where v is a (possibly empty) vector of arguments, in the case of a table-valued function call, whereas it’s None in the case of a regular table name.

with_hints: Vec<Expr>

MSSQL-specific WITH (...) hints such as NOLOCK.

version: Option<TableVersion>

Optional version qualifier to facilitate table time-travel, as supported by BigQuery and MSSQL.

with_ordinality: bool

For example, SELECT * FROM generate_series(1, 10) WITH ORDINALITY AS t(a, b); WITH ORDINALITY, supported by Postgres.

partitions: Vec<Ident>

Partition selection, supported by MySQL.

json_path: Option<JsonPath>

Optional PartiQL JsonPath: https://partiql.org/dql/from.html

sample: Option<TableSampleKind>

Optional table sample modifier See: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#sample-clause

index_hints: Vec<TableIndexHints>

Optional index hints(mysql) See: https://dev.mysql.com/doc/refman/8.4/en/index-hints.html

Derived

A derived table (a parenthesized subquery), optionally LATERAL.

Fields

lateral: bool

Whether the derived table is LATERAL.

subquery: Box<Query>

The subquery producing the derived table.

alias: Option<TableAlias>

Optional alias for the derived table.

sample: Option<TableSampleKind>

Optional table sample modifier

TableFunction

TABLE(<expr>)[ AS <alias> ]

Fields

expr: Expr

Expression representing the table function call.

alias: Option<TableAlias>

Optional alias for the table function result.

Function

e.g. LATERAL FLATTEN(<args>)[ AS <alias> ]

Fields

lateral: bool

Whether the function is LATERAL.

name: ObjectName

Name of the table function.

args: Vec<FunctionArg>

Arguments passed to the function.

with_ordinality: bool

Whether WITH ORDINALITY was specified to include ordinality.

alias: Option<TableAlias>

Optional alias for the result of the function.

UNNEST

SELECT * FROM UNNEST ([10,20,30]) as numbers WITH OFFSET;
+---------+--------+
| numbers | offset |
+---------+--------+
| 10      | 0      |
| 20      | 1      |
| 30      | 2      |
+---------+--------+

Fields

alias: Option<TableAlias>

Optional alias for the UNNEST table (e.g. UNNEST(...) AS t).

array_exprs: Vec<Expr>

Expressions producing the arrays to be unnested.

with_offset: bool

Whether WITH OFFSET was specified to include element offsets.

with_offset_alias: Option<Ident>

Optional alias for the offset column when WITH OFFSET is used.

with_ordinality: bool

Whether WITH ORDINALITY was specified to include ordinality.

JsonTable

The JSON_TABLE table-valued function. Part of the SQL standard, but implemented only by MySQL, Oracle, and DB2.

https://modern-sql.com/blog/2017-06/whats-new-in-sql-2016#json_table https://dev.mysql.com/doc/refman/8.0/en/json-table-functions.html#function_json-table

SELECT * FROM JSON_TABLE(
   '[{"a": 1, "b": 2}, {"a": 3, "b": 4}]',
   '$[*]' COLUMNS(
       a INT PATH '$.a' DEFAULT '0' ON EMPTY,
       b INT PATH '$.b' NULL ON ERROR
    )
) AS jt;

Fields

json_expr: Expr

The JSON expression to be evaluated. It must evaluate to a json string

json_path: ValueWithSpan

The path to the array or object to be iterated over. It must evaluate to a json array or object.

columns: Vec<JsonTableColumn>

The columns to be extracted from each element of the array or object. Each column must have a name and a type.

alias: Option<TableAlias>

The alias for the table.

OpenJsonTable

The MSSQL’s OPENJSON table-valued function.

OPENJSON( jsonExpression [ , path ] )  [ <with_clause> ]

<with_clause> ::= WITH ( { colName type [ column_path ] [ AS JSON ] } [ ,...n ] )

Reference: https://learn.microsoft.com/en-us/sql/t-sql/functions/openjson-transact-sql?view=sql-server-ver16#syntax

Fields

json_expr: Expr

The JSON expression to be evaluated. It must evaluate to a json string

json_path: Option<ValueWithSpan>

The path to the array or object to be iterated over. It must evaluate to a json array or object.

columns: Vec<OpenJsonTableColumn>

The columns to be extracted from each element of the array or object. Each column must have a name and a type.

alias: Option<TableAlias>

The alias for the table.

NestedJoin

Represents a parenthesized table factor. The SQL spec only allows a join expression ((foo <JOIN> bar [ <JOIN> baz ... ])) to be nested, possibly several times.

The parser may also accept non-standard nesting of bare tables for some dialects, but the information about such nesting is stripped from AST.

Fields

table_with_joins: Box<TableWithJoins>

The nested join expression contained in parentheses.

alias: Option<TableAlias>

Optional alias for the nested join.

Pivot

Represents PIVOT operation on a table. For example FROM monthly_sales PIVOT(sum(amount) FOR MONTH IN ('JAN', 'FEB'))

BigQuery Snowflake Oracle

Fields

table: Box<TableFactor>

The input table to pivot.

aggregate_functions: Vec<ExprWithAlias>

Aggregate expressions used as pivot values (optionally aliased).

value_column: Vec<Expr>

Columns producing the values to be pivoted.

value_source: PivotValueSource

Source of pivot values (e.g. list of literals or columns).

default_on_null: Option<Expr>

Optional expression providing a default when a pivot produces NULL.

alias: Option<TableAlias>

Optional alias for the pivoted table.

Unpivot

An UNPIVOT operation on a table.

Syntax:

table UNPIVOT [ { INCLUDE | EXCLUDE } NULLS ] (value FOR name IN (column1, [ column2, ... ])) [ alias ]

Snowflake Databricks BigQuery Oracle

Fields

table: Box<TableFactor>

The input table to unpivot.

value: Expr

Expression producing the unpivoted value.

name: Ident

Identifier used for the generated column name.

columns: Vec<ExprWithAlias>

Columns or expressions to unpivot, optionally aliased.

null_inclusion: Option<NullInclusion>

Whether to include or exclude NULLs during unpivot.

alias: Option<TableAlias>

Optional alias for the resulting table.

MatchRecognize

A MATCH_RECOGNIZE operation on a table.

See https://docs.snowflake.com/en/sql-reference/constructs/match_recognize.

Fields

table: Box<TableFactor>

The input table to apply MATCH_RECOGNIZE on.

partition_by: Vec<Expr>

PARTITION BY <expr> [, ... ]

order_by: Vec<OrderByExpr>

ORDER BY <expr> [, ... ]

measures: Vec<Measure>

MEASURES <expr> [AS] <alias> [, ... ]

rows_per_match: Option<RowsPerMatch>

ONE ROW PER MATCH | ALL ROWS PER MATCH [ <option> ]

after_match_skip: Option<AfterMatchSkip>

AFTER MATCH SKIP <option>

pattern: MatchRecognizePattern

PATTERN ( <pattern> )

symbols: Vec<SymbolDefinition>

DEFINE <symbol> AS <expr> [, ... ]

alias: Option<TableAlias>

The alias for the table.

XmlTable

The XMLTABLE table-valued function. Part of the SQL standard, supported by PostgreSQL, Oracle, and DB2.

https://www.postgresql.org/docs/15/functions-xml.html#FUNCTIONS-XML-PROCESSING

SELECT xmltable.*
FROM xmldata,
XMLTABLE('//ROWS/ROW'
    PASSING data
    COLUMNS id int PATH '@id',
    ordinality FOR ORDINALITY,
    "COUNTRY_NAME" text,
    country_id text PATH 'COUNTRY_ID',
    size_sq_km float PATH 'SIZE[@unit = "sq_km"]',
    size_other text PATH 'concat(SIZE[@unit!="sq_km"], " ", SIZE[@unit!="sq_km"]/@unit)',
    premier_name text PATH 'PREMIER_NAME' DEFAULT 'not specified'
);

Fields

namespaces: Vec<XmlNamespaceDefinition>

Optional XMLNAMESPACES clause (empty if not present)

row_expression: Expr

The row-generating XPath expression.

passing: XmlPassingClause

The PASSING clause specifying the document expression.

columns: Vec<XmlTableColumn>

The columns to be extracted from each generated row.

alias: Option<TableAlias>

The alias for the table.

SemanticView

Snowflake’s SEMANTIC_VIEW function for semantic models.

https://docs.snowflake.com/en/sql-reference/constructs/semantic_view

SELECT * FROM SEMANTIC_VIEW(
    tpch_analysis
    DIMENSIONS customer.customer_market_segment
    METRICS orders.order_average_value
);

Fields

name: ObjectName

The name of the semantic model

dimensions: Vec<Expr>

List of dimensions or expression referring to dimensions (e.g. DATE_PART(‘year’, col))

metrics: Vec<Expr>

List of metrics (references to objects like orders.value, value, orders.*)

facts: Vec<Expr>

List of facts or expressions referring to facts or dimensions.

where_clause: Option<Expr>

WHERE clause for filtering

alias: Option<TableAlias>

The alias for the table

Trait Implementations

impl Clone for TableFactor

fn clone(&self) -> TableFactor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TableFactor

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

Formats the value using the given formatter.

impl Display for TableFactor

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

Formats the value using the given formatter.

impl Eq for TableFactor

impl Hash for TableFactor

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

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 Ord for TableFactor

fn cmp(&self, other: &TableFactor) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for TableFactor

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

fn partial_cmp(&self, other: &TableFactor) -> 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 Spanned for TableFactor

partial span

Missing spans:

• TableFactor::JsonTable

fn span(&self) -> Span

Return the Span (the minimum and maximum Location) for this AST node, by recursively combining the spans of its children.

impl StructuralPartialEq for TableFactor

impl Visit for TableFactor

fn visit<V>(&self, visitor: &mut V) -> ControlFlow<<V as Visitor>::Break>

where V: Visitor,

Visit this node with the provided Visitor.

impl VisitMut for TableFactor

fn visit<V>(&mut self, visitor: &mut V) -> ControlFlow<<V as VisitorMut>::Break>

where V: VisitorMut,

Mutably visit this node with the provided VisitorMut.