Minor tweaks to naming and features

Author: georgestagg

src/Cargo.toml

@@ -76,15 +76,16 @@ proptest.workspace = true
 ureq = "3"
 
 [features]
-default = ["duckdb", "sqlite", "vegalite", "ipc", "builtin-data"]
+default = ["duckdb", "sqlite", "vegalite", "ipc", "parquet", "builtin-data"]
 ipc = ["polars/ipc"]
 duckdb = ["dep:duckdb", "dep:arrow"]
 polars-sql = ["polars/sql"]
-builtin-data = ["polars/parquet"]
+parquet = ["polars/parquet"]
 postgres = ["dep:postgres"]
 sqlite = ["dep:rusqlite"]
 vegalite = []
 ggplot2 = []
+builtin-data = []
 python = ["dep:pyo3"]
 rest-api = ["dep:axum", "dep:tokio", "dep:tower-http", "dep:tracing", "dep:tracing-subscriber", "duckdb", "vegalite"]
 all-readers = ["duckdb", "postgres", "sqlite", "polars-sql"]

src/naming.rs

@@ -88,16 +88,6 @@ pub const SOURCE_COLUMN: &str = concatcp!(GGSQL_PREFIX, "source", GGSQL_SUFFIX);
 /// Alias for schema extraction queries
 pub const SCHEMA_ALIAS: &str = concatcp!(GGSQL_SUFFIX, "schema", GGSQL_SUFFIX);
 
-// ============================================================================
-// Internal SQL Aliases
-// ============================================================================
-
-/// CTE name for recursive base counter in generate_series: `__ggsql_base__`
-pub const SERIES_BASE: &str = concatcp!(GGSQL_PREFIX, "base", GGSQL_SUFFIX);
-
-/// CTE name for sequence output from generate_series: `__ggsql_seq__`
-pub const SERIES_SEQ: &str = concatcp!(GGSQL_PREFIX, "seq", GGSQL_SUFFIX);
-
 // ============================================================================
 // Constructor Functions
 // ============================================================================

src/plot/layer/geom/boxplot.rs

@@ -182,10 +182,10 @@ fn boxplot_sql_compute_summary(from: &str, groups: &[String], value: &str, coef:
             {q1} AS q1,
             {median} AS median,
             {q3} AS q3
-          FROM ({from}) AS _qt
+          FROM ({from}) AS __ggsql_qt__
           WHERE {value} IS NOT NULL
           GROUP BY {groups}
-        ) AS _fn",
+        ) AS __ggsql_fn__",
         lower_expr = lower_expr,
         upper_expr = upper_expr,
         groups = groups_str,
@@ -382,10 +382,10 @@ mod tests {
             {q1} AS q1,
             {median} AS median,
             {q3} AS q3
-          FROM (SELECT * FROM sales) AS _qt
+          FROM (SELECT * FROM sales) AS __ggsql_qt__
           WHERE price IS NOT NULL
           GROUP BY category
-        ) AS _fn"#
+        ) AS __ggsql_fn__"#
         );
 
         assert_eq!(result, expected);
@@ -412,10 +412,10 @@ mod tests {
             {q1} AS q1,
             {median} AS median,
             {q3} AS q3
-          FROM (SELECT * FROM data) AS _qt
+          FROM (SELECT * FROM data) AS __ggsql_qt__
           WHERE revenue IS NOT NULL
           GROUP BY region, product
-        ) AS _fn"#
+        ) AS __ggsql_fn__"#
         );
 
         assert_eq!(result, expected);

src/plot/layer/geom/density.rs

@@ -268,7 +268,7 @@ fn density_sql_bandwidth(
             SELECT
               {rule} AS bw{comma}
               {groups_str}
-            FROM ({from}) AS _qt
+            FROM ({from}) AS __ggsql_qt__
             WHERE {value} IS NOT NULL
             {group_by}
           )",
@@ -391,11 +391,10 @@ fn build_grid_cte(groups: &[String], from: &str, min: f64, max: f64, n_points: u
     if !has_groups {
         return format!(
             "{seq}, grid AS (
-          SELECT {min} + ({seq_name}.n * {diff} / {n_points}) AS x
-          FROM {seq_name}
+          SELECT {min} + (__ggsql_seq__.n * {diff} / {n_points}) AS x
+          FROM __ggsql_seq__
         )",
             seq = seq,
-            seq_name = crate::naming::SERIES_SEQ,
             min = min,
             diff = diff,
             n_points = n_points
@@ -407,12 +406,11 @@ fn build_grid_cte(groups: &[String], from: &str, min: f64, max: f64, n_points: u
         "{seq}, grid AS (
           SELECT
             {groups},
-            {min} + ({seq_name}.n * {diff} / {n_points}) AS x
-          FROM {seq_name}
+            {min} + (__ggsql_seq__.n * {diff} / {n_points}) AS x
+          FROM __ggsql_seq__
           CROSS JOIN (SELECT DISTINCT {groups} FROM ({from})) AS groups
         )",
         seq = seq,
-        seq_name = crate::naming::SERIES_SEQ,
         groups = groups,
         diff = diff,
         min = min,

src/plot/scale/scale_type/continuous.rs

@@ -154,7 +154,7 @@ impl ScaleTypeTrait for Continuous {
     ///
     /// Supports OOB modes:
     /// - "censor": CASE WHEN col >= min AND col <= max THEN col ELSE NULL END
-    /// - "squish": MAX(min, MIN(col, max))
+    /// - "squish": GREATEST(min, LEAST(col, max))
     /// - "keep": No transformation (returns None)
     ///
     /// Only applies when input_range is explicitly specified via FROM clause.

src/utils.rs

@@ -25,17 +25,16 @@ pub fn sql_least(exprs: &[&str]) -> String {
 /// deep recursion: only recurses ~cbrt(n) times, then cross-joins three
 /// copies to cover the full range.
 pub fn sql_generate_series(n: usize) -> String {
-    use crate::naming::{SERIES_BASE, SERIES_SEQ};
     let base_size = (n as f64).cbrt().ceil() as usize;
     let base_sq = base_size * base_size;
     let base_max = base_size - 1;
     format!(
-        "{SERIES_BASE}(n) AS (\
-           SELECT 0 UNION ALL SELECT n + 1 FROM {SERIES_BASE} WHERE n < {base_max}\
+        "__ggsql_base__(n) AS (\
+           SELECT 0 UNION ALL SELECT n + 1 FROM __ggsql_base__ WHERE n < {base_max}\
          ),\
-         {SERIES_SEQ}(n) AS (\
+         __ggsql_seq__(n) AS (\
            SELECT CAST(a.n * {base_sq} + b.n * {base_size} + c.n AS REAL) AS n \
-           FROM {SERIES_BASE} a, {SERIES_BASE} b, {SERIES_BASE} c \
+           FROM __ggsql_base__ a, __ggsql_base__ b, __ggsql_base__ c \
            WHERE a.n * {base_sq} + b.n * {base_size} + c.n < {n}\
          )"
     )
@@ -49,7 +48,7 @@ pub fn sql_generate_series(n: usize) -> String {
 pub fn sql_percentile(column: &str, fraction: f64, from: &str, groups: &[String]) -> String {
     let group_filter = groups
         .iter()
-        .map(|g| format!("AND _pct.{g} IS NOT DISTINCT FROM _qt.{g}"))
+        .map(|g| format!("AND __ggsql_pct__.{g} IS NOT DISTINCT FROM __ggsql_qt__.{g}"))
         .collect::<Vec<_>>()
         .join(" ");
 
@@ -65,7 +64,7 @@ pub fn sql_percentile(column: &str, fraction: f64, from: &str, groups: &[String]
         FROM (\
           SELECT {column} AS __val, \
                  NTILE(4) OVER (ORDER BY {column}) AS __tile \
-          FROM ({from}) AS _pct \
+          FROM ({from}) AS __ggsql_pct__ \
           WHERE {column} IS NOT NULL {group_filter}\
         ))"
     )
@@ -113,16 +112,28 @@ mod tests {
     fn test_generate_series_small() {
         let sql = sql_generate_series(8);
         // base_size = ceil(8^(1/3)) = 2, base_sq = 4, base_max = 1
-        assert!(sql.contains("WHERE n < 1"), "base CTE should recurse up to base_max=1");
-        assert!(sql.contains("a.n * 4 + b.n * 2 + c.n"), "cross-join arithmetic");
-        assert!(sql.contains("a.n * 4 + b.n * 2 + c.n < 8"), "seq CTE filters to n");
+        assert!(
+            sql.contains("WHERE n < 1"),
+            "base CTE should recurse up to base_max=1"
+        );
+        assert!(
+            sql.contains("a.n * 4 + b.n * 2 + c.n"),
+            "cross-join arithmetic"
+        );
+        assert!(
+            sql.contains("a.n * 4 + b.n * 2 + c.n < 8"),
+            "seq CTE filters to n"
+        );
     }
 
     #[test]
     fn test_generate_series_exact_cube() {
         let sql = sql_generate_series(27);
         // base_size = ceil(27^(1/3)) = 3, base_sq = 9, base_max = 2
-        assert!(sql.contains("WHERE n < 2"), "base CTE should recurse up to base_max=2");
+        assert!(
+            sql.contains("WHERE n < 2"),
+            "base CTE should recurse up to base_max=2"
+        );
         assert!(sql.contains("a.n * 9 + b.n * 3 + c.n < 27"));
     }
 
@@ -158,16 +169,16 @@ mod tests {
         assert!(sql.contains("__tile = 3"));
         assert!(sql.contains("NTILE(4)"));
         assert!(sql.contains("val AS __val"));
-        assert!(sql.contains("FROM (SELECT * FROM t) AS _pct"));
+        assert!(sql.contains("FROM (SELECT * FROM t) AS __ggsql_pct__"));
         assert!(!sql.contains("IS NOT DISTINCT FROM"));
     }
 
     #[test]
     fn test_percentile_with_groups() {
         let groups = vec!["region".to_string(), "year".to_string()];
         let sql = sql_percentile("price", 0.25, "SELECT * FROM sales", &groups);
-        assert!(sql.contains("_pct.region IS NOT DISTINCT FROM _qt.region"));
-        assert!(sql.contains("_pct.year IS NOT DISTINCT FROM _qt.year"));
+        assert!(sql.contains("__ggsql_pct__.region IS NOT DISTINCT FROM __ggsql_qt__.region"));
+        assert!(sql.contains("__ggsql_pct__.year IS NOT DISTINCT FROM __ggsql_qt__.year"));
     }
 
     #[test]