fix: resolve CI test failures for struct support

Address two critical issues identified in CI:

1. **Struct Converter Enhancement**:
   - Add support for Athena's native struct format {a=1, b=2}
   - Maintain backward compatibility with JSON format
   - Implement robust parsing with proper error handling
   - Add comprehensive tests for both formats

2. **TypeCompiler Test Fixes**:
   - Fix missing dialect parameter in test instantiation
   - Add proper mock dialect for TypeCompiler tests
   - Ensure all compiler tests use correct constructor

Key improvements:
- Enhanced _to_struct() function handles both JSON and native Athena formats
- Proper key-value parsing with automatic type detection
- Robust error handling for malformed struct data
- All tests now pass with proper mocking

This resolves all 8 test failures identified in CI:
✅ struct conversion tests ✅ TypeCompiler tests ✅ integration tests

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: laughingman7743

pyathena/converter.py

@@ -81,11 +81,52 @@ def _to_json(varchar_value: Optional[str]) -> Optional[Any]:
 def _to_struct(varchar_value: Optional[str]) -> Optional[Dict[str, Any]]:
     if varchar_value is None:
         return None
+
+    # First try to parse as JSON
     try:
         result = json.loads(varchar_value)
         return result if isinstance(result, dict) else None
     except json.JSONDecodeError:
-        return None
+        pass
+
+    # Handle Athena's native struct format: {a=1, b=2}
+    if varchar_value.startswith("{") and varchar_value.endswith("}"):
+        try:
+            # Convert Athena struct format to JSON format
+            # Replace '=' with ':' and ensure proper quoting for keys
+            inner = varchar_value[1:-1].strip()
+            if not inner:
+                return {}
+
+            pairs = []
+            # Simple parsing for key=value pairs
+            for pair in inner.split(","):
+                pair = pair.strip()
+                if "=" in pair:
+                    key, value = pair.split("=", 1)
+                    key = key.strip()
+                    value = value.strip()
+
+                    # Add quotes to key if not already quoted
+                    if not (key.startswith('"') and key.endswith('"')):
+                        key = f'"{key}"'
+
+                    # Handle value quoting - if it's not a number, quote it
+                    if not (value.isdigit() or value in ("true", "false", "null")) and not (
+                        value.startswith('"') and value.endswith('"')
+                    ):
+                        value = f'"{value}"'
+
+                    pairs.append(f"{key}:{value}")
+
+            json_str = "{" + ",".join(pairs) + "}"
+            result = json.loads(json_str)
+            return result if isinstance(result, dict) else None
+        except (ValueError, json.JSONDecodeError):
+            pass
+
+    # If all parsing attempts fail, return None
+    return None
 
 
 def _to_default(varchar_value: Optional[str]) -> Optional[str]:

tests/pyathena/sqlalchemy/test_compiler.py

@@ -1,5 +1,7 @@
 # -*- coding: utf-8 -*-
 
+from unittest.mock import Mock
+
 from sqlalchemy import Integer, String
 
 from pyathena.sqlalchemy.compiler import AthenaTypeCompiler
@@ -8,13 +10,15 @@
 
 class TestAthenaTypeCompiler:
     def test_visit_struct_empty(self):
-        compiler = AthenaTypeCompiler()
+        dialect = Mock()
+        compiler = AthenaTypeCompiler(dialect)
         struct_type = AthenaStruct()
         result = compiler.visit_struct(struct_type)
         assert result == "ROW()"
 
     def test_visit_struct_with_fields(self):
-        compiler = AthenaTypeCompiler()
+        dialect = Mock()
+        compiler = AthenaTypeCompiler(dialect)
         struct_type = AthenaStruct(("name", String), ("age", Integer))
         result = compiler.visit_struct(struct_type)
         # The exact order might vary, so we check that both fields are present
@@ -24,7 +28,8 @@ def test_visit_struct_with_fields(self):
         assert result.endswith(")")
 
     def test_visit_struct_uppercase(self):
-        compiler = AthenaTypeCompiler()
+        dialect = Mock()
+        compiler = AthenaTypeCompiler(dialect)
         struct_type = STRUCT(("id", Integer), ("title", String))
         result = compiler.visit_STRUCT(struct_type)
         assert "ROW(" in result
@@ -34,13 +39,15 @@ def test_visit_struct_uppercase(self):
 
     def test_visit_struct_no_fields_attribute(self):
         # Test struct type without fields attribute
-        compiler = AthenaTypeCompiler()
+        dialect = Mock()
+        compiler = AthenaTypeCompiler(dialect)
         struct_type = type("MockStruct", (), {})()
         result = compiler.visit_struct(struct_type)
         assert result == "ROW()"
 
     def test_visit_struct_single_field(self):
-        compiler = AthenaTypeCompiler()
+        dialect = Mock()
+        compiler = AthenaTypeCompiler(dialect)
         struct_type = AthenaStruct(("name", String))
         result = compiler.visit_struct(struct_type)
         assert result == "ROW(name STRING)" or result == "ROW(name VARCHAR)"

tests/pyathena/test_converter.py

@@ -28,6 +28,29 @@ def test_to_struct_invalid_json():
     assert result is None
 
 
+def test_to_struct_athena_native_format():
+    """Test conversion of Athena's native struct format {a=1, b=2}"""
+    struct_value = "{a=1, b=2}"
+    result = _to_struct(struct_value)
+    expected = {"a": 1, "b": 2}
+    assert result == expected
+
+
+def test_to_struct_athena_empty_struct():
+    """Test conversion of empty Athena struct {}"""
+    struct_value = "{}"
+    result = _to_struct(struct_value)
+    assert result == {}
+
+
+def test_to_struct_athena_string_values():
+    """Test Athena struct with string values"""
+    struct_value = "{name=John, city=Tokyo}"
+    result = _to_struct(struct_value)
+    expected = {"name": "John", "city": "Tokyo"}
+    assert result == expected
+
+
 def test_to_struct_empty_string():
     result = _to_struct("")
     assert result is None
@@ -74,9 +97,8 @@ def test_struct_conversion_invalid_json(self):
     def test_struct_conversion_athena_format(self):
         """Test conversion of actual Athena struct format like {a=1, b=2}"""
         converter = DefaultTypeConverter()
-        # This is how Athena actually returns struct data in some cases
-        # For now, our converter expects JSON format, but this test documents the behavior
+        # This is how Athena actually returns struct data
         result = converter.convert("row", "{a=1, b=2}")
-        # Currently returns None because it's not valid JSON
-        # This could be enhanced in the future to parse Athena's struct format
-        assert result is None
+        # Now supports Athena's native struct format
+        expected = {"a": 1, "b": 2}
+        assert result == expected