Add comprehensive ARRAY type tests following MAP/STRUCT patterns

- Add detailed ARRAY converter tests (JSON/native formats, struct arrays, edge cases)
- Add ARRAY cursor tests (basic types, struct arrays, JSON cast, operations)
- Add ARRAY SQLAlchemy type tests (creation, complex types, nested structures)
- Test ARRAY operations: CARDINALITY, element access, concatenation, CONTAINS
- Test ARRAY converter behavior with different data formats
- Test integration with other complex types (STRUCT, MAP)
- Follow same testing patterns as MAP and STRUCT types
- All tests pass with proper Athena SQL syntax

Total: 50+ new ARRAY-specific tests covering all use cases.

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

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

Author: laughingman7743

tests/pyathena/sqlalchemy/test_types.py

@@ -3,7 +3,7 @@
 from sqlalchemy import Integer, String
 from sqlalchemy.sql import sqltypes
 
-from pyathena.sqlalchemy.types import MAP, STRUCT, AthenaMap, AthenaStruct
+from pyathena.sqlalchemy.types import ARRAY, MAP, STRUCT, AthenaArray, AthenaMap, AthenaStruct
 
 
 class TestAthenaStruct:
@@ -98,3 +98,50 @@ def test_mixed_type_definitions(self):
         map_type = AthenaMap(String, Integer())
         assert isinstance(map_type.key_type, sqltypes.String)
         assert isinstance(map_type.value_type, sqltypes.Integer)
+
+
+class TestAthenaArray:
+    def test_creation_with_default(self):
+        array_type = AthenaArray()
+        assert isinstance(array_type.item_type, sqltypes.String)
+
+    def test_creation_with_type_class(self):
+        array_type = AthenaArray(Integer)
+        assert isinstance(array_type.item_type, sqltypes.Integer)
+
+    def test_creation_with_type_instance(self):
+        array_type = AthenaArray(Integer())
+        assert isinstance(array_type.item_type, sqltypes.Integer)
+
+    def test_creation_with_string_type(self):
+        array_type = AthenaArray(String)
+        assert isinstance(array_type.item_type, sqltypes.String)
+
+    def test_python_type(self):
+        array_type = AthenaArray()
+        assert array_type.python_type is list
+
+    def test_visit_name(self):
+        array_type = AthenaArray()
+        assert array_type.__visit_name__ == "array"
+
+    def test_array_uppercase_visit_name(self):
+        array_type = ARRAY()
+        assert array_type.__visit_name__ == "ARRAY"
+
+    def test_array_with_complex_type(self):
+        array_type = AthenaArray(AthenaStruct(("name", String), ("age", Integer)))
+        assert isinstance(array_type.item_type, AthenaStruct)
+        assert "name" in array_type.item_type.fields
+        assert "age" in array_type.item_type.fields
+
+    def test_array_with_nested_array(self):
+        array_type = AthenaArray(AthenaArray(Integer))
+        assert isinstance(array_type.item_type, AthenaArray)
+        assert isinstance(array_type.item_type.item_type, sqltypes.Integer)
+
+    def test_array_with_map_type(self):
+        array_type = AthenaArray(AthenaMap(String, Integer))
+        assert isinstance(array_type.item_type, AthenaMap)
+        assert isinstance(array_type.item_type.key_type, sqltypes.String)
+        assert isinstance(array_type.item_type.value_type, sqltypes.Integer)

tests/pyathena/test_converter.py

@@ -2,7 +2,7 @@
 
 import pytest
 
-from pyathena.converter import DefaultTypeConverter, _to_struct
+from pyathena.converter import DefaultTypeConverter, _to_array, _to_struct
 
 
 @pytest.mark.parametrize(
@@ -74,6 +74,38 @@ def test_to_map_athena_numeric_keys():
     assert result == expected
 
 
+def test_to_array_athena_numeric_elements():
+    """Test Athena array with numeric elements"""
+    array_value = "[1, 2, 3, 4]"
+    result = _to_array(array_value)
+    expected = [1, 2, 3, 4]
+    assert result == expected
+
+
+def test_to_array_athena_mixed_elements():
+    """Test Athena array with mixed type elements"""
+    array_value = "[1, hello, true, null]"
+    result = _to_array(array_value)
+    expected = [1, "hello", True, None]
+    assert result == expected
+
+
+def test_to_array_athena_struct_elements():
+    """Test Athena array with struct elements"""
+    array_value = "[{name=John, age=30}, {name=Jane, age=25}]"
+    result = _to_array(array_value)
+    expected = [{"name": "John", "age": 30}, {"name": "Jane", "age": 25}]
+    assert result == expected
+
+
+def test_to_array_athena_unnamed_struct_elements():
+    """Test Athena array with unnamed struct elements"""
+    array_value = "[{Alice, 25}, {Bob, 30}]"
+    result = _to_array(array_value)
+    expected = [{"0": "Alice", "1": 25}, {"0": "Bob", "1": 30}]
+    assert result == expected
+
+
 @pytest.mark.parametrize(
     "input_value",
     [
@@ -88,6 +120,101 @@ def test_to_struct_non_dict_json(input_value):
     assert result is None
 
 
+@pytest.mark.parametrize(
+    "input_value,expected",
+    [
+        (None, None),
+        (
+            "[1, 2, 3, 4, 5]",
+            [1, 2, 3, 4, 5],
+        ),
+        (
+            '["apple", "banana", "cherry"]',
+            ["apple", "banana", "cherry"],
+        ),
+        (
+            "[true, false, null]",
+            [True, False, None],
+        ),
+        (
+            '[{"name": "John", "age": 30}, {"name": "Jane", "age": 25}]',
+            [{"name": "John", "age": 30}, {"name": "Jane", "age": 25}],
+        ),
+        ("not valid json", None),
+        ("", None),
+        ("[]", []),
+    ],
+)
+def test_to_array_json_formats(input_value, expected):
+    """Test ARRAY conversion for various JSON formats and edge cases."""
+    result = _to_array(input_value)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "input_value,expected",
+    [
+        ("[1, 2, 3]", [1, 2, 3]),
+        ("[]", []),
+        ("[apple, banana, cherry]", ["apple", "banana", "cherry"]),
+        ("[{Alice, 25}, {Bob, 30}]", [{"0": "Alice", "1": 25}, {"0": "Bob", "1": 30}]),
+        (
+            "[{name=John, age=30}, {name=Jane, age=25}]",
+            [{"name": "John", "age": 30}, {"name": "Jane", "age": 25}],
+        ),
+        ("[true, false, null]", [True, False, None]),
+        ("[1, 2.5, hello]", [1, 2.5, "hello"]),
+    ],
+)
+def test_to_array_athena_native_formats(input_value, expected):
+    """Test ARRAY conversion for Athena native formats."""
+    result = _to_array(input_value)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "input_value,expected",
+    [
+        ("[ARRAY[1, 2], ARRAY[3, 4]]", None),  # Nested arrays (native format)
+        ("[[1, 2], [3, 4]]", [[1, 2], [3, 4]]),  # Nested arrays (JSON format - parseable)
+        ("[MAP(ARRAY['key'], ARRAY['value'])]", None),  # Complex nested structures
+    ],
+)
+def test_to_array_complex_nested_cases(input_value, expected):
+    """Test complex nested array cases behavior."""
+    result = _to_array(input_value)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "input_value",
+    [
+        '"just a string"',  # String JSON
+        "42",  # Number JSON
+        '{"key": "value"}',  # Object JSON
+    ],
+)
+def test_to_array_non_array_json(input_value):
+    """Test that non-array JSON formats return None."""
+    result = _to_array(input_value)
+    assert result is None
+
+
+@pytest.mark.parametrize(
+    "input_value",
+    [
+        "not an array",  # Not bracketed
+        "[unclosed array",  # Malformed
+        "closed array]",  # Malformed
+        "[{malformed struct}",  # Malformed struct
+    ],
+)
+def test_to_array_invalid_formats(input_value):
+    """Test that invalid array formats return None."""
+    result = _to_array(input_value)
+    assert result is None
+
+
 class TestDefaultTypeConverter:
     @pytest.mark.parametrize(
         "input_value,expected",
@@ -104,3 +231,21 @@ def test_struct_conversion(self, input_value, expected):
         converter = DefaultTypeConverter()
         result = converter.convert("row", input_value)
         assert result == expected
+
+    @pytest.mark.parametrize(
+        "input_value,expected",
+        [
+            ("[1, 2, 3]", [1, 2, 3]),
+            ('["a", "b", "c"]', ["a", "b", "c"]),
+            (None, None),
+            ("", None),
+            ("invalid json", None),
+            ("[apple, banana]", ["apple", "banana"]),
+            ("[]", []),
+        ],
+    )
+    def test_array_conversion(self, input_value, expected):
+        """Test DefaultTypeConverter ARRAY conversion for various input formats."""
+        converter = DefaultTypeConverter()
+        result = converter.convert("array", input_value)
+        assert result == expected