raise more meaningful error on invalid queries, raise on cte without name instead of silently skipping, extract mypy and ruff into separate workflows

Author: collerek

.github/workflows/lint.yml

@@ -0,0 +1,30 @@
+name: Lint
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v6
+    - name: Set up Python
+      uses: actions/setup-python@v6
+      with:
+        python-version: "3.12"
+
+    - name: Install Poetry
+      uses: snok/install-poetry@v1.4.1
+      with:
+        version: latest
+        virtualenvs-create: true
+        virtualenvs-in-project: true
+
+    - name: Install dependencies with poetry
+      run: poetry install --no-root
+
+    - name: Lint with ruff
+      run: make lint

.github/workflows/python-ci.yml

@@ -74,11 +74,5 @@ jobs:
         pip install coveralls
         poetry run coveralls --service=github
 
-    - name: Lint with ruff
-      run: make lint
-
-    - name: Type check with mypy
-      run: make type_check
-
     - name: Build a distribution package
       run: poetry build -vvv

.github/workflows/type-check.yml

@@ -0,0 +1,30 @@
+name: Type Check
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+
+jobs:
+  type-check:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v6
+    - name: Set up Python
+      uses: actions/setup-python@v6
+      with:
+        python-version: "3.12"
+
+    - name: Install Poetry
+      uses: snok/install-poetry@v1.4.1
+      with:
+        version: latest
+        virtualenvs-create: true
+        virtualenvs-in-project: true
+
+    - name: Install dependencies with poetry
+      run: poetry install --no-root
+
+    - name: Type check with mypy
+      run: make type_check

sql_metadata/__init__.py

@@ -15,7 +15,8 @@
 MSSQL, MySQL, Hive/Spark, and TSQL bracket notation.
 """
 
+from sql_metadata.exceptions import InvalidQueryDefinition
 from sql_metadata.keywords_lists import QueryType
 from sql_metadata.parser import Parser
 
-__all__ = ["Parser", "QueryType"]
+__all__ = ["InvalidQueryDefinition", "Parser", "QueryType"]

sql_metadata/column_extractor.py

@@ -16,6 +16,7 @@
 
 from sqlglot import exp
 
+from sql_metadata.exceptions import InvalidQueryDefinition
 from sql_metadata.utils import UniqueList, _make_reverse_cte_map, last_segment
 
 # ---------------------------------------------------------------------------
@@ -509,9 +510,10 @@ def _handle_cte(self, cte: exp.CTE, depth: int) -> None:
         """Handle a CTE (Common Table Expression) AST node."""
         c = self._collector
         alias = cte.alias
-        # TODO: revisit if sqlglot ever produces CTE nodes without aliases
-        if not alias:  # pragma: no cover
-            return
+        if not alias:
+            raise InvalidQueryDefinition(
+                "All CTEs require an alias, not a valid SQL"
+            )
 
         c.cte_names.append(alias)
 

sql_metadata/dialect_parser.py

@@ -15,6 +15,7 @@ class so that callers only need to call :meth:`DialectParser.parse`.
 from sqlglot.tokens import Tokenizer as BaseTokenizer
 
 from sql_metadata.comments import _has_hash_variables
+from sql_metadata.exceptions import InvalidQueryDefinition
 
 #: Table names that indicate a degraded parse result.
 _BAD_TABLE_NAMES = frozenset({"IGNORE", ""})
@@ -136,13 +137,17 @@ def _try_dialects(
                 return result, dialect
             except (ParseError, TokenError):
                 if dialect is not None and dialect == dialects[-1]:
-                    raise ValueError("This query is wrong")
+                    raise InvalidQueryDefinition(
+                        "Query could not be parsed — SQL syntax error"
+                    )
                 continue
 
         # TODO: revisit if sqlglot starts returning None from parse for last dialect
         if last_result is not None:  # pragma: no cover
             return last_result, winning_dialect
-        raise ValueError("This query is wrong")
+        raise InvalidQueryDefinition(
+            "Query could not be parsed — no dialect could handle this SQL"
+        )
 
     @staticmethod
     def _parse_with_dialect(clean_sql: str, dialect: Any) -> Optional[exp.Expression]:

sql_metadata/exceptions.py

@@ -0,0 +1,5 @@
+"""Custom exceptions for the sql-metadata package."""
+
+
+class InvalidQueryDefinition(ValueError):
+    """Raised when the SQL query is structurally invalid or unsupported."""

sql_metadata/query_type_extractor.py

@@ -10,6 +10,7 @@
 
 from sqlglot import exp
 
+from sql_metadata.exceptions import InvalidQueryDefinition
 from sql_metadata.keywords_lists import QueryType
 
 logger = logging.getLogger(__name__)
@@ -61,7 +62,9 @@ def extract(self) -> QueryType:
         node_type = type(root)
 
         if node_type is exp.With:
-            raise ValueError("This query is wrong")
+            raise InvalidQueryDefinition(
+                "WITH clause without a main statement is not valid SQL"
+            )
 
         simple = _SIMPLE_TYPE_MAP.get(node_type)
         if simple is not None:
@@ -74,7 +77,7 @@ def extract(self) -> QueryType:
 
         shorten_query = " ".join(self._raw_query.split(" ")[:3])
         logger.error("Not supported query type: %s", shorten_query)
-        raise ValueError("Not supported query type!")
+        raise InvalidQueryDefinition("Not supported query type!")
 
     @staticmethod
     def _unwrap_parens(ast: exp.Expression) -> exp.Expression:
@@ -100,5 +103,7 @@ def _raise_for_none_ast(self) -> "NoReturn":
 
         stripped = strip_comments(self._raw_query) if self._raw_query else ""
         if stripped.strip():
-            raise ValueError("This query is wrong")
-        raise ValueError("Empty queries are not supported!")
+            raise InvalidQueryDefinition(
+                "Could not parse the query — the SQL syntax appears to be invalid"
+            )
+        raise InvalidQueryDefinition("Empty queries are not supported!")

sql_metadata/sql_cleaner.py

@@ -11,6 +11,7 @@
 from typing import NamedTuple, Optional
 
 from sql_metadata.comments import strip_comments_for_parsing as _strip_comments
+from sql_metadata.exceptions import InvalidQueryDefinition
 from sql_metadata.utils import DOT_PLACEHOLDER
 
 
@@ -174,4 +175,6 @@ def _detect_malformed_with(clean_sql: str) -> None:
         if re.search(
             r"\)\s+AS\s+" + main_kw + r"\b", clean_sql, re.IGNORECASE
         ) or re.search(r"\)\s+AS\s+\w+\s+" + main_kw + r"\b", clean_sql, re.IGNORECASE):
-            raise ValueError("This query is wrong")
+            raise InvalidQueryDefinition(
+                "Malformed WITH clause — extra AS keyword after CTE body"
+            )

test/test_create_table.py

@@ -1,11 +1,11 @@
 import pytest
 
-from sql_metadata import Parser
+from sql_metadata import InvalidQueryDefinition, Parser
 from sql_metadata.keywords_lists import QueryType
 
 
 def test_is_create_table_query():
-    with pytest.raises(ValueError):
+    with pytest.raises(InvalidQueryDefinition):
         assert Parser("BEGIN").query_type
 
     assert Parser("SELECT * FROM `foo` ()").query_type == QueryType.SELECT