Fix parser robustness: matching paren lookup and unnamed struct split

- Use _find_matching_paren() instead of assuming closing ')' is at
  end of string, so trailing modifiers don't break parsing
- Replace naive comma split with _split_array_items() in unnamed
  struct path to handle nested values correctly

Closes #693, closes #694.

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

Author: laughingman7743

pyathena/parser.py

@@ -130,7 +130,8 @@ def parse(self, type_str: str) -> TypeNode:
         type_name = type_str[:paren_idx].strip().lower()
         type_name = _TYPE_ALIASES.get(type_name, type_name)
 
-        inner = type_str[paren_idx + 1 : -1].strip()
+        close_idx = self._find_matching_paren(type_str, paren_idx)
+        inner = type_str[paren_idx + 1 : close_idx].strip()
 
         if type_name in ("row", "struct"):
             parts = self._split_type_args(inner)
@@ -192,6 +193,27 @@ def _split_type_args(self, s: str) -> list[str]:
             parts.append("".join(current).strip())
         return parts
 
+    @staticmethod
+    def _find_matching_paren(s: str, open_idx: int) -> int:
+        """Find the index of the closing parenthesis matching the one at *open_idx*.
+
+        Args:
+            s: The full string.
+            open_idx: Index of the opening ``(``.
+
+        Returns:
+            Index of the matching ``)``.
+        """
+        depth = 0
+        for i in range(open_idx, len(s)):
+            if s[i] == "(":
+                depth += 1
+            elif s[i] == ")":
+                depth -= 1
+                if depth == 0:
+                    return i
+        return len(s) - 1
+
     def _find_field_name_boundary(self, part: str) -> int:
         """Find the boundary between field name and type in a row field definition.
 
@@ -479,7 +501,7 @@ def _convert_typed_struct(self, value: str, type_node: TypeNode) -> dict[str, An
 
         # Unnamed struct
         field_names = type_node.field_names or []
-        values = [v.strip() for v in inner.split(",")]
+        values = _split_array_items(inner)
         result = {}
         for i, v in enumerate(values):
             ft = field_types[i] if i < len(field_types) else TypeNode("varchar")

tests/pyathena/test_parser.py

@@ -158,6 +158,13 @@ def test_normalize_hive_syntax_noop(self):
     def test_normalize_hive_syntax_replaces(self):
         assert _normalize_hive_syntax("array<struct<a:int>>") == "array(struct(a int))"
 
+    def test_trailing_modifier_after_paren(self):
+        """Type with content after closing paren should not break parsing."""
+        parser = TypeSignatureParser()
+        # Simulates a hypothetical "timestamp(3) with time zone" style input
+        node = parser.parse("decimal(10, 2) extra")
+        assert node.type_name == "decimal"
+
 
 class TestTypedValueConverter:
     @pytest.fixture
@@ -261,3 +268,10 @@ def test_map_json_null_value_preserved(self, converter):
         result = converter.convert('{"a": null, "b": "null"}', node)
         assert result["a"] is None
         assert result["b"] == "null"
+
+    def test_unnamed_struct_with_nested_value(self, converter):
+        """Unnamed struct split must respect nested braces."""
+        parser = TypeSignatureParser()
+        node = parser.parse("row(inner row(x integer, y integer), val varchar)")
+        result = converter.convert("{inner={x=1, y=2}, val=hello}", node)
+        assert result == {"inner": {"x": 1, "y": 2}, "val": "hello"}