- normalizer:       sqllexer.NewNormalizer(sqllexer.WithCollectTables(true), sqllexer.WithCollectComments(true)),
+ normalizer:       sqllexer.NewNormalizer(
+                       sqllexer.WithCollectTables(true),
+                       sqllexer.WithCollectComments(true),
+                       sqllexer.WithKeepIdentifierQuotation(true),
+                   ),

-// IsValid returns whether or not a given database and parsed table name exists in the source-of-truth table registry
-func (tr *TableRegistry) IsValid(database database, parsedTableName string) bool {
+// IsValid returns whether a given database and parsed table name exists in the registry,
+// and also returns the resolved (possibly normalized) table name.
+func (tr *TableRegistry) IsValid(database database, parsedTableName string) (string, bool) {
     tr.mu.RLock()
     defer tr.mu.RUnlock()

     schemas, ok := tr.tables[database]
     if !ok {
-        return false
+        return parsedTableName, false
     }

     schemaName, tableName := parseSchemaQualifiedIfAny(parsedTableName)

     switch schemaName {
     case "":
         for _, tables := range schemas {
             if _, ok := tables[tableName]; ok {
-                return true
+                return string(tableName), true
             }
+            // Without schema, sqllexer doesn't preserve quotes; emulate PG folding
+            lowercaseName := table(strings.ToLower(string(tableName)))
+            if lowercaseName != tableName {
+                if _, ok := tables[lowercaseName]; ok {
+                    return string(lowercaseName), true
+                }
+            }
         }
     default:
         if tables, ok := schemas[schemaName]; ok {
-            _, ok := tables[tableName]
-            return ok
+            if _, exists := tables[tableName]; exists {
+                return string(schemaName) + "." + string(tableName), true
+            }
         }
     }
-    return false
+    return parsedTableName, false
 }

-// parseSchemaQualifiedIfAny returns separated schema and table if the parsedTableName is schema-qualified, e.g. SELECT * FROM schema_name.table_name
+// parseSchemaQualifiedIfAny returns separated schema and table if the parsedTableName is schema-qualified.
+// It normalizes identifiers: quoted => preserve case; unquoted => lowercase (PG folding).
 func parseSchemaQualifiedIfAny(parsedTableName string) (schema, table) {
     parts := strings.SplitN(parsedTableName, ".", 2)
     if len(parts) == 2 {
-        return schema(parts[0]), table(parts[1])
+        return schema(formatPostgresIdentifier(parts[0])), table(formatPostgresIdentifier(parts[1]))
     }
     return "", table(parsedTableName)
 }

+func formatPostgresIdentifier(identifier string) string {
+    if len(identifier) >= 2 && identifier[0] == '"' && identifier[len(identifier)-1] == '"' {
+        return identifier[1 : len(identifier)-1]
+    }
+    return strings.ToLower(identifier)
+}

-validated := false
+validated := false
+resolvedTable := table
 if c.tableRegistry != nil {
-    validated = c.tableRegistry.IsValid(databaseName, table)
+    resolvedTable, validated = c.tableRegistry.IsValid(databaseName, table)
 }

 c.entryHandler.Chan() <- database_observability.BuildLokiEntry(
     logging.LevelInfo,
     OP_QUERY_PARSED_TABLE_NAME,
-    fmt.Sprintf(`queryid="%s" datname="%s" table="%s" validated="%t"`, queryID, databaseName, table, validated),
+    fmt.Sprintf(`queryid="%s" datname="%s" table="%s" validated="%t"`, queryID, databaseName, resolvedTable, validated),
 )