Struct TableReference 

pub struct TableReference {
    pub catalog: Option<Ident>,
    pub schema: Option<Ident>,
    pub name: Ident,
}

Physical table identity — the catalog.schema.name triplet.

TableReference deliberately carries no alias: aliasing is a use-site decoration, not part of a table’s identity. Use-site alias information, when needed, is carried by the structures that wrap a TableReference (e.g. resolver bindings).

Equality has two levels. The derived Eq / Hash are structural — case- and quote-sensitive, exact segments. That is the right dedup when references come from catalog-backed analysis (matched tables are canonicalized, so equal tables produce equal references) and for direct cross-statement comparison. For catalog-free dedup, where the same table may appear under fold-equivalent spellings (users vs USERS), use identity_key / same_table, which fold by a dialect’s IdentifierCasing.

Fields

catalog: Option<Ident>

schema: Option<Ident>

name: Ident

Implementations

impl TableReference

pub fn identity_key(&self, casing: &IdentifierCasing) -> TableIdentityKey

The dialect-aware TableIdentityKey for this reference: each segment folded by casing’s table rule. Equal keys denote the same table under that dialect’s casing.

This is the catalog-free dedup key. The structural Eq on TableReference is exact (case- and quote-sensitive), so without a catalog to canonicalize spellings it over-counts users and USERS as two tables; folding by the dialect’s casing collapses them.

use std::collections::HashSet;
use sql_insight::{CaseRule, IdentifierCasing, TableReference};

let users = TableReference { catalog: None, schema: None, name: "users".into() };
let upper = TableReference { catalog: None, schema: None, name: "USERS".into() };

// Structural equality is exact — these read as two different tables.
assert_ne!(users, upper);

// Under a case-folding dialect (here lower-folding, e.g. PostgreSQL)
// they share one identity.
let casing = IdentifierCasing::uniform(CaseRule::Lower);
assert!(users.same_table(&upper, &casing));

// So a fold-keyed set counts the table once, where a structural
// `HashSet<TableReference>` would count two.
let distinct: HashSet<_> = [&users, &upper]
    .iter()
    .map(|t| t.identity_key(&casing))
    .collect();
assert_eq!(distinct.len(), 1);

// Identity, not wildcard: a bare name and a schema-qualified one stay
// distinct (different identities, not a prefix match).
let qualified = TableReference {
    catalog: None,
    schema: Some("public".into()),
    name: "users".into(),
};
assert!(!users.same_table(&qualified, &casing));

pub fn same_table(&self, other: &Self, casing: &IdentifierCasing) -> bool

Whether self and other denote the same table under casing — equivalent to comparing their identity_keys.

Trait Implementations

impl Clone for TableReference

fn clone(&self) -> TableReference

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TableReference

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

Formats the value using the given formatter.

impl Display for TableReference

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

Formats the value using the given formatter.

impl Eq for TableReference

impl Hash for TableReference

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

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 PartialEq for TableReference

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

impl TryFrom<&Insert> for TableReference

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: &Insert) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&ObjectName> for TableReference

type Error = Error

The type returned in the event of a conversion error.

fn try_from(obj_name: &ObjectName) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&TableFactor> for TableReference

type Error = Error

The type returned in the event of a conversion error.

fn try_from(table: &TableFactor) -> Result<Self, Self::Error>

Performs the conversion.