Add sqlite reader

Author: georgestagg

Cargo.toml

@@ -37,8 +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"
-sqlx = { version = "0.8", features = ["postgres"] }
-rusqlite = "0.32"
+rusqlite = { version = "0.38", features = ["bundled", "chrono", "functions", "window"] }
 
 # Writers
 plotters = "0.3"

src/Cargo.toml

@@ -38,7 +38,6 @@ polars-ops.workspace = true
 duckdb = { workspace = true, optional = true }
 arrow = { workspace = true, optional = true }
 postgres = { workspace = true, optional = true }
-sqlx = { workspace = true, optional = true }
 rusqlite = { workspace = true, optional = true }
 
 # Writers

src/execute/layer.rs

@@ -518,12 +518,6 @@ where
             if stat_rename_exprs.is_empty() {
                 transformed_query
             } else {
-                let stat_col_names: Vec<String> = stat_columns
-                    .iter()
-                    .map(|s| naming::stat_column(s))
-                    .collect();
-                let exclude_clause = format!("EXCLUDE ({})", stat_col_names.join(", "));
-
                 // If the transformed query uses CTEs (WITH ... SELECT ...),
                 // we can't wrap it in a subquery because Polars SQL doesn't
                 // support CTEs inside subqueries. Instead, split into CTE
@@ -536,16 +530,14 @@ where
                         .and_then(super::cte::split_with_query)
                 {
                     format!(
-                        "{}, __ggsql_stat__ AS ({}) SELECT * {}, {} FROM __ggsql_stat__",
+                        "{}, __ggsql_stat__ AS ({}) SELECT *, {} FROM __ggsql_stat__",
                         cte_prefix,
                         trailing_select,
-                        exclude_clause,
                         stat_rename_exprs.join(", ")
                     )
                 } else {
                     format!(
-                        "SELECT * {}, {} FROM ({}) AS __ggsql_stat__",
-                        exclude_clause,
+                        "SELECT *, {} FROM ({}) AS __ggsql_stat__",
                         stat_rename_exprs.join(", "),
                         transformed_query
                     )

src/execute/schema.rs

@@ -145,7 +145,7 @@ pub fn extract_series_value(
 
 /// Fetch only column types (no min/max) from a query.
 ///
-/// Uses LIMIT 0 to get schema without reading data.
+/// Uses LIMIT 1 to get schema while minimally reading data.
 /// Returns `(name, dtype, is_discrete)` tuples for each column.
 ///
 /// This is the first phase of the split schema extraction approach:
@@ -157,7 +157,7 @@ where
     F: Fn(&str) -> Result<DataFrame>,
 {
     let schema_query = format!(
-        "SELECT * FROM ({}) AS {} LIMIT 0",
+        "SELECT * FROM ({}) AS {} LIMIT 1",
         query,
         naming::SCHEMA_ALIAS
     );

src/plot/layer/geom/boxplot.rs

@@ -166,16 +166,16 @@ fn boxplot_sql_compute_summary(from: &str, groups: &[String], value: &str, coef:
     format!(
         "SELECT
           *,
-          GREATEST(q1 - {coef} * (q3 - q1), min) AS lower,
-          LEAST(   q3 + {coef} * (q3 - q1), max) AS upper
+          MAX(q1 - {coef} * (q3 - q1), min) AS lower,
+          MIN(q3 + {coef} * (q3 - q1), max) AS upper
         FROM (
           SELECT
             {groups},
             MIN({value}) AS min,
             MAX({value}) AS max,
-            QUANTILE_CONT({value}, 0.25) AS q1,
-            QUANTILE_CONT({value}, 0.50) AS median,
-            QUANTILE_CONT({value}, 0.75) AS q3
+            PERCENTILE_CONT(0.25) WITHIN GROUP (ORDER BY {value}) AS q1,
+            PERCENTILE_CONT(0.50) WITHIN GROUP (ORDER BY {value}) AS median,
+            PERCENTILE_CONT(0.75) WITHIN GROUP (ORDER BY {value}) AS q3
           FROM ({from}) AS __ggsql_qt__
           WHERE {value} IS NOT NULL
           GROUP BY {groups}
@@ -266,10 +266,8 @@ fn boxplot_sql_append_outliers(
         )
         {summary_select}
         UNION ALL
-        (
           SELECT {groups}, type AS {type_name}, value AS {value_name}, NULL AS {value2_name}
           FROM outliers
-        )
         ",
         summary = from,
         outliers = outliers,
@@ -307,32 +305,32 @@ mod tests {
     fn test_sql_compute_summary_basic() {
         let groups = vec!["category".to_string()];
         let result = boxplot_sql_compute_summary("data", &groups, "value", &1.5);
-        assert!(result.contains("QUANTILE_CONT(value, 0.25)"));
-        assert!(result.contains("QUANTILE_CONT(value, 0.50)"));
-        assert!(result.contains("QUANTILE_CONT(value, 0.75)"));
+        assert!(result.contains("PERCENTILE_CONT(0.25) WITHIN GROUP (ORDER BY value)"));
+        assert!(result.contains("PERCENTILE_CONT(0.50) WITHIN GROUP (ORDER BY value)"));
+        assert!(result.contains("PERCENTILE_CONT(0.75) WITHIN GROUP (ORDER BY value)"));
         assert!(result.contains("MIN(value) AS min"));
         assert!(result.contains("MAX(value) AS max"));
         assert!(result.contains("WHERE value IS NOT NULL"));
         assert!(result.contains("GROUP BY category"));
-        assert!(result.contains("GREATEST"));
-        assert!(result.contains("LEAST"));
+        assert!(result.contains("MAX(q1 - 1.5"));
+        assert!(result.contains("MIN(q3 + 1.5"));
     }
 
     #[test]
     fn test_sql_compute_summary_multiple_groups() {
         let groups = vec!["cat".to_string(), "region".to_string()];
         let result = boxplot_sql_compute_summary("tbl", &groups, "val", &1.5);
         assert!(result.contains("GROUP BY cat, region"));
-        assert!(result.contains("QUANTILE_CONT(val, 0.25)"));
+        assert!(result.contains("PERCENTILE_CONT(0.25) WITHIN GROUP (ORDER BY val)"));
     }
 
     #[test]
     fn test_sql_compute_summary_custom_coef() {
         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("GREATEST(q1 - 2.5 * (q3 - q1), min)"));
-        assert!(result.contains("LEAST(   q3 + 2.5 * (q3 - q1), max)"));
+        assert!(result.contains("MAX(q1 - 2.5 * (q3 - q1), min)"));
+        assert!(result.contains("MIN(q3 + 2.5 * (q3 - q1), max)"));
     }
 
     #[test]
@@ -355,16 +353,16 @@ mod tests {
 
         let expected = r#"SELECT
           *,
-          GREATEST(q1 - 1.5 * (q3 - q1), min) AS lower,
-          LEAST(   q3 + 1.5 * (q3 - q1), max) AS upper
+          MAX(q1 - 1.5 * (q3 - q1), min) AS lower,
+          MIN(q3 + 1.5 * (q3 - q1), max) AS upper
         FROM (
           SELECT
             category,
             MIN(price) AS min,
             MAX(price) AS max,
-            QUANTILE_CONT(price, 0.25) AS q1,
-            QUANTILE_CONT(price, 0.50) AS median,
-            QUANTILE_CONT(price, 0.75) AS q3
+            PERCENTILE_CONT(0.25) WITHIN GROUP (ORDER BY price) AS q1,
+            PERCENTILE_CONT(0.50) WITHIN GROUP (ORDER BY price) AS median,
+            PERCENTILE_CONT(0.75) WITHIN GROUP (ORDER BY price) AS q3
           FROM (SELECT * FROM sales) AS __ggsql_qt__
           WHERE price IS NOT NULL
           GROUP BY category
@@ -380,16 +378,16 @@ mod tests {
 
         let expected = r#"SELECT
           *,
-          GREATEST(q1 - 1.5 * (q3 - q1), min) AS lower,
-          LEAST(   q3 + 1.5 * (q3 - q1), max) AS upper
+          MAX(q1 - 1.5 * (q3 - q1), min) AS lower,
+          MIN(q3 + 1.5 * (q3 - q1), max) AS upper
         FROM (
           SELECT
             region, product,
             MIN(revenue) AS min,
             MAX(revenue) AS max,
-            QUANTILE_CONT(revenue, 0.25) AS q1,
-            QUANTILE_CONT(revenue, 0.50) AS median,
-            QUANTILE_CONT(revenue, 0.75) AS q3
+            PERCENTILE_CONT(0.25) WITHIN GROUP (ORDER BY revenue) AS q1,
+            PERCENTILE_CONT(0.50) WITHIN GROUP (ORDER BY revenue) AS median,
+            PERCENTILE_CONT(0.75) WITHIN GROUP (ORDER BY revenue) AS q3
           FROM (SELECT * FROM data) AS __ggsql_qt__
           WHERE revenue IS NOT NULL
           GROUP BY region, product

src/plot/layer/geom/density.rs

@@ -282,7 +282,7 @@ fn silverman_rule(adjust: f64, value_column: &str) -> String {
     // We absorb the adjustment in the 0.9 multiplier of the rule
     let adjust = 0.9 * adjust;
     format!(
-        "{adjust} * LEAST(STDDEV({value}), (QUANTILE_CONT({value}, 0.75) - QUANTILE_CONT({value}, 0.25)) / 1.34) * POWER(COUNT(*), -0.2)",
+        "{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
     )
@@ -340,7 +340,7 @@ fn choose_kde_kernel(parameters: &HashMap<String, ParameterValue>) -> Result<Str
     // Use weighted sum for density computation
     // Weighted: density = (1/h) × Σ(wi × K((x-xi)/h)) / Σwi
     Ok(format!(
-        "SUM(data.weight * ({kernel})) / ANY_VALUE(bandwidth.bw)",
+        "SUM(data.weight * ({kernel})) / MIN(bandwidth.bw)",
         kernel = kernel
     ))
 }
@@ -662,11 +662,11 @@ mod tests {
 
         let bw_cte = density_sql_bandwidth(query, &groups, "x", &parameters);
 
-        // Verify exact SQL structure uses QUANTILE_CONT
-        let expected = "WITH
+        // Verify exact SQL structure uses PERCENTILE_CONT
+        let expected = "WITH RECURSIVE
           bandwidth AS (
             SELECT
-              0.9 * LEAST(STDDEV(x), (QUANTILE_CONT(x, 0.75) - QUANTILE_CONT(x, 0.25)) / 1.34) * POWER(COUNT(*), -0.2) AS bw
+              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
             FROM (SELECT x FROM (VALUES (1.0), (2.0), (3.0), (4.0), (5.0)) AS t(x))
             WHERE x IS NOT NULL
 
@@ -692,11 +692,11 @@ mod tests {
 
         let bw_cte = density_sql_bandwidth(query, &groups, "x", &parameters);
 
-        // Verify exact SQL structure uses QUANTILE_CONT with GROUP BY
-        let expected = "WITH
+        // Verify exact SQL structure uses PERCENTILE_CONT with GROUP BY
+        let expected = "WITH RECURSIVE
           bandwidth AS (
             SELECT
-              0.9 * LEAST(STDDEV(x), (QUANTILE_CONT(x, 0.75) - QUANTILE_CONT(x, 0.25)) / 1.34) * POWER(COUNT(*), -0.2) AS bw,
+              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,
               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/layer/geom/histogram.rs

@@ -163,9 +163,11 @@ fn stat_histogram(
             w = bin_width
         )
     } else {
-        // Right-closed (a, b]: use CEIL - 1 with GREATEST for min value
+        // Right-closed (a, b]: use CEIL - 1, clamped to 0 minimum
+        // Use CASE instead of MAX(a,b) because this expression appears in GROUP BY
+        // where MAX would be interpreted as the aggregate function
         format!(
-            "(GREATEST(CEIL(({x} - {min} + {w} * 0.5) / {w}) - 1, 0)) * {w} + {min} - {w} * 0.5",
+            "(CASE WHEN CEIL(({x} - {min} + {w} * 0.5) / {w}) - 1 > 0 THEN CEIL(({x} - {min} + {w} * 0.5) / {w}) - 1 ELSE 0 END) * {w} + {min} - {w} * 0.5",
             x = x_col,
             min = min_val,
             w = bin_width

src/plot/scale/scale_type/continuous.rs

@@ -153,7 +153,7 @@ impl ScaleTypeTrait for Continuous {
     ///
     /// Supports OOB modes:
     /// - "censor": CASE WHEN col >= min AND col <= max THEN col ELSE NULL END
-    /// - "squish": GREATEST(min, LEAST(col, max))
+    /// - "squish": MAX(min, MIN(col, max))
     /// - "keep": No transformation (returns None)
     ///
     /// Only applies when input_range is explicitly specified via FROM clause.
@@ -197,7 +197,7 @@ impl ScaleTypeTrait for Continuous {
                 column_name, min, column_name, max, column_name
             )),
             OOB_SQUISH => Some(format!(
-                "GREATEST({}, LEAST({}, {}))",
+                "MAX({}, MIN({}, {}))",
                 min, max, column_name
             )),
             _ => None, // "keep" = no transformation
@@ -268,9 +268,9 @@ mod tests {
 
         assert!(sql.is_some());
         let sql = sql.unwrap();
-        // Should generate GREATEST/LEAST for squish
-        assert!(sql.contains("GREATEST"));
-        assert!(sql.contains("LEAST"));
+        // Should generate MAX/MIN for squish
+        assert!(sql.contains("MAX("));
+        assert!(sql.contains("MIN("));
     }
 
     #[test]

src/reader/mod.rs

@@ -44,6 +44,9 @@ pub mod duckdb;
 #[cfg(feature = "polars-sql")]
 pub mod polars_sql;
 
+#[cfg(feature = "sqlite")]
+pub mod sqlite;
+
 pub mod connection;
 pub mod data;
 mod spec;
@@ -54,6 +57,9 @@ pub use duckdb::DuckDBReader;
 #[cfg(feature = "polars-sql")]
 pub use polars_sql::PolarsReader;
 
+#[cfg(feature = "sqlite")]
+pub use sqlite::SqliteReader;
+
 // ============================================================================
 // Spec - Result of reader.execute()
 // ============================================================================