@malloydata/malloy-tests 0.0.310 → 0.0.312

package/package.json

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

package/postgres/postgres_start.sh

@@ -0,0 +1,41 @@
+#! /bin/bash
+#
+# Setup postgres as a docker container
+#
+set -e
+
+rm -rf .tmp
+mkdir .tmp
+
+# run docker
+SCRIPTDIR=$(cd $(dirname $0); pwd)
+DATADIR=$(dirname $SCRIPTDIR)/data/postgres
+
+// set these in your enviornment
+export PGHOST=localhost
+export PGPORT=5432
+export PGUSER=root
+export PGPASSWORD=postgres
+
+docker run -p 5432:5432 -d -v $DATADIR:/init_data \
+ --name postgres-malloy \
+  -e POSTGRES_USER=root -e POSTGRES_PASSWORD=postgres \
+  --health-cmd pg_isready \
+  --health-interval 10s \
+  --health-timeout 5s \
+  --health-retries 5 \
+  -d postgres
+
+CONTAINER_NAME="postgres-malloy"
+
+echo "Waiting for container $CONTAINER_NAME to become healthy..."
+
+while [ "$(docker inspect -f {{.State.Health.Status}} $CONTAINER_NAME)" != "healthy" ]; do
+    sleep 2; # Adjust the sleep duration as needed
+done
+
+echo "Container $CONTAINER_NAME is now healthy!"
+
+#  configure
+echo CREATE EXTENSION tsm_system_rows\; | psql
+gunzip -c ${DATADIR}/malloytest-postgres.sql.gz | psql

package/postgres/postgres_stop.sh

@@ -0,0 +1,7 @@
+#! /bin/bash
+
+# clear tmp files
+rm -rf .tmp
+
+# stop container
+docker rm -f postgres-malloy

package/src/core/bugless.spec.ts

@@ -18,4 +18,36 @@ describe('misc tests for regressions that have no better home', () => {
       } -> { group_by: carriers.airline; limit: 1 }
     `).malloyResultMatches(runtime, [{}]);
   });
+
+  test('result data structure contains time zones for nested queries', async () => {
+    const query = runtime.loadQuery(`
+      run: duckdb.table('malloytest.flights') -> {
+        nest: arrive_yekaterinburg is {
+          timezone: 'Asia/Yekaterinburg'
+          group_by: utc_time is arr_time::string, civil_time is arr_time
+          limit: 5
+        }
+      }
+    `);
+    const result = await query.run();
+
+    // Inspect the result schema to find timezone metadata
+    const schema = result.resultExplore;
+
+    // Find the nested field
+    const nestedField = schema.getFieldByName('arrive_yekaterinburg');
+    expect(nestedField).toBeDefined();
+
+    if (nestedField?.isExploreField()) {
+      // Check if timezone information is present in the result data structure
+      const queryTimezone = nestedField.queryTimezone;
+
+      // Verify timezone is accessible in the result structure
+      expect(queryTimezone).toBe('Asia/Yekaterinburg');
+
+      // The timezone info should be available for later serialization
+      // (this is what gets turned into annotations during the to-stable process)
+      expect(nestedField.queryTimezone).toBeDefined();
+    }
+  });
 });

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

@@ -183,6 +183,21 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
           select: nm
         }`).malloyResultMatches(abc, got('xback'));
     });
+    test('string or with pipe', async () => {
+      await expect(`
+    run: abc -> {
+      where: s ~ f'abc | def'
+      select: nm; order_by: nm asc
+    }`).malloyResultMatches(abc, got('abc,def'));
+    });
+
+    test('string and with semicolon', async () => {
+      await expect(`
+    run: abc -> {
+      where: s ~ f'%b% ; %c'
+      select: nm; order_by: nm asc
+    }`).malloyResultMatches(abc, got('abc'));
+    });
   });
 
   describe('numeric filter expressions', () => {
@@ -319,6 +334,13 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
           select: n; order_by: n asc
         }`).malloyResultMatches(nums, [{n: 0}, {n: 1}]);
     });
+    test('not <=1', async () => {
+      await expect(`
+        run: nums -> {
+          where: n ~ f'not <=1'
+          select: n; order_by: n asc
+        }`).malloyResultMatches(nums, [{n: 2}, {n: 3}, {n: 4}]);
+    });
   });
 
   const testBoolean = db.dialect.booleanType === 'supported';
@@ -365,6 +387,27 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
           select: t; order_by: t asc
         }`).malloyResultMatches(facts, [{t: 'false'}, {t: 'true'}]);
     });
+    test.when(testBoolean)('not true', async () => {
+      await expect(`
+    run: facts -> {
+      where: b ~ f'not true'
+      select: t; order_by: t asc
+    }`).malloyResultMatches(facts, [{t: 'false'}, {t: 'null'}]);
+    });
+    test.when(testBoolean)('not false', async () => {
+      await expect(`
+    run: facts -> {
+      where: b ~ f'not false'
+      select: t; order_by: t asc
+    }`).malloyResultMatches(facts, [{t: 'true'}]);
+    });
+    test.when(testBoolean)('not =false', async () => {
+      await expect(`
+    run: facts -> {
+      where: b ~ f'not =false'
+      select: t; order_by: t asc
+    }`).malloyResultMatches(facts, [{t: 'null'}, {t: 'true'}]);
+    });
     test.when(testBoolean)('empty boolean filter', async () => {
       await expect(`
         run: facts -> {

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

@@ -274,6 +274,33 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
     });
   });
 
+  it(`symmetric sum and average large  - ${databaseName}`, async () => {
+    await expect(`
+      source: a is ${databaseName}.table('malloytest.airports') extend {
+        primary_key: code
+        dimension: big_elevation is elevation * 100000
+        measure:
+          total_elevation is elevation.sum()
+          average_elevation is floor(elevation.avg())
+          total_big_elevation is big_elevation.sum()
+          average_big_elevation is floor(big_elevation.avg())
+      }
+      query: two_rows is ${databaseName}.table('malloytest.state_facts') -> {select: state;  limit: 2}
+      source: b is two_rows extend {
+        join_cross: a on 1=1
+      }
+
+      run: b -> {aggregate: a.total_elevation, a.average_elevation, a.total_big_elevation, a.average_big_elevation}
+      // run: two_rows
+
+    `).malloyResultMatches(runtime, {
+      total_elevation: 22629146,
+      average_elevation: 1143,
+      total_big_elevation: 2262914600000,
+      average_big_elevation: 114329035,
+    });
+  });
+
   it(`limit - provided - ${databaseName}`, async () => {
     // a cross join produces a Many to Many result.
     // symmetric aggregate are needed on both sides of the join
@@ -919,6 +946,34 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
       `).malloyResultMatches(runtime, {'fun.t1': 52});
   });
 
+  // not sure this works on all dialect.
+  it("stage names don't conflict- ${databaseName}", async () => {
+    await expect(`
+        source: airports is ${databaseName}.table('malloytest.state_facts') extend {
+        }
+
+        query: st0 is airports -> {
+          select: state
+        } -> {
+          select: *
+        }
+
+        query: st1 is airports -> {
+          select: state
+        } -> {
+          select: *
+        }
+
+        query: u is ${databaseName}.sql("""SELECT * FROM %{st0 } as x UNION ALL %{st1 }""") -> {
+          select: *
+        }
+        // # test.debug
+        run: u -> {
+          aggregate: c is count()
+        }
+    `).malloyResultMatches(runtime, {c: 102});
+  });
+
   const sql1234 = `${databaseName}.sql('SELECT 1 as ${q`a`}, 2 as ${q`b`} UNION ALL SELECT 3, 4')`;
 
   it(`sql as source - ${databaseName}`, async () => {

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

@@ -31,6 +31,7 @@ import {
   runQuery,
 } from '../../util';
 import {DateTime as LuxonDateTime} from 'luxon';
+import {API} from '@malloydata/malloy';
 
 const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
 
@@ -736,6 +737,67 @@ describe.each(runtimes.runtimeList)('%s: query tz', (dbName, runtime) => {
       }`
     ).malloyResultMatches(runtime, {mex_ts: zone_2020.toJSDate()});
   });
+
+  // Test for timezone rendering issue with nested queries
+  test.when(runtime.supportsNesting)(
+    'nested queries preserve timezone in rendering',
+    async () => {
+      const result = await runQuery(
+        runtime,
+        `run: ${dbName}.table('malloytest.flights') extend {
+        view: arrivals is {
+          group_by: arr_time.hour
+          order_by: arr_time desc
+          limit: 1
+        }
+      } -> {
+        nest: arrive_utc is arrivals
+        nest: arrive_yekaterinburg is arrivals + { timezone: 'Asia/Yekaterinburg' }
+      }`
+      );
+
+      // First, check that the raw result has the correct timezone metadata
+      const rawFields = result.resultExplore.structDef.fields;
+      const rawArriveUtc = rawFields.find(f => f.name === 'arrive_utc');
+      const rawArriveYek = rawFields.find(
+        f => f.name === 'arrive_yekaterinburg'
+      );
+
+      expect(rawArriveUtc).toBeDefined();
+      expect(rawArriveYek).toBeDefined();
+
+      // Check timezone properties on raw array/record fields
+      expect(rawArriveUtc!['queryTimezone']).toBeUndefined(); // Should be undefined for UTC
+      expect(rawArriveYek!['queryTimezone']).toBe('Asia/Yekaterinburg');
+
+      // Now check that the wrapped result also preserves timezone metadata
+      const wrappedResult = API.util.wrapResult(result);
+      const wrappedFields = wrappedResult.schema.fields;
+      const wrappedArriveUtc = wrappedFields.find(f => f.name === 'arrive_utc');
+      const wrappedArriveYek = wrappedFields.find(
+        f => f.name === 'arrive_yekaterinburg'
+      );
+
+      expect(wrappedArriveUtc).toBeDefined();
+      expect(wrappedArriveYek).toBeDefined();
+
+      // Check timezone properties in the wrapped result
+      // For nested views, the timezone should be in the annotations
+      const arriveUtcAnnotations = wrappedArriveUtc?.annotations;
+      const arriveYekAnnotations = wrappedArriveYek?.annotations;
+
+      // Check if timezone info is present in annotations
+      const utcTimezoneAnnotation = arriveUtcAnnotations?.find(ann =>
+        ann.value.includes('query_timezone')
+      );
+      const yekTimezoneAnnotation = arriveYekAnnotations?.find(ann =>
+        ann.value.includes('query_timezone')
+      );
+
+      expect(utcTimezoneAnnotation).toBeUndefined(); // UTC should have no timezone annotation
+      expect(yekTimezoneAnnotation?.value).toContain('Asia/Yekaterinburg');
+    }
+  );
 });
 
 afterAll(async () => {