@malloydata/malloy-tests 0.0.296 → 0.0.298

package/package.json

@@ -21,14 +21,14 @@
   },
   "dependencies": {
     "@jest/globals": "^29.4.3",
-    "@malloydata/db-bigquery": "0.0.296",
-    "@malloydata/db-duckdb": "0.0.296",
-    "@malloydata/db-postgres": "0.0.296",
-    "@malloydata/db-snowflake": "0.0.296",
-    "@malloydata/db-trino": "0.0.296",
-    "@malloydata/malloy": "0.0.296",
-    "@malloydata/malloy-tag": "0.0.296",
-    "@malloydata/render": "0.0.296",
+    "@malloydata/db-bigquery": "0.0.298",
+    "@malloydata/db-duckdb": "0.0.298",
+    "@malloydata/db-postgres": "0.0.298",
+    "@malloydata/db-snowflake": "0.0.298",
+    "@malloydata/db-trino": "0.0.298",
+    "@malloydata/malloy": "0.0.298",
+    "@malloydata/malloy-tag": "0.0.298",
+    "@malloydata/render": "0.0.298",
     "events": "^3.3.0",
     "jsdom": "^22.1.0",
     "luxon": "^2.4.0",
@@ -38,5 +38,5 @@
     "@types/jsdom": "^21.1.1",
     "@types/luxon": "^2.4.0"
   },
-  "version": "0.0.296"
+  "version": "0.0.298"
 }

package/src/databases/presto-trino/presto-trino.spec.ts

@@ -29,43 +29,35 @@ describe.each(runtimes.runtimeList)(
     });
 
     describe('HLL Window Functions', () => {
-      it(`hll_accumulate_moving function - ${databaseName}`, async () => {
-        await expect(`run: ${databaseName}.sql("""
+      it.when(presto)(
+        `hll_accumulate_moving function - ${databaseName}`,
+        async () => {
+          await expect(`run: ${databaseName}.sql("""
           SELECT 'A' as category, 'value1' as val, 1 as seq
           UNION ALL SELECT 'A' as category, 'value2' as val, 2 as seq
           UNION ALL SELECT 'B' as category, 'value1' as val, 1 as seq
           UNION ALL SELECT 'B' as category, 'value3' as val, 2 as seq
         """) -> {
-          group_by: category
+          select: *
           order_by: category, seq
-          calculate: hll_moving is hll_estimate_moving(hll_accumulate_moving(val, 1), 1)
-        }`).malloyResultMatches(runtime, [
-          {category: 'A', hll_moving: 1},
-          {category: 'A', hll_moving: 2},
-          {category: 'B', hll_moving: 1},
-          {category: 'B', hll_moving: 1},
-        ]);
-      });
-
-      it(`hll_combine_moving function - ${databaseName}`, async () => {
-        await expect(`run: ${databaseName}.sql("""
-          SELECT 'A' as category, 'value1' as val, 1 as seq
-          UNION ALL SELECT 'A' as category, 'value2' as val, 2 as seq
-          UNION ALL SELECT 'B' as category, 'value1' as val, 1 as seq
-        """) -> {
-          group_by: category
-          aggregate: hll_set is hll_accumulate(val)
+          calculate: hll_acc is hll_accumulate_moving(val, 1)
         } -> {
-          order_by: category
-          calculate: combined_hll is hll_estimate_moving(hll_combine_moving(hll_set, 1), 1)
+          select:
+            *
+            hll_moving is hll_estimate(hll_acc)
         }`).malloyResultMatches(runtime, [
-          {category: 'A', combined_hll: 2},
-          {category: 'B', combined_hll: 1},
-        ]);
-      });
+            {category: 'A', val: 'value1', seq: 1, hll_moving: 1},
+            {category: 'A', val: 'value2', seq: 2, hll_moving: 2},
+            {category: 'B', val: 'value1', seq: 1, hll_moving: 2},
+            {category: 'B', val: 'value3', seq: 2, hll_moving: 2},
+          ]);
+        }
+      );
 
-      it(`hll_estimate_moving function - ${databaseName}`, async () => {
-        await expect(`run: ${databaseName}.sql("""
+      it.when(presto)(
+        `hll_combine_moving function - ${databaseName}`,
+        async () => {
+          await expect(`run: ${databaseName}.sql("""
           SELECT 'A' as category, 'value1' as val, 1 as seq
           UNION ALL SELECT 'A' as category, 'value2' as val, 2 as seq
           UNION ALL SELECT 'B' as category, 'value1' as val, 1 as seq
@@ -73,13 +65,19 @@ describe.each(runtimes.runtimeList)(
           group_by: category
           aggregate: hll_set is hll_accumulate(val)
         } -> {
+          select: *
           order_by: category
-          calculate: estimated_count is hll_estimate_moving(hll_set, 1)
+          calculate: combined_hll is hll_combine_moving(hll_set, 1)
+        } -> {
+          select:
+           *
+           final_count is hll_estimate(combined_hll)
         }`).malloyResultMatches(runtime, [
-          {category: 'A', estimated_count: 2},
-          {category: 'B', estimated_count: 1},
-        ]);
-      });
+            {category: 'A', final_count: 2},
+            {category: 'B', final_count: 2},
+          ]);
+        }
+      );
     });
     test.when(databaseName === 'presto')(
       'schema parser does not throw on compound types',
@@ -652,6 +650,236 @@ describe.each(runtimes.runtimeList)(
         """) -> { aggregate: n is count() }
       `).matchesRows(runtime, {n: 1});
     });
+
+    describe('T-Digest functions', () => {
+      const testData = `${databaseName}.sql("""
+        SELECT CAST(1.0 AS DOUBLE) as n, CAST(1 AS BIGINT) as w
+        UNION ALL SELECT CAST(2.0 AS DOUBLE) as n, CAST(2 AS BIGINT) as w
+        UNION ALL SELECT CAST(3.0 AS DOUBLE) as n, CAST(1 AS BIGINT) as w
+        UNION ALL SELECT CAST(4.0 AS DOUBLE) as n, CAST(3 AS BIGINT) as w
+        UNION ALL SELECT CAST(5.0 AS DOUBLE) as n, CAST(1 AS BIGINT) as w
+        UNION ALL SELECT CAST(6.0 AS DOUBLE) as n, CAST(2 AS BIGINT) as w
+        UNION ALL SELECT CAST(7.0 AS DOUBLE) as n, CAST(1 AS BIGINT) as w
+        UNION ALL SELECT CAST(8.0 AS DOUBLE) as n, CAST(2 AS BIGINT) as w
+        UNION ALL SELECT CAST(9.0 AS DOUBLE) as n, CAST(1 AS BIGINT) as w
+        UNION ALL SELECT CAST(10.0 AS DOUBLE) as n, CAST(3 AS BIGINT) as w
+      """)`;
+
+      it.when(presto)(
+        `runs the basic tdigest_agg function - ${databaseName}`,
+        async () => {
+          await expect(`run: ${testData} -> {
+          aggregate:
+            median is value_at_quantile(tdigest_agg(n), 0.5)
+        }`).malloyResultMatches(runtime, {
+            median: 6,
+          });
+        }
+      );
+
+      it.when(presto)(
+        `runs the tdigest_agg with weight function - ${databaseName}`,
+        async () => {
+          await expect(`run: ${testData} -> {
+          aggregate:
+            weighted_median is value_at_quantile(tdigest_agg(n, w), 0.5)
+        }`).malloyResultMatches(runtime, {
+            weighted_median: 5.5,
+          });
+        }
+      );
+
+      it.when(presto)(
+        `runs the tdigest_agg with weight and compression function - ${databaseName}`,
+        async () => {
+          await expect(`run: ${testData} -> {
+          aggregate:
+            compressed_median is value_at_quantile(tdigest_agg(n, w, 100), 0.5)
+        }`).malloyResultMatches(runtime, {
+            compressed_median: 5.5,
+          });
+        }
+      );
+
+      it.when(presto)(
+        `runs the value_at_quantile function - ${databaseName}`,
+        async () => {
+          await expect(`run: ${testData} -> {
+          aggregate:
+            q25 is value_at_quantile(tdigest_agg(n), 0.25)
+            q50 is value_at_quantile(tdigest_agg(n), 0.5)
+            q75 is value_at_quantile(tdigest_agg(n), 0.75)
+            q90 is value_at_quantile(tdigest_agg(n), 0.9)
+        }`).malloyResultMatches(runtime, {
+            q25: 3,
+            q50: 6,
+            q75: 8,
+            q90: 10,
+          });
+        }
+      );
+
+      it.when(presto)(
+        `runs the quantile_at_value function - ${databaseName}`,
+        async () => {
+          await expect(`run: ${testData} -> {
+          aggregate:
+            q_at_5 is quantile_at_value(tdigest_agg(n), 5.0)
+            q_at_2 is quantile_at_value(tdigest_agg(n), 2.0)
+            q_at_8 is quantile_at_value(tdigest_agg(n), 8.0)
+        }`).malloyResultMatches(runtime, {
+            q_at_5: 0.45,
+            q_at_2: 0.15,
+            q_at_8: 0.75,
+          });
+        }
+      );
+
+      it.when(presto)(
+        `runs the values_at_quantiles function - ${databaseName}`,
+        async () => {
+          await expect(`run: ${testData} -> {
+          aggregate:
+            quantiles is values_at_quantiles(tdigest_agg(n), [0.25, 0.5, 0.75])
+        }`).malloyResultMatches(runtime, {
+            quantiles: [3, 6, 8],
+          });
+        }
+      );
+
+      it.when(presto)(
+        `runs the scale_tdigest function - ${databaseName}`,
+        async () => {
+          await expect(`run: ${testData} -> {
+          aggregate:
+            original_median is value_at_quantile(tdigest_agg(n), 0.5)
+            scaled_median is value_at_quantile(scale_tdigest(tdigest_agg(n), 2.0), 0.5)
+        }`).malloyResultMatches(runtime, {
+            original_median: 6,
+            scaled_median: 5.5,
+          });
+        }
+      );
+
+      it.when(presto)(
+        `runs the trimmed_mean function - ${databaseName}`,
+        async () => {
+          await expect(`run: ${testData} -> {
+          aggregate:
+            trimmed_mean_10_90 is trimmed_mean(tdigest_agg(n), 0.1, 0.9)
+            trimmed_mean_25_75 is trimmed_mean(tdigest_agg(n), 0.25, 0.75)
+        }`).malloyResultMatches(runtime, {
+            trimmed_mean_10_90: 6,
+            trimmed_mean_25_75: 5.5,
+          });
+        }
+      );
+
+      it.when(presto)(
+        `runs the merge tdigest function - ${databaseName}`,
+        async () => {
+          await expect(`run: ${testData} -> {
+          group_by: group_col is case when n <= 5 then 'A' else 'B' end
+          aggregate: td is tdigest_agg(n)
+        } -> {
+          aggregate:
+            overall_median is value_at_quantile(merge_tdigest(td), 0.5)
+        }`).malloyResultMatches(runtime, {
+            overall_median: 6,
+          });
+        }
+      );
+
+      it.when(presto)(
+        `runs the merge_tdigest array function - ${databaseName}`,
+        async () => {
+          await expect(`run: ${testData} -> {
+          group_by: group_col is case when n <= 5 then 'A' else 'B' end
+          aggregate: td is tdigest_agg(n)
+        } -> {
+          aggregate:
+            overall_median is value_at_quantile(merge_tdigest_array(array_agg(td)), 0.5)
+        }`).malloyResultMatches(runtime, {
+            overall_median: 6,
+          });
+        }
+      );
+
+      it.skip(`runs the destructure_tdigest function - ${databaseName}`, async () => {
+        // TODO: Fix this test - destructure_tdigest returns a record type
+        // which needs special handling in the test
+        await expect(`run: ${testData} -> {
+          aggregate:
+            destructured is destructure_tdigest(tdigest_agg(n))
+        }`).malloyResultMatches(runtime, {
+          destructured: {
+            centroid_means: [],
+            centroid_weights: [],
+            min_value: 1.0,
+            max_value: 10.0,
+            sum_value: 55.0,
+            count_value: 10,
+          },
+        });
+      });
+
+      it.skip(`runs the construct_tdigest function - ${databaseName}`, async () => {
+        // This test is complex because construct_tdigest needs the output of destructure_tdigest
+        // For now, we'll test that the function exists and can be called with sample data
+        await expect(`run: ${databaseName}.sql("SELECT 1 as dummy") -> {
+          select:
+            test_construct is value_at_quantile(
+              construct_tdigest(
+                [1.0, 2.0, 3.0],
+                [1.0, 1.0, 1.0],
+                1.0,
+                3.0,
+                6.0,
+                3.0,
+                100
+              ),
+              0.5
+            )
+        }`).malloyResultMatches(runtime, {
+          test_construct: 2,
+        });
+      });
+
+      it.when(presto)(
+        `runs tdigest functions with edge cases - ${databaseName}`,
+        async () => {
+          const singleValueData = `${databaseName}.sql("SELECT CAST(5.0 AS DOUBLE) as n")`;
+          await expect(`run: ${singleValueData} -> {
+          aggregate:
+            median is value_at_quantile(tdigest_agg(n), 0.5)
+            q25 is value_at_quantile(tdigest_agg(n), 0.25)
+            q75 is value_at_quantile(tdigest_agg(n), 0.75)
+        }`).malloyResultMatches(runtime, {
+            median: 5.0,
+            q25: 5.0,
+            q75: 5.0,
+          });
+        }
+      );
+
+      it.when(presto)(
+        `runs tdigest functions with extreme quantiles - ${databaseName}`,
+        async () => {
+          await expect(`run: ${testData} -> {
+          aggregate:
+            min_quantile is value_at_quantile(tdigest_agg(n), 0.0)
+            max_quantile is value_at_quantile(tdigest_agg(n), 1.0)
+            q_at_min is quantile_at_value(tdigest_agg(n), 1.0)
+            q_at_max is quantile_at_value(tdigest_agg(n), 10.0)
+        }`).malloyResultMatches(runtime, {
+            min_quantile: 1,
+            max_quantile: 10,
+            q_at_min: 0.05,
+            q_at_max: 0.95,
+          });
+        }
+      );
+    });
   }
 );