@malloydata/malloy-tests 0.0.294 → 0.0.296

package/README.md

@@ -13,7 +13,7 @@ Assumes that postgres has been installed via nix (installs but doesn't configure
 ADD to environment: `export PGHOST=localhost`
 
 **postgres_init.sh** - builds a database as the current user in .tmp/data/malloytestdb. Starts server running on localhost:5432
-copies the test data in `malloytest-postgres.sql.gz` into the database.
+copies the test data in `malloytest-postgres.sql.gz` into the database. - You may also need to add state_facts.sql for some tests
 
 **postgres_start.sh** - starts the postgres server, once it has been installed (use after a reboot, for example)
 
@@ -30,7 +30,7 @@ Setting up DuckDB:
 
 # Using the custom matcher for running queries
 
-There is now a custom matcher, `malloyResultMatches` for running queries.  The customer matcher makes it easy to write readable tests which need to look at query results, and produces useful output when the test fails to make it easier to develop tests or respond to the output of failing tests.
+There is now a custom matcher, `malloyResultMatches` for running queries. The customer matcher makes it easy to write readable tests which need to look at query results, and produces useful output when the test fails to make it easier to develop tests or respond to the output of failing tests.
 
 ## Check for results in the first row of output
 
@@ -54,9 +54,9 @@ import './util/db-jest-matchers';
 
 This will check the following things.
 
-* There is at least one row of data in the output. So `.malloyQueryMatches(rt, {})` will fail if the query returns no rows
-* There are entries in that row for each key. `{}` matches any row
-* The entries are equal, but it will error if the expected data as a number and the returned data is a string.
+- There is at least one row of data in the output. So `.malloyQueryMatches(rt, {})` will fail if the query returns no rows
+- There are entries in that row for each key. `{}` matches any row
+- The entries are equal, but it will error if the expected data as a number and the returned data is a string.
 
 ## Accessing nested results
 
@@ -79,11 +79,11 @@ example also shows passing a model instead of a runtime to the matcher.
   });
 ```
 
-  > [!WARNING]
-  > There is currently a ... feature ... where if the source code of a test
-  > contains the characters `nest:` and the runtime connection does not support nesting,
-  > the test passes without actually doing anything. There will better handling of
-  > this problem in the future, but if your test is mysteriously passing, this is why.
+> [!WARNING]
+> There is currently a ... feature ... where if the source code of a test
+> contains the characters `nest:` and the runtime connection does not support nesting,
+> the test passes without actually doing anything. There will better handling of
+> this problem in the future, but if your test is mysteriously passing, this is why.
 
 ## Queries returning more than one row of data
 
@@ -102,8 +102,8 @@ An array of match rows may can also be used, if the test needs to verify more th
 
 This will pass if ..
 
-* There are exactly two rows of output. If there are not exactly two the matcher will fail. If the query makes more than two rows, you will need to add a `limit: 2` to allow the matcher to pass.
-* Each row is matches the matching criteria, again `{}` means "pass if there is a row"
+- There are exactly two rows of output. If there are not exactly two the matcher will fail. If the query makes more than two rows, you will need to add a `limit: 2` to allow the matcher to pass.
+- Each row is matches the matching criteria, again `{}` means "pass if there is a row"
 
 ## Reading failure output
 
@@ -235,7 +235,9 @@ The old template for a test looked something like
 ```
 
 The actual matcher for a result is limited to an equality test, in the old pattern you would have written something using an existing matcher for a data value
+
 ```TypeScript
     expect(result.data.patch(0, 'numThings').value).toBeGreaterThan(7);
 ```
-and if this is desirable, more work on the custom matcher would be needed to allow expressions like this to be written.
+
+and if this is desirable, more work on the custom matcher would be needed to allow expressions like this to be written.

package/package.json

@@ -21,14 +21,14 @@
   },
   "dependencies": {
     "@jest/globals": "^29.4.3",
-    "@malloydata/db-bigquery": "0.0.294",
-    "@malloydata/db-duckdb": "0.0.294",
-    "@malloydata/db-postgres": "0.0.294",
-    "@malloydata/db-snowflake": "0.0.294",
-    "@malloydata/db-trino": "0.0.294",
-    "@malloydata/malloy": "0.0.294",
-    "@malloydata/malloy-tag": "0.0.294",
-    "@malloydata/render": "0.0.294",
+    "@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",
     "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.294"
+  "version": "0.0.296"
 }

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

@@ -27,6 +27,60 @@ describe.each(runtimes.runtimeList)(
         `run: ${databaseName}.sql("SELECT 1 as n") -> { select: n }`
       ).malloyResultMatches(runtime, {n: 1});
     });
+
+    describe('HLL Window Functions', () => {
+      it(`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
+          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)
+        } -> {
+          order_by: category
+          calculate: combined_hll is hll_estimate_moving(hll_combine_moving(hll_set, 1), 1)
+        }`).malloyResultMatches(runtime, [
+          {category: 'A', combined_hll: 2},
+          {category: 'B', combined_hll: 1},
+        ]);
+      });
+
+      it(`hll_estimate_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)
+        } -> {
+          order_by: category
+          calculate: estimated_count is hll_estimate_moving(hll_set, 1)
+        }`).malloyResultMatches(runtime, [
+          {category: 'A', estimated_count: 2},
+          {category: 'B', estimated_count: 1},
+        ]);
+      });
+    });
     test.when(databaseName === 'presto')(
       'schema parser does not throw on compound types',
       async () => {