Struct ColumnReference 

pub struct ColumnReference {
    pub table: Option<TableReference>,
    pub name: Ident,
}

A column-level identity reference: an optional owning table plus the column name.

table is Option because a column the resolver couldn’t pin to a single owning table — Ambiguous or Unresolved (see ColumnRead::resolution for why) — still surfaces its name with table: None. Identity is name-based: two ColumnReferences with the same table and name compare equal, independent of where they appeared in the SQL or how the resolver placed them. (For dialect-aware equality, see identity_key.)

Fields

table: Option<TableReference>

name: Ident

Implementations

impl ColumnReference

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

The dialect-aware ColumnIdentityKey for this reference: the owning table folded by the table rule, the column name by the column rule. Equal keys denote the same column under that dialect’s casing.

Like TableReference::identity_key this is the catalog-free dedup key — folding both the owning table and the column name (by their separate rules, which a dialect can set apart). The owning table is part of the identity: same column name, different table → different column.

use sql_insight::{CaseRule, ColumnReference, IdentifierCasing, TableReference};

let owned = |t: &str| Some(TableReference { catalog: None, schema: None, name: t.into() });
let lower = ColumnReference { table: owned("users"), name: "id".into() };
let upper = ColumnReference { table: owned("USERS"), name: "ID".into() };

// Structural equality is exact; a case-folding casing merges them.
assert_ne!(lower, upper);
let casing = IdentifierCasing::uniform(CaseRule::Insensitive);
assert!(lower.same_column(&upper, &casing));

// A different owning table is a different column, same name or not.
let other = ColumnReference { table: owned("accounts"), name: "id".into() };
assert!(!lower.same_column(&other, &casing));

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

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

Trait Implementations

impl Clone for ColumnReference

fn clone(&self) -> ColumnReference

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ColumnReference

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

Formats the value using the given formatter.

impl Display for ColumnReference

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

table.column when the owning table is known (the table renders as its own TableReference path), otherwise just column. Mirrors TableReference’s Display for the column-identity case.

use sql_insight::{ColumnReference, TableReference};

let qualified = ColumnReference {
    table: Some(TableReference {
        catalog: None,
        schema: Some("public".into()),
        name: "users".into(),
    }),
    name: "id".into(),
};
assert_eq!(qualified.to_string(), "public.users.id");

let bare = ColumnReference { table: None, name: "id".into() };
assert_eq!(bare.to_string(), "id");

impl Eq for ColumnReference

impl Hash for ColumnReference

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 ColumnReference

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