Portable GREATEST/LEAST and various sqlite tweaks

Author: georgestagg

Cargo.toml

@@ -37,7 +37,7 @@ polars-ops = { version = "0.52", features = ["pivot"] }
 duckdb = { version = "1.4", features = ["bundled", "vtab-arrow"] }
 arrow = { version = "56", default-features = false, features = ["ipc"] }
 postgres = "0.19"
-rusqlite = { version = "0.38", features = ["bundled"] }
+rusqlite = { version = "0.38", features = ["bundled", "functions", "window", "series"] }
 
 # Writers
 plotters = "0.3"

src/lib.rs

@@ -48,6 +48,7 @@ pub mod writer;
 
 pub mod execute;
 
+pub mod utils;
 pub mod validate;
 
 // Re-export key types for convenience

src/plot/layer/geom/boxplot.rs

@@ -9,6 +9,7 @@ use crate::{
         geom::types::get_column_name, DefaultAestheticValue, DefaultParam, DefaultParamValue,
         ParameterValue, StatResult,
     },
+    utils::{scalar_max, scalar_min},
     DataFrame, GgsqlError, Mappings, Result,
 };
 
@@ -163,11 +164,13 @@ fn stat_boxplot(
 
 fn boxplot_sql_compute_summary(from: &str, groups: &[String], value: &str, coef: &f64) -> String {
     let groups_str = groups.join(", ");
+    let lower_expr = scalar_max(&[&format!("q1 - {coef} * (q3 - q1)"), "min"]);
+    let upper_expr = scalar_min(&[&format!("q3 + {coef} * (q3 - q1)"), "max"]);
     format!(
         "SELECT
           *,
-          MAX(q1 - {coef} * (q3 - q1), min) AS lower,
-          MIN(q3 + {coef} * (q3 - q1), max) AS upper
+          {lower_expr} AS lower,
+          {upper_expr} AS upper
         FROM (
           SELECT
             {groups},
@@ -180,7 +183,8 @@ fn boxplot_sql_compute_summary(from: &str, groups: &[String], value: &str, coef:
           WHERE {value} IS NOT NULL
           GROUP BY {groups}
         ) AS __ggsql_fn__",
-        coef = coef,
+        lower_expr = lower_expr,
+        upper_expr = upper_expr,
         groups = groups_str,
         value = value,
         from = from
@@ -312,8 +316,8 @@ mod tests {
         assert!(result.contains("MAX(value) AS max"));
         assert!(result.contains("WHERE value IS NOT NULL"));
         assert!(result.contains("GROUP BY category"));
-        assert!(result.contains("MAX(q1 - 1.5"));
-        assert!(result.contains("MIN(q3 + 1.5"));
+        assert!(result.contains("SELECT MAX(v) FROM (VALUES (q1 - 1.5"));
+        assert!(result.contains("SELECT MIN(v) FROM (VALUES (q3 + 1.5"));
     }
 
     #[test]
@@ -329,8 +333,8 @@ mod tests {
         let groups = vec!["pos1".to_string()];
         let result = boxplot_sql_compute_summary("q", &groups, "pos2", &2.5);
         assert!(result.contains("2.5"));
-        assert!(result.contains("MAX(q1 - 2.5 * (q3 - q1), min)"));
-        assert!(result.contains("MIN(q3 + 2.5 * (q3 - q1), max)"));
+        assert!(result.contains("SELECT MAX(v) FROM (VALUES (q1 - 2.5 * (q3 - q1)), (min)) AS t(v)"));
+        assert!(result.contains("SELECT MIN(v) FROM (VALUES (q3 + 2.5 * (q3 - q1)), (max)) AS t(v)"));
     }
 
     #[test]
@@ -353,8 +357,8 @@ mod tests {
 
         let expected = r#"SELECT
           *,
-          MAX(q1 - 1.5 * (q3 - q1), min) AS lower,
-          MIN(q3 + 1.5 * (q3 - q1), max) AS upper
+          (SELECT MAX(v) FROM (VALUES (q1 - 1.5 * (q3 - q1)), (min)) AS t(v)) AS lower,
+          (SELECT MIN(v) FROM (VALUES (q3 + 1.5 * (q3 - q1)), (max)) AS t(v)) AS upper
         FROM (
           SELECT
             category,
@@ -378,8 +382,8 @@ mod tests {
 
         let expected = r#"SELECT
           *,
-          MAX(q1 - 1.5 * (q3 - q1), min) AS lower,
-          MIN(q3 + 1.5 * (q3 - q1), max) AS upper
+          (SELECT MAX(v) FROM (VALUES (q1 - 1.5 * (q3 - q1)), (min)) AS t(v)) AS lower,
+          (SELECT MIN(v) FROM (VALUES (q3 + 1.5 * (q3 - q1)), (max)) AS t(v)) AS upper
         FROM (
           SELECT
             region, product,

src/plot/layer/geom/density.rs

@@ -7,6 +7,7 @@ use crate::{
         geom::types::get_column_name, DefaultAestheticValue, DefaultParam, DefaultParamValue,
         ParameterValue, StatResult,
     },
+    utils::scalar_min,
     GgsqlError, Mappings, Result,
 };
 use std::collections::HashMap;
@@ -281,11 +282,16 @@ fn silverman_rule(adjust: f64, value_column: &str) -> String {
     // The query computes Silverman's rule of thumb (R's `stats::bw.nrd0()`).
     // We absorb the adjustment in the 0.9 multiplier of the rule
     let adjust = 0.9 * adjust;
-    format!(
-        "{adjust} * MIN(SQRT(AVG({value}*{value}) - AVG({value})*AVG({value})), (PERCENTILE_CONT(0.75) WITHIN GROUP (ORDER BY {value}) - PERCENTILE_CONT(0.25) WITHIN GROUP (ORDER BY {value})) / 1.34) * POW(COUNT(*), -0.2)",
-        adjust = adjust,
-        value = value_column
-    )
+    let stddev = format!(
+        "SQRT(AVG({v}*{v}) - AVG({v})*AVG({v}))",
+        v = value_column
+    );
+    let iqr = format!(
+        "(PERCENTILE_CONT(0.75) WITHIN GROUP (ORDER BY {v}) - PERCENTILE_CONT(0.25) WITHIN GROUP (ORDER BY {v})) / 1.34",
+        v = value_column
+    );
+    let min_expr = scalar_min(&[&stddev, &iqr]);
+    format!("{adjust} * {min_expr} * POW(COUNT(*), -0.2)")
 }
 
 fn choose_kde_kernel(parameters: &HashMap<String, ParameterValue>) -> Result<String> {
@@ -533,7 +539,7 @@ mod tests {
         FROM (
           SELECT
             grid.x AS __ggsql_stat_x,
-            SUM(data.weight * ((EXP(-0.5 * (grid.x - data.val) * (grid.x - data.val) / (bandwidth.bw * bandwidth.bw))) * 0.3989422804014327)) / ANY_VALUE(bandwidth.bw) AS __ggsql_stat_intensity,
+            SUM(data.weight * ((EXP(-0.5 * (grid.x - data.val) * (grid.x - data.val) / (bandwidth.bw * bandwidth.bw))) * 0.3989422804014327)) / MIN(bandwidth.bw) AS __ggsql_stat_intensity,
             SUM(data.weight) AS __norm
           FROM data
           INNER JOIN bandwidth ON true
@@ -600,7 +606,7 @@ mod tests {
           SELECT
             grid.x AS __ggsql_stat_x,
             grid.region, grid.category,
-            SUM(data.weight * ((EXP(-0.5 * (grid.x - data.val) * (grid.x - data.val) / (bandwidth.bw * bandwidth.bw))) * 0.3989422804014327)) / ANY_VALUE(bandwidth.bw) AS __ggsql_stat_intensity,
+            SUM(data.weight * ((EXP(-0.5 * (grid.x - data.val) * (grid.x - data.val) / (bandwidth.bw * bandwidth.bw))) * 0.3989422804014327)) / MIN(bandwidth.bw) AS __ggsql_stat_intensity,
             SUM(data.weight) AS __norm
           FROM data
           INNER JOIN bandwidth ON data.region IS NOT DISTINCT FROM bandwidth.region AND data.category IS NOT DISTINCT FROM bandwidth.category
@@ -666,7 +672,7 @@ mod tests {
         let expected = "WITH RECURSIVE
           bandwidth AS (
             SELECT
-              0.9 * MIN(SQRT(AVG(x*x) - AVG(x)*AVG(x)), (PERCENTILE_CONT(0.75) WITHIN GROUP (ORDER BY x) - PERCENTILE_CONT(0.25) WITHIN GROUP (ORDER BY x)) / 1.34) * POW(COUNT(*), -0.2) AS bw
+              0.9 * (SELECT MIN(v) FROM (VALUES (SQRT(AVG(x*x) - AVG(x)*AVG(x))), ((PERCENTILE_CONT(0.75) WITHIN GROUP (ORDER BY x) - PERCENTILE_CONT(0.25) WITHIN GROUP (ORDER BY x)) / 1.34)) AS t(v)) * POW(COUNT(*), -0.2) AS bw
             FROM (SELECT x FROM (VALUES (1.0), (2.0), (3.0), (4.0), (5.0)) AS t(x))
             WHERE x IS NOT NULL
 
@@ -696,7 +702,7 @@ mod tests {
         let expected = "WITH RECURSIVE
           bandwidth AS (
             SELECT
-              0.9 * MIN(SQRT(AVG(x*x) - AVG(x)*AVG(x)), (PERCENTILE_CONT(0.75) WITHIN GROUP (ORDER BY x) - PERCENTILE_CONT(0.25) WITHIN GROUP (ORDER BY x)) / 1.34) * POW(COUNT(*), -0.2) AS bw,
+              0.9 * (SELECT MIN(v) FROM (VALUES (SQRT(AVG(x*x) - AVG(x)*AVG(x))), ((PERCENTILE_CONT(0.75) WITHIN GROUP (ORDER BY x) - PERCENTILE_CONT(0.25) WITHIN GROUP (ORDER BY x)) / 1.34)) AS t(v)) * POW(COUNT(*), -0.2) AS bw,
               region
             FROM (SELECT x, region FROM (VALUES (1.0, 'A'), (2.0, 'A'), (3.0, 'B')) AS t(x, region))
             WHERE x IS NOT NULL

src/plot/scale/scale_type/continuous.rs

@@ -5,6 +5,7 @@ use polars::prelude::DataType;
 use super::{ScaleTypeKind, ScaleTypeTrait, SqlTypeNames, TransformKind, OOB_CENSOR, OOB_SQUISH};
 use crate::plot::types::{DefaultParam, DefaultParamValue};
 use crate::plot::{ArrayElement, ParameterValue};
+use crate::utils::{scalar_max, scalar_min};
 
 /// Continuous scale type - for continuous numeric data
 #[derive(Debug, Clone, Copy)]
@@ -196,10 +197,12 @@ impl ScaleTypeTrait for Continuous {
                 "(CASE WHEN {} >= {} AND {} <= {} THEN {} ELSE NULL END)",
                 column_name, min, column_name, max, column_name
             )),
-            OOB_SQUISH => Some(format!(
-                "MAX({}, MIN({}, {}))",
-                min, max, column_name
-            )),
+            OOB_SQUISH => {
+                let min_s = min.to_string();
+                let max_s = max.to_string();
+                let inner = scalar_min(&[&max_s, column_name]);
+                Some(scalar_max(&[&min_s, &inner]))
+            }
             _ => None, // "keep" = no transformation
         }
     }
@@ -268,9 +271,9 @@ mod tests {
 
         assert!(sql.is_some());
         let sql = sql.unwrap();
-        // Should generate MAX/MIN for squish
-        assert!(sql.contains("MAX("));
-        assert!(sql.contains("MIN("));
+        // Should generate portable scalar MAX/MIN via subquery for squish
+        assert!(sql.contains("SELECT MAX(v) FROM (VALUES"));
+        assert!(sql.contains("SELECT MIN(v) FROM (VALUES"));
     }
 
     #[test]

src/reader/sqlite.rs

@@ -3,7 +3,6 @@
 //! Provides a reader for SQLite databases with Polars DataFrame integration.
 //! Works on both native targets and wasm32-unknown-unknown (via sqlite-wasm-rs).
 
-use crate::naming::DATA_PREFIX;
 use crate::reader::Reader;
 use crate::{DataFrame, GgsqlError, Result};
 use chrono::Datelike;

src/utils.rs

@@ -0,0 +1,52 @@
+/// Portable scalar MAX across any number of SQL expressions.
+/// Replaces GREATEST(a, b, ...) which is not supported by all backends.
+/// Generates: `(SELECT MAX(v) FROM (VALUES (a), (b), ...) AS t(v))`
+pub fn scalar_max(exprs: &[&str]) -> String {
+    let values = exprs
+        .iter()
+        .map(|e| format!("({e})"))
+        .collect::<Vec<_>>()
+        .join(", ");
+    format!("(SELECT MAX(v) FROM (VALUES {values}) AS t(v))")
+}
+
+/// Portable scalar MIN across any number of SQL expressions.
+/// Replaces LEAST(a, b, ...) which is not supported by all backends.
+/// Generates: `(SELECT MIN(v) FROM (VALUES (a), (b), ...) AS t(v))`
+pub fn scalar_min(exprs: &[&str]) -> String {
+    let values = exprs
+        .iter()
+        .map(|e| format!("({e})"))
+        .collect::<Vec<_>>()
+        .join(", ");
+    format!("(SELECT MIN(v) FROM (VALUES {values}) AS t(v))")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_scalar_max_two_args() {
+        assert_eq!(
+            scalar_max(&["a", "b"]),
+            "(SELECT MAX(v) FROM (VALUES (a), (b)) AS t(v))"
+        );
+    }
+
+    #[test]
+    fn test_scalar_min_two_args() {
+        assert_eq!(
+            scalar_min(&["a", "b"]),
+            "(SELECT MIN(v) FROM (VALUES (a), (b)) AS t(v))"
+        );
+    }
+
+    #[test]
+    fn test_scalar_max_three_args() {
+        assert_eq!(
+            scalar_max(&["x", "y", "z"]),
+            "(SELECT MAX(v) FROM (VALUES (x), (y), (z)) AS t(v))"
+        );
+    }
+}