add back long-form aggregation

Author: thomasp85

CHANGELOG.md

@@ -3,13 +3,21 @@
 ### Added
 
 - New `aggregate` SETTING on Identity-stat layers (point, line, area, bar, ribbon,
-range, segment, arrow, rule, text). Collapses each group to a single row by
-replacing every numeric mapping in place with its aggregated value. Accepts a
-single string or array of strings; entries are either unprefixed defaults
-(`'mean'`) or per-aesthetic targets (`'y:max'`, `'color:median'`). Up to two
-defaults may be supplied — the first applies to lower-half aesthetics plus all
-non-range layers, the second to upper-half (`max`/`end` suffix). Numeric
-mappings without a target or applicable default are dropped with a warning.
+range, segment, arrow, rule, text). By default it collapses each group to a
+single row by replacing every numeric mapping in place with its aggregated
+value. Accepts a single string or array of strings; entries are either
+unprefixed defaults (`'mean'`) or per-aesthetic targets (`'y:max'`,
+`'color:median'`). Up to two defaults may be supplied — the first applies to
+lower-half aesthetics plus all non-range layers, the second to upper-half
+(`max`/`end` suffix). Numeric mappings without a target or applicable default
+are dropped with a warning. Targeting the same aesthetic more than once
+(e.g. `aggregate => ('y:min', 'y:max')`) produces one row per function with
+a synthetic `aggregate` column tagging each row, available for `REMAPPING` to
+another aesthetic; targets with a single function and the unprefixed defaults
+are reused unchanged across the exploded rows. The `aggregate` column's value
+is built from the dedup-and-joined function names of all exploded targets at
+each row, separated by `/` (so `('y:min', 'y:max', 'color:sum', 'color:prod')`
+yields `'min/sum'` and `'max/prod'`). Mixed lengths above 1 are an error.
 - Add cell delimiters and code lens actions to the Positron extension (#366)
 - ODBC is now turned on for the CLI as well (#344)
 - `FROM` can now come before `VISUALIZE`, mirroring the DuckDB style. This means

doc/syntax/clause/draw.qmd

@@ -86,6 +86,17 @@ The setting takes a single string or an array of strings. Each string is one of:
 
 A numeric mapping that has neither a target nor an applicable default is dropped from the layer with a warning.
 
+You can also target the same aesthetic more than once to produce **multiple rows per group** — one for each function. For example `aggregate => ('y:min', 'y:max')` emits a min row and a max row per group, so a single `DRAW line` produces two summary lines that connect within each group rather than across them.
+
+The stat exposes a synthetic `aggregate` column tagging each row, which you can pick up with a `REMAPPING` to drive another aesthetic — e.g. `REMAPPING aggregate AS stroke` to colour the two lines differently. The column's value is built from the per-row function names of the *exploded* targets, deduplicated, and joined with `/`:
+
+* `aggregate => ('y:min', 'y:max')` → rows tagged `'min'`, `'max'`.
+* `aggregate => ('y:min', 'y:max', 'color:sum', 'color:prod')` → rows tagged `'min/sum'`, `'max/prod'`.
+* `aggregate => ('y:mean', 'y:max', 'color:mean', 'color:prod')` → rows tagged `'mean'`, `'max/prod'` (the duplicate `'mean'` collapses).
+* `aggregate => ('y:min', 'y:max', 'color:median')` → rows tagged `'min'`, `'max'` (the single-function `color` target is recycled across rows and is not part of the label).
+
+When several aesthetics are targeted with the same number of functions, they explode in lockstep (row 1 uses each aesthetic's first function, row 2 the second, and so on); aesthetics with a single function — and the unprefixed defaults — are reused unchanged across every row. Mixing different lengths above 1 is an error.
+
 The simple functions are:
 
 * `'count'`: Non-null tally of the bound column.
@@ -102,7 +113,7 @@ Allowed offsets are: `'mean'`, `'median'`, `'geomean'`, `'harmean'`, `'rms'`, `'
 
 Allowed expansions are: `'sdev'`, `'se'`, `'var'`, `'iqr'`, and `'range'`
 
-Aggregation applies in place: there is no extra `aggregate` column to remap, and you do not need a `REMAPPING` clause to consume aggregate output. The aggregated value replaces the bound column for the same aesthetic.
+In the single-row (reduction) case aggregation applies in place — no `REMAPPING` is needed and no synthetic column is added. Only the multi-row (explosion) case described above introduces the synthetic `aggregate` column.
 
 ### `FILTER`
 ```ggsql

doc/syntax/layer/type/line.qmd

@@ -96,13 +96,12 @@ DRAW line
 SCALE linewidth TO (0, 30)
 ```
 
-Use aggregation to draw min and max lines from a set of observations. Each layer produces one summary trace; stack two layers for both bounds.
+Use aggregation to draw min and max lines from a set of observations on a single layer. Targeting `y` twice produces one summary line per function within the same layer, with a synthetic `aggregate` column tagging each row that you can remap to colour the lines distinctly:
 
 ```{ggsql}
 VISUALISE Day AS x, Temp AS y FROM ggsql:airquality
 DRAW line
-  SETTING aggregate => 'min'
-DRAW line
-  SETTING aggregate => 'max'
+  REMAPPING aggregate AS stroke
+  SETTING aggregate => ('y:min', 'y:max')
 DRAW point
 ```

src/execute/layer.rs

@@ -604,6 +604,24 @@ where
                 }
             }
 
+            // The synthetic `aggregate` stat column produced by an exploded
+            // Aggregate stat tags each row with its function name. For mark
+            // types that connect rows within a group (line, area, path,
+            // polygon) we add this column to `layer.partition_by` so e.g.
+            // `aggregate => ('y:min', 'y:max')` renders as two separate lines
+            // rather than one zigzag through both. Resolves to the post-rename
+            // data-column name: if the user remapped `aggregate AS <aes>`, the
+            // prefixed aesthetic column; otherwise the stat column.
+            if stat_columns.iter().any(|s| s == "aggregate") {
+                let partition_col = match final_remappings.get("aggregate") {
+                    Some(aes) => naming::aesthetic_column(aes),
+                    None => naming::stat_column("aggregate"),
+                };
+                if !layer.partition_by.contains(&partition_col) {
+                    layer.partition_by.push(partition_col);
+                }
+            }
+
             // Apply stat_columns to layer aesthetics using the remappings
             for stat in &stat_columns {
                 if let Some(aesthetic) = final_remappings.get(stat) {