feat: case-insensitive identifier matching

`SELECT Id FROM Users` against a schema declaring `id`/`users` was
reported as missing. SQL dialects vary on case-sensitivity (Postgres
folds to lower, ANSI to upper, BigQuery is strict, etc.) and the
case mismatch produces noisy false positives, so default to ASCII
case-insensitive comparisons throughout.

Implementation:
- schema/sql introduces a `lc()` helper and case-folds every name it
  inserts into the `tables` map (CREATE TABLE, CREATE VIEW, CTAS,
  ALTER TABLE add/drop/rename column, qualified twins, the bare key).
- Lookup sites case-fold their input before consulting the map:
  asserts::is_relation_in_schema, table_ref::resolve_table_columns,
  column_in_relation, and INSERT/UPDATE column-list checks.
- For the borrowed-`&str` extras map (CTE / derived-table aliases
  tied to AST lifetimes), case-insensitive lookups via three small
  helpers in asserts: extras_contains, extras_get, set_contains_ci.
- resolve_qualified now compares `rel.qualifier()` to the user's
  qualifier with `eq_ignore_ascii_case`.

Error messages preserve the user's original casing — `Column \`BOGUS\`
not found in table \`users\`` — only matching is folded.

Quoted-vs-unquoted distinction (`"Id"` vs `id` in Postgres) is not
modeled; sqlshield treats both as the same identifier. Per-dialect
folding rules can layer on top later.

Schema module's `sql` is now `pub(crate)` so the `lc` helper can be
imported from validation. Otherwise unchanged.

8 tests cover lower-vs-upper schemas, mixed-case qualifiers, CTE
references, ALTER TABLE, schema-qualified tables, INSERT target
column lists, and a confirmatory test that genuinely missing columns
still error (with the original casing in the message).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: davidsmfreire

sqlshield/src/schema/mod.rs

@@ -1,6 +1,6 @@
 //! Parses schema definitions into the `TablesAndColumns` map consumed by validation.
 
-mod sql;
+pub(crate) mod sql;
 
 use std::{
     collections::{HashMap, HashSet},

sqlshield/src/schema/sql.rs

@@ -60,19 +60,24 @@ fn ingest_create_table(
     // names from the source query's projection. Plain CREATE TABLE uses
     // the explicit list. If both are present, the explicit list wins.
     let columns_set: HashSet<String> = if !columns.is_empty() {
-        columns.iter().map(|e| e.name.value.clone()).collect()
+        columns.iter().map(|e| lc(&e.name.value)).collect()
     } else if let Some(q) = query {
-        project_column_names(q).into_iter().collect()
+        project_column_names(q)
+            .into_iter()
+            .map(|s| lc(&s))
+            .collect()
     } else {
         HashSet::new()
     };
 
     // Store the bare table name so unqualified queries resolve; if the
     // schema was declared as `schema.table`, ALSO store the fully
     // qualified form so qualified queries can be resolved strictly.
-    tables.insert(last_ident.value.clone(), columns_set.clone());
+    // Both keys are case-folded: identifier matching is ASCII case-insensitive
+    // throughout sqlshield.
+    tables.insert(lc(&last_ident.value), columns_set.clone());
     if name.0.len() > 1 {
-        tables.insert(display_name(name), columns_set);
+        tables.insert(lc(&display_name(name)), columns_set);
     }
 }
 
@@ -88,16 +93,26 @@ fn ingest_create_view(
     // Explicit column list `CREATE VIEW v(a, b) AS …` overrides whatever
     // names the body projects.
     let columns_set: HashSet<String> = if !columns.is_empty() {
-        columns.iter().map(|c| c.name.value.clone()).collect()
+        columns.iter().map(|c| lc(&c.name.value)).collect()
     } else {
-        project_column_names(query).into_iter().collect()
+        project_column_names(query)
+            .into_iter()
+            .map(|s| lc(&s))
+            .collect()
     };
-    tables.insert(last_ident.value.clone(), columns_set.clone());
+    tables.insert(lc(&last_ident.value), columns_set.clone());
     if name.0.len() > 1 {
-        tables.insert(display_name(name), columns_set);
+        tables.insert(lc(&display_name(name)), columns_set);
     }
 }
 
+/// Case-fold to ASCII lowercase. Used at every identifier insertion and
+/// lookup site so the schema map and query-side identifiers compare
+/// case-insensitively.
+pub(crate) fn lc(s: &str) -> String {
+    s.to_ascii_lowercase()
+}
+
 /// Owned-string version of `validation::project_columns`. Used at schema-
 /// ingestion time to capture the column names that a view or CTAS body
 /// projects.
@@ -162,10 +177,10 @@ fn target_keys(name: &ObjectName, tables: &HashMap<String, HashSet<String>>) ->
     let Some(last) = name.0.last() else {
         return Vec::new();
     };
-    let bare = last.value.as_str();
+    let bare = lc(&last.value);
     if name.0.len() > 1 {
         // Qualified ALTER: target only the exact qualified key.
-        let q = display_name(name);
+        let q = lc(&display_name(name));
         if tables.contains_key(&q) {
             return vec![q];
         }
@@ -180,7 +195,7 @@ fn target_keys(name: &ObjectName, tables: &HashMap<String, HashSet<String>>) ->
             k.as_str() == bare
                 || k.rsplit('.')
                     .next()
-                    .is_some_and(|seg| seg == bare && k != &bare)
+                    .is_some_and(|seg| seg == bare && k.as_str() != bare)
         })
         .cloned()
         .collect()
@@ -189,17 +204,17 @@ fn target_keys(name: &ObjectName, tables: &HashMap<String, HashSet<String>>) ->
 fn apply_one(cols: &mut HashSet<String>, op: &AlterTableOperation) {
     match op {
         AlterTableOperation::AddColumn { column_def, .. } => {
-            cols.insert(column_def.name.value.clone());
+            cols.insert(lc(&column_def.name.value));
         }
         AlterTableOperation::DropColumn { column_name, .. } => {
-            cols.remove(column_name.value.as_str());
+            cols.remove(lc(&column_name.value).as_str());
         }
         AlterTableOperation::RenameColumn {
             old_column_name,
             new_column_name,
         } => {
-            if cols.remove(old_column_name.value.as_str()) {
-                cols.insert(new_column_name.value.clone());
+            if cols.remove(lc(&old_column_name.value).as_str()) {
+                cols.insert(lc(&new_column_name.value));
             }
         }
         // Other ops (constraints, RLS, RENAME TABLE, …) don't change the

sqlshield/src/validation/asserts.rs

@@ -1,10 +1,12 @@
 use std::collections::{HashMap, HashSet};
 
 use crate::schema;
+use crate::schema::sql::lc;
 
 /// Returns `Some(name)` if the relation cannot be resolved against the schema
 /// or CTE extras. Qualified references (`schema.table`) require an exact
 /// qualified match; unqualified references match on the bare table name.
+/// Comparisons are ASCII case-insensitive.
 pub fn is_relation_in_schema(
     relation: &sqlparser::ast::TableFactor,
     schema: &schema::TablesAndColumns,
@@ -18,25 +20,48 @@ pub fn is_relation_in_schema(
                 .map(|e| e.value.as_str())
                 .collect::<Vec<&str>>()
                 .join(".");
+            let name_full_lc = lc(&name_full);
 
             if name.0.len() > 1 {
-                if schema.contains_key(&name_full) || extras.contains_key(name_full.as_str()) {
+                if schema.contains_key(&name_full_lc) || extras_contains(extras, &name_full_lc) {
                     return None;
                 }
                 return Some(name_full);
             }
 
-            let last = name
+            let last_lc = lc(&name
                 .0
                 .last()
                 .expect("sqlparser guarantees ObjectName has ≥1 ident")
-                .value
-                .as_str();
-            if schema.contains_key(last) || extras.contains_key(last) {
+                .value);
+            if schema.contains_key(&last_lc) || extras_contains(extras, &last_lc) {
                 return None;
             }
             Some(name_full)
         }
         _ => None,
     }
 }
+
+/// Case-insensitive lookup against the borrowed-`&str` extras map. Extras
+/// keys come from query-side identifiers (CTE / derived-table aliases) and
+/// aren't lowercased at insertion since they're tied to AST lifetimes.
+pub(crate) fn extras_contains(extras: &HashMap<&str, HashSet<&str>>, key: &str) -> bool {
+    extras.keys().any(|k| k.eq_ignore_ascii_case(key))
+}
+
+/// Case-insensitive lookup that returns the matching value.
+pub(crate) fn extras_get<'a>(
+    extras: &'a HashMap<&'a str, HashSet<&'a str>>,
+    key: &str,
+) -> Option<&'a HashSet<&'a str>> {
+    extras
+        .iter()
+        .find(|(k, _)| k.eq_ignore_ascii_case(key))
+        .map(|(_, v)| v)
+}
+
+/// Case-insensitive `set.contains` for a borrowed `&str` set.
+pub(crate) fn set_contains_ci(set: &HashSet<&str>, needle: &str) -> bool {
+    set.iter().any(|s| s.eq_ignore_ascii_case(needle))
+}

sqlshield/src/validation/clauses/insert.rs

@@ -2,6 +2,7 @@
 
 use sqlparser::ast::{Ident, ObjectName};
 
+use crate::schema::sql::lc;
 use crate::schema::TablesAndColumns;
 
 use super::table_ref::{display_name, resolve_table_columns};
@@ -22,7 +23,7 @@ pub(crate) fn validate_insert(
     };
 
     for col in columns {
-        if !cols.contains(col.value.as_str()) {
+        if !cols.contains(&lc(&col.value)) {
             errors.push(format!(
                 "Column `{}` not found in table `{}`",
                 col.value,

sqlshield/src/validation/clauses/select.rs

@@ -5,6 +5,7 @@ use sqlparser::ast::{
     SelectItem, TableFactor, TableWithJoins,
 };
 
+use crate::schema::sql::lc;
 use crate::{schema, validation::asserts};
 
 use super::ClauseValidation;
@@ -177,17 +178,20 @@ fn collect_from_factor<'a>(factor: &'a TableFactor, out: &mut Vec<VisibleRelatio
 /// the real schema or CTE-derived extras). Returns `Some(true)` if yes,
 /// `Some(false)` if the relation is known but the column isn't, and `None`
 /// if the relation is entirely unknown (caller should not over-report).
+/// All identifier comparisons are ASCII case-insensitive.
 fn column_in_relation(
     col: &str,
     rel: &VisibleRelation<'_>,
     schema: &schema::TablesAndColumns,
     extras: &HashMap<&str, HashSet<&str>>,
 ) -> Option<bool> {
-    if let Some(cols) = schema.get(rel.name) {
-        return Some(cols.contains(col));
+    let rel_name_lc = lc(rel.name);
+    let col_lc = lc(col);
+    if let Some(cols) = schema.get(&rel_name_lc) {
+        return Some(cols.contains(&col_lc));
     }
-    if let Some(cols) = extras.get(rel.name) {
-        return Some(cols.contains(col));
+    if let Some(cols) = asserts::extras_get(extras, rel.name) {
+        return Some(asserts::set_contains_ci(cols, col));
     }
     None
 }
@@ -230,7 +234,9 @@ fn resolve_qualified(
     schema: &schema::TablesAndColumns,
     extras: &HashMap<&str, HashSet<&str>>,
 ) -> Option<String> {
-    let matched = relations.iter().find(|r| r.qualifier() == qualifier)?;
+    let matched = relations
+        .iter()
+        .find(|r| r.qualifier().eq_ignore_ascii_case(qualifier))?;
     match column_in_relation(col, matched, schema, extras) {
         Some(false) => Some(format!(
             "Column `{col}` not found in table `{}`",

sqlshield/src/validation/clauses/table_ref.rs

@@ -4,9 +4,11 @@ use std::collections::HashSet;
 
 use sqlparser::ast::ObjectName;
 
+use crate::schema::sql::lc;
 use crate::schema::TablesAndColumns;
 
 /// Human-readable form of `ObjectName`: `public.users` or `users`.
+/// Preserves the user's casing for error messages.
 pub(crate) fn display_name(name: &ObjectName) -> String {
     name.0
         .iter()
@@ -17,13 +19,14 @@ pub(crate) fn display_name(name: &ObjectName) -> String {
 
 /// Resolve a table reference to its column set, respecting qualified vs.
 /// unqualified lookup semantics (see `asserts::is_relation_in_schema`).
+/// Identifier matching is ASCII case-insensitive.
 pub(crate) fn resolve_table_columns<'a>(
     name: &ObjectName,
     schema: &'a TablesAndColumns,
 ) -> Option<&'a HashSet<String>> {
     if name.0.len() > 1 {
-        return schema.get(&display_name(name));
+        return schema.get(&lc(&display_name(name)));
     }
     let last = name.0.last()?.value.as_str();
-    schema.get(last)
+    schema.get(&lc(last))
 }

sqlshield/src/validation/clauses/update.rs

@@ -4,6 +4,7 @@ use std::collections::{HashMap, HashSet};
 
 use sqlparser::ast::{Assignment, Expr, TableFactor, TableWithJoins};
 
+use crate::schema::sql::lc;
 use crate::schema::TablesAndColumns;
 use crate::validation::asserts;
 
@@ -33,7 +34,7 @@ pub(crate) fn validate_update<'a>(
                 let Some(last) = assignment.id.last() else {
                     continue;
                 };
-                if !cols.contains(last.value.as_str()) {
+                if !cols.contains(&lc(&last.value)) {
                     errors.push(format!(
                         "Column `{}` not found in table `{}`",
                         last.value,

sqlshield/tests/case_insensitive.rs

@@ -0,0 +1,65 @@
+//! Identifier matching is case-insensitive (ASCII fold) — the schema-vs-
+//! query case mismatch was a stream of false positives.
+
+use sqlshield::validate_query;
+
+#[test]
+fn lowercase_schema_uppercase_query() {
+    let schema = "CREATE TABLE users (id INT, name VARCHAR(255));";
+    let errs = validate_query("SELECT ID, NAME FROM USERS", schema).unwrap();
+    assert!(errs.is_empty(), "got: {errs:?}");
+}
+
+#[test]
+fn uppercase_schema_lowercase_query() {
+    let schema = "CREATE TABLE Users (Id INT, FullName VARCHAR(255));";
+    let errs = validate_query("SELECT id, fullname FROM users", schema).unwrap();
+    assert!(errs.is_empty(), "got: {errs:?}");
+}
+
+#[test]
+fn mixed_case_qualifier_resolves() {
+    let schema = "CREATE TABLE users (id INT);";
+    let errs = validate_query("SELECT U.Id FROM Users U", schema).unwrap();
+    assert!(errs.is_empty(), "got: {errs:?}");
+}
+
+#[test]
+fn truly_missing_column_still_errors() {
+    let schema = "CREATE TABLE users (id INT);";
+    let errs = validate_query("SELECT BOGUS FROM users", schema).unwrap();
+    // Error message reports the column name as the user wrote it.
+    assert!(errs.iter().any(|e| e.contains("BOGUS")), "got: {errs:?}");
+}
+
+#[test]
+fn cte_reference_is_case_insensitive() {
+    let schema = "CREATE TABLE users (id INT);";
+    let sql = "WITH MyCTE AS (SELECT id FROM users) SELECT mycte.id FROM MYCTE";
+    let errs = validate_query(sql, schema).unwrap();
+    assert!(errs.is_empty(), "got: {errs:?}");
+}
+
+#[test]
+fn alter_table_case_insensitive() {
+    let schema = "
+        CREATE TABLE users (id INT);
+        ALTER TABLE Users ADD COLUMN Email VARCHAR(255);
+    ";
+    let errs = validate_query("SELECT email FROM users", schema).unwrap();
+    assert!(errs.is_empty(), "got: {errs:?}");
+}
+
+#[test]
+fn schema_qualified_table_case_insensitive() {
+    let schema = "CREATE TABLE Public.Users (id INT);";
+    let errs = validate_query("SELECT id FROM public.users", schema).unwrap();
+    assert!(errs.is_empty(), "got: {errs:?}");
+}
+
+#[test]
+fn insert_target_columns_case_insensitive() {
+    let schema = "CREATE TABLE users (id INT, name VARCHAR(255));";
+    let errs = validate_query("INSERT INTO Users (ID, NAME) VALUES (1, 'a')", schema).unwrap();
+    assert!(errs.is_empty(), "got: {errs:?}");
+}