jarify 0.3.0__tar.gz → 0.3.2__tar.gz

{jarify-0.3.0 → jarify-0.3.2}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.3.2] - 2026-04-27
+### Bug Fixes
+
+- handle mixed agg/non-agg SELECT exprs in prefer-group-by-all ([#198](https://github.com/amfaro/jarify/pull/198)) ([#198](https://github.com/amfaro/jarify/pull/198))
+
+## [0.3.1] - 2026-04-27
+### Bug Fixes
+
+- preserve bare numeric/decimal without injecting default precision ([#195](https://github.com/amfaro/jarify/pull/195)) ([#195](https://github.com/amfaro/jarify/pull/195))
+
 ## [0.3.0] - 2026-04-27
 ### Features
 

{jarify-0.3.0 → jarify-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jarify
-Version: 0.3.0
+Version: 0.3.2
 Summary: Bespoke SQL linter and formatter for DuckDB, powered by sqlglot
 Project-URL: Homepage, https://github.com/amfaro/jarify
 Project-URL: Repository, https://github.com/amfaro/jarify

{jarify-0.3.0 → jarify-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "jarify"
-version = "0.3.0"
+version = "0.3.2"
 description = "Bespoke SQL linter and formatter for DuckDB, powered by sqlglot"
 readme = "README.md"
 requires-python = ">=3.12"

{jarify-0.3.0 → jarify-0.3.2}/src/jarify/formatter.py

@@ -14,10 +14,12 @@ from jarify.parser import (
     _extract_ctas_body_placeholders,
     _extract_line_rust_fmt_placeholders,
     _mask_ifnull,
+    _mask_numeric,
     _mask_rust_fmt_placeholders,
     _reinsert_line_rust_fmt_placeholders,
     _restore_ctas_body_placeholders,
     _unmask_ifnull,
+    _unmask_numeric,
     _unmask_rust_fmt_placeholders,
     parse_sql,
 )
@@ -59,6 +61,7 @@ def format_sql(
     stripped_sql, line_insertions = _extract_line_rust_fmt_placeholders(processed_sql)
     masked_sql, inline_mask = _mask_rust_fmt_placeholders(stripped_sql)
     masked_sql = _mask_ifnull(masked_sql)
+    masked_sql = _mask_numeric(masked_sql)
 
     try:
         trees = parse_sql(masked_sql, dialect=config.dialect)
@@ -67,6 +70,7 @@ def format_sql(
         if result is not None:
             result = _unmask_rust_fmt_placeholders(result, inline_mask)
             result = _unmask_ifnull(result)
+            result = _unmask_numeric(result)
             result = _reinsert_line_rust_fmt_placeholders(result, line_insertions)
             return _restore_ctas_body_placeholders(result, ctas_body_map), warnings
         warnings.append(FormatWarning(f"could not parse SQL (formatting skipped): {exc}"))
@@ -87,6 +91,7 @@ def format_sql(
     formatted = "\n;\n\n".join(formatted_parts) + ("\n;\n" if formatted_parts else "")
     formatted = _unmask_rust_fmt_placeholders(formatted, inline_mask)
     formatted = _unmask_ifnull(formatted)
+    formatted = _unmask_numeric(formatted)
     result = _reinsert_line_rust_fmt_placeholders(formatted, line_insertions)
     return _restore_ctas_body_placeholders(result, ctas_body_map), warnings
 

{jarify-0.3.0 → jarify-0.3.2}/src/jarify/parser.py

@@ -4,13 +4,40 @@ from __future__ import annotations
 
 import functools
 import re
+import typing
 
 import sqlglot
+import sqlglot.expressions as _exp
+from sqlglot.dialects.duckdb import DuckDB as _DuckDB
 from sqlglot.errors import ParseError
 from sqlglot.expressions import Expression
 
 DUCKDB_DIALECT = "duckdb"
 
+# ---------------------------------------------------------------------------
+# Custom DuckDB dialect — preserve bare NUMERIC/DECIMAL without injecting
+# default precision/scale into the AST.
+# ---------------------------------------------------------------------------
+# sqlglot's DuckDB parser registers a TYPE_CONVERTERS handler for DECIMAL that
+# calls build_default_decimal_type(precision=18, scale=3).  This fires for any
+# bare NUMERIC or DECIMAL type (no user-supplied params) and injects (18, 3)
+# into the AST, causing jarify to regenerate `decimal(18, 3)` when the
+# original SQL only said `numeric` or `decimal`.  We remove that converter so
+# bare types stay bare and round-trip cleanly.
+
+
+class _JarifyDuckDBParser(_DuckDB.Parser):
+    TYPE_CONVERTERS: typing.ClassVar = {
+        k: v for k, v in _DuckDB.Parser.TYPE_CONVERTERS.items() if k != _exp.DType.DECIMAL
+    }
+
+
+class _JarifyDuckDB(_DuckDB):
+    Parser = _JarifyDuckDBParser
+
+
+_JARIFY_DIALECT: type[_DuckDB] = _JarifyDuckDB
+
 # ---------------------------------------------------------------------------
 # Rust format-string placeholder handling
 # ---------------------------------------------------------------------------
@@ -260,6 +287,29 @@ def _unmask_ifnull(sql: str) -> str:
     return sql.replace(_IFNULL_SENTINEL, "ifnull")
 
 
+# ---------------------------------------------------------------------------
+# numeric preservation
+# ---------------------------------------------------------------------------
+# sqlglot's DuckDB dialect normalises NUMERIC to DType.DECIMAL at parse time,
+# losing the original keyword.  We mask it with a same-length sentinel so the
+# original spelling is preserved through the format round-trip.
+#
+# Sentinel is 7 chars (same as "numeric") so type-column alignment in CREATE
+# TABLE is not disturbed before the unmask.
+_NUMERIC_SENTINEL = "_numer_"
+_NUMERIC_RE = re.compile(r"\bnumeric\b", re.IGNORECASE)
+
+
+def _mask_numeric(sql: str) -> str:
+    """Replace numeric with a sentinel so sqlglot doesn't normalise it to decimal."""
+    return _NUMERIC_RE.sub(_NUMERIC_SENTINEL, sql)
+
+
+def _unmask_numeric(sql: str) -> str:
+    """Restore numeric from its sentinel."""
+    return sql.replace(_NUMERIC_SENTINEL, "numeric")
+
+
 # ---------------------------------------------------------------------------
 # Reserved-keyword type-cast pre-processor
 # ---------------------------------------------------------------------------
@@ -316,6 +366,16 @@ def _quote_reserved_cast_types(sql: str) -> str:
     return _reserved_cast_re().sub(_replacer, sql)
 
 
+def _read_dialect(dialect: str) -> type[_DuckDB] | str:
+    """Return the parser dialect to use for *dialect*.
+
+    For the DuckDB dialect we substitute our custom subclass that preserves
+    bare NUMERIC/DECIMAL types without injecting default precision/scale.
+    All other dialects are passed through unchanged.
+    """
+    return _JARIFY_DIALECT if dialect == DUCKDB_DIALECT else dialect
+
+
 def parse_sql(sql: str, dialect: str = DUCKDB_DIALECT) -> list[Expression]:
     """Parse a SQL string into a list of sqlglot expression trees.
 
@@ -324,23 +384,24 @@ def parse_sql(sql: str, dialect: str = DUCKDB_DIALECT) -> list[Expression]:
     ``::filter[]``) so sqlglot can handle them.
     """
     preprocessed = _quote_reserved_cast_types(sql)
-    return sqlglot.parse(preprocessed, read=dialect, error_level=sqlglot.ErrorLevel.RAISE)
+    return sqlglot.parse(preprocessed, read=_read_dialect(dialect), error_level=sqlglot.ErrorLevel.RAISE)
 
 
 def parse_sql_lenient(sql: str, dialect: str = DUCKDB_DIALECT) -> tuple[list[Expression], list[ParseError]]:
     """Parse SQL leniently, collecting errors instead of raising."""
     preprocessed = _quote_reserved_cast_types(sql)
+    read = _read_dialect(dialect)
     errors: list[ParseError] = []
     try:
-        trees = sqlglot.parse(preprocessed, read=dialect, error_level=sqlglot.ErrorLevel.RAISE)
+        trees = sqlglot.parse(preprocessed, read=read, error_level=sqlglot.ErrorLevel.RAISE)
     except ParseError:
         # Fall back to lenient parsing so we still get partial trees.
         # Use IGNORE (not WARN) to suppress sqlglot's side-effect stderr prints;
         # errors are re-captured via the RAISE pass below.
-        trees = sqlglot.parse(preprocessed, read=dialect, error_level=sqlglot.ErrorLevel.IGNORE)
+        trees = sqlglot.parse(preprocessed, read=read, error_level=sqlglot.ErrorLevel.IGNORE)
         # Re-parse to capture the actual errors
         try:
-            sqlglot.parse(preprocessed, read=dialect, error_level=sqlglot.ErrorLevel.RAISE)
+            sqlglot.parse(preprocessed, read=read, error_level=sqlglot.ErrorLevel.RAISE)
         except ParseError as e:
             errors.append(e)
     return trees, errors

jarify-0.3.2/src/jarify/rules/prefer_group_by_all.py

@@ -0,0 +1,119 @@
+"""Rule: rewrite explicit GROUP BY column list to GROUP BY ALL when equivalent."""
+
+from __future__ import annotations
+
+import sqlglot.expressions as exp
+
+from jarify.rules.base import FormatterRule, _node_pos
+from jarify.types import LintViolation
+
+
+def _free_col_refs(expr: exp.Expression) -> set[str]:
+    """Return SQL strings of Column nodes in *expr* that are not inside any AggFunc.
+
+    For a purely non-aggregate expression like ``LOWER(name)`` this returns
+    ``{"name"}`` (the leaf column, not the whole expression).  Callers that
+    need the full expression SQL for purely non-aggregate items should call
+    ``expr.sql()`` directly instead.
+    """
+    if isinstance(expr, exp.AggFunc):
+        return set()
+    if isinstance(expr, exp.Column):
+        return {expr.sql(dialect="duckdb")}
+    result: set[str] = set()
+    for child in expr.args.values():
+        if isinstance(child, list):
+            for c in child:
+                if isinstance(c, exp.Expression):
+                    result |= _free_col_refs(c)
+        elif isinstance(child, exp.Expression):
+            result |= _free_col_refs(child)
+    return result
+
+
+def _non_agg_sqls(select: exp.Select) -> set[str]:
+    """Derive the set of "non-aggregate expressions" that GROUP BY ALL would use.
+
+    Rules:
+    - If a SELECT item contains **no** AggFunc anywhere, the whole item counts
+      as a GROUP BY candidate (e.g. ``LOWER(name)``, ``col1``).
+    - If a SELECT item is a **mixed** expression (contains an AggFunc *and*
+      free column references outside that AggFunc), those free column refs are
+      the GROUP BY candidates (e.g. ``'prefix' || col1 || STRING_AGG(x)``
+      contributes ``col1``).
+    - Pure aggregate items (e.g. ``SUM(col)`` with no outer column refs)
+      contribute nothing.
+    """
+    result: set[str] = set()
+    for item in select.expressions:
+        inner = item.this if isinstance(item, exp.Alias) else item
+        if not inner.find(exp.AggFunc):
+            # Entirely non-aggregate — use the whole expression as-is.
+            result.add(inner.sql(dialect="duckdb"))
+        else:
+            # Mixed or pure aggregate — collect free (non-agg) column refs.
+            result |= _free_col_refs(inner)
+    return result
+
+
+class PreferGroupByAllRule(FormatterRule):
+    """Format and lint: rewrite explicit GROUP BY col list to GROUP BY ALL when equivalent."""
+
+    def __init__(self, severity: str = "warn") -> None:
+        self.severity = severity
+
+    @property
+    def name(self) -> str:
+        return "prefer-group-by-all"
+
+    def apply(self, tree: exp.Expression) -> exp.Expression:
+        """Rewrite GROUP BY <cols> → GROUP BY ALL when all non-agg SELECT cols are covered."""
+        for select in tree.find_all(exp.Select):
+            group = select.args.get("group")
+            if not group or not group.expressions:
+                continue
+            if group.args.get("all"):
+                continue
+
+            non_agg = _non_agg_sqls(select)
+            if not non_agg:
+                continue
+
+            group_sqls = {e.sql(dialect="duckdb") for e in group.expressions}
+            if non_agg == group_sqls:
+                group.set("all", True)
+                group.set("expressions", [])
+
+        return tree
+
+    def check(self, tree: exp.Expression) -> list[LintViolation]:
+        if self.severity == "off":
+            return []
+        violations: list[LintViolation] = []
+
+        for select in tree.find_all(exp.Select):
+            group = select.args.get("group")
+            if not group or not group.expressions:
+                continue
+            if group.args.get("all"):
+                # Already GROUP BY ALL — nothing to flag
+                continue
+
+            non_agg = _non_agg_sqls(select)
+            if not non_agg:
+                continue
+
+            group_sqls = {e.sql(dialect="duckdb") for e in group.expressions}
+            if non_agg == group_sqls:
+                _line, _col = _node_pos(group)
+                violations.append(
+                    LintViolation(
+                        rule=self.name,
+                        severity=self.severity,
+                        message="All non-aggregated SELECT columns are listed in GROUP BY; prefer GROUP BY ALL",
+                        line=_line,
+                        column=_col,
+                    )
+                )
+
+        return violations

jarify-0.3.2/tests/fixtures/create_table/inline_primary_key.expected.sql

@@ -0,0 +1,7 @@
+CREATE TABLE orders
+(
+   order_id int     NOT NULL PRIMARY KEY
+  ,customer text    NOT NULL
+  ,total    decimal
+)
+;

jarify-0.3.2/tests/fixtures/duckdb/numeric_decimal_type.expected.sql

@@ -0,0 +1,8 @@
+SELECT
+   x::numeric
+  ,x::decimal
+  ,x::decimal(10, 2)
+  ,x::numeric(8, 4)
+  ,(ir.rate_data->>'value')::numeric
+FROM t
+;

jarify-0.3.2/tests/fixtures/duckdb/numeric_decimal_type.input.sql

@@ -0,0 +1,7 @@
+SELECT
+    x::numeric
+    ,x::decimal
+    ,x::decimal(10, 2)
+    ,x::numeric(8, 4)
+    ,(ir.rate_data->>'value')::numeric
+FROM t

jarify-0.3.2/tests/fixtures/select/group_by_all_mixed_expr.expected.sql

@@ -0,0 +1,5 @@
+SELECT
+   'prefix: ' || group_field || STRING_AGG(transaction_id, ', ') || group_key
+FROM t
+GROUP BY ALL
+;

jarify-0.3.2/tests/fixtures/select/group_by_all_mixed_expr.input.sql

@@ -0,0 +1,5 @@
+SELECT
+  'prefix: ' || group_field || string_agg(transaction_id, ', ') || group_key
+FROM t
+GROUP BY group_field, group_key
+;

{jarify-0.3.0 → jarify-0.3.2}/uv.lock

@@ -34,7 +34,7 @@ wheels = [
 
 [[package]]
 name = "jarify"
-version = "0.3.0"
+version = "0.3.2"
 source = { editable = "." }
 dependencies = [
     { name = "click" },

jarify-0.3.0/src/jarify/rules/prefer_group_by_all.py

@@ -1,84 +0,0 @@
-"""Rule: rewrite explicit GROUP BY column list to GROUP BY ALL when equivalent."""
-
-from __future__ import annotations
-
-import sqlglot.expressions as exp
-
-from jarify.rules.base import FormatterRule, _node_pos
-from jarify.types import LintViolation
-
-
-class PreferGroupByAllRule(FormatterRule):
-    """Format and lint: rewrite explicit GROUP BY col list to GROUP BY ALL when equivalent."""
-
-    def __init__(self, severity: str = "warn") -> None:
-        self.severity = severity
-
-    @property
-    def name(self) -> str:
-        return "prefer-group-by-all"
-
-    def apply(self, tree: exp.Expression) -> exp.Expression:
-        """Rewrite GROUP BY <cols> → GROUP BY ALL when all non-agg SELECT cols are covered."""
-        for select in tree.find_all(exp.Select):
-            group = select.args.get("group")
-            if not group or not group.expressions:
-                continue
-            if group.args.get("all"):
-                continue
-
-            non_agg_sqls: list[str] = []
-            for item in select.expressions:
-                inner = item.this if isinstance(item, exp.Alias) else item
-                if not inner.find(exp.AggFunc):
-                    non_agg_sqls.append(inner.sql(dialect="duckdb"))
-
-            if not non_agg_sqls:
-                continue
-
-            group_sqls = {e.sql(dialect="duckdb") for e in group.expressions}
-            if set(non_agg_sqls) == group_sqls:
-                group.set("all", True)
-                group.set("expressions", [])
-
-        return tree
-
-    def check(self, tree: exp.Expression) -> list[LintViolation]:
-        if self.severity == "off":
-            return []
-        violations: list[LintViolation] = []
-
-        for select in tree.find_all(exp.Select):
-            group = select.args.get("group")
-            if not group or not group.expressions:
-                continue
-            if group.args.get("all"):
-                # Already GROUP BY ALL — nothing to flag
-                continue
-
-            # Collect non-aggregate SELECT expressions (unwrap aliases)
-            non_agg_sqls: list[str] = []
-            for item in select.expressions:
-                inner = item.this if isinstance(item, exp.Alias) else item
-                if not inner.find(exp.AggFunc):
-                    non_agg_sqls.append(inner.sql(dialect="duckdb"))
-
-            if not non_agg_sqls:
-                continue
-
-            group_sqls = {e.sql(dialect="duckdb") for e in group.expressions}
-            non_agg_set = set(non_agg_sqls)
-
-            if non_agg_set and non_agg_set == group_sqls:
-                _line, _col = _node_pos(group)
-                violations.append(
-                    LintViolation(
-                        rule=self.name,
-                        severity=self.severity,
-                        message="All non-aggregated SELECT columns are listed in GROUP BY; prefer GROUP BY ALL",
-                        line=_line,
-                        column=_col,
-                    )
-                )
-
-        return violations

jarify-0.3.0/tests/fixtures/create_table/inline_primary_key.expected.sql

@@ -1,7 +0,0 @@
-CREATE TABLE orders
-(
-   order_id int            NOT NULL PRIMARY KEY
-  ,customer text           NOT NULL
-  ,total    decimal(18, 3)
-)
-;