Fix literal mappings (#132)

Author: thomasp85

src/execute/layer.rs

@@ -372,6 +372,22 @@ where
     // Build the aesthetic-named schema for stat transforms
     let aesthetic_schema: Schema = build_aesthetic_schema(layer, schema);
 
+    // Collect literal aesthetic column names BEFORE conversion to Column values.
+    // Literal columns contain constant values (same for every row), so adding them to
+    // GROUP BY doesn't affect aggregation results - they're simply preserved through grouping.
+    let literal_columns: Vec<String> = layer
+        .mappings
+        .aesthetics
+        .iter()
+        .filter_map(|(aesthetic, value)| {
+            if value.is_literal() {
+                Some(naming::aesthetic_column(aesthetic))
+            } else {
+                None
+            }
+        })
+        .collect();
+
     // Update mappings to use prefixed aesthetic names
     // This must happen BEFORE stat transforms so they use aesthetic names
     layer.update_mappings_for_aesthetic_columns();
@@ -393,6 +409,15 @@ where
         }
     }
 
+    // Add literal aesthetic columns to group_by so they survive stat transforms.
+    // Since literal columns contain constant values (same for every row), adding them
+    // to GROUP BY doesn't affect aggregation results - they're simply preserved.
+    for col in &literal_columns {
+        if !group_by.contains(col) {
+            group_by.push(col.clone());
+        }
+    }
+
     // Apply statistical transformation (uses aesthetic names)
     let stat_result = layer.geom.apply_stat_transform(
         &query,

src/execute/mod.rs

@@ -1188,4 +1188,71 @@ mod tests {
         assert_eq!(result.data.get(layer0_key).unwrap().height(), 3);
         assert_eq!(result.data.get(layer1_key).unwrap().height(), 3);
     }
+
+    /// Test that literal mappings survive stat transforms (e.g., histogram grouping).
+    ///
+    /// This tests the fix for issue #129 where literal aesthetic columns like
+    /// `'foo' AS stroke` were lost during stat transforms because they weren't
+    /// included in the GROUP BY clause.
+    #[cfg(feature = "duckdb")]
+    #[test]
+    fn test_histogram_with_literal_mapping() {
+        let reader = DuckDBReader::from_connection_string("duckdb://memory").unwrap();
+
+        // Create test data
+        reader
+            .connection()
+            .execute(
+                "CREATE TABLE hist_literal_test AS SELECT RANDOM() * 100 as value FROM range(100)",
+                duckdb::params![],
+            )
+            .unwrap();
+
+        // Histogram with a literal stroke mapping - should preserve the literal column
+        let query = r#"
+            SELECT * FROM hist_literal_test
+            VISUALISE value AS x
+            DRAW histogram MAPPING 'foo' AS stroke
+        "#;
+
+        let result = prepare_data_with_reader(query, &reader).unwrap();
+
+        // Should have layer 0 data with binned results
+        assert!(result.data.contains_key(&naming::layer_key(0)));
+        let layer_df = result.data.get(&naming::layer_key(0)).unwrap();
+
+        // Should have prefixed aesthetic-named columns
+        let col_names: Vec<String> = layer_df
+            .get_column_names_str()
+            .iter()
+            .map(|s| s.to_string())
+            .collect();
+
+        let x_col = naming::aesthetic_column("x");
+        let y_col = naming::aesthetic_column("y");
+        let stroke_col = naming::aesthetic_column("stroke");
+
+        assert!(
+            col_names.contains(&x_col),
+            "Should have '{}' column: {:?}",
+            x_col,
+            col_names
+        );
+        assert!(
+            col_names.contains(&y_col),
+            "Should have '{}' column: {:?}",
+            y_col,
+            col_names
+        );
+        // The literal stroke column should survive the stat transform
+        assert!(
+            col_names.contains(&stroke_col),
+            "Should have '{}' column (literal mapping should survive stat transform): {:?}",
+            stroke_col,
+            col_names
+        );
+
+        // Should have fewer rows than original (binned)
+        assert!(layer_df.height() < 100);
+    }
 }

src/writer/vegalite.rs

@@ -1303,9 +1303,11 @@ impl VegaLiteWriter {
                     } else {
                         " (global data)".to_string()
                     };
+                    // Use user-friendly column name (extract aesthetic name from internal names)
+                    let display_col = naming::extract_aesthetic_name(col).unwrap_or(col.as_str());
                     return Err(GgsqlError::ValidationError(format!(
                         "Column '{}' referenced in aesthetic '{}' (layer {}{}) does not exist.\nAvailable columns: {}",
-                        col,
+                        display_col,
                         aesthetic,
                         layer_idx + 1,
                         source_desc,