Collation Mismatch in IN Clause Due to Expression vs Column Comparison

Understanding Collation Inheritance in Expressions and Columns

Core Discrepancy: Collation Application in CASE Expressions vs Direct Column References

The central issue revolves around how SQLite applies collation rules when comparing values in an IN clause, particularly when one side is a column with an explicit collation and the other is an expression (like a CASE statement) that implicitly loses collation metadata. The problem manifests when two seemingly equivalent queries return different results due to hidden collation mismatches.

Example Scenario

Test Case 1: A CASE expression wraps the column t2.c10, leading to a comparison using the RTRIM collation from the subquery’s t0.c5. This results in a match between ' ' (space) and '' (empty string) under RTRIM rules.
Test Case 2: Directly referencing t2.c10 (which defaults to BINARY collation) causes a strict comparison where ' ' and '' are considered distinct.

The discrepancy arises because SQLite prioritizes collation metadata differently depending on whether the operand is a column or an expression. This behavior is intentional but non-intuitive for developers unfamiliar with collation precedence rules.

Collation Precedence Rules and Implicit Type Handling

1. Collation Inheritance in Columns vs Expressions

Columns: Inherit collation from their table definition unless overridden with COLLATE. For example, t0.c5 explicitly uses RTRIM, while t2.c10 defaults to BINARY.
Expressions: Lose collation metadata unless explicitly specified. A CASE expression like CASE WHEN ... THEN t2.c10 END strips away t2.c10’s BINARY collation, making it "collation-less."

2. Collation Resolution During Comparisons

SQLite uses the following hierarchy when comparing two values:

If the left operand has a collation, use it.
If the right operand has a collation, use it.
Default to BINARY.

In Test Case 1:

Left operand (CASE ... END) has no collation.
Right operand (t0.c5) uses RTRIM.
→ RTRIM governs the comparison, allowing ' ' (space) to match '' (empty).

In Test Case 2:

Left operand (t2.c10) uses BINARY.
Right operand (t0.c5) uses RTRIM.
→ Left operand’s BINARY takes precedence, causing ' ' ≠ ''.

3. Type Affinity and Collation Interaction

SQLite’s type affinity system can further complicate matters. Even if values are logically equivalent, differing collations break equality checks. For instance:

'A' COLLATE BINARY = 'a' COLLATE NOCASE → true.
'A' COLLATE BINARY = 'a' COLLATE BINARY → false.

Resolving Collation Conflicts and Ensuring Consistent Comparisons

Step 1: Diagnose Collation Mismatches

Use PRAGMA collation_list;
Verify registered collations and ensure RTRIM is available.
Inspect Column Collations
Query sqlite_schema to see table definitions:
```
SELECT sql FROM sqlite_schema WHERE name IN ('t0', 't2');
```
Confirm t0.c5 uses COLLATE RTRIM and t2.c10 has no explicit collation (defaults to BINARY).
Check Collation of Expressions
Temporarily modify the query to display collation metadata:
```
SELECT typeof(t2.c10), t2.c10 COLLATE BINARY AS col1, 
       (CASE WHEN TRUE THEN t2.c10 END) AS expr1 
FROM t2;
```
Observe that expr1 has no collation.

Step 2: Standardize Collation Explicitly

Force consistency using COLLATE in queries:

Modify Test Case 1
Apply COLLATE RTRIM to the CASE expression:
```
SELECT * FROM t2 
WHERE (CASE WHEN TRUE THEN t2.c10 END COLLATE RTRIM) IN (SELECT ref_1.c5 FROM t0 AS ref_1);
```
This ensures both sides use RTRIM, yielding 0 rows (matches Test Case 2).
Modify Test Case 2
Apply COLLATE BINARY to the subquery:
```
SELECT * FROM t2 
WHERE t2.c10 IN (SELECT ref_1.c5 COLLATE BINARY FROM t0 AS ref_1);
```
This enforces BINARY on both sides, returning 1 row (matches Test Case 1).

Step 3: Schema Redesign for Collation Consistency

Avoid runtime surprises by aligning collations at the schema level:

Option A: Harmonize Column Collations
Recreate t2 with COLLATE RTRIM:
```
CREATE TABLE t2 (vkey INTEGER, c10 TEXT COLLATE RTRIM);
```
Both t0.c5 and t2.c10 now use RTRIM, ensuring consistent comparisons.
Option B: Use CAST for Type Enforcement
Convert values to a type with no inherent collation (e.g., BLOB):
```
SELECT * FROM t2 
WHERE CAST(t2.c10 AS BLOB) IN (SELECT CAST(ref_1.c5 AS BLOB) FROM t0 AS ref_1);
```
This bypasses collation rules entirely, treating values as binary blobs.

Step 4: Advanced Debugging with EXPLAIN

Use EXPLAIN to see how collation is applied internally:

EXPLAIN 
SELECT * FROM t2 WHERE t2.c10 IN (SELECT ref_1.c5 FROM t0 AS ref_1);

Look for Collation(RTRIM) or Collation(BINARY) in the opcode comments.

Summary of Fixes and Best Practices

Explicit Collation in Expressions
Always use COLLATE on expressions when comparing against columns with non-default collations.
Schema-Level Collation Harmonization
Define collations consistently across related columns to prevent hidden mismatches.
Debugging Tools
Leverage PRAGMA collation_list, EXPLAIN, and temporary diagnostic queries to trace collation application.

By understanding SQLite’s collation precedence rules and proactively managing metadata inheritance, developers can eliminate inconsistencies in query results caused by implicit collation handling.