@malloydata/malloy-tests 0.0.144 → 0.0.145

package/package.json

@@ -21,13 +21,13 @@
   },
   "dependencies": {
     "@jest/globals": "^29.4.3",
-    "@malloydata/db-bigquery": "^0.0.144",
-    "@malloydata/db-duckdb": "^0.0.144",
-    "@malloydata/db-postgres": "^0.0.144",
-    "@malloydata/db-snowflake": "^0.0.144",
-    "@malloydata/db-trino": "^0.0.144",
-    "@malloydata/malloy": "^0.0.144",
-    "@malloydata/render": "^0.0.144",
+    "@malloydata/db-bigquery": "^0.0.145",
+    "@malloydata/db-duckdb": "^0.0.145",
+    "@malloydata/db-postgres": "^0.0.145",
+    "@malloydata/db-snowflake": "^0.0.145",
+    "@malloydata/db-trino": "^0.0.145",
+    "@malloydata/malloy": "^0.0.145",
+    "@malloydata/render": "^0.0.145",
     "jsdom": "^22.1.0",
     "luxon": "^2.4.0",
     "madge": "^6.0.0"
@@ -36,5 +36,5 @@
     "@types/jsdom": "^21.1.1",
     "@types/luxon": "^2.4.0"
   },
-  "version": "0.0.144"
+  "version": "0.0.145"
 }

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

@@ -23,7 +23,7 @@
  */
 
 import {RuntimeList, allDatabases} from '../../runtimes';
-import {databasesFromEnvironmentOr} from '../../util';
+import {brokenIn, databasesFromEnvironmentOr} from '../../util';
 import '../../util/db-jest-matchers';
 import * as malloy from '@malloydata/malloy';
 
@@ -112,29 +112,32 @@ expressionModels.forEach((expressionModel, databaseName) => {
   };
 
   describe('concat', () => {
-    it(`works - ${databaseName}`, async () => {
-      const expected = {
-        'bigquery': 'foo2003-01-01 12:00:00+00',
-        'snowflake': 'foo2003-01-01T12:00:00.000Z',
-      };
-
-      await funcTestMultiple(
-        ["concat('foo', 'bar')", 'foobar'],
-        ["concat(1, 'bar')", '1bar'],
-        [
-          "concat('cons', true)",
-          databaseName === 'postgres' ? 'const' : 'construe',
-        ],
-        ["concat('foo', @2003)", 'foo2003-01-01'],
-        [
-          "concat('foo', @2003-01-01 12:00:00)",
-          expected[databaseName] ?? 'foo2003-01-01 12:00:00',
-        ],
-        // TODO Maybe implement consistent null behavior
-        // ["concat('foo', null)", null],
-        ['concat()', '']
-      );
-    });
+    it.when(!brokenIn('trino', databaseName) /* crswenson */)(
+      `works - ${databaseName}`,
+      async () => {
+        const expected = {
+          'bigquery': 'foo2003-01-01 12:00:00+00',
+          'snowflake': 'foo2003-01-01T12:00:00.000Z',
+        };
+
+        await funcTestMultiple(
+          ["concat('foo', 'bar')", 'foobar'],
+          ["concat(1, 'bar')", '1bar'],
+          [
+            "concat('cons', true)",
+            databaseName === 'postgres' ? 'const' : 'construe',
+          ],
+          ["concat('foo', @2003)", 'foo2003-01-01'],
+          [
+            "concat('foo', @2003-01-01 12:00:00)",
+            expected[databaseName] ?? 'foo2003-01-01 12:00:00',
+          ],
+          // TODO Maybe implement consistent null behavior
+          // ["concat('foo', null)", null],
+          ['concat()', '']
+        );
+      }
+    );
   });
 
   describe('round', () => {
@@ -430,6 +433,33 @@ expressionModels.forEach((expressionModel, databaseName) => {
       expect(result.data.path(2, 'neg_r').value).toBe(-3);
       expect(result.data.path(3, 'neg_r').value).toBe(-3);
     });
+
+    it(`properly isolated nested calculations - ${databaseName}`, async () => {
+      const result = await expressionModel
+        .loadQuery(
+          `run: ${databaseName}.table('malloytest.airports') -> {
+            group_by: faa_region
+            aggregate: airport_count is count()
+            calculate: id is row_number()
+            nest: by_fac_type is {
+              group_by: fac_type
+              aggregate: airport_count is count()
+              calculate: id2 is row_number()
+              nest: elevation is {
+                aggregate: avg_elevation is elevation.avg()
+              }
+              limit: 2
+            }
+          }
+          -> {
+            // should be 2 rows, max of 2
+            group_by: by_fac_type.id2
+            order_by: id2 desc
+          }`
+        )
+        .run();
+      expect(result.data.path(0, 'id2').value).toBe(2);
+    });
   });
 
   describe('lag', () => {

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

@@ -24,7 +24,12 @@
 
 import {RuntimeList, allDatabases} from '../../runtimes';
 import '../../util/db-jest-matchers';
-import {databasesFromEnvironmentOr, mkSqlEqWith, runQuery} from '../../util';
+import {
+  brokenIn,
+  databasesFromEnvironmentOr,
+  mkSqlEqWith,
+  runQuery,
+} from '../../util';
 import {DateTime as LuxonDateTime} from 'luxon';
 
 const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
@@ -457,15 +462,18 @@ describe.each(runtimes.runtimeList)('%s date and time', (dbName, runtime) => {
     });
   });
 
-  test('dependant join dialect fragments', async () => {
-    await expect(`
+  test.when(!brokenIn('trino', dbName) /* mtoy */)(
+    'dependant join dialect fragments',
+    async () => {
+      await expect(`
       source: timeData is ${dbName}.sql("""${timeSQL}""")
       run: timeData -> {
         extend: {join_one: joined is timeData on t_date = joined.t_date}
         group_by: t_month is joined.t_timestamp.month
       }
     `).malloyResultMatches(runtime, {t_month: new Date('2021-02-01')});
-  });
+    }
+  );
 
   describe('timezone set correctly', () => {
     test('timezone set in source used by query', async () => {
@@ -613,54 +621,63 @@ const utc_2020 = LuxonDateTime.fromObject(
 );
 
 describe.each(runtimes.runtimeList)('%s: tz literals', (dbName, runtime) => {
-  test(`${dbName} - default timezone is UTC`, async () => {
-    // this makes sure that the tests which use the test timezome are actually
-    // testing something ... file this under "abundance of caution". It
-    // really tests nothing, but I feel calmer with this here.
-    const query = runtime.loadQuery(
-      `
+  test.when(!brokenIn('trino', dbName) /* mtoy */)(
+    `${dbName} - default timezone is UTC`,
+    async () => {
+      // this makes sure that the tests which use the test timezome are actually
+      // testing something ... file this under "abundance of caution". It
+      // really tests nothing, but I feel calmer with this here.
+      const query = runtime.loadQuery(
+        `
         run: ${dbName}.sql("SELECT 1 as one") -> {
           group_by: literal_time is @2020-02-20 00:00:00
         }
 `
-    );
-    const result = await query.run();
-    const literal = result.data.path(0, 'literal_time').value as Date;
-    const have = LuxonDateTime.fromJSDate(literal);
-    expect(have.valueOf()).toEqual(utc_2020.valueOf());
-  });
-
-  test('literal with zone name', async () => {
-    const query = runtime.loadQuery(
-      `
+      );
+      const result = await query.run();
+      const literal = result.data.path(0, 'literal_time').value as Date;
+      const have = LuxonDateTime.fromJSDate(literal);
+      expect(have.valueOf()).toEqual(utc_2020.valueOf());
+    }
+  );
+
+  test.when(!brokenIn('trino', dbName) /* mtoy */)(
+    'literal with zone name',
+    async () => {
+      const query = runtime.loadQuery(
+        `
         run: ${dbName}.sql("SELECT 1 as one") -> {
           group_by: literal_time is @2020-02-20 00:00:00[America/Mexico_City]
         }
 `
-    );
-    const result = await query.run();
-    const literal = result.data.path(0, 'literal_time').value as Date;
-    const have = LuxonDateTime.fromJSDate(literal);
-    expect(have.valueOf()).toEqual(zone_2020.valueOf());
-  });
+      );
+      const result = await query.run();
+      const literal = result.data.path(0, 'literal_time').value as Date;
+      const have = LuxonDateTime.fromJSDate(literal);
+      expect(have.valueOf()).toEqual(zone_2020.valueOf());
+    }
+  );
 });
 
 describe.each(runtimes.runtimeList)('%s: query tz', (dbName, runtime) => {
   const q = runtime.getQuoter();
-  test('literal timestamps', async () => {
-    const query = runtime.loadQuery(
-      `
+  test.when(!brokenIn('trino', dbName) /* mtoy */)(
+    'literal timestamps',
+    async () => {
+      const query = runtime.loadQuery(
+        `
         run: ${dbName}.sql("SELECT 1 as one") -> {
           timezone: '${zone}'
           group_by: literal_time is @2020-02-20 00:00:00
         }
       `
-    );
-    const result = await query.run();
-    const literal = result.data.path(0, 'literal_time').value as Date;
-    const have = LuxonDateTime.fromJSDate(literal);
-    expect(have.valueOf()).toEqual(zone_2020.valueOf());
-  });
+      );
+      const result = await query.run();
+      const literal = result.data.path(0, 'literal_time').value as Date;
+      const have = LuxonDateTime.fromJSDate(literal);
+      expect(have.valueOf()).toEqual(zone_2020.valueOf());
+    }
+  );
 
   test('extract', async () => {
     await expect(
@@ -674,7 +691,7 @@ describe.each(runtimes.runtimeList)('%s: query tz', (dbName, runtime) => {
     ).malloyResultMatches(runtime, {mex_midnight: 18, mex_day: 19});
   });
 
-  test('truncate day', async () => {
+  test.when(!brokenIn('trino', dbName) /* mtoy */)('truncate day', async () => {
     // At midnight in london it the 19th in Mexico, so that truncates to
     // midnight on the 19th
     const mex_19 = LuxonDateTime.fromISO('2020-02-19T00:00:00', {zone});
@@ -687,26 +704,32 @@ describe.each(runtimes.runtimeList)('%s: query tz', (dbName, runtime) => {
     ).malloyResultMatches(runtime, {mex_day: mex_19.toJSDate()});
   });
 
-  test('cast timestamp to date', async () => {
-    // At midnight in london it is the 19th in Mexico, so when we cast that
-    // to a date, it should be the 19th.
-    await expect(
-      `run: ${dbName}.sql("SELECT 1 as x") -> {
+  test.when(!brokenIn('trino', dbName) /* mtoy */)(
+    'cast timestamp to date',
+    async () => {
+      // At midnight in london it is the 19th in Mexico, so when we cast that
+      // to a date, it should be the 19th.
+      await expect(
+        `run: ${dbName}.sql("SELECT 1 as x") -> {
         timezone: '${zone}'
         extend: { dimension: utc_midnight is @2020-02-20 00:00:00[UTC] }
         select: mex_day is day(utc_midnight::date)
       }`
-    ).malloyResultMatches(runtime, {mex_day: 19});
-  });
-
-  test('cast date to timestamp', async () => {
-    await expect(
-      `run: ${dbName}.sql(""" SELECT DATE '2020-02-20'  AS ${q`mex_20`} """) -> {
+      ).malloyResultMatches(runtime, {mex_day: 19});
+    }
+  );
+
+  test.when(!brokenIn('trino', dbName) /* mtoy */)(
+    'cast date to timestamp',
+    async () => {
+      await expect(
+        `run: ${dbName}.sql(""" SELECT DATE '2020-02-20'  AS ${q`mex_20`} """) -> {
         timezone: '${zone}'
         select: mex_ts is mex_20::timestamp
       }`
-    ).malloyResultMatches(runtime, {mex_ts: zone_2020.toJSDate()});
-  });
+      ).malloyResultMatches(runtime, {mex_ts: zone_2020.toJSDate()});
+    }
+  );
 });
 
 afterAll(async () => {