break internal cyclical imports, change test to use parser instead of internal method

Author: collerek

sql_metadata/dialect_parser.py

@@ -254,6 +254,9 @@ 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

@@ -8,6 +8,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Callable
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -121,6 +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.
         return super().not_sql(expression)  # type: ignore[arg-type, no-any-return]
 
 
@@ -172,10 +177,19 @@ class NestedResolver:
        aliases defined inside nested queries.
 
     :param ast: Root AST node (for body extraction).
+    :param parser_factory: Callable that constructs a :class:`Parser` from
+        a SQL string. Injected to break the ``parser.py`` ↔ ``nested_resolver.py``
+        import cycle — ``parser.py`` already imports this module, so it passes
+        the ``Parser`` class itself at resolver-construction time.
     """
 
-    def __init__(self, ast: exp.Expression):
+    def __init__(
+        self,
+        ast: exp.Expression,
+        parser_factory: Callable[[str], "Parser"],
+    ) -> None:
         self._ast = ast
+        self._parser_factory = parser_factory
 
         # Lazy caches
         self._subqueries_parsers: dict[str, "Parser"] = {}
@@ -453,11 +467,11 @@ def _lookup_alias_in_nested(
                SELECT name FROM (SELECT id FROM users) AS sub
                -- "name" not in subquery → returns None
         """
-        from sql_metadata.parser import Parser
-
         for nested_name in names:
             nested_def = definitions[nested_name]
-            nested_parser = parser_cache.setdefault(nested_name, Parser(nested_def))
+            nested_parser = parser_cache.setdefault(
+                nested_name, self._parser_factory(nested_def)
+            )
             if col_name in nested_parser.columns_aliases_names:
                 # Path 1: alias match — resolve through the full alias chain
                 # e.g. SELECT col1 AS a ... then SELECT a AS x ...
@@ -479,8 +493,8 @@ def _lookup_alias_in_nested(
         # Path 3: not found in any nested query
         return None
 
-    @staticmethod
     def _resolve_nested_query(
+        self,
         subquery_alias: str,
         nested_queries_names: list[str],
         nested_queries: dict[str, str],
@@ -498,15 +512,15 @@ def _resolve_nested_query(
         Resolving ``"sub.id"``: prefix ``"sub"`` matches, column
         ``"id"`` is found in the subquery → returns ``["id"]``.
         """
-        from sql_metadata.parser import Parser
-
         parts = subquery_alias.split(".")
         if len(parts) != 2 or parts[0] not in nested_queries_names:
             # e.g. "table.col" or "schema.table.col" — not a subquery ref
             return [subquery_alias]
         sub_query, column_name = parts[0], parts[-1]
         sub_query_definition = nested_queries[sub_query]
-        subparser = already_parsed.setdefault(sub_query, Parser(sub_query_definition))
+        subparser = already_parsed.setdefault(
+            sub_query, self._parser_factory(sub_query_definition)
+        )
         return NestedResolver._resolve_column_in_subparser(
             column_name, subparser, subquery_alias
         )
@@ -612,12 +626,11 @@ def _resolve_column_alias(
                 for x in alias
                 for item in self._resolve_column_alias(x, columns_aliases, visited)
             ]
-        while alias in columns_aliases and alias not in visited:
+        if alias in columns_aliases and alias not in visited:
             visited.add(alias)
-            alias = columns_aliases[alias]
-            if isinstance(alias, list):
-                # e.g. alias mapped to [col1, col2] — resolve list recursively
-                return self._resolve_column_alias(alias, columns_aliases, visited)
+            return self._resolve_column_alias(
+                columns_aliases[alias], columns_aliases, visited
+            )
         return [alias]
 
     # -------------------------------------------------------------------

sql_metadata/parser.py

@@ -89,7 +89,7 @@ def _get_resolver(self) -> NestedResolver:
         if self._resolver is None:
             ast = self._ast_parser.ast
             assert ast is not None
-            self._resolver = NestedResolver(ast)
+            self._resolver = NestedResolver(ast, parser_factory=Parser)
         return self._resolver
 
     @property

test/test_edge_cases.py

@@ -1,13 +1,13 @@
-"""Edge-case tests for internal utilities.
+"""Edge-case tests exercised through the public :class:`Parser` API.
 
-These tests exercise code paths (depth guards, degenerate inputs) that
-are difficult or impossible to trigger through the public Parser API.
-They test internal symbols directly and may need updating if those
-internals are refactored.
+These tests cover degenerate inputs (empty SQL after paren stripping,
+unterminated comments, deeply nested parentheses) by feeding them into
+``Parser`` and asserting on its public properties — no internal helpers
+are imported.
 """
 
 from sql_metadata import Parser
-from sql_metadata.sql_cleaner import SqlCleaner, _strip_outer_parens
+from sql_metadata.sql_cleaner import SqlCleaner
 from sql_metadata.utils import UniqueList
 
 
@@ -43,9 +43,9 @@ def test_clean_empty_after_paren_strip():
 
 
 def test_strip_outer_parens_depth_guard():
-    """Deeply nested parentheses hit the depth guard instead of stack overflow."""
-    deep = "(" * 150 + "SELECT 1" + ")" * 150
-    result = _strip_outer_parens(deep)
-    # Depth guard stops at 100 — some parens remain
-    assert "SELECT 1" in result
-    assert result.startswith("(")
+    """Deeply nested parentheses don't stack-overflow the cleaner's recursion."""
+    # 150 levels exceeds the 100-deep recursion guard in _strip_outer_parens;
+    # parsing through Parser must return gracefully rather than raise
+    # RecursionError.
+    parser = Parser("(" * 150 + "SELECT 1" + ")" * 150)
+    assert parser.columns == []