Fix string escape handling in lexer and explain layer

The lexer now properly unescapes string literals:
- \' → single quote
- \\ → backslash
- \n → newline
- \t → tab
- \r → carriage return
- \0 → null byte
- \b → backspace
- \f → form feed
- \xNN → hex byte value
- '' → single quote (SQL-style escape)

The explain layer re-escapes these characters for display in EXPLAIN AST
output, using ClickHouse's double-escaping format (e.g., null becomes \\0).

Test results improved from 6,000 to 6,006 passing tests.

Author: claude

TODO.md

@@ -2,8 +2,8 @@
 
 ## Current State
 
-- **Tests passing:** 6,000 (87.9%)
-- **Tests skipped:** 824 (12.1%)
+- **Tests passing:** 6,006 (88.0%)
+- **Tests skipped:** 819 (12.0%)
 
 ## Recently Fixed (explain layer)
 
@@ -21,6 +21,7 @@
 - ✅ DROP TABLE with multiple tables (e.g., `DROP TABLE t1, t2, t3`)
 - ✅ Negative integer/float literals (e.g., `-1` → `Literal Int64_-1`)
 - ✅ Empty tuple in ORDER BY (e.g., `ORDER BY ()` → `Function tuple` with empty `ExpressionList`)
+- ✅ String escape handling (lexer now unescapes `\'`, `\\`, `\n`, `\t`, `\0`, etc.)
 
 ## Parser Issues (High Priority)
 
@@ -46,14 +47,6 @@ CREATE TABLE t (c Int TTL expr()) ENGINE=MergeTree;
 -- Expected: ColumnDeclaration with 2 children (type + TTL function)
 ```
 
-### String Escape Handling
-Parser stores escaped characters literally instead of unescaping:
-```sql
-SELECT 'x\'e2\'';
--- Parser stores: x\'e2\'  (with backslashes)
--- Should store: x'e2'  (unescaped)
-```
-
 ## Parser Issues (Medium Priority)
 
 ### CREATE DICTIONARY

internal/explain/format.go

@@ -14,6 +14,35 @@ func FormatFloat(val float64) string {
 	return strconv.FormatFloat(val, 'f', -1, 64)
 }
 
+// escapeStringLiteral escapes special characters in a string for EXPLAIN AST output
+// Uses double-escaping as ClickHouse EXPLAIN AST displays strings
+func escapeStringLiteral(s string) string {
+	var sb strings.Builder
+	for _, r := range s {
+		switch r {
+		case '\\':
+			sb.WriteString("\\\\\\\\") // backslash becomes four backslashes (\\\\)
+		case '\'':
+			sb.WriteString("\\'")
+		case '\n':
+			sb.WriteString("\\\\n") // newline becomes \\n
+		case '\t':
+			sb.WriteString("\\\\t") // tab becomes \\t
+		case '\r':
+			sb.WriteString("\\\\r") // carriage return becomes \\r
+		case '\x00':
+			sb.WriteString("\\\\0") // null becomes \\0
+		case '\b':
+			sb.WriteString("\\\\b") // backspace becomes \\b
+		case '\f':
+			sb.WriteString("\\\\f") // form feed becomes \\f
+		default:
+			sb.WriteRune(r)
+		}
+	}
+	return sb.String()
+}
+
 // FormatLiteral formats a literal value for EXPLAIN AST output
 func FormatLiteral(lit *ast.Literal) string {
 	switch lit.Type {
@@ -35,8 +64,8 @@ func FormatLiteral(lit *ast.Literal) string {
 		return fmt.Sprintf("Float64_%s", FormatFloat(val))
 	case ast.LiteralString:
 		s := lit.Value.(string)
-		// Escape backslashes in strings
-		s = strings.ReplaceAll(s, "\\", "\\\\")
+		// Escape special characters for display
+		s = escapeStringLiteral(s)
 		return fmt.Sprintf("\\'%s\\'", s)
 	case ast.LiteralBoolean:
 		if lit.Value.(bool) {

lexer/lexer.go

@@ -270,24 +270,62 @@ func (l *Lexer) readString(quote rune) Item {
 
 	for !l.eof {
 		if l.ch == quote {
-			// Check for escaped quote
+			// Check for escaped quote (e.g., '' becomes ')
 			if l.peekChar() == quote {
-				sb.WriteRune(l.ch)
-				l.readChar()
-				sb.WriteRune(l.ch)
-				l.readChar()
+				sb.WriteRune(l.ch) // Write one quote (the escaped result)
+				l.readChar()       // skip first quote
+				l.readChar()       // skip second quote
 				continue
 			}
 			l.readChar() // skip closing quote
 			break
 		}
 		if l.ch == '\\' {
-			sb.WriteRune(l.ch)
-			l.readChar()
-			if !l.eof {
-				sb.WriteRune(l.ch)
+			l.readChar() // consume backslash
+			if l.eof {
+				break
+			}
+			// Interpret escape sequence
+			switch l.ch {
+			case '\'':
+				sb.WriteRune('\'')
+			case '"':
+				sb.WriteRune('"')
+			case '\\':
+				sb.WriteRune('\\')
+			case 'n':
+				sb.WriteRune('\n')
+			case 't':
+				sb.WriteRune('\t')
+			case 'r':
+				sb.WriteRune('\r')
+			case '0':
+				sb.WriteRune('\x00')
+			case 'b':
+				sb.WriteRune('\b')
+			case 'f':
+				sb.WriteRune('\f')
+			case 'x':
+				// Hex escape: \xNN
 				l.readChar()
+				if l.eof {
+					break
+				}
+				hex1 := l.ch
+				l.readChar()
+				if l.eof {
+					sb.WriteRune(rune(hexValue(hex1)))
+					continue
+				}
+				hex2 := l.ch
+				// Convert hex digits to byte
+				val := hexValue(hex1)*16 + hexValue(hex2)
+				sb.WriteByte(byte(val))
+			default:
+				// Unknown escape, just write the character after backslash
+				sb.WriteRune(l.ch)
 			}
+			l.readChar()
 			continue
 		}
 		sb.WriteRune(l.ch)
@@ -428,6 +466,19 @@ func isHexDigit(ch rune) bool {
 	return unicode.IsDigit(ch) || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F')
 }
 
+func hexValue(ch rune) int {
+	if ch >= '0' && ch <= '9' {
+		return int(ch - '0')
+	}
+	if ch >= 'a' && ch <= 'f' {
+		return int(ch-'a') + 10
+	}
+	if ch >= 'A' && ch <= 'F' {
+		return int(ch-'A') + 10
+	}
+	return 0
+}
+
 func (l *Lexer) readIdentifier() Item {
 	pos := l.pos
 	var sb strings.Builder