Struct ColumnIdentifier 

pub struct ColumnIdentifier { /* private fields */ }

A SQL column identifier with proper case handling per SQL:1999.

This type handles column references with optional table and schema qualifiers. Each component (schema, table, column) has independent quoted/unquoted semantics.

Supported Forms

SQL Form	Description
id	Unqualified column reference
users.id	Table-qualified column reference
myschema.users.id	Fully-qualified column reference

SQL:1999 Compliance

Per SQL:1999, identifier handling depends on whether each component was quoted:

Input	Quoted	Canonical	Matches mycolumn?
MyColumn	No	mycolumn	Yes
"MyColumn"	Yes	MyColumn	No
MYCOLUMN	No	mycolumn	Yes

Example

use vibesql_ast::ColumnIdentifier;

// Unquoted identifiers are case-insensitive
let c1 = ColumnIdentifier::simple("MyColumn", false);
let c2 = ColumnIdentifier::simple("mycolumn", false);
assert_eq!(c1, c2);

// Quoted identifiers are case-sensitive
let quoted = ColumnIdentifier::simple("MyColumn", true);
assert_ne!(c1, quoted);

// Table-qualified column
let qualified = ColumnIdentifier::qualified("users", false, "id", false);
assert_eq!(qualified.canonical(), "users.id");

Implementations

impl ColumnIdentifier

pub fn simple(column: &str, quoted: bool) -> Self

Create a simple (unqualified) column identifier.

Arguments

• column - The column name as written by the user
• quoted - Whether the identifier was quoted (delimited) in SQL

Example

use vibesql_ast::ColumnIdentifier;

let c = ColumnIdentifier::simple("MyColumn", false);
assert_eq!(c.canonical(), "mycolumn");
assert_eq!(c.display(), "MyColumn");

pub fn qualified( table: &str, table_quoted: bool, column: &str, column_quoted: bool, ) -> Self

Create a table-qualified column identifier.

Arguments

• table - The table name as written by the user
• table_quoted - Whether the table was quoted in SQL
• column - The column name as written by the user
• column_quoted - Whether the column was quoted in SQL

Example

use vibesql_ast::ColumnIdentifier;

let c = ColumnIdentifier::qualified("Users", false, "ID", false);
assert_eq!(c.canonical(), "users.id");
assert_eq!(c.table_canonical(), Some("users"));
assert_eq!(c.column_canonical(), "id");

pub fn fully_qualified( schema: &str, schema_quoted: bool, table: &str, table_quoted: bool, column: &str, column_quoted: bool, ) -> Self

Create a fully-qualified (schema.table.column) identifier.

Arguments

• schema - The schema name as written by the user
• schema_quoted - Whether the schema was quoted in SQL
• table - The table name as written by the user
• table_quoted - Whether the table was quoted in SQL
• column - The column name as written by the user
• column_quoted - Whether the column was quoted in SQL

Example

use vibesql_ast::ColumnIdentifier;

let c = ColumnIdentifier::fully_qualified(
    "myApp", true,   // quoted schema
    "users", false,  // unquoted table
    "ID", false      // unquoted column
);
assert_eq!(c.canonical(), "myApp.users.id");

pub fn unquoted(column: &str) -> Self

Create an unquoted column identifier (convenience constructor).

This creates a simple, case-insensitive column reference.

Example

use vibesql_ast::ColumnIdentifier;

let c = ColumnIdentifier::unquoted("MyColumn");
assert_eq!(c.canonical(), "mycolumn");

pub fn quoted(column: &str) -> Self

Create a quoted column identifier (convenience constructor).

This creates a simple, case-sensitive column reference.

Example

use vibesql_ast::ColumnIdentifier;

let c = ColumnIdentifier::quoted("MyColumn");
assert_eq!(c.canonical(), "MyColumn");

pub fn table_column(table: &str, column: &str) -> Self

Create a table.column reference with unquoted identifiers.

Example

use vibesql_ast::ColumnIdentifier;

let c = ColumnIdentifier::table_column("users", "id");
assert_eq!(c.canonical(), "users.id");

pub fn from_canonical(canonical: String, quoted: bool) -> Self

Create an identifier from a canonical name (for internal use).

This is used when loading from persistence where we only have the canonical form. The display form is set to match canonical.

pub fn canonical(&self) -> &str

Get the canonical form of the identifier.

This is used for HashMap keys and equality comparison. Format: “schema.table.column” or “table.column” or “column”

pub fn display(&self) -> &str

Get the display form of the identifier.

This preserves the user’s original input and should be used in error messages and user-facing output.

pub fn column_canonical(&self) -> &str

Get the column name in canonical form.

pub fn column_display(&self) -> &str

Get the column name in display form.

pub fn is_column_quoted(&self) -> bool

Check if the column was quoted.

pub fn table_canonical(&self) -> Option<&str>

Get the table name in canonical form (if qualified).

pub fn table_display(&self) -> Option<&str>

Get the table name in display form (if qualified).

pub fn is_table_quoted(&self) -> bool

Check if the table was quoted (if qualified).

pub fn schema_canonical(&self) -> Option<&str>

Get the schema name in canonical form (if fully qualified).

pub fn schema_display(&self) -> Option<&str>

Get the schema name in display form (if fully qualified).

pub fn is_schema_quoted(&self) -> bool

Check if the schema was quoted (if fully qualified).

pub fn is_qualified(&self) -> bool

Check if this is a table-qualified column (has table but not schema).

pub fn is_fully_qualified(&self) -> bool

Check if this is a fully-qualified column (has schema.table.column).

pub fn is_ambiguous(&self) -> bool

Check if this column reference is ambiguous (no table qualifier).

pub fn into_canonical(self) -> String

Get the canonical form as an owned String.

pub fn matches_column_name(&self, name: &str, case_sensitive: bool) -> bool

Check if this column matches another by canonical column name only.

This ignores table and schema qualifiers, useful for finding columns by name across different tables.

pub fn resolve_against(&self, table: &TableIdentifier) -> Self

Resolve an ambiguous column against a table.

If this column is unqualified, creates a new column identifier qualified with the given table. If already qualified, returns self.

pub fn matches(&self, other: &ColumnIdentifier) -> bool

Check if this column reference matches another.

Matching rules:

• An unqualified column matches if the column names match
• A qualified column matches only if both table and column match
• A fully-qualified column matches only if schema, table, and column match

pub fn unqualify(&self) -> Self

Create a column identifier by stripping qualifiers.

Returns a new unqualified column identifier with just the column name.

pub fn with_table(&self, table: &str, table_quoted: bool) -> Self

Create a column identifier with a different table qualifier.

Useful when remapping columns during query planning.

Trait Implementations

impl Clone for ColumnIdentifier

fn clone(&self) -> ColumnIdentifier

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ColumnIdentifier

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

Formats the value using the given formatter.

impl Display for ColumnIdentifier

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

Display uses the original user input form.

impl From<&str> for ColumnIdentifier

fn from(s: &str) -> Self

Convert from a string, assuming unquoted (case-insensitive).

impl From<String> for ColumnIdentifier

fn from(s: String) -> Self

Convert from a String, assuming unquoted (case-insensitive).

impl Hash for ColumnIdentifier

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

Hash based on canonical form for consistent HashMap behavior.

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 ColumnIdentifier

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

Two column identifiers are equal if their canonical forms match.

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 Eq for ColumnIdentifier