sql-metadata 3.0.0__tar.gz → 3.0.1__tar.gz

{sql_metadata-3.0.0 → sql_metadata-3.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql_metadata
-Version: 3.0.0
+Version: 3.0.1
 Summary: Uses sqlglot to parse SQL queries and extract metadata
 License: MIT
 License-File: LICENSE
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: sqlglot (>=30.0.3,<31.0.0)
+Requires-Dist: sqlglot (>=30.12.0,<31.0.0)
 Project-URL: Homepage, https://github.com/macbre/sql-metadata
 Project-URL: Repository, https://github.com/macbre/sql-metadata
 Description-Content-Type: text/markdown

{sql_metadata-3.0.0 → sql_metadata-3.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "sql_metadata"
-version = "3.0.0"
+version = "3.0.1"
 license="MIT"
 description = "Uses sqlglot to parse SQL queries and extract metadata"
 authors = ["Maciej Brencz <maciej.brencz@gmail.com>", "Radosław Drążkiewicz <collerek@gmail.com>"]
@@ -14,14 +14,14 @@ packages = [
 
 [tool.poetry.dependencies]
 python = "^3.10"
-sqlglot = "^30.0.3"
+sqlglot = "^30.12.0"
 
 [tool.poetry.group.dev.dependencies]
-coverage = {extras = ["toml"], version = "^7.13"}
-pytest = "^9.0.3"
+coverage = {extras = ["toml"], version = "^7.14"}
+pytest = "^9.1.1"
 pytest-cov = "^7.1.0"
-ruff = "^0.11"
-mypy = "^1.19"
+ruff = "^0.15"
+mypy = "^2.1"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]

{sql_metadata-3.0.0 → sql_metadata-3.0.1}/sql_metadata/column_extractor.py

@@ -199,8 +199,12 @@ class _Collector:
         self.alias_names.append(name)
         if clause:
             self.alias_dict.setdefault(clause, UniqueList()).append(name)
-        if target is not None:
-            self.alias_map[name] = target
+        if target is None:
+            return
+        existing = self.alias_map.get(name, [])
+        merged = UniqueList(existing if isinstance(existing, list) else [existing])
+        merged.extend(target if isinstance(target, list) else [target])
+        self.alias_map[name] = merged if len(merged) > 1 else merged[0]
 
 
 # ---------------------------------------------------------------------------

{sql_metadata-3.0.0 → sql_metadata-3.0.1}/sql_metadata/comments.py

@@ -41,7 +41,11 @@ def _choose_tokenizer(sql: str) -> Tokenizer:
     if "#" in sql and not _has_hash_variables(sql):
         from sqlglot.dialects.mysql import MySQL
 
-        return MySQL.Tokenizer()
+        # Pass dialect="mysql" so the cached TokenizerCore (sqlglot >=30.7.0
+        # caches per-class) is built with MySQL identifier semantics — without
+        # it the cache is primed from the default dialect and later mysql
+        # parses misclassify e.g. ``0020_big_table`` as NUMBER + VAR.
+        return MySQL.Tokenizer(dialect="mysql")
     return Tokenizer()
 
 
@@ -167,7 +171,10 @@ def strip_comments_for_parsing(sql: str) -> str:
     else:
         from sqlglot.dialects.mysql import MySQL
 
-        tokenizer = MySQL.Tokenizer()
+        # See _choose_tokenizer — the explicit dialect prevents the
+        # sqlglot >=30.7.0 TokenizerCore cache from being primed with
+        # default-dialect semantics.
+        tokenizer = MySQL.Tokenizer(dialect="mysql")
     try:
         tokens = list(tokenizer.tokenize(sql))
     except TokenError:

{sql_metadata-3.0.0 → sql_metadata-3.0.1}/sql_metadata/nested_resolver.py

@@ -15,6 +15,7 @@ if TYPE_CHECKING:
     from sql_metadata.parser import Parser
 
 from sqlglot import exp
+from sqlglot.errors import ErrorLevel
 from sqlglot.generator import Generator
 
 from sql_metadata.utils import (
@@ -206,7 +207,7 @@ class NestedResolver:
     def extract_cte_names(
         self,
         cte_name_map: dict[str, str],
-    ) -> list[str]:
+    ) -> UniqueList:
         """Extract CTE names from the AST.
 
         Called by :attr:`Parser.with_names`.
@@ -246,7 +247,7 @@ class NestedResolver:
     @staticmethod
     def extract_subqueries(
         ast: exp.Expression,
-    ) -> tuple[list[str], dict[str, str]]:
+    ) -> tuple[UniqueList, dict[str, str]]:
         """Extract subquery names and bodies in a single post-order walk.
 
         Aliased subqueries keep their alias as the name.  Unaliased
@@ -261,7 +262,7 @@ class NestedResolver:
         :returns: ``(names, bodies)`` where *names* is ordered innermost-first,
             e.g. ``(["subquery_1", "sub"], {...})``.
         """
-        names: list[str] = UniqueList()
+        names = UniqueList()
         bodies: dict[str, str] = {}
         NestedResolver._walk_subqueries(ast, names, bodies, 0)
         return names, bodies
@@ -678,7 +679,13 @@ class NestedResolver:
         body = node.copy()
         for ident in body.find_all(exp.Identifier):
             ident.set("quoted", False)
-        return _PreservingGenerator().generate(body, copy=False)
+        # IGNORE unsupported-feature warnings: the rendered SQL is only fed
+        # back into a sub-Parser and never shown to the user, so warnings
+        # about constructs sqlglot can't faithfully re-emit (e.g. T-SQL
+        # FOR XML PATH) are noise.
+        return _PreservingGenerator(unsupported_level=ErrorLevel.IGNORE).generate(
+            body, copy=False
+        )
 
     @staticmethod
     def _walk_subqueries(

{sql_metadata-3.0.0 → sql_metadata-3.0.1}/sql_metadata/parser.py

@@ -63,13 +63,13 @@ class Parser:
         self._columns_aliases_dict: dict[str, UniqueList] = {}
         self._output_columns: list[str] = []
 
-        self._tables: list[str] | None = None
+        self._tables: UniqueList | None = None
         self._table_aliases: dict[str, str] | None = None
 
-        self._with_names: list[str] | None = None
+        self._with_names: UniqueList | None = None
         self._with_queries: dict[str, str] | None = None
         self._subqueries: dict[str, str] | None = None
-        self._subqueries_names: list[str] | None = None
+        self._subqueries_names: UniqueList | None = None
 
         self._limit_and_offset: tuple[int, int] | None = None
 
@@ -168,7 +168,7 @@ class Parser:
         return self._tokens
 
     @property
-    def columns(self) -> list[str]:
+    def columns(self) -> UniqueList:
         """Return the list of column names referenced in the query.
 
         Walks the sqlglot AST via :class:`ColumnExtractor` in a single DFS
@@ -177,7 +177,7 @@ class Parser:
         SQL), falls back to a regex extraction of ``INTO … (col1, col2)``
         column lists.
 
-        :rtype: list[str]
+        :rtype: UniqueList
         """
         if self._columns_extracted:
             return self._columns
@@ -276,10 +276,10 @@ class Parser:
         return self._columns_aliases_dict
 
     @property
-    def columns_aliases_names(self) -> list[str]:
+    def columns_aliases_names(self) -> UniqueList:
         """Return the names of all column aliases used in the query.
 
-        :rtype: list[str]
+        :rtype: UniqueList
         """
         if not self._columns_extracted:
             _ = self.columns
@@ -299,14 +299,14 @@ class Parser:
         return self._output_columns
 
     @property
-    def tables(self) -> list[str]:
+    def tables(self) -> UniqueList:
         """Return the list of table names referenced in the query.
 
         Tables are extracted from the AST by :class:`TableExtractor`,
         sorted by their position in the SQL text, and filtered to exclude
         CTE names (which appear in :attr:`with_names` instead).
 
-        :rtype: list[str]
+        :rtype: UniqueList
         """
         if self._tables is not None:
             return self._tables
@@ -339,10 +339,10 @@ class Parser:
         return self._table_aliases
 
     @property
-    def with_names(self) -> list[str]:
+    def with_names(self) -> UniqueList:
         """Return the CTE (Common Table Expression) names from the query.
 
-        :rtype: list[str]
+        :rtype: UniqueList
         """
         if self._with_names is not None:
             return self._with_names
@@ -387,13 +387,13 @@ class Parser:
         return self._subqueries
 
     @property
-    def subqueries_names(self) -> list[str]:
+    def subqueries_names(self) -> UniqueList:
         """Return the names of all subqueries (innermost first).
 
         Aliased subqueries use their alias; unaliased ones get
         auto-generated names (``subquery_1``, ``subquery_2``, …).
 
-        :rtype: list[str]
+        :rtype: UniqueList
         """
         if self._subqueries_names is not None:
             return self._subqueries_names
@@ -482,7 +482,9 @@ class Parser:
         is_multi = values and isinstance(values[0], list)
         first_row = values[0] if is_multi else values
         if not columns:
-            columns = [f"column_{ind + 1}" for ind in range(len(first_row))]
+            columns = UniqueList(
+                f"column_{ind + 1}" for ind in range(len(first_row))
+            )
 
         if is_multi:
             self._values_dict = {

{sql_metadata-3.0.0 → sql_metadata-3.0.1}/sql_metadata/table_extractor.py

@@ -141,7 +141,7 @@ class TableExtractor:
     # Public API
     # -------------------------------------------------------------------
 
-    def extract(self) -> list[str]:
+    def extract(self) -> UniqueList:
         """Extract table names, excluding CTE definitions.
 
         For ``CREATE TABLE`` statements, the target table is always placed