Struct TableRef 

pub struct TableRef {
    pub name: String,
    pub alias: Option<String>,
    pub sub: Option<Box<Select>>,
    pub args: Option<Vec<Expr>>,
    pub col_aliases: Vec<String>,
    pub lateral: bool,
    pub as_of: Option<u64>,
    pub valid_as_of: Option<String>,
    pub search: Option<String>,
    pub trace: Option<String>,
    pub trace_reverse: bool,
    pub traverse: Option<String>,
}

Fields

name: String

The table name as written, minus quoting. A pg_catalog. qualifier is preserved here and resolved by the caller, because information_schema table names collide with plausible user collection names.

For a derived table this is the literal (subquery), and for a table function it is the function’s bare name — both only ever shown in a plan, never resolved as a relation.

alias: Option<String>

sub: Option<Box<Select>>

FROM (SELECT ...) AS t — the relation is the subquery’s output. psql’s \dd is one seven-arm UNION ALL wrapped exactly this way.

args: Option<Vec<Expr>>

FROM generate_series(0, n) s / FROM unnest(arr) AS t(x) — a table function with its arguments. Evaluated in the enclosing row’s scope, because psql writes unnest(evttags) over the OUTER row’s column.

col_aliases: Vec<String>

AS t(x, y) — column aliases for a derived table or table function.

lateral: bool

LATERAL (SELECT ...) — the derived table may read the FROM items before it, so it is re-evaluated once per row of those. psql’s \dP+ sizes each partitioned table this way.

as_of: Option<u64>

FROM orders AS OF SYSTEM TIME 42 — read this relation at that NEDB sequence instead of at the tip.

It hangs on the TABLE rather than on the query for two reasons. It is where PostgreSQL’s own grammar would take it (relation_expr, the production table_ref is built from), and it is the only placement that can express the query worth having: one relation AS OF a past sequence joined against another at the tip, which is how you ask what changed.

A sequence, never a wall-clock time. NEDB’s history is sequence-addressed and never garbage-collected, so a seq is exact where a timestamp would be approximate — the same refusal the translator has always made, made in the same words.

valid_as_of: Option<String>

FROM orders VALID AS OF '2026-01-01' — bi-temporal: what was believed TRUE as of that date, as distinct from what the log SAID at a sequence. A date string, because application-time validity is a wall-clock notion where system time is a sequence.

search: Option<String>

FROM orders SEARCH 'acme' — full-text over the document’s fields.

Per-table like the others, which is the point: one relation searched and another joined to it is a sentence SQL can now say.

trace: Option<String>

FROM orders TRACE caused_by [REVERSE] — the causal chain that produced each row, walked over caused_by edges.

The last two NQL verbs to arrive here, and the reason they were last is that they are the two that CHANGE THE ROW SET rather than filter it: a trace replaces each row with its chain. That is also why they belong on the table rather than in the WHERE — the transform happens as the relation is produced, and everything SQL does (join, subquery, set operation, aggregate) then composes around the traced relation.

Unreserved, by the same discipline as SEARCH and VALID: TRACE starts a clause only when an identifier follows it, so FROM orders trace still aliases the relation trace.

trace_reverse: bool

REVERSE on the trace — walk effects instead of causes.

traverse: Option<String>

FROM orders TRAVERSE ships_to — one hop along a named relation, replacing each row with its neighbours.

Implementations

impl TableRef

pub fn named(name: impl Into<String>, alias: Option<String>) -> Self

A plain named relation.

pub fn binding(&self) -> String

How this table’s columns are addressed: the alias when given, else the table’s own bare name, which is what SQL says.

Trait Implementations

impl Clone for TableRef

fn clone(&self) -> TableRef

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TableRef

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

Formats the value using the given formatter.

impl PartialEq for TableRef

fn eq(&self, other: &TableRef) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for TableRef