minor cleanup

Author: collerek

sql_metadata/column_extractor.py

@@ -148,10 +148,7 @@ def _is_date_part_unit(node: exp.Column) -> bool:
 
 
 class _Collector:
-    """Mutable accumulator for metadata gathered during the AST walk.
-
-    :param table_aliases: Pre-computed table alias → real name mapping.
-    """
+    """Mutable accumulator for metadata gathered during the AST walk."""
 
     __slots__ = (
         "columns",

sql_metadata/dialect_parser.py

@@ -254,9 +254,6 @@ def _parse_with_dialect(clean_sql: str, dialect: Any) -> exp.Expression | None:
 
         if not results or results[0] is None:
             return None
-        # sqlglot.parse's stub returns list[Expression | None]; the None case
-        # is filtered one line above but mypy does not narrow through the
-        # indexed access.
         return results[0]  # type: ignore[return-value]
 
     # -- quality checks -----------------------------------------------------

sql_metadata/nested_resolver.py

@@ -122,14 +122,10 @@ def not_sql(self, expression: exp.Expression) -> str:
             return f"{self.sql(child, 'this')} IS NOT NULL"
         if isinstance(child, exp.In):
             return f"{self.sql(child, 'this')} NOT IN ({self.expressions(child)})"
-        # sqlglot's Generator.not_sql is typed to take exp.Not; we widen the
-        # parameter to exp.Expression to match the override signature across
-        # all custom *_sql methods, and sqlglot's return type is inferred as
-        # Any from partially-typed stubs.
+        # sqlglot stubs under-type not_sql's parameter and return type.
         return super().not_sql(expression)  # type: ignore[arg-type, no-any-return]
 
 
-
 # ---------------------------------------------------------------------------
 # Resolution helpers
 # ---------------------------------------------------------------------------

sql_metadata/sql_cleaner.py

@@ -6,7 +6,6 @@
 outer-parenthesis removal.
 """
 
-import itertools
 import re
 from typing import NamedTuple
 
@@ -36,34 +35,39 @@ def _is_wrapped(text: str) -> bool:
     """
     if len(text) < 2 or text[0] != "(" or text[-1] != ")":
         return False
-    inner = text[1:-1]
-    depths = list(
-        itertools.accumulate(
-            (1 if c == "(" else -1 if c == ")" else 0) for c in inner
-        )
-    )
-    return not depths or min(depths) >= 0
-
-
-def _strip_outer_parens(sql: str, _depth: int = 0) -> str:
+    depth = 0
+    for c in text[1:-1]:
+        if c == "(":
+            depth += 1
+        elif c == ")":
+            depth -= 1
+            if depth < 0:
+                return False
+    return True
+
+
+def _strip_outer_parens(sql: str) -> str:
     """Strip redundant outer parentheses from *sql*.
 
     Needed because sqlglot cannot parse double-wrapped non-SELECT
-    statements like ``((UPDATE ...))``.  Uses ``itertools.accumulate``
-    to verify balanced parens in one pass, with recursion for nesting.
-    A depth guard prevents stack overflow on pathological input.
+    statements like ``((UPDATE ...))``.  A depth guard prevents stack
+    overflow on pathological input.
 
     :param sql: SQL string that may be wrapped in outer parentheses.
     :type sql: str
     :returns: The unwrapped SQL string.
     :rtype: str
     """
-    if _depth > 100:
-        return sql
-    s = sql.strip()
-    if _is_wrapped(s):
-        return _strip_outer_parens(s[1:-1].strip(), _depth + 1)
-    return s
+
+    def _recur(s: str, depth: int) -> str:
+        if depth > 100:
+            return s
+        s = s.strip()
+        if _is_wrapped(s):
+            return _recur(s[1:-1], depth + 1)
+        return s
+
+    return _recur(sql, 0)
 
 
 def _normalize_cte_names(sql: str) -> tuple[str, dict[str, str]]:

test/test_edge_cases.py

@@ -56,3 +56,12 @@ def test_strip_outer_parens_depth_guard():
     # RecursionError.
     parser = Parser("(" * 150 + "SELECT 1" + ")" * 150)
     assert parser.columns == []
+
+
+def test_strip_outer_parens_unbalanced_middle():
+    """Queries that look paren-wrapped but aren't (UNION of parenthesised SELECTs)."""
+    # "(SELECT ...) UNION (SELECT ...)" starts with "(" and ends with ")" but the
+    # inner parens go negative — _is_wrapped must short-circuit and leave the SQL
+    # intact so both SELECT branches parse.
+    parser = Parser("(SELECT a FROM t1) UNION (SELECT b FROM t2)")
+    assert parser.tables == ["t1", "t2"]