@malloydata/malloy-tests 0.0.435 → 0.0.436

package/CONTEXT.md

@@ -40,7 +40,7 @@ Tests that run against **all** supported databases to ensure consistent behavior
 
 These tests are particularly important for verifying that Malloy's abstraction works correctly across all supported SQL dialects.
 
-An experimental dialect is not in `allDatabases`. CI runs only its smoke job, `ci-<name>-smoketest`, which selects the dialect's own jest project and must stay green; the shared suite is run by hand with `MALLOY_DATABASE=<name>` (`ci-<name>`) and is allowed to be red until the dialect leaves experimental. A follow-up that implements a feature moves its shared-suite tests into the green set by flipping the capability flag they are gated on. The files carry no `##! experimental.dialect.<name>` lines: `runtimeFor` in `runtimes.ts` calls `acceptExperimental()` on the dialect under test once per process, which is the only place that acknowledgment is waived.
+An experimental dialect is not in `allDatabases`; run the shared suite on one with `MALLOY_DATABASE=<name>` (`ci-<name>`) and expect failures. What CI runs for an experimental dialect is decided per dialect; see [adding-a-new-database.md](../packages/malloy/src/doc/adding-a-new-database.md). The files carry no `##! experimental.dialect.<name>` lines: `runtimeFor` in `runtimes.ts` calls `acceptExperimental()` on the dialect under test once per process, which is the only place that acknowledgment is waived.
 
 ### Consumer-contract canary (`test/consumer-canary/`)
 Not a normal test — it consumes the *built* `@malloydata/*` packages the way a downstream app does (esbuild bundle + plain ts-jest, no babel) to catch native/ESM leaks that malloy's own CI is blind to. Run locally with `npm run test-consumer-canary` (it builds first). See [`test/consumer-canary/CONTEXT.md`](consumer-canary/CONTEXT.md).
@@ -177,7 +177,7 @@ All cross-database tests (`test/src/databases/all/`) reference tables as `malloy
 | DuckDB | DuckDB `CREATE TABLE AS SELECT FROM read_parquet()` | `test/duckdb/load_test_data.sh` (wraps `load_test_data.ts`) | Run via `sh test/duckdb/load_test_data.sh` (or `npm run build-duckdb-db`). Creates `test/data/duckdb/duckdb_test.db` |
 | PostgreSQL | DuckDB's `postgres` extension: `ATTACH` the server, `CREATE TABLE AS SELECT FROM read_parquet()` | `test/postgres/load_test_data.sh` (wraps `load_test_data.ts`) | Run by `test/postgres/postgres_start.sh` and by CI against a running server; connects with the `PG*` variables. No `ga_sample` (no anonymous record type) |
 | MySQL | DuckDB's `mysql` extension, likewise | `test/mysql/load_test_data.sh` (wraps `load_test_data.ts`) | Run by `test/mysql/mysql_start.sh`; connects with the `MYSQL_*` variables. No `ga_sample`, and `alltypes` without its array columns |
-| SQL Server | DuckDB's community `mssql` extension, likewise | `test/mssql/load_test_data.sh` (wraps `load_test_data.ts`) | Run by `test/mssql/mssql_start.sh`, which sets the `MSSQL_*` variables for the loader; the tests and both SQL Server test runtimes (`sqlserver`, `mssql_via_duckdb`) read the same variables from their own environment. Waits for the server itself. Same table set as MySQL. `db-sqlserver.yaml` runs on dispatch only while the dialect is experimental |
+| SQL Server | DuckDB's community `mssql` extension, likewise | `test/mssql/load_test_data.sh` (wraps `load_test_data.ts`) | Run by `test/mssql/mssql_start.sh`, which sets the `MSSQL_*` variables for the loader; the tests and both SQL Server test runtimes (`sqlserver`, `mssql_via_duckdb`) read the same variables from their own environment. Waits for the server itself. Same table set as MySQL. In CI, `db-sqlserver.yaml` runs the same script on SQL Server 2017, the oldest the dialect supports |
 | Trino/Presto | The hive connector reads the parquet in place: each file is mounted into the container and declared as an external table | `test/trino/hive_ddl.ts`, `test/trino/hive.properties`, `test/presto/hive.properties` | `trino_start.sh` / `presto_start.sh` derive the DDL from the parquet schemas at container start. The hive metastore lowercases names, so a table with nested columns (`ga_sample`) is a `_hive` table plus a view that casts the nested field names back; top-level column names stay lowercase, since Trino lowercases those in every connector |
 | BigQuery | Pre-loaded manually in `malloydata-org` project | (none) | No loader script in repo. Data assumed to exist. |
 | Snowflake | SQL: `PUT` local parquet → stage, `COPY INTO` table | `test/snowflake/load_test_data.sh` (wraps `load_test_data.sql`) | Run via `sh test/snowflake/load_test_data.sh` (needs the `snowsql` CLI) |

package/package.json

@@ -20,16 +20,16 @@
     "malloyc": "ts-node ../scripts/malloy-to-json"
   },
   "dependencies": {
-    "@malloydata/db-bigquery": "0.0.435",
-    "@malloydata/db-duckdb": "0.0.435",
-    "@malloydata/db-postgres": "0.0.435",
-    "@malloydata/db-snowflake": "0.0.435",
-    "@malloydata/db-sqlserver": "0.0.435",
-    "@malloydata/db-trino": "0.0.435",
-    "@malloydata/malloy": "0.0.435",
-    "@malloydata/malloy-tag": "0.0.435",
-    "@malloydata/render": "0.0.435",
-    "@malloydata/render-validator": "0.0.435",
+    "@malloydata/db-bigquery": "0.0.436",
+    "@malloydata/db-duckdb": "0.0.436",
+    "@malloydata/db-postgres": "0.0.436",
+    "@malloydata/db-snowflake": "0.0.436",
+    "@malloydata/db-sqlserver": "0.0.436",
+    "@malloydata/db-trino": "0.0.436",
+    "@malloydata/malloy": "0.0.436",
+    "@malloydata/malloy-tag": "0.0.436",
+    "@malloydata/render": "0.0.436",
+    "@malloydata/render-validator": "0.0.436",
     "events": "^3.3.0",
     "jsdom": "^22.1.0",
     "luxon": "^3.7.2",
@@ -43,5 +43,5 @@
   "overrides": {
     "typescript": "^6.0.3"
   },
-  "version": "0.0.435"
+  "version": "0.0.436"
 }

package/src/core/persist.spec.ts

@@ -14,6 +14,9 @@ import type {
 } from '@malloydata/malloy';
 import {
   ConnectionRuntime,
+  MalloyConfig,
+  Manifest,
+  Runtime,
   SingleConnectionRuntime,
   EMPTY_BUILD_MANIFEST,
 } from '@malloydata/malloy';
@@ -2656,9 +2659,9 @@ describe('source persistence', () => {
     });
 
     it('a given with an inline default keeps both sides on one key', async () => {
-      // The other half of the rule: `resolvedGivens` also changes the SQL, but
-      // only the compiler can produce one, so neither side resolves givens.
-      // Resolve on one side only and this throws — the builder emits
+      // The other half of the rule: `resolvedGivens` also changes the SQL, so
+      // both sides bind givens through the one function, inline folding
+      // included. Fold on one side only and this throws — the builder emits
       // `'admin'='admin'` where the compiler folds the same expression.
       const model = `${PERSIST_ANNOTATION}
         ##! experimental.givens
@@ -2802,4 +2805,273 @@ describe('source persistence', () => {
       expect(sql).toContain('LIMIT 7');
     });
   });
+
+  describe('a persisted source that reads a given', () => {
+    // The value is in the SQL that is hashed, and both sides compile that SQL
+    // under the same values, so a query running under other values computes
+    // another key and does not find the table.
+    const GIVEN_MODEL = `
+      ##! experimental { persistence givens }
+      given: CARRIER :: string is "WN"
+      ${FLIGHTS_SOURCE}
+
+      #@ persist
+      source: by_carrier is flights -> {
+        where: carrier = $CARRIER
+        group_by: carrier
+        aggregate: flight_count is count()
+      }
+
+      query: q is by_carrier -> { select: * }
+    `;
+
+    /** The no-default form, with a second source that reads no given. */
+    const SUPPLIED_MODEL = `
+      ##! experimental { persistence givens }
+      given: CARRIER :: string
+      ${FLIGHTS_SOURCE}
+
+      #@ persist
+      source: carrier_stats is flights -> {
+        group_by: carrier
+        aggregate: flight_count is count()
+      }
+
+      #@ persist
+      source: by_carrier is flights -> {
+        where: carrier = $CARRIER
+        group_by: carrier
+        aggregate: flight_count is count()
+      }
+
+      query: q is by_carrier -> { select: * }
+    `;
+
+    async function onlyTarget(
+      rt: Runtime,
+      modelText: string,
+      givens?: Record<string, string>
+    ): Promise<BuildTarget> {
+      const model = await rt.loadModel(modelText).getModel();
+      const {connections, unbuildable} = await rt.getBuildTargets(
+        model,
+        givens ? {givens} : undefined
+      );
+      expect(unbuildable).toEqual([]);
+      const targets = connections.flatMap(c => c.targets);
+      expect(targets).toHaveLength(1);
+      return targets[0];
+    }
+
+    it('is built for the default, and a query under the default finds it', async () => {
+      const manifest = createManifest();
+      const rt = runtimeWithManifest(manifest);
+      const target = await onlyTarget(rt, GIVEN_MODEL);
+      expect(target.readsGivens).toBe(true);
+      expect(target.sql).toContain("'WN'");
+      addManifestEntry(manifest, target.buildId, 'wn_table');
+
+      const query = rt.loadModel(GIVEN_MODEL).loadQueryByName('q');
+      expect(await query.getSQL()).toContain('wn_table');
+      expect(await query.getSQL({givens: {CARRIER: 'WN'}})).toContain(
+        'wn_table'
+      );
+    });
+
+    it('a query under another value does not find it, and runs live', async () => {
+      const manifest = createManifest();
+      const rt = runtimeWithManifest(manifest);
+      const target = await onlyTarget(rt, GIVEN_MODEL);
+      addManifestEntry(manifest, target.buildId, 'wn_table');
+
+      const sql = await rt
+        .loadModel(GIVEN_MODEL)
+        .loadQueryByName('q')
+        .getSQL({givens: {CARRIER: 'AA'}});
+      expect(sql).not.toContain('wn_table');
+      expect(sql).toContain("'AA'");
+    });
+
+    it('under a strict manifest the miss says the source reads givens', async () => {
+      const manifest = createManifest();
+      manifest.strict = true;
+      const rt = runtimeWithManifest(manifest);
+      const target = await onlyTarget(rt, GIVEN_MODEL);
+      addManifestEntry(manifest, target.buildId, 'wn_table');
+
+      await expect(
+        rt
+          .loadModel(GIVEN_MODEL)
+          .loadQueryByName('q')
+          .getSQL({givens: {CARRIER: 'AA'}})
+      ).rejects.toThrow(/strict manifest.*reads givens/s);
+    });
+
+    it('a build under another value is another table, and each query finds its own', async () => {
+      const manifest = createManifest();
+      const rt = runtimeWithManifest(manifest);
+      const wn = await onlyTarget(rt, GIVEN_MODEL);
+      const aa = await onlyTarget(rt, GIVEN_MODEL, {CARRIER: 'AA'});
+      expect(aa.buildId).not.toBe(wn.buildId);
+      expect(aa.sql).toContain("'AA'");
+      addManifestEntry(manifest, wn.buildId, 'wn_table');
+      addManifestEntry(manifest, aa.buildId, 'aa_table');
+
+      const query = rt.loadModel(GIVEN_MODEL).loadQueryByName('q');
+      expect(await query.getSQL()).toContain('wn_table');
+      expect(await query.getSQL({givens: {CARRIER: 'AA'}})).toContain(
+        'aa_table'
+      );
+    });
+
+    it('the rows a query reads are the rows for its own value', async () => {
+      const rwConn = new DuckDBConnection({
+        name: tstDB,
+        databasePath: ':memory:',
+        workingDirectory: 'test/data/duckdb',
+      });
+      try {
+        const flightsPath = 'test/data/malloytest-parquet/flights.parquet';
+        const modelText = GIVEN_MODEL.replace(
+          FLIGHTS_SOURCE,
+          `source: flights is ${tstDB}.table('${flightsPath}')`
+        );
+        const rt = new SingleConnectionRuntime({
+          connection: rwConn,
+          urlReader: testFileSpace,
+        });
+        const manifest = new Manifest();
+        const build = async (name: string, givens?: Record<string, string>) => {
+          const target = await onlyTarget(rt, modelText, givens);
+          await rwConn.runSQL(
+            `CREATE TABLE ${name} AS ${target.buildSQL(manifest.buildManifest)}`
+          );
+          manifest.update(target.buildId, {tableName: name});
+        };
+        await build('wn_table');
+        await build('aa_table', {CARRIER: 'AA'});
+        rt.buildManifest = manifest.buildManifest;
+
+        const query = rt.loadModel(modelText).loadQueryByName('q');
+        const carriers = async (givens?: Record<string, string>) => {
+          const result = await query.run(givens ? {givens} : undefined);
+          return result.data.toObject().map(row => row['carrier']);
+        };
+        expect(await carriers()).toEqual(['WN']);
+        expect(await carriers({CARRIER: 'AA'})).toEqual(['AA']);
+        expect(await query.getSQL({givens: {CARRIER: 'AA'}})).toContain(
+          'aa_table'
+        );
+      } finally {
+        await rwConn.close();
+      }
+    });
+
+    it('with no default and no value for the build it is unbuildable, and the rest is planned', async () => {
+      const model = await tstRuntime.loadModel(SUPPLIED_MODEL).getModel();
+      const {connections, unbuildable} =
+        await tstRuntime.getBuildTargets(model);
+
+      expect(
+        connections.flatMap(c => c.targets).map(t => t.sources[0].name)
+      ).toEqual(['carrier_stats']);
+      expect(unbuildable.map(u => u.source.name)).toEqual(['by_carrier']);
+      const [{problem}] = unbuildable;
+      expect(problem.code).toBe('runtime-persist-given-no-value');
+      expect(problem.message).toMatch(/by_carrier@.*reads given 'CARRIER'/);
+    });
+
+    it('a query over the unbuildable source runs live under a manifest of other tables', async () => {
+      const manifest = createManifest();
+      const rt = runtimeWithManifest(manifest);
+      const model = await rt.loadModel(SUPPLIED_MODEL).getModel();
+      const {connections} = await rt.getBuildTargets(model);
+      const [stats] = connections.flatMap(c => c.targets);
+      addManifestEntry(manifest, stats.buildId, 'carrier_stats_table');
+
+      const sql = await rt
+        .loadModel(SUPPLIED_MODEL)
+        .loadQueryByName('q')
+        .getSQL({givens: {CARRIER: 'WN'}});
+      expect(sql).toContain("'WN'");
+      expect(sql).not.toContain('carrier_stats_table');
+    });
+
+    it('a value supplied to the build is a value', async () => {
+      const target = await onlyTarget(
+        tstRuntime,
+        SUPPLIED_MODEL.replace(/#@ persist\s+source: carrier_stats[^}]*}/, ''),
+        {CARRIER: 'WN'}
+      );
+      expect(target.sql).toContain("'WN'");
+    });
+
+    it("the Runtime's givens are the build's givens", async () => {
+      const rt = new Runtime({
+        connections: tstRuntime.connections,
+        urlReader: testFileSpace,
+        givens: {CARRIER: 'UA'},
+      });
+      const target = await onlyTarget(
+        rt,
+        SUPPLIED_MODEL.replace(/#@ persist\s+source: carrier_stats[^}]*}/, '')
+      );
+      expect(target.sql).toContain("'UA'");
+    });
+
+    it('a finalized given cannot be supplied to a build', async () => {
+      const config = new MalloyConfig(
+        {finalizeGivens: ['CARRIER']},
+        {configURL: 'file:///finalized/malloy-config.json'}
+      );
+      const rt = new Runtime({
+        config,
+        connections: tstRuntime.connections,
+        urlReader: testFileSpace,
+        givens: {CARRIER: 'WN'},
+      });
+      const model = await rt.loadModel(GIVEN_MODEL).getModel();
+      await expect(
+        rt.getBuildTargets(model, {givens: {CARRIER: 'AA'}})
+      ).rejects.toThrow(/'CARRIER'.*finalized/);
+    });
+  });
+
+  describe('a build and its virtualMap', () => {
+    const VIRTUAL_MODEL = `${PERSIST_ANNOTATION}
+      ##! experimental.virtual_source
+      type: ff is { carrier :: string }
+      source: vf is ${tstDB}.virtual('vflights')::ff
+
+      #@ persist
+      source: by_carrier is vf -> { group_by: carrier }
+
+      run: by_carrier -> { select: * }
+    `;
+    const virtualMap: VirtualMap = new Map([
+      [tstDB, new Map([['vflights', 'malloytest.flights']])],
+    ]);
+
+    it('a virtual source with no entry is unbuildable, not a failed plan', async () => {
+      const model = await tstRuntime.loadModel(VIRTUAL_MODEL).getModel();
+      const {connections, unbuildable} =
+        await tstRuntime.getBuildTargets(model);
+      expect(connections).toEqual([]);
+      expect(unbuildable.map(u => u.problem.code)).toEqual([
+        'runtime-virtual-map-missing',
+      ]);
+    });
+
+    it('a virtualMap given to the build keys and builds the table', async () => {
+      const model = await tstRuntime.loadModel(VIRTUAL_MODEL).getModel();
+      const {connections, unbuildable} = await tstRuntime.getBuildTargets(
+        model,
+        {virtualMap}
+      );
+      expect(unbuildable).toEqual([]);
+      const [target] = connections[0].targets;
+      expect(target.sql).toContain('malloytest.flights');
+      expect(target.buildSQL(createManifest())).toContain('malloytest.flights');
+    });
+  });
 });

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

@@ -697,6 +697,13 @@ describe.each(runtimes.runtimeList)('filter expressions %s', (dbName, db) => {
         run: range + { where: t ~ f'2001' }
       `).toMatchRows(range, inRange);
     });
+    test('date in month, in a query time zone east of UTC', async () => {
+      // Midnight starting a month in Tokyo is still the previous day in UTC
+      const range = mkDateRange('2001-01-01', '2001-02-01');
+      await expect(`
+        run: range + { timezone: 'Asia/Tokyo'; where: t ~ f'2001-01' }
+      `).toMatchRows(range, inRange);
+    });
     test('2 days ago', async () => {
       nowIs('2001-01-15 12:00:00');
       const rangeQuery = mkRangeQuery(

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

@@ -527,12 +527,13 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
       source: a is ${databaseName}.table('malloytest.aircraft_models') extend { where: aircraft_model_code ? '0270202' }
 
       run: a -> {
-          group_by: boolean_1 is sql_boolean("\${seats} > 20")
-          group_by: boolean_2 is sql_boolean("\${engines} = 2")
+          group_by:
+            boolean_1 is pick 'yes' when sql_boolean("\${seats} > 20") else 'no'
+            boolean_2 is pick 'yes' when sql_boolean("\${engines} = 2") else 'no'
         }
   `).toMatchResult(testModel, {
-        boolean_1: true,
-        boolean_2: false,
+        boolean_1: 'yes',
+        boolean_2: 'no',
       });
     });
 
@@ -1067,12 +1068,12 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
         dimension: fot is (false) or (true)
       } -> {
         select:
-          no_paren is false and fot
-          paren is    false and (fot)
+          no_paren is pick 'yes' when false and fot else 'no'
+          paren is    pick 'yes' when false and (fot) else 'no'
       }`
     ).toMatchResult(testModel, {
-      paren: false,
-      no_paren: false,
+      paren: 'no',
+      no_paren: 'no',
     });
   });
 });

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

@@ -51,8 +51,6 @@ expressionModels.forEach((x, databaseName) => {
   const expressionModel = x.expressionModel;
   const runtime = x.runtime;
   const testModel = wrapTestModel(runtime, modelText(databaseName));
-  const dbTrue = runtime.dialect.resultBoolean(true);
-  const dbFalse = runtime.dialect.resultBoolean(false);
   const funcTestGeneral = async (
     expr: string,
     type: 'group_by' | 'aggregate',
@@ -124,14 +122,6 @@ expressionModels.forEach((x, databaseName) => {
       await funcTestMultiple(
         ["concat('foo', 'bar')", 'foobar'],
         ["concat(1, 'bar')", '1bar'],
-        [
-          "concat('cons', true)",
-          databaseName === 'postgres'
-            ? 'const'
-            : databaseName === 'mysql'
-              ? 'cons1'
-              : 'construe',
-        ],
         ["concat('foo', @2003)", 'foo2003-01-01'],
         [
           "concat('foo', @2003-01-01 12:00:00)",
@@ -142,6 +132,20 @@ expressionModels.forEach((x, databaseName) => {
         ['concat()', '']
       );
     });
+    it.when(
+      runtime.dialect.booleanType !== 'none' &&
+        !brokenIn('trino', databaseName) &&
+        !brokenIn('presto', databaseName)
+    )(`works with a boolean - ${databaseName}`, async () => {
+      await funcTest(
+        "concat('cons', true)",
+        databaseName === 'postgres'
+          ? 'const'
+          : databaseName === 'mysql'
+            ? 'cons1'
+            : 'construe'
+      );
+    });
   });
 
   describe('round', () => {
@@ -624,16 +628,13 @@ expressionModels.forEach((x, databaseName) => {
           # test.debug
           run: state_facts -> {
             group_by: state
-            calculate: lag_val is lag(@2011-11-11 11:11:11, 1, now).year = now.year
+            calculate: lag_val is
+              pick 'now' when lag(@2011-11-11 11:11:11, 1, now).year = now.year else 'then'
           }`
         )
         .run();
-      expect(result.data.path(0, 'lag_val').value).toBe(
-        runtime.dialect.resultBoolean(true)
-      );
-      expect(result.data.path(1, 'lag_val').value).toBe(
-        runtime.dialect.resultBoolean(false)
-      );
+      expect(result.data.path(0, 'lag_val').value).toBe('now');
+      expect(result.data.path(1, 'lag_val').value).toBe('then');
     });
   });
 
@@ -855,32 +856,45 @@ expressionModels.forEach((x, databaseName) => {
       : "'+inf'::number";
     it.when(databaseName !== 'mysql')(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
-        [`is_inf(${inf})`, dbTrue],
-        ['is_inf(100)', dbFalse],
-        ['is_inf(null)', dbFalse]
+        [`pick 'yes' when is_inf(${inf}) else 'no'`, 'yes'],
+        ["pick 'yes' when is_inf(100) else 'no'", 'no'],
+        ["pick 'yes' when is_inf(null) else 'no'", 'no']
       );
     });
+    // A null input is false, not null
+    it.when(databaseName !== 'mysql' && runtime.dialect.booleanType !== 'none')(
+      `is false for null - ${databaseName}`,
+      async () => {
+        await funcTest('is_inf(null)', runtime.dialect.resultBoolean(false));
+      }
+    );
   });
   describe('is_nan', () => {
     it.when(databaseName !== 'mysql')(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
-        ["is_nan('NaN'::number)", dbTrue],
-        ['is_nan(100)', dbFalse],
-        ['is_nan(null)', dbFalse]
+        ["pick 'yes' when is_nan('NaN'::number) else 'no'", 'yes'],
+        ["pick 'yes' when is_nan(100) else 'no'", 'no'],
+        ["pick 'yes' when is_nan(null) else 'no'", 'no']
       );
     });
+    it.when(databaseName !== 'mysql' && runtime.dialect.booleanType !== 'none')(
+      `is false for null - ${databaseName}`,
+      async () => {
+        await funcTest('is_nan(null)', runtime.dialect.resultBoolean(false));
+      }
+    );
   });
   describe('greatest', () => {
     it(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
         ['greatest(1, 10, -100)', 10],
         [
-          'greatest(@2003, @2004, @1994) = @2004',
-          runtime.dialect.resultBoolean(true),
+          "pick 'yes' when greatest(@2003, @2004, @1994) = @2004 else 'no'",
+          'yes',
         ],
         [
-          'greatest(@2023-05-26 11:58:00, @2023-05-26 11:59:00) = @2023-05-26 11:59:00',
-          runtime.dialect.resultBoolean(true),
+          "pick 'yes' when greatest(@2023-05-26 11:58:00, @2023-05-26 11:59:00) = @2023-05-26 11:59:00 else 'no'",
+          'yes',
         ],
         ["greatest('a', 'b')", 'b'],
         ['greatest(1, null, 0)', null],
@@ -892,13 +906,10 @@ expressionModels.forEach((x, databaseName) => {
     it(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
         ['least(1, 10, -100)', -100],
+        ["pick 'yes' when least(@2003, @2004, @1994) = @1994 else 'no'", 'yes'],
         [
-          'least(@2003, @2004, @1994) = @1994',
-          runtime.dialect.resultBoolean(true),
-        ],
-        [
-          'least(@2023-05-26 11:58:00, @2023-05-26 11:59:00) = @2023-05-26 11:58:00',
-          runtime.dialect.resultBoolean(true),
+          "pick 'yes' when least(@2023-05-26 11:58:00, @2023-05-26 11:59:00) = @2023-05-26 11:58:00 else 'no'",
+          'yes',
         ],
         ["least('a', 'b')", 'a'],
         ['least(1, null, 0)', null],
@@ -929,36 +940,48 @@ expressionModels.forEach((x, databaseName) => {
     it(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
         [
-          "starts_with('hello world', 'hello')",
-          runtime.dialect.resultBoolean(true),
+          "pick 'yes' when starts_with('hello world', 'hello') else 'no'",
+          'yes',
         ],
-        [
-          "starts_with('hello world', 'world')",
-          runtime.dialect.resultBoolean(false),
-        ],
-        ["starts_with(null, 'world')", runtime.dialect.resultBoolean(false)],
-        [
-          "starts_with('hello world', null)",
-          runtime.dialect.resultBoolean(false),
-        ]
+        ["pick 'yes' when starts_with('hello world', 'world') else 'no'", 'no'],
+        ["pick 'yes' when starts_with(null, 'world') else 'no'", 'no'],
+        ["pick 'yes' when starts_with('hello world', null) else 'no'", 'no']
       );
     });
+    it.when(runtime.dialect.booleanType !== 'none')(
+      `is false for null - ${databaseName}`,
+      async () => {
+        await funcTestMultiple(
+          ["starts_with(null, 'world')", runtime.dialect.resultBoolean(false)],
+          [
+            "starts_with('hello world', null)",
+            runtime.dialect.resultBoolean(false),
+          ]
+        );
+      }
+    );
   });
   describe('ends_with', () => {
     it(`works - ${databaseName}`, async () => {
       await funcTestMultiple(
-        [
-          "ends_with('hello world', 'world')",
-          runtime.dialect.resultBoolean(true),
-        ],
-        [
-          "ends_with('hello world', 'hello')",
-          runtime.dialect.resultBoolean(false),
-        ],
-        ["ends_with(null, 'world')", runtime.dialect.resultBoolean(false)],
-        ["ends_with('hello world', null)", runtime.dialect.resultBoolean(false)]
+        ["pick 'yes' when ends_with('hello world', 'world') else 'no'", 'yes'],
+        ["pick 'yes' when ends_with('hello world', 'hello') else 'no'", 'no'],
+        ["pick 'yes' when ends_with(null, 'world') else 'no'", 'no'],
+        ["pick 'yes' when ends_with('hello world', null) else 'no'", 'no']
       );
     });
+    it.when(runtime.dialect.booleanType !== 'none')(
+      `is false for null - ${databaseName}`,
+      async () => {
+        await funcTestMultiple(
+          ["ends_with(null, 'world')", runtime.dialect.resultBoolean(false)],
+          [
+            "ends_with('hello world', null)",
+            runtime.dialect.resultBoolean(false),
+          ]
+        );
+      }
+    );
   });
   describe('trim', () => {
     it(`trim works - ${databaseName}`, async () => {
@@ -1001,14 +1024,17 @@ expressionModels.forEach((x, databaseName) => {
       // There are around a billion values that rand() can be, so if this
       // test fails, most likely something is broken. Otherwise, you're the lucky
       // one in a billion!
-      await funcTest('rand() = rand()', runtime.dialect.resultBoolean(false));
+      await funcTest(
+        "pick 'same' when rand() = rand() else 'differ'",
+        'differ'
+      );
     });
   });
   describe('pi', () => {
     it(`is pi - ${databaseName}`, async () => {
       await funcTest(
-        'abs(pi() - 3.141592653589793) < 0.0000000000001',
-        runtime.dialect.resultBoolean(true)
+        "pick 'yes' when abs(pi() - 3.141592653589793) < 0.0000000000001 else 'no'",
+        'yes'
       );
     });
   });

package/src/databases/all/new-matchers.spec.ts

@@ -11,8 +11,11 @@ import '@malloydata/malloy/test/matchers';
 const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
 
 describe.each(runtimes.runtimeList)('New matchers for %s', (db, runtime) => {
+  // A dialect without boolean values has no boolean column
+  const booleans = runtime.dialect.booleanType !== 'none';
+
   describe('mkTestModel and TV', () => {
-    test('basic types with type inference', async () => {
+    test.when(booleans)('basic types with type inference', async () => {
       const tm = mkTestModel(runtime, {
         data: [
           {t_int: 1, t_string: 'a', t_bool: true},
@@ -155,16 +158,19 @@ describe.each(runtimes.runtimeList)('New matchers for %s', (db, runtime) => {
       });
     });
 
-    test('plain booleans work with dialect boolean handling', async () => {
-      const tm = mkTestModel(runtime, {
-        data: [{a: true, b: false}],
-      });
-      // Booleans are handled by dialect.resultBoolean() in the matcher
-      await expect('run: data -> { select: * }').toMatchResult(tm, {
-        a: true,
-        b: false,
-      });
-    });
+    test.when(booleans)(
+      'plain booleans work with dialect boolean handling',
+      async () => {
+        const tm = mkTestModel(runtime, {
+          data: [{a: true, b: false}],
+        });
+        // Booleans are handled by dialect.resultBoolean() in the matcher
+        await expect('run: data -> { select: * }').toMatchResult(tm, {
+          a: true,
+          b: false,
+        });
+      }
+    );
   });
 
   describe('test.debug tag', () => {

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

@@ -24,20 +24,26 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
     }`
   );
 
-  it(`boolean type - ${databaseName}`, async () => {
-    await expect(`
+  // A dialect without boolean values cannot group by one
+  it.when(runtime.dialect.booleanType !== 'none')(
+    `boolean type - ${databaseName}`,
+    async () => {
+      await expect(`
       run: models-> {
         group_by: big is seats >=20
         aggregate: model_count is count()
       }
     `).toMatchResult(orderByModel, {
-      big: false,
-      model_count: 58451,
-    });
-  });
+        big: false,
+        model_count: 58451,
+      });
+    }
+  );
 
-  it(`boolean in pipeline - ${databaseName}`, async () => {
-    await expect(`
+  it.when(runtime.dialect.booleanType !== 'none')(
+    `boolean in pipeline - ${databaseName}`,
+    async () => {
+      await expect(`
       run: models->{
         group_by:
           manufacturer,
@@ -48,10 +54,11 @@ describe.each(runtimes.runtimeList)('%s', (databaseName, runtime) => {
         aggregate: model_count is model_count.sum()
       }
     `).toMatchResult(orderByModel, {
-      big: false,
-      model_count: 58500,
-    });
-  });
+        big: false,
+        model_count: 58500,
+      });
+    }
+  );
 
   it(`filtered measures in model are aggregates #352 - ${databaseName}`, async () => {
     await expect(`

package/src/databases/all/test-select.spec.ts

@@ -15,8 +15,11 @@ describe.each(runtimes.runtimeList)('TestSelect for %s', (db, runtime) => {
   const ts = new TestSelect(runtime.dialect);
   const testModel = wrapTestModel(runtime, '');
 
+  // A dialect without boolean values has no boolean column
+  const booleans = runtime.dialect.booleanType !== 'none';
+
   // Basic Type Tests
-  test(`${db} inferred basic types`, async () => {
+  test.when(booleans)(`${db} inferred basic types`, async () => {
     const sql = ts.generate(
       {t_int: 1, t_string: 'a', t_bool: true, t_float: 1.5},
       {t_int: 2, t_string: 'b', t_bool: false, t_float: 2.5}
@@ -27,7 +30,7 @@ describe.each(runtimes.runtimeList)('TestSelect for %s', (db, runtime) => {
     ]);
   });
 
-  test(`${db} explicit type hints`, async () => {
+  test.when(booleans)(`${db} explicit type hints`, async () => {
     const sql = ts.generate({
       t_int: ts.mk_int(1),
       t_float: ts.mk_float(1.5),

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

@@ -274,11 +274,11 @@ describe.each(runtimes.runtimeList)('%s date and time', (dbName, runtime) => {
     });
   });
 
-  test.when(runtime.dialect.hasTimestamptz)(
+  test.when(timestamptz)(
     'extract from timestamptz without query timezone',
     async () => {
       // TIMESTAMPTZ representing midnight UTC
-      // Without query timezone, extract should happen in UTC (or stored tz for Trino)
+      // Without query timezone, extract should happen in UTC
       // Expected: hour = 0, day = 20
       await expect(
         `run: ${dbName}.sql("SELECT 1 as x") -> {
@@ -291,6 +291,80 @@ describe.each(runtimes.runtimeList)('%s date and time', (dbName, runtime) => {
     }
   );
 
+  // 20:00 on the 30th in Mexico City is 02:00 on the 31st in UTC. With no
+  // query time zone the value is read in UTC, not in the zone it was written in.
+  describe('timestamptz written in another zone', () => {
+    const tzModel = () =>
+      mkTestModel(runtime, {
+        tzdata: [
+          {
+            tstz: TV.timestamptz('2020-01-30 20:00:00[America/Mexico_City]'),
+            same_instant: TV.timestamp('2020-01-31 02:00:00'),
+            same_digits: TV.timestamp('2020-01-30 20:00:00'),
+          },
+        ],
+      });
+
+    test.when(timestamptz)('extract', async () => {
+      await expect(
+        'run: tzdata -> { select: h is hour(tstz), d is day(tstz) }'
+      ).toMatchResult(tzModel(), {h: 2, d: 31});
+    });
+
+    test.when(timestamptz)('truncate', async () => {
+      await expect('run: tzdata -> { select: d is tstz.day }').toMatchResult(
+        tzModel(),
+        {d: '2020-01-31T00:00:00.000Z'}
+      );
+    });
+
+    test.when(timestamptz)('add a month', async () => {
+      // Jan 31 + 1 month is Feb 29; Jan 30 + 1 month in Mexico City is Mar 1 UTC
+      await expect(
+        'run: tzdata -> { select: next is tstz + 1 month }'
+      ).toMatchResult(tzModel(), {next: '2020-02-29T02:00:00.000Z'});
+    });
+
+    test.when(timestamptz)('cast to date', async () => {
+      await expect('run: tzdata -> { select: d is tstz::date }').toMatchResult(
+        tzModel(),
+        {d: '2020-01-31'}
+      );
+    });
+
+    test.when(timestamptz)('cast keeps the instant', async () => {
+      await expect(`
+        run: tzdata -> {
+          select:
+            ts is tstz::timestamp
+            same is pick 'yes' when tstz::timestamp = tstz else 'no'
+            back is pick 'yes' when same_instant::timestamptz = tstz else 'no'
+        }
+      `).toMatchResult(tzModel(), {
+        ts: '2020-01-31T02:00:00.000Z',
+        same: 'yes',
+        back: 'yes',
+      });
+    });
+
+    test.when(timestamptz)('compare to timestamp', async () => {
+      await expect(`
+        run: tzdata -> {
+          select:
+            eq_instant is pick 'yes' when tstz = same_instant else 'no'
+            eq_digits is pick 'yes' when tstz = same_digits else 'no'
+            gt_digits is pick 'yes' when tstz > same_digits else 'no'
+            lt_digits is pick 'yes' when same_digits < tstz else 'no'
+        }
+      `).toMatchResult(tzModel(), {
+        eq_instant: 'yes',
+        eq_digits: 'no',
+        gt_digits: 'yes',
+        lt_digits: 'yes',
+      });
+    });
+  });
+
   describe('date truncation', () => {
     test('date trunc day', async () => {
       const eq = sqlEq('t_date.day', '@2021-02-24');
@@ -526,16 +600,16 @@ describe.each(runtimes.runtimeList)('%s date and time', (dbName, runtime) => {
       });
       await expect(`
         run: fourTimes -> { select:
-          isBefore is tbefore ? @2026-01-01
-          isFirst is tfirst ? @2026-01-01
-          isLast is tlast ? @2026-01-01
-          isAfter is tafter ? @2026-01-01
+          isBefore is pick 'in' when tbefore ? @2026-01-01 else 'out'
+          isFirst is pick 'in' when tfirst ? @2026-01-01 else 'out'
+          isLast is pick 'in' when tlast ? @2026-01-01 else 'out'
+          isAfter is pick 'in' when tafter ? @2026-01-01 else 'out'
         }
       `).toMatchResult(tm, {
-        isBefore: false,
-        isFirst: true,
-        isLast: true,
-        isAfter: false,
+        isBefore: 'out',
+        isFirst: 'in',
+        isLast: 'in',
+        isAfter: 'out',
       });
     });
   });
@@ -730,6 +804,7 @@ describe.each(runtimes.runtimeList)('%s: tz literals', (dbName, runtime) => {
 
 describe.each(runtimes.runtimeList)('%s: query tz', (dbName, runtime) => {
   const testModel = wrapTestModel(runtime, '');
+  const timestamptz = runtime.dialect.hasTimestamptz;
   const ts = new TestSelect(runtime.dialect);
   const selectMidnight = `"""${ts.generate({
     utc_midnight_ts: ts.mk_timestamp('2020-02-20 00:00:00'),
@@ -762,7 +837,7 @@ describe.each(runtimes.runtimeList)('%s: query tz', (dbName, runtime) => {
     ).toMatchResult(testModel, {mex_midnight: 18, mex_day: 19});
   });
 
-  test.when(runtime.dialect.hasTimestamptz)(
+  test.when(timestamptz)(
     'extract from timestamptz with query timezone',
     async () => {
       // TIMESTAMPTZ representing midnight UTC
@@ -792,6 +867,16 @@ describe.each(runtimes.runtimeList)('%s: query tz', (dbName, runtime) => {
     ).toMatchResult(testModel, {mex_day: mex_19.toJSDate()});
   });
 
+  test('truncate hour in a zone a half hour off UTC', async () => {
+    // 02:10 in Kolkata is 20:40 UTC, and the Kolkata hour starts at 20:30
+    await expect(
+      `run: ${dbName}.sql("SELECT 1 as x") -> {
+        timezone: 'Asia/Kolkata'
+        select: kol_hour is @2020-01-31 02:10:00.hour
+      }`
+    ).toMatchResult(testModel, {kol_hour: '2020-01-30T20:30:00.000Z'});
+  });
+
   test('truncate week', async () => {
     // the 19th in mexico is a wednesday, so trunc to the 15th
     const mex_19 = LuxonDateTime.fromISO('2020-02-19T00:00:00', {zone});
@@ -814,18 +899,15 @@ describe.each(runtimes.runtimeList)('%s: query tz', (dbName, runtime) => {
       }`
     ).toMatchResult(testModel, {mex_date: '2020-02-19'});
   });
-  test.when(runtime.dialect.hasTimestamptz)(
-    'cast timestamptz to date',
-    async () => {
-      await expect(
-        `run: ${dbName}.sql("SELECT 1 as x") -> {
+  test.when(timestamptz)('cast timestamptz to date', async () => {
+    await expect(
+      `run: ${dbName}.sql("SELECT 1 as x") -> {
           timezone: '${zone}'
           extend: { dimension: utc_tstz is @2020-02-20 00:00:00[UTC]::timestamptz }
           select: mex_date is utc_tstz::date
         }`
-      ).toMatchResult(testModel, {mex_date: '2020-02-19'});
-    }
-  );
+    ).toMatchResult(testModel, {mex_date: '2020-02-19'});
+  });
   test('cast date to timestamp', async () => {
     await expect(
       `run: ${dbName}.sql(${selectMidnight}) -> {
@@ -842,31 +924,95 @@ describe.each(runtimes.runtimeList)('%s: query tz', (dbName, runtime) => {
       }`
     ).toMatchResult(testModel, {d2020: '2020-02-20'});
   });
-  test.when(runtime.dialect.hasTimestamptz)(
-    'cast date to timestamptz',
-    async () => {
-      await expect(
-        `run: ${dbName}.sql(${selectMidnight}) -> {
+  test.when(timestamptz)('cast date to timestamptz', async () => {
+    await expect(
+      `run: ${dbName}.sql(${selectMidnight}) -> {
           timezone: '${zone}'
           select: mex_date is date_2020::timestamptz
         }`
-      ).toMatchResult(testModel, {mex_date: zone_2020.toJSDate()});
-    }
-  );
+    ).toMatchResult(testModel, {mex_date: zone_2020.toJSDate()});
+  });
 
-  test.when(runtime.dialect.hasTimestamptz)(
-    'compare timestamptz to range',
-    async () => {
-      const tzModel = mkTestModel(runtime, {
+  test.when(timestamptz)('compare timestamptz to range', async () => {
+    const tzModel = mkTestModel(runtime, {
+      tzdata: [
+        {updated: TV.timestamptz('2020-01-15 00:00:00[America/Mexico_City]')},
+      ],
+    });
+    await expect(
+      "run: tzdata -> { select: cmp is pick 'in' when updated ? @2020-01 else 'out' }"
+    ).toMatchResult(tzModel, {cmp: 'in'});
+  });
+
+  // 11:00 on the 31st in Tokyo is 20:00 on the 30th in Mexico City. With a
+  // query time zone the value is read there, not in the zone it was written in.
+  describe('timestamptz written in another zone', () => {
+    const tzModel = () =>
+      mkTestModel(runtime, {
         tzdata: [
-          {updated: TV.timestamptz('2020-01-15 00:00:00[America/Mexico_City]')},
+          {
+            tstz: TV.timestamptz('2020-01-31 11:00:00[Asia/Tokyo]'),
+            same_instant: TV.timestamp('2020-01-31 02:00:00'),
+          },
         ],
       });
-      await expect(
-        'run: tzdata -> { select: cmp is updated ? @2020-01 }'
-      ).toMatchResult(tzModel, {cmp: true});
-    }
-  );
+
+    test.when(timestamptz)('extract', async () => {
+      await expect(`
+        run: tzdata -> {
+          timezone: '${zone}'
+          select: h is hour(tstz), d is day(tstz)
+        }
+      `).toMatchResult(tzModel(), {h: 20, d: 30});
+    });
+
+    test.when(timestamptz)('truncate', async () => {
+      const mex_30 = LuxonDateTime.fromISO('2020-01-30T00:00:00', {zone});
+      await expect(`
+        run: tzdata -> {
+          timezone: '${zone}'
+          select: d is tstz.day
+        }
+      `).toMatchResult(tzModel(), {d: mex_30.toJSDate()});
+    });
+
+    test.when(timestamptz)('add a month', async () => {
+      // Jan 30 + 1 month is Feb 29 in Mexico City; Jan 31 + 1 month in Tokyo
+      // or UTC is a day earlier
+      const mex_29 = LuxonDateTime.fromISO('2020-02-29T20:00:00', {zone});
+      await expect(`
+        run: tzdata -> {
+          timezone: '${zone}'
+          select: next is tstz + 1 month
+        }
+      `).toMatchResult(tzModel(), {next: mex_29.toJSDate()});
+    });
+
+    test.when(timestamptz)('cast to date', async () => {
+      await expect(`
+        run: tzdata -> {
+          timezone: '${zone}'
+          select: d is tstz::date
+        }
+      `).toMatchResult(tzModel(), {d: '2020-01-30'});
+    });
+
+    test.when(timestamptz)('cast keeps the instant', async () => {
+      await expect(`
+        run: tzdata -> {
+          timezone: '${zone}'
+          select:
+            ts is tstz::timestamp
+            same is pick 'yes' when tstz::timestamp = tstz else 'no'
+            back is pick 'yes' when same_instant::timestamptz = tstz else 'no'
+        }
+      `).toMatchResult(tzModel(), {
+        ts: '2020-01-31T02:00:00.000Z',
+        same: 'yes',
+        back: 'yes',
+      });
+    });
+  });
 
   // Test for timezone rendering issue with nested queries
   test.when(runtime.supportsNesting)(
@@ -946,16 +1092,16 @@ describe.each(runtimes.runtimeList)('%s: query tz', (dbName, runtime) => {
         timezone: 'Europe/Dublin'
         select:
           june1_correct,
-          month_ok is by_month = june1_correct, by_month
-          day_ok is by_day = june1_correct, by_day
-          hour_ok is by_hour = june1_correct, by_hour
-          quarter_ok is by_quarter = august1_correct, by_quarter
+          month_ok is pick 'yes' when by_month = june1_correct else 'no', by_month
+          day_ok is pick 'yes' when by_day = june1_correct else 'no', by_day
+          hour_ok is pick 'yes' when by_hour = june1_correct else 'no', by_hour
+          quarter_ok is pick 'yes' when by_quarter = august1_correct else 'no', by_quarter
       }`
     ).toMatchResult(testModel, {
-      month_ok: true,
-      day_ok: true,
-      hour_ok: true,
-      quarter_ok: true,
+      month_ok: 'yes',
+      day_ok: 'yes',
+      hour_ok: 'yes',
+      quarter_ok: 'yes',
     });
   });
 });

package/src/databases/sqlserver/sqlserver.spec.ts

@@ -94,23 +94,82 @@ describe('SQL Server', () => {
       `).toEqualResult(tm, [{n: 51}]);
     });
 
-    test('a declared boolean is a 0/1 value', async () => {
+    test('a declared boolean in a result column is refused, naming the value to write', async () => {
+      await expect(
+        runtime
+          .loadQuery(
+            `run: sqlserver.table('malloytest.state_facts') extend {
+              dimension: big is airport_count > 500
+            } -> { group_by: big; aggregate: n is count() }`
+          )
+          .run()
+      ).rejects.toThrow(
+        "'sqlserver' does not support a boolean as a result column; write the value, pick 'yes' when big else 'no'"
+      );
+    });
+
+    test('a declared boolean is a condition in where: and having:', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') extend {
+          dimension: big is airport_count > 500
+          measure: n is count()
+        } -> {
+          where: big
+          aggregate: n
+          having: n > 1
+        }
+      `).toEqualResult(tm, [{n: 12}]);
+    });
+
+    test('not, and a comparison true on NULL, follow Malloy rather than SQL', async () => {
+      await expect(`
+        run: sqlserver.sql('SELECT CAST(NULL AS INT) AS n, 1 AS one') -> {
+          select:
+            not_null is pick 'yes' when not (n = 1) else 'no'
+            ne_null is pick 'yes' when n != 1 else 'no'
+            not_one is pick 'yes' when not (one = 1) else 'no'
+            ne_one is pick 'yes' when one != 1 else 'no'
+        }
+      `).toEqualResult(tm, [
+        {not_null: 'yes', ne_null: 'yes', not_one: 'no', ne_one: 'no'},
+      ]);
+    });
+
+    test('a comparison picks', async () => {
       await expect(`
         run: sqlserver.table('malloytest.state_facts') -> {
-          group_by:
-            big is airport_count > 500
-            c_state is starts_with(state, 'C')
+          group_by: size is pick 'big' when airport_count > 500 else 'small'
           aggregate: n is count()
-          order_by: big desc, c_state desc
+          order_by: size
         }
       `).toEqualResult(tm, [
-        {big: true, c_state: true, n: 1},
-        {big: true, c_state: false, n: 11},
-        {big: false, c_state: true, n: 2},
-        {big: false, c_state: false, n: 37},
+        {size: 'big', n: 12},
+        {size: 'small', n: 39},
       ]);
     });
 
+    test('a boolean function is a condition', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          where: starts_with(state, 'C') and not ends_with(state, 'A')
+          select: state
+          order_by: state
+        }
+      `).toEqualResult(tm, [{state: 'CO'}, {state: 'CT'}]);
+    });
+
+    test('sql_boolean is a condition', async () => {
+      await expect(`
+        ##! experimental { sql_functions }
+        run: sqlserver.table('malloytest.state_facts') extend {
+          dimension: big is sql_boolean("\${airport_count} > 500")
+        } -> {
+          where: big
+          aggregate: n is count()
+        }
+      `).toEqualResult(tm, [{n: 12}]);
+    });
+
     test('a cast to boolean is refused', async () => {
       await expect(
         runtime
@@ -123,7 +182,7 @@ describe('SQL Server', () => {
       ).rejects.toThrow(/boolean/);
     });
 
-    test('starts_with and ends_with are conditions', async () => {
+    test('starts_with, ends_with and is_nan filter an aggregate', async () => {
       await expect(`
         run: sqlserver.table('malloytest.state_facts') -> {
           aggregate:
@@ -211,13 +270,13 @@ describe('SQL Server', () => {
     test('a constant dimension groups with the others', async () => {
       await expect(`
         run: sqlserver.table('malloytest.state_facts') -> {
-          group_by: tag is 'facts', big is airport_count > 500
+          group_by: tag is 'facts', size is pick 'big' when airport_count > 500 else 'small'
           aggregate: n is count()
-          order_by: big desc
+          order_by: size
         }
       `).toEqualResult(tm, [
-        {tag: 'facts', big: true, n: 12},
-        {tag: 'facts', big: false, n: 39},
+        {tag: 'facts', size: 'big', n: 12},
+        {tag: 'facts', size: 'small', n: 39},
       ]);
     });
 
@@ -363,6 +422,61 @@ describe('SQL Server', () => {
     });
   });
 
+  describe('a datetimeoffset', () => {
+    // 12:34:56 at -05:00 is 17:34:56 UTC; 22:34:56 at -05:00 is 03:34:56 UTC the next day
+    const noon = "CAST('2024-03-20 12:34:56 -05:00' AS DATETIMEOFFSET)";
+    const night = "CAST('2024-03-20 22:34:56 -05:00' AS DATETIMEOFFSET)";
+
+    test('is an instant', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT ${noon} AS t") -> {
+          select: t, utc is t::timestamp
+        }
+      `).toMatchResult(tm, {
+        t: new Date('2024-03-20T17:34:56Z'),
+        utc: new Date('2024-03-20T17:34:56Z'),
+      });
+    });
+
+    test('reads its clock at UTC without a query time zone', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT ${night} AS t") -> {
+          select: h is hour(t), d is t.day, dt is t::date
+        }
+      `).toMatchResult(tm, {
+        h: 3,
+        d: new Date('2024-03-21T00:00:00Z'),
+        dt: '2024-03-21',
+      });
+    });
+
+    test('compares as an instant', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT ${noon} AS t") -> {
+          where: t > @2024-03-20 15:00:00
+          aggregate: n is count()
+        }
+      `).toMatchResult(tm, {n: 1});
+    });
+
+    test('offsets by a calendar unit at UTC', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT CAST('2024-01-30 22:34:56 -05:00' AS DATETIMEOFFSET) AS t") -> {
+          select: next is t + 1 month
+        }
+      `).toMatchResult(tm, {next: new Date('2024-02-29T03:34:56Z')});
+    });
+
+    test('measures between two offsets as instants', async () => {
+      await expect(`
+        run: sqlserver.sql("""
+          SELECT CAST('2024-03-20 12:00:00 +00:00' AS DATETIMEOFFSET) AS a,
+                 CAST('2024-03-20 12:00:00 -05:00' AS DATETIMEOFFSET) AS b
+        """) -> { select: h is hours(a to b) }
+      `).toMatchResult(tm, {h: 5});
+    });
+  });
+
   describe('joins', () => {
     test('sums each side of a fan-out once', async () => {
       await expect(`