@malloydata/malloy-tests 0.0.264-dev250414205448 → 0.0.264-dev250414221049

package/package.json

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

package/src/databases/all/compound-atomic.spec.ts

@@ -26,15 +26,17 @@ const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
  * so fix that one first if the tests are failing.
  */
 
+function literalNum(num: Number): Expr {
+  const literal = num.toString();
+  return {node: 'numberLiteral', literal, sql: literal};
+}
+
 describe.each(runtimes.runtimeList)(
   'compound atomic datatypes %s',
   (conName, runtime) => {
     const supportsNestedArrays = runtime.dialect.nestedArrays;
     const quote = runtime.dialect.sqlMaybeQuoteIdentifier;
-    function literalNum(num: Number): Expr {
-      const literal = num.toString();
-      return {node: 'numberLiteral', literal, sql: literal};
-    }
+
     const empty = `${conName}.sql("SELECT 0 as z")`;
     function arraySelectVal(...val: Number[]): string {
       const literal: ArrayLiteralNode = {
@@ -67,7 +69,6 @@ describe.each(runtimes.runtimeList)(
       literal.sql = runtime.dialect.sqlLiteralRecord(literal);
       return literal;
     }
-
     function recordSelectVal(fromObj: Record<string, number>): string {
       return runtime.dialect.sqlLiteralRecord(recordLiteral(fromObj));
     }
@@ -89,6 +90,8 @@ describe.each(runtimes.runtimeList)(
     const evens = `${conName}.sql("""
       SELECT ${evensSQL} AS ${quote('evens')}
     """)`;
+    const d4 = [1, 2, 3, 4];
+    const d4SQL = arraySelectVal(...d4);
 
     describe('simple arrays', () => {
       test('array literal dialect function', async () => {
@@ -158,24 +161,26 @@ describe.each(runtimes.runtimeList)(
           {die_roll: 4},
         ]);
       });
-      test.skip('cross join arrays', async () => {
+      test.when(canReadCompoundSchema)('cross join two arrays', async () => {
         await expect(`
-          run: ${empty} extend {
-            dimension: d1 is [1,2,3,4]
-            join_cross: d2 is [1,2,3,4]
-          } -> {
-            group_by: roll is d1.each + d2.each
-            aggregate: rolls is count()
+          run: ${conName}.sql("""
+            SELECT ${d4SQL} as ${quote('d1')}, ${d4SQL} as ${quote('d2')}
+          """) -> { select: roll is d1.each + d2.each }
+          -> {
+            group_by: roll
+            aggregate: n is count()
+            order_by: roll asc
           }
-        `).malloyResultMatches(runtime, [
-          {roll: 2, rolls: 1},
-          {roll: 3, rolls: 2},
-          {roll: 4, rolls: 3},
-          {roll: 5, rolls: 4},
-          {roll: 6, rolls: 3},
-          {roll: 7, rolls: 2},
-          {roll: 8, rolls: 1},
-        ]);
+          `).matchesRows(
+          runtime,
+          {roll: 2, n: 1},
+          {roll: 3, n: 2},
+          {roll: 4, n: 3},
+          {roll: 5, n: 4},
+          {roll: 6, n: 3},
+          {roll: 7, n: 2},
+          {roll: 8, n: 1}
+        );
       });
       // can't use special chars in column names in bq
       test.when(conName !== 'bigquery')(
@@ -243,6 +248,25 @@ describe.each(runtimes.runtimeList)(
           run: ${empty} extend { dimension: aoa is [[1,2]] } -> { select: aoa.each.each }
         `).malloyResultMatches(runtime, [{each: 1}, {each: 2}]);
       });
+      test('group by array', async () => {
+        const oddsObj = [1, 3, 5, 7];
+        const oddsSql = arraySelectVal(...oddsObj);
+        await expect(`
+          run: ${conName}.sql("""
+            SELECT ${evensSQL} as ${quote('nums')}, 1 as ${quote('n')}
+            UNION ALL SELECT ${evensSQL}, 10
+            UNION ALL SELECT ${oddsSql}, 100
+            UNION ALL SELECT ${oddsSql}, 1000
+          """) -> {
+            group_by: nums
+            aggregate: addem is n.sum()
+            order_by: addem asc
+          }`).matchesRows(
+          runtime,
+          {nums: evensObj, addem: 11},
+          {nums: oddsObj, addem: 1100}
+        );
+      });
     });
     describe('record', () => {
       function rec_eq(as?: string): Record<string, Number> {
@@ -433,10 +457,10 @@ describe.each(runtimes.runtimeList)(
         {a: 10, b: 11},
         {a: 20, b: 21},
       ];
-      const abMalloy = '[{a is 10, b is 11}, {a is 20, b is 21}]';
       function selectAB(n: string) {
         return `SELECT ${ab} AS ${quote(n)}`;
       }
+      const abMalloy = '[{a is 10, b is 11}, {a is 20, b is 21}]';
 
       test('repeated record from nest', async () => {
         await expect(`

package/src/databases/all/join.spec.ts

@@ -302,4 +302,15 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
       }
     `).malloyResultMatches(joinModel, {c: 0});
   });
+
+  it.when(runtime.dialect.nestedArrays)(
+    'finds join dependency in non basic atomic fields',
+    async () => {
+      await expect(`
+      run: ${databaseName}.sql("SELECT 1 as n")
+        extend { dimension: a1 is [[1]], a2 is [[2]] }
+        -> { select: pick_a1 is pick a1.each when true else a2.each }
+      `).matchesRows(runtime, {pick_a1: [1]});
+    }
+  );
 });