Defaults for aesthetics

doc/syntax/layer/density.qmd

@@ -73,14 +73,14 @@ A typical KDE computation with different groups:
 
 ```{ggsql}
 VISUALISE bill_dep AS x, species AS colour FROM ggsql:penguins
-  DRAW density SETTING opacity => 0.8
+  DRAW density
 ```
 
 Changing the relative bandwidth through the `adjust` setting.
 
 ```{ggsql}
 VISUALISE bill_dep AS x, species AS colour FROM ggsql:penguins
-  DRAW density SETTING opacity => 0.8, adjust => 0.1
+  DRAW density SETTING adjust => 0.1
 ```
 
 Stacking the different groups instead of overlaying them.
@@ -94,9 +94,7 @@ Using weighted estimates by mapping a column to the optional weight aesthetic. N
 
 ```{ggsql}
 VISUALISE bill_dep AS x, species AS colour FROM ggsql:penguins
-  DRAW density 
-    MAPPING body_mass AS weight
-    SETTING opacity => 0.8
+  DRAW density MAPPING body_mass AS weight
 ```
 
 If you want to compare a histogram and a density layer, you can use the `intensity` computed variable to match the histogram scale.
@@ -114,8 +112,6 @@ Note the relative height of the groups.
 
 ```{ggsql}
 VISUALISE bill_dep AS x, species AS colour FROM ggsql:penguins
-  DRAW density 
-    REMAPPING intensity AS y
-    SETTING opacity => 0.8
+  DRAW density REMAPPING intensity AS y
 ```
 

doc/syntax/layer/point.qmd

@@ -35,7 +35,6 @@ Create a classic scatterplot
 VISUALISE FROM ggsql:penguins
 DRAW point
     MAPPING bill_len AS x, bill_dep AS y, species AS fill
-    SETTING size => 30
 ```
 
 Map to size to create a bubble chart
@@ -52,6 +51,5 @@ Use filter to only plot a subset of the data
 VISUALISE FROM ggsql:penguins
 DRAW point
     MAPPING bill_len AS x, bill_dep AS y, species AS fill
-    SETTING size => 30
     FILTER sex = 'female'
 ```

src/execute/mod.rs

@@ -50,7 +50,7 @@ use crate::reader::DuckDBReader;
 fn validate(layers: &[Layer], layer_schemas: &[Schema]) -> Result<()> {
     for (idx, (layer, schema)) in layers.iter().zip(layer_schemas.iter()).enumerate() {
         let schema_columns: HashSet<&str> = schema.iter().map(|c| c.name.as_str()).collect();
-        let supported = layer.geom.aesthetics().supported;
+        let supported = layer.geom.aesthetics().supported();
 
         // Validate required aesthetics for this geom
         layer
@@ -97,14 +97,10 @@ fn validate(layers: &[Layer], layer_schemas: &[Schema]) -> Result<()> {
         }
 
         // Validate remapping target aesthetics are supported by geom
-        // Target can be in supported OR hidden (hidden = valid REMAPPING targets but not MAPPING targets)
+        // REMAPPING can target any aesthetic (including Delayed ones from stat transforms)
         let aesthetics_info = layer.geom.aesthetics();
         for target_aesthetic in layer.remappings.aesthetics.keys() {
-            let is_supported = aesthetics_info
-                .supported
-                .contains(&target_aesthetic.as_str());
-            let is_hidden = aesthetics_info.hidden.contains(&target_aesthetic.as_str());
-            if !is_supported && !is_hidden {
+            if !aesthetics_info.contains(target_aesthetic) {
                 return Err(GgsqlError::ValidationError(format!(
                     "Layer {}: REMAPPING targets unsupported aesthetic '{}' for geom '{}'",
                     idx + 1,
@@ -157,7 +153,7 @@ fn validate(layers: &[Layer], layer_schemas: &[Schema]) -> Result<()> {
 fn merge_global_mappings_into_layers(specs: &mut [Plot], layer_schemas: &[Schema]) {
     for spec in specs {
         for (layer, schema) in spec.layers.iter_mut().zip(layer_schemas.iter()) {
-            let supported = layer.geom.aesthetics().supported;
+            let supported = layer.geom.aesthetics().supported();
             let schema_columns: HashSet<&str> = schema.iter().map(|c| c.name.as_str()).collect();
 
             // 1. First merge explicit global aesthetics (layer overrides global)
@@ -180,14 +176,14 @@ fn merge_global_mappings_into_layers(specs: &mut [Plot], layer_schemas: &[Schema
             // 2. Smart wildcard expansion: only expand to columns that exist in schema
             let has_wildcard = layer.mappings.wildcard || spec.global_mappings.wildcard;
             if has_wildcard {
-                for &aes in supported {
+                for aes in &supported {
                     // Only create mapping if column exists in the schema
-                    if schema_columns.contains(aes) {
+                    if schema_columns.contains(*aes) {
                         layer
                             .mappings
                             .aesthetics
                             .entry(crate::parser::builder::normalise_aes_name(aes))
-                            .or_insert(AestheticValue::standard_column(aes));
+                            .or_insert(AestheticValue::standard_column(*aes));
                     }
                 }
             }
@@ -228,10 +224,10 @@ fn split_color_aesthetic(spec: &mut Plot) {
     // 2. Split color mapping to fill/stroke in layers, then remove color
     for layer in &mut spec.layers {
         if let Some(color_value) = layer.mappings.aesthetics.get("color").cloned() {
-            let supported = layer.geom.aesthetics().supported;
+            let aesthetics = layer.geom.aesthetics();
 
             for &aes in &["stroke", "fill"] {
-                if supported.contains(&aes) {
+                if aesthetics.is_supported(aes) {
                     layer
                         .mappings
                         .aesthetics
@@ -248,10 +244,10 @@ fn split_color_aesthetic(spec: &mut Plot) {
     // 3. Split color parameter (SETTING) to fill/stroke in layers
     for layer in &mut spec.layers {
         if let Some(color_value) = layer.parameters.get("color").cloned() {
-            let supported = layer.geom.aesthetics().supported;
+            let aesthetics = layer.geom.aesthetics();
 
             for &aes in &["stroke", "fill"] {
-                if supported.contains(&aes) {
+                if aesthetics.is_supported(aes) {
                     layer
                         .parameters
                         .entry(aes.to_string())
@@ -1127,6 +1123,11 @@ pub fn prepare_data_with_reader<R: Reader>(query: &str, reader: &R) -> Result<Pr
             // Update layer mappings for all layers (even if data shared)
             l.update_mappings_for_remappings();
         }
+
+        // Resolve aesthetics (SETTING/defaults) after all mapping updates
+        // This ensures query literals have been converted to columns, and SETTING/defaults
+        // are added as new Literal entries that remain as constant values
+        l.resolve_aesthetics();
     }
 
     // Validate we have some data (every layer should have its own data)

src/plot/layer/geom/abline.rs

@@ -1,6 +1,7 @@
 //! AbLine geom implementation
 
-use super::{GeomAesthetics, GeomTrait, GeomType};
+use super::{DefaultAesthetics, GeomTrait, GeomType};
+use crate::plot::types::DefaultAestheticValue;
 
 /// AbLine geom - lines with slope and intercept
 #[derive(Debug, Clone, Copy)]
@@ -11,18 +12,16 @@ impl GeomTrait for AbLine {
         GeomType::AbLine
     }
 
-    fn aesthetics(&self) -> GeomAesthetics {
-        GeomAesthetics {
-            supported: &[
-                "slope",
-                "intercept",
-                "stroke",
-                "linetype",
-                "linewidth",
-                "opacity",
+    fn aesthetics(&self) -> DefaultAesthetics {
+        DefaultAesthetics {
+            defaults: &[
+                ("slope", DefaultAestheticValue::Required),
+                ("intercept", DefaultAestheticValue::Required),
+                ("stroke", DefaultAestheticValue::String("black")),
+                ("linewidth", DefaultAestheticValue::Number(1.0)),
+                ("opacity", DefaultAestheticValue::Number(1.0)),
+                ("linetype", DefaultAestheticValue::String("solid")),
             ],
-            required: &["slope", "intercept"],
-            hidden: &[],
         }
     }
 }

src/plot/layer/geom/area.rs

@@ -1,8 +1,8 @@
 //! Area geom implementation
 
-use crate::plot::{DefaultParam, DefaultParamValue};
+use crate::plot::{types::DefaultAestheticValue, DefaultParam, DefaultParamValue};
 
-use super::{GeomAesthetics, GeomTrait, GeomType};
+use super::{DefaultAesthetics, GeomTrait, GeomType};
 
 /// Area geom - filled area charts
 #[derive(Debug, Clone, Copy)]
@@ -13,19 +13,17 @@ impl GeomTrait for Area {
         GeomType::Area
     }
 
-    fn aesthetics(&self) -> GeomAesthetics {
-        GeomAesthetics {
-            supported: &[
-                "x",
-                "y",
-                "fill",
-                "stroke",
-                "opacity",
-                "linewidth",
-                // "linetype", // vegalite doesn't support strokeDash
+    fn aesthetics(&self) -> DefaultAesthetics {
+        DefaultAesthetics {
+            defaults: &[
+                ("x", DefaultAestheticValue::Required),
+                ("y", DefaultAestheticValue::Required),
+                ("fill", DefaultAestheticValue::String("black")),
+                ("stroke", DefaultAestheticValue::String("black")),
+                ("opacity", DefaultAestheticValue::Number(0.8)),
+                ("linewidth", DefaultAestheticValue::Number(1.0)),
+                ("linetype", DefaultAestheticValue::String("solid")),
             ],
-            required: &["x", "y"],
-            hidden: &[],
         }
     }
 

src/plot/layer/geom/arrow.rs

@@ -1,6 +1,7 @@
 //! Arrow geom implementation
 
-use super::{GeomAesthetics, GeomTrait, GeomType};
+use super::{DefaultAesthetics, GeomTrait, GeomType};
+use crate::plot::types::DefaultAestheticValue;
 
 /// Arrow geom - line segments with arrowheads
 #[derive(Debug, Clone, Copy)]
@@ -11,20 +12,19 @@ impl GeomTrait for Arrow {
         GeomType::Arrow
     }
 
-    fn aesthetics(&self) -> GeomAesthetics {
-        GeomAesthetics {
-            supported: &[
-                "x",
-                "y",
-                "xend",
-                "yend",
-                "stroke",
-                "linetype",
-                "linewidth",
-                "opacity",
+    fn aesthetics(&self) -> DefaultAesthetics {
+        DefaultAesthetics {
+            defaults: &[
+                ("x", DefaultAestheticValue::Required),
+                ("y", DefaultAestheticValue::Required),
+                ("xend", DefaultAestheticValue::Required),
+                ("yend", DefaultAestheticValue::Required),
+                ("stroke", DefaultAestheticValue::String("black")),
+                ("linewidth", DefaultAestheticValue::Number(1.0)),
+                ("opacity", DefaultAestheticValue::Number(1.0)),
+                ("linetype", DefaultAestheticValue::String("solid")),
+                ("fill", DefaultAestheticValue::Null),
             ],
-            required: &["x", "y", "xend", "yend"],
-            hidden: &[],
         }
     }
 }

src/plot/layer/geom/bar.rs

@@ -4,7 +4,7 @@ use std::collections::HashMap;
 use std::collections::HashSet;
 
 use super::types::get_column_name;
-use super::{DefaultParam, DefaultParamValue, GeomAesthetics, GeomTrait, GeomType, StatResult};
+use super::{DefaultAesthetics, DefaultParam, DefaultParamValue, GeomTrait, GeomType, StatResult};
 use crate::naming;
 use crate::plot::types::{DefaultAestheticValue, ParameterValue};
 use crate::{DataFrame, GgsqlError, Mappings, Result};
@@ -20,15 +20,23 @@ impl GeomTrait for Bar {
         GeomType::Bar
     }
 
-    fn aesthetics(&self) -> GeomAesthetics {
-        GeomAesthetics {
+    fn aesthetics(&self) -> DefaultAesthetics {
+        DefaultAesthetics {
             // Bar supports optional x and y - stat decides aggregation
             // If x is missing: single bar showing total
             // If y is missing: stat computes COUNT or SUM(weight)
             // weight: optional, if mapped uses SUM(weight) instead of COUNT(*)
-            supported: &["x", "y", "weight", "fill", "stroke", "width", "opacity"],
-            required: &[],
-            hidden: &[],
+            // width is a parameter, not an aesthetic.
+            // if we ever want to make 'width' an aesthetic, we'd probably need to
+            // translate it to 'size'.
+            defaults: &[
+                ("x", DefaultAestheticValue::Null), // Optional - stat may provide
+                ("y", DefaultAestheticValue::Null), // Optional - stat may compute
+                ("weight", DefaultAestheticValue::Null),
+                ("fill", DefaultAestheticValue::String("black")),
+                ("stroke", DefaultAestheticValue::String("black")),
+                ("opacity", DefaultAestheticValue::Number(0.8)),
+            ],
         }
     }
 

src/plot/layer/geom/boxplot.rs

@@ -2,7 +2,7 @@
 
 use std::collections::HashMap;
 
-use super::{GeomAesthetics, GeomTrait, GeomType};
+use super::{DefaultAesthetics, GeomTrait, GeomType};
 use crate::{
     naming,
     plot::{
@@ -21,22 +21,22 @@ impl GeomTrait for Boxplot {
         GeomType::Boxplot
     }
 
-    fn aesthetics(&self) -> GeomAesthetics {
-        GeomAesthetics {
-            supported: &[
-                "x",
-                "y",
-                "fill",
-                "stroke",
-                "opacity",
-                "linetype",
-                "linewidth",
-                "size",
-                "shape",
+    fn aesthetics(&self) -> DefaultAesthetics {
+        DefaultAesthetics {
+            defaults: &[
+                ("x", DefaultAestheticValue::Required),
+                ("y", DefaultAestheticValue::Required),
+                ("stroke", DefaultAestheticValue::String("black")),
+                ("fill", DefaultAestheticValue::String("white")),
+                ("linewidth", DefaultAestheticValue::Number(1.0)),
+                ("opacity", DefaultAestheticValue::Number(0.8)),
+                ("linetype", DefaultAestheticValue::String("solid")),
+                ("size", DefaultAestheticValue::Number(3.0)),
+                ("shape", DefaultAestheticValue::String("circle")),
+                // Internal aesthetics produced by stat transform
+                ("type", DefaultAestheticValue::Delayed),
+                ("yend", DefaultAestheticValue::Delayed),
             ],
-            required: &["x", "y"],
-            // Internal aesthetics produced by stat transform
-            hidden: &["type", "y", "yend"],
         }
     }
 
@@ -547,21 +547,21 @@ mod tests {
         let boxplot = Boxplot;
         let aes = boxplot.aesthetics();
 
-        assert!(aes.required.contains(&"x"));
-        assert!(aes.required.contains(&"y"));
-        assert_eq!(aes.required.len(), 2);
+        assert!(aes.is_required("x"));
+        assert!(aes.is_required("y"));
+        assert_eq!(aes.required().len(), 2);
     }
 
     #[test]
     fn test_boxplot_aesthetics_supported() {
         let boxplot = Boxplot;
         let aes = boxplot.aesthetics();
 
-        assert!(aes.supported.contains(&"x"));
-        assert!(aes.supported.contains(&"y"));
-        assert!(aes.supported.contains(&"fill"));
-        assert!(aes.supported.contains(&"stroke"));
-        assert!(aes.supported.contains(&"opacity"));
+        assert!(aes.is_supported("x"));
+        assert!(aes.is_supported("y"));
+        assert!(aes.is_supported("fill"));
+        assert!(aes.is_supported("stroke"));
+        assert!(aes.is_supported("opacity"));
     }
 
     #[test]