jarify 0.3.1__tar.gz → 0.3.2__tar.gz

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

@@ -1,5 +1,10 @@
 # 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
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jarify
-Version: 0.3.1
+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.1 → jarify-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "jarify"
-version = "0.3.1"
+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.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/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.1 → jarify-0.3.2}/uv.lock

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

jarify-0.3.1/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