Struct TableScope 

pub struct TableScope {
    pub tables: HashMap<String, ResolvedTable>,
    /* private fields */
}

Context built during FROM clause resolution.

Fields

tables: HashMap<String, ResolvedTable>

Tables by reference name (alias or table name).

Implementations

impl TableScope

pub fn bare_column_qualifier(&self, column: &str) -> Result<Option<String>>

The qualifier an unqualified column reference is rewritten to.

Some only over a join’s merged rows, for a column of one of this scope’s own relations that the merged row keys by qualifier. The reference is checked in every naming.

pub fn qualified_column_qualifier(&self, table_ref: &str) -> Option<String>

The qualifier a qualified column reference converts with.

A qualifier naming one of this scope’s own relations becomes that relation’s row qualifier over a join’s merged rows, and is dropped over a join aggregate’s output rows. Any other qualifier, and every qualifier in AsWritten naming, is kept.

impl TableScope

pub fn new() -> Self

pub fn add(&mut self, table: ResolvedTable) -> Result<()>

Add a resolved table. Returns error if name conflicts.

pub fn add_qualified_only(&mut self, table: ResolvedTable) -> Result<()>

Add a relation that only a qualified reference reaches.

A bare column name skips it, so a name both this relation and a bare-resolvable one declare is not ambiguous.

pub fn single_table(&self) -> Option<&ResolvedTable>

Get the single table in scope (for single-table queries).

pub fn is_row_scope(&self) -> bool

Whether an expression here is evaluated once per row of some relation.

A scope with no relation of its own and no enclosing query stands behind a FROM-less SELECT, which produces exactly one row and evaluates its projection at plan time.

pub fn nested_in(self, outer: TableScope) -> Self

A copy of this scope nested inside outer, for planning a correlated subquery body. The body’s own clauses refuse a sequence accessor even when the enclosing SELECT list allows one.

pub fn as_statement_output(self) -> Self

This scope marked as backing the SELECT that produces the statement’s result rows.

pub fn is_statement_output(&self) -> bool

Whether the SELECT this scope backs produces the statement’s result rows.

pub fn allowing_cp_functions(self) -> Self

This scope with sequence accessors allowed: the expression it resolves is a SELECT-list item the Control Plane evaluates per output row.

pub fn allows_cp_functions(&self) -> bool

Whether a sequence accessor resolves here despite rows being in scope.

pub fn with_output_names(&self, names: impl IntoIterator<Item = String>) -> Self

A copy of this scope widened with output column names.

An ORDER BY, GROUP BY, or HAVING identifier resolves against input columns first and output names second, so this only widens: a name that already resolves to a column keeps resolving to it.

pub fn single(table: ResolvedTable) -> Result<Self>

A single-relation scope, for the DML planners that resolve one collection and build no FROM clause.

pub fn check_name(&self, table_ref: Option<&str>, column: &str) -> Result<()>

Reject a column reference that names nothing in scope.

pub fn resolve_bare(&self, column: &str) -> Result<BareColumn<'_>>

Where an unqualified column reference resolves.

A SELECT output name wins. Otherwise the relations a bare name reaches are tried:

• One relation declares the column: it resolves there, even beside an open-schema relation.
• Two or more declare it: refused as ambiguous.
• None declares it and exactly one accepts any name (an open schema, an implicit column): it resolves there.
• None declares it and two or more accept any name: refused as ambiguous. Picking one would read NULL for a field the other holds.
• None accepts it: the enclosing query’s scope is tried, else the column is unknown.

pub fn with_column_naming(self, naming: ColumnNaming) -> Self

This scope with column references named for naming’s rows.

pub fn column_naming(&self) -> ColumnNaming

How this scope’s column references name their fields.

pub fn check_using_column( &self, right_ref: Option<&str>, column: &str, ) -> Result<()>

Reject a USING (column) key that right_ref’s relation or every other relation lacks. Both sides of the join must carry it.

pub fn tables_in_order(&self) -> impl Iterator<Item = &ResolvedTable>

The resolved tables, in the order the FROM clause introduced them.

pub fn table_by_ref(&self, ref_name: &str) -> Option<&ResolvedTable>

The relation registered under ref_name, alias or table name.

pub fn declared_column( &self, table_ref: Option<&str>, column: &str, ) -> Option<&ColumnInfo>

The declared column a reference names, when the relation declares it.

pub fn resolve_from( catalog: &dyn SqlCatalog, functions: &FunctionRegistry, temporal: TemporalScope, from: &[TableWithJoins], ) -> Result<Self>

Resolve tables from a FROM clause.

A derived-subquery factor is planned here so its relation carries the search cells its plan produces; the planner context (functions, temporal) is required for that and for no other arm.

Trait Implementations

impl Clone for TableScope

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TableScope

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

Formats the value using the given formatter.

impl Default for TableScope

fn default() -> Self

Returns the “default value” for a type.