Enum ResolutionKind 

pub enum ResolutionKind {
    Cataloged,
    Inferred,
    Ambiguous,
    Unresolved,
}

How a reference was resolved — “what kind of resolution backs this (table, name) placement?”.

Catalog-less mode runs as an inference mode: every real-table binding’s schema is unknown, so a single-candidate resolution is best-effort, not catalog-backed. CTE and derived bodies do carry known schemas (the resolver derives them from the body’s projection), but those refs are synthetic and dropped from the public reads / lineage by the resolver’s post-pass.

Ambiguous and Unresolved are the two failure modes. Both come with table: None on the ColumnReference; the variant tells the consumer why the resolver gave up. (Unresolved arises only for columns — a table reference always has a name present.)

Invariants

• Catalog-less mode → no public Cataloged: every surviving non-synthetic ref points at an unknown real table, so the strongest claim the resolver can make is Inferred. Catalog-aware analysis is therefore detectable by the presence of Cataloged.
• Catalog-aware mode does not imply Cataloged: catalogs are often partial. Refs against tables the catalog doesn’t cover, or against a real unknown table that won a multi-candidate tiebreaker over known ones, both still come back as Inferred.

How each variant arises

Situation	ResolutionKind
catalog-less, real unknown table, sole candidate	Inferred
catalog-less, two real unknown tables in scope	Ambiguous
catalog-less, CTE known body confirms the column	(internal Cataloged; synthetic, dropped)
catalog-less, CTE known body denies the column (SELECT typo FROM cte where cte = [id])	Unresolved
catalog-aware, known binding lists the column	Cataloged
catalog-aware, known binding doesn’t list the column	Unresolved
catalog-aware, one known confirms + one unknown suspect (known-witness-over-unknown-suspects)	Inferred
catalog-aware, two or more known schemas confirm	Ambiguous
qualified t.col where t is unknown	Inferred
qualified t.col where t is known and lists col	Cataloged

Consumer guidance

• Strict mode validation: a fully resolved, catalog-confirmed statement satisfies op.diagnostics.is_empty() && op.reads.iter().all(|r| r.resolution == ResolutionKind::Cataloged).
• DFD / CRUD comprehension: treat Cataloged and Inferred interchangeably as “resolved” (use the (table, name) pair); treat Ambiguous and Unresolved as “incomplete”.

Variants

Cataloged

Backed by a known schema that lists the column / names the table. On the public surface this means a catalog (or registry) entry backed the reference. Internally a CTE / derived body’s known schema also yields this variant on a synthetic ref, but the post-pass drops those — so consumers only ever see Cataloged for catalog-backed real references.

Inferred

Resolution succeeded by assuming the reference exists where the resolver placed it: an unknown-schema binding adopted as the sole candidate, a qualified reference whose qualifier alone determined the table, or a known witness winning over unknown suspects in a multi-candidate scope. All defensible inferences in catalog-less or partial-catalog mode, but not proven.

Ambiguous

Multiple plausible candidates and the resolver couldn’t pick one: either two-or-more known schemas confirmed the column (genuine ambiguity), or every candidate was an unknown suspect with no tiebreaker. ColumnReference.table is None.

Unresolved

No in-scope binding could plausibly own the column: either every known schema in scope explicitly denied it, or the scope chain held no bindings at all. ColumnReference.table is None. Columns only.

Trait Implementations

impl Clone for ResolutionKind

fn clone(&self) -> ResolutionKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ResolutionKind

impl Debug for ResolutionKind

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

Formats the value using the given formatter.

impl Eq for ResolutionKind

impl Hash for ResolutionKind

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 ResolutionKind

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