@malloydata/malloy-tests 0.0.434 → 0.0.435

package/CONTEXT.md

@@ -40,6 +40,8 @@ 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.
+
 ### 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).
 
@@ -99,7 +101,7 @@ npm run build-duckdb-db  # Creates test/data/duckdb/duckdb_test.db
 
 This creates a local DuckDB database file populated with test data.
 
-### PostgreSQL, MySQL, Trino, Presto
+### PostgreSQL, MySQL, Trino, Presto, SQL Server
 These databases require Docker containers to be running.
 
 **Starting database containers:**
@@ -108,6 +110,7 @@ Each database has a startup script in the test directory:
 - `test/mysql/mysql_start.sh`
 - `test/trino/trino_start.sh`
 - `test/presto/presto_start.sh`
+- `test/mssql/mssql_start.sh`
 
 These scripts start Docker containers with appropriate test configurations and data.
 
@@ -174,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`; connects as the test runtime does (`sa`, localhost:1433). Waits for the server itself. Same table set as MySQL. Not in CI |
+| 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 |
 | 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/mssql/connection_string.ts

@@ -4,9 +4,25 @@
  */
 
 /**
- * The SQL Server the mssql tests and loader connect to: the container
- * mssql_start.sh runs, with the password it sets.
+ * The SQL Server the mssql tests and loader connect to, from the MSSQL_*
+ * variables mssql_start.sh exports. The test runtimes read the same
+ * variables through SQLServerExecutor.getConnectionOptionsFromEnv.
  */
+function required(name: string): string {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`${name} is not set; see test/mssql/mssql_start.sh`);
+  }
+  return value;
+}
+
+/** The ADO-style string DuckDB's mssql extension takes in ATTACH */
 export function mssqlConnectionString(database: string): string {
-  return `Server=localhost;Port=1433;Database=${database};User Id=sa;Password=Malloy_Test_123;TrustServerCertificate=true`;
+  const host = required('MSSQL_HOST');
+  const port = required('MSSQL_PORT');
+  const user = required('MSSQL_USER');
+  const password = required('MSSQL_PASSWORD');
+  const trust = process.env['MSSQL_TRUST_SERVER_CERTIFICATE'] === 'true';
+  // `Server=host,port`: the extension reads no separate Port key
+  return `Server=${host},${port};Database=${database};User Id=${user};Password=${password};TrustServerCertificate=${trust}`;
 }

package/mssql/mssql_start.sh

@@ -6,9 +6,17 @@
 set -e
 
 SCRIPTDIR=$(cd $(dirname $0); pwd)
-CONTAINER_NAME="mssql-malloy"
-# Must match test/mssql/connection_string.ts
-SA_PASSWORD="Malloy_Test_123"
+# MSSQL_IMAGE and MSSQL_CONTAINER select a server version to run beside the default
+CONTAINER_NAME="${MSSQL_CONTAINER:-mssql-malloy}"
+# The loader and the tests read MSSQL_*; this script is the only place a
+# default is written. Export the same values to run the tests by hand.
+export MSSQL_HOST="${MSSQL_HOST:-localhost}"
+export MSSQL_PORT="${MSSQL_PORT:-1433}"
+export MSSQL_TRUST_SERVER_CERTIFICATE="${MSSQL_TRUST_SERVER_CERTIFICATE:-true}"
+export MSSQL_USER="${MSSQL_USER:-sa}"
+export MSSQL_PASSWORD="${MSSQL_PASSWORD:-Malloy_Test_123}"
+export MSSQL_DATABASE="${MSSQL_DATABASE:-malloytest}"
+SA_PASSWORD="$MSSQL_PASSWORD"
 
 # Check for existing container
 if docker container inspect "$CONTAINER_NAME" > /dev/null 2>&1; then
@@ -20,24 +28,21 @@ if docker container inspect "$CONTAINER_NAME" > /dev/null 2>&1; then
   docker start "$CONTAINER_NAME"
   # The loader waits for the server; reloading is cheap
   sh "$SCRIPTDIR/load_test_data.sh"
-  echo "MSSQL running on port 1433"
+  echo "MSSQL running on port $MSSQL_PORT"
   exit 0
 fi
 
-# Detect architecture — Azure SQL Edge for ARM64, SQL Server for x64
-ARCH=$(uname -m)
-if [ "$ARCH" = "arm64" ] || [ "$ARCH" = "aarch64" ]; then
-  IMAGE="mcr.microsoft.com/azure-sql-edge:latest"
-else
-  IMAGE="mcr.microsoft.com/mssql/server:2022-latest"
-fi
+# SQL Server 2022 by default; MSSQL_IMAGE picks another version, 2017 being
+# the oldest the sqlserver dialect runs on. The x64 image runs under emulation
+# on ARM64 Macs.
+IMAGE="${MSSQL_IMAGE:-mcr.microsoft.com/mssql/server:2022-latest}"
 
 echo "Starting $CONTAINER_NAME ($IMAGE)..."
 docker run -d \
   --name "$CONTAINER_NAME" \
   -e "ACCEPT_EULA=Y" \
   -e "MSSQL_SA_PASSWORD=$SA_PASSWORD" \
-  -p 1433:1433 \
+  -p "$MSSQL_PORT:1433" \
   "$IMAGE"
 
 # The loader waits for the server. A container without its tables must not
@@ -47,4 +52,5 @@ echo "Loading test data..."
 sh "$SCRIPTDIR/load_test_data.sh"
 trap - ERR
 
-echo "MSSQL running on port 1433, database: malloytest"
+echo "MSSQL running on port $MSSQL_PORT, database: $MSSQL_DATABASE"
+echo "Tests need the same MSSQL_HOST/MSSQL_PORT/MSSQL_USER/MSSQL_PASSWORD/MSSQL_DATABASE in their environment"

package/mssql/mssql_stop.sh

@@ -1,4 +1,4 @@
 #!/bin/bash
 
-# stop and remove container
-docker rm -f mssql-malloy
+# stop and remove the container mssql_start.sh started
+docker rm -f "${MSSQL_CONTAINER:-mssql-malloy}"

package/package.json

@@ -14,21 +14,22 @@
   "scripts": {
     "lint": "eslint '**/*.ts{,x}'",
     "lint-fix": "eslint '**/*.ts{,x}' --fix",
-    "test": "jest --config=../jest.config.js",
+    "test": "echo 'Read the Testing section of the repo-root CONTEXT.md for information on testing in this monorepo'; exit 1",
     "build": "node ../node_modules/typescript/bin/tsc --build",
     "clean": "node ../node_modules/typescript/bin/tsc --build --clean && rm -f tsconfig.tsbuildinfo",
     "malloyc": "ts-node ../scripts/malloy-to-json"
   },
   "dependencies": {
-    "@malloydata/db-bigquery": "0.0.434",
-    "@malloydata/db-duckdb": "0.0.434",
-    "@malloydata/db-postgres": "0.0.434",
-    "@malloydata/db-snowflake": "0.0.434",
-    "@malloydata/db-trino": "0.0.434",
-    "@malloydata/malloy": "0.0.434",
-    "@malloydata/malloy-tag": "0.0.434",
-    "@malloydata/render": "0.0.434",
-    "@malloydata/render-validator": "0.0.434",
+    "@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",
     "events": "^3.3.0",
     "jsdom": "^22.1.0",
     "luxon": "^3.7.2",
@@ -42,5 +43,5 @@
   "overrides": {
     "typescript": "^6.0.3"
   },
-  "version": "0.0.434"
+  "version": "0.0.435"
 }

package/src/core/experimental-dialects.spec.ts

@@ -3,13 +3,14 @@
  * SPDX-License-Identifier: MIT
  */
 
-import type {
-  FetchSchemaOptions,
-  MalloyError,
-  SQLSourceDef,
+import type {MalloyError} from '@malloydata/malloy';
+import {
+  DuckDBDialect,
+  getDialect,
+  InMemoryURLReader,
+  registerDialect,
+  SingleConnectionRuntime,
 } from '@malloydata/malloy';
-import {DuckDBDialect, registerDialect} from '@malloydata/malloy';
-import {testRuntimeFor} from '../runtimes';
 import {DuckDBConnection} from '@malloydata/db-duckdb';
 
 const envDatabases = (
@@ -33,30 +34,24 @@ async function getError<T>(promise: Promise<T>): Promise<Error | undefined> {
   return undefined;
 }
 
+/**
+ * A file acknowledges an experimental dialect with
+ * `##! experimental.dialect.NAME` wherever it takes one on: by naming a
+ * connection on it, or by importing a source or query that uses it. The
+ * acknowledgment is a pragma, so an importer gets no credit for the line in
+ * the file it imports.
+ */
 describe('experimental dialects', () => {
   const duckdbX = 'duckdb_experimental';
+  const flag = `##! experimental.dialect.${duckdbX}`;
+
   class DuckdbXConnection extends DuckDBConnection {
     name = duckdbX;
-    public async festchSchemaFOrSQLSource(
-      sqlRef: SQLSourceDef,
-      options: FetchSchemaOptions
-    ): Promise<
-      | {structDef: SQLSourceDef; error?: undefined}
-      | {error: string; structDef?: undefined}
-    > {
-      const result = await super.fetchSchemaForSQLStruct(sqlRef, options);
-      if (result.error === undefined) {
-        return {structDef: {...result.structDef, dialect: duckdbX}};
-      }
-      return result;
-    }
     get dialectName(): string {
       return duckdbX;
     }
   }
 
-  const connection = new DuckdbXConnection(duckdbX, ':memory:');
-
   class DuckdbXDialect extends DuckDBDialect {
     experimental = true;
     name = duckdbX;
@@ -65,35 +60,124 @@ describe('experimental dialects', () => {
     }
   }
 
+  const connection = new DuckdbXConnection(duckdbX, ':memory:');
   registerDialect(new DuckdbXDialect());
-  const runtime = testRuntimeFor(connection);
-  runtime.isTestRuntime = false; // Enables checking experimental dialects
-
-  test('generate an error when used without experiment enabled', async () => {
-    const error = await getError(
-      runtime.getModel(`
-        source: s is ${duckdbX}.sql('SELECT 1 as one')
-      `)
+
+  const libURL = 'file:///lib.malloy';
+  const lib = [
+    flag,
+    `source: s is ${duckdbX}.sql('SELECT 1 as one')`,
+    'query: q is s -> { select: one }',
+  ].join('\n');
+
+  function runtime(): SingleConnectionRuntime {
+    return new SingleConnectionRuntime({
+      connection,
+      urlReader: new InMemoryURLReader(new Map([[libURL, lib]])),
+    });
+  }
+
+  /** The one problem a refused compile reports, with the line it points at. */
+  async function refusal(
+    src: string
+  ): Promise<{message: string; line: number | undefined}> {
+    const error = await getError(runtime().getModel(src));
+    expect(error).toBeDefined();
+    const problems = (error as MalloyError).problems;
+    expect(problems).toHaveLength(1);
+    return {
+      message: problems[0].message,
+      line: problems[0].at?.range.start.line,
+    };
+  }
+
+  test('naming a connection on the dialect needs the flag', async () => {
+    const got = await refusal(
+      ['-- line zero', `source: s is ${duckdbX}.sql('SELECT 1 as one')`].join(
+        '\n'
+      )
     );
-    expect(error).not.toBeUndefined();
-    if (error !== undefined) {
-      const problems = (error as MalloyError).problems;
-      expect(problems.length).toBe(1);
-      expect(problems[0].message).toContain(
-        `##! experimental.dialect.${duckdbX}`
+    expect(got.message).toContain(flag);
+    expect(got.line).toBe(1);
+  });
+
+  test.each([['constructor'], ['__proto__'], ['toString']])(
+    'a connection named %s is checked like any other',
+    async connName => {
+      const named = new DuckdbXConnection(duckdbX, ':memory:');
+      named.name = connName;
+      const error = await getError(
+        new SingleConnectionRuntime({connection: named}).getModel(
+          `source: s is ${connName}.sql('SELECT 1 as one')`
+        )
       );
+      expect(error).toBeDefined();
+      expect((error as MalloyError).problems[0].message).toContain(flag);
+      await named.close();
     }
+  );
+
+  test('the flag admits a connection on the dialect', async () => {
+    await runtime().getModel(
+      [flag, `source: s is ${duckdbX}.sql('SELECT 1 as one')`].join('\n')
+    );
   });
 
-  test('does not generate an error when used with experiment enabled', async () => {
-    await runtime.getModel(`
-      ##! experimental.dialect.${duckdbX}
-      source: s is ${duckdbX}.sql('SELECT 1 as one')
-    `);
+  test('importing a source on the dialect needs the flag, reported at the import', async () => {
+    const got = await refusal(
+      ['-- line zero', `import "${libURL}"`, 'run: s -> { select: one }'].join(
+        '\n'
+      )
+    );
+    expect(got.message).toContain(flag);
+    expect(got.line).toBe(1);
+  });
+
+  test('importing only a query on the dialect needs the flag', async () => {
+    const got = await refusal(`import {q} from "${libURL}"`);
+    expect(got.message).toContain(flag);
+  });
+
+  test('the flag admits an import and use of the dialect', async () => {
+    const sql = await runtime()
+      .loadModel([flag, `import "${libURL}"`].join('\n'))
+      .loadQuery('run: s -> { select: one }')
+      .getSQL();
+    expect(sql).toContain('SELECT');
+  });
+
+  test('a query over a model needs nothing of its own', async () => {
+    const sql = await runtime()
+      .loadModel(
+        [flag, `source: s is ${duckdbX}.sql('SELECT 1 as one')`].join('\n')
+      )
+      .loadQuery('run: s -> { select: one }')
+      .getSQL();
+    expect(sql).toContain('SELECT');
+  });
+
+  test('an accepted dialect needs no flag anywhere', async () => {
+    // What the shared-suite harness does once per process for the dialect
+    // under test. Undone below by registering a fresh dialect object.
+    getDialect(duckdbX).acceptExperimental();
+    try {
+      const sql = await runtime()
+        .loadModel(
+          [
+            `import "${libURL}"`,
+            `source: t is ${duckdbX}.sql('SELECT 2 as two')`,
+          ].join('\n')
+        )
+        .loadQuery('run: s -> { select: one }')
+        .getSQL();
+      expect(sql).toContain('SELECT');
+    } finally {
+      registerDialect(new DuckdbXDialect());
+    }
   });
 
   afterAll(async () => {
-    await runtime.connection.close();
+    await connection.close();
     registerDialect(new DuckDBDialect());
   });
 });

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

@@ -79,11 +79,13 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
     `).toMatchResult(testModel, {fieldName: 'one', weight: 51});
   });
 
-  // bigquery doesn't support row count based sampling.
+  // bigquery doesn't support row count based sampling; sqlserver's TABLESAMPLE
+  // returns whole pages, not the count asked for.
   test.when(
     databaseName !== 'bigquery' &&
       databaseName !== 'trino' &&
-      databaseName !== 'presto'
+      databaseName !== 'presto' &&
+      databaseName !== 'sqlserver'
   )(`index rows count - ${databaseName}`, async () => {
     await expect(`
         run: ${databaseName}.table('malloytest.state_facts') extend {

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

@@ -0,0 +1,395 @@
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+
+import {RuntimeList} from '../../runtimes';
+import {describeIfDatabaseAvailable} from '../../util';
+import '@malloydata/malloy/test/matchers';
+import {wrapTestModel} from '@malloydata/malloy/test';
+
+const [describe] = describeIfDatabaseAvailable(['sqlserver']);
+
+/*
+ * The dialect is built up here in the order a query grows: a literal, a
+ * table, a filter, an ordering, a grouping, a join. Each block is what the
+ * next one stands on, and what the cross-dialect suite in ../all assumes.
+ */
+describe('SQL Server', () => {
+  const runtimes = new RuntimeList(['sqlserver']);
+  const runtime = runtimes.runtimeMap.get('sqlserver');
+  if (runtime === undefined) {
+    throw new Error("Couldn't build runtime");
+  }
+  // A test runtime enables experimental dialects; no compiler flag is needed
+  const tm = wrapTestModel(runtime, '');
+
+  afterAll(async () => {
+    await runtimes.closeAll();
+  });
+
+  describe('a SQL block', () => {
+    test('selects a literal', async () => {
+      await expect(
+        'run: sqlserver.sql("SELECT 1 AS n") -> { select: n }'
+      ).toMatchResult(tm, {n: 1});
+    });
+
+    test('carries string, date and timestamp values', async () => {
+      await expect(`
+        run: sqlserver.sql("""
+          SELECT N'héllo' AS s,
+                 CAST('2021-02-24' AS DATE) AS d,
+                 CAST('2021-02-24 03:05:06' AS DATETIME2) AS t
+        """) -> { select: s, d, t }
+      `).toMatchResult(tm, {
+        s: 'héllo',
+        d: new Date('2021-02-24T00:00:00Z'),
+        t: new Date('2021-02-24T03:05:06Z'),
+      });
+    });
+
+    test('carries a newline in a string literal', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT 1 AS n") -> { select: s is 'a\\nb' }
+      `).toMatchResult(tm, {s: 'a\nb'});
+    });
+
+    test('quotes a field named like a keyword', async () => {
+      await expect(`
+        run: sqlserver.sql('SELECT 1 AS "select"') -> {
+          select: \`select\`, \`create\` is \`select\` + 1
+        }
+      `).toMatchResult(tm, {select: 1, create: 2});
+    });
+  });
+
+  describe('a table', () => {
+    test('a boolean literal is a condition', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          where: true
+          aggregate: n is count(), none is count() { where: false }
+        }
+      `).toEqualResult(tm, [{n: 51, none: 0}]);
+    });
+
+    test('a bit column is an integer', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.alltypes') -> {
+          select: t_bool_true, t_bool_false, t_bool_null
+        }
+      `).toEqualResult(tm, [
+        {t_bool_true: 1, t_bool_false: 0, t_bool_null: null},
+      ]);
+    });
+
+    test('a limit of zero is no limit', async () => {
+      // FETCH NEXT 0 ROWS is a parse error; the compiler writes no limit at all
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          select: state
+          limit: 0
+        } -> { aggregate: n is count() }
+      `).toEqualResult(tm, [{n: 51}]);
+    });
+
+    test('a declared boolean is a 0/1 value', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          group_by:
+            big is airport_count > 500
+            c_state is starts_with(state, 'C')
+          aggregate: n is count()
+          order_by: big desc, c_state desc
+        }
+      `).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},
+      ]);
+    });
+
+    test('a cast to boolean is refused', async () => {
+      await expect(
+        runtime
+          .loadQuery(
+            `run: sqlserver.table('malloytest.state_facts') -> {
+              select: b is airport_count::boolean
+            }`
+          )
+          .run()
+      ).rejects.toThrow(/boolean/);
+    });
+
+    test('starts_with and ends_with are conditions', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          aggregate:
+            c_states is count() { where: starts_with(state, 'C') }
+            a_states is count() { where: ends_with(state, 'A') }
+            nan_counts is count() { where: is_nan(airport_count) }
+        }
+      `).toEqualResult(tm, [{c_states: 3, a_states: 8, nan_counts: 0}]);
+    });
+
+    test('reads a column', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          select: state
+          where: state = 'CA'
+        }
+      `).toEqualResult(tm, [{state: 'CA'}]);
+    });
+
+    test('reads a bracket-quoted path', async () => {
+      await expect(`
+        run: sqlserver.table('[malloytest].[state_facts]') -> {
+          select: state
+          where: state = 'CA'
+        }
+      `).toEqualResult(tm, [{state: 'CA'}]);
+    });
+
+    test('reads a database-qualified path', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.malloytest.state_facts') -> {
+          aggregate: n is count()
+        }
+      `).toMatchResult(tm, {n: 51});
+    });
+
+    test('orders and limits', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          select: state
+          order_by: state desc
+          limit: 2
+        }
+      `).toEqualResult(tm, [{state: 'WY'}, {state: 'WV'}]);
+    });
+
+    test('limits a stage that feeds another', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          select: state
+          order_by: state desc
+          limit: 3
+        } -> {
+          select: state
+          order_by: state asc
+        }
+      `).toEqualResult(tm, [{state: 'WI'}, {state: 'WV'}, {state: 'WY'}]);
+    });
+
+    test('filters on a comparison', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          aggregate: n is count()
+          where: airport_count > 500
+        }
+      `).toMatchResult(tm, {n: 12});
+    });
+
+    test('escapes a bracket in a LIKE pattern', async () => {
+      await expect(`
+        run: sqlserver.sql("""
+          SELECT s FROM (VALUES (N'a[b'), (N'ab'), (N'axb')) v(s)
+        """) -> { select: s; where: s ~ 'a[%' }
+      `).toEqualResult(tm, [{s: 'a[b'}]);
+    });
+  });
+
+  describe('aggregation', () => {
+    test('a group of only constants is one row', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> { group_by: x is 1, y is 'a' }
+      `).toEqualResult(tm, [{x: 1, y: 'a'}]);
+    });
+
+    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
+          aggregate: n is count()
+          order_by: big desc
+        }
+      `).toEqualResult(tm, [
+        {tag: 'facts', big: true, n: 12},
+        {tag: 'facts', big: false, n: 39},
+      ]);
+    });
+
+    test('counts without a group', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          aggregate: state_count is count()
+        }
+      `).toMatchResult(tm, {state_count: 51});
+    });
+
+    test('groups by a column', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          group_by: popular_name
+          aggregate: state_count is count()
+          order_by: state_count desc
+        }
+      `).toMatchResult(tm, {popular_name: 'Isabella'});
+    });
+
+    test('groups by an expression', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          group_by: first is substr(state, 1, 1)
+          aggregate: state_count is count()
+          order_by: state_count desc, first
+        }
+      `).toMatchResult(tm, {first: 'M', state_count: 8});
+    });
+
+    test('orders and limits a grouped result', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          group_by: popular_name
+          aggregate: state_count is count()
+          order_by: state_count desc, popular_name
+          limit: 2
+        }
+      `).toEqualResult(tm, [
+        {popular_name: 'Isabella', state_count: 24},
+        {popular_name: 'Sophia', state_count: 11},
+      ]);
+    });
+
+    test('orders a query used as a source', async () => {
+      await expect(`
+        source: by_name is sqlserver.table('malloytest.state_facts') -> {
+          group_by: popular_name
+          aggregate: state_count is count()
+          order_by: state_count desc
+        }
+        run: by_name -> {
+          select: popular_name
+          where: state_count > 10
+          order_by: popular_name
+        }
+      `).toEqualResult(tm, [
+        {popular_name: 'Isabella'},
+        {popular_name: 'Sophia'},
+      ]);
+    });
+
+    test('orders the last stage of a pipeline', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          group_by: popular_name
+          aggregate: state_count is count()
+        } -> {
+          select: popular_name, state_count
+          order_by: state_count asc, popular_name desc
+          limit: 2
+        }
+      `).toEqualResult(tm, [
+        {popular_name: 'Madison', state_count: 3},
+        {popular_name: 'Ava', state_count: 3},
+      ]);
+    });
+
+    test('divides as a float', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT 7 AS a, 2 AS b") -> {
+          select: q is a / b
+        }
+      `).toMatchResult(tm, {q: 3.5});
+    });
+  });
+
+  describe('functions', () => {
+    test('pow computes in floating point', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT 1 AS n") -> {
+          select: root is round(pow(2, 0.5), 6), hundredth is pow(10, -2)
+        }
+      `).toEqualResult(tm, [{root: 1.414214, hundredth: 0.01}]);
+    });
+
+    test('length counts trailing spaces', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT 1 AS n") -> {
+          select:
+            padded is length('abc  ')
+            back is substr('abc ', -2)
+        }
+      `).toEqualResult(tm, [{padded: 5, back: 'c '}]);
+    });
+  });
+
+  describe('time zones', () => {
+    test('converts a query time zone through its Windows name', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT CAST('2020-02-20 00:00:00' AS DATETIME2) AS t") -> {
+          timezone: 'America/Mexico_City'
+          select: mex_day is t.day, mex_hour is hour(t)
+        }
+      `).toMatchResult(tm, {
+        mex_day: new Date('2020-02-19T06:00:00Z'),
+        mex_hour: 18,
+      });
+    });
+
+    test('a zone is known by its current IANA name as well as its old one', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT CAST('2021-02-24 03:05:06' AS DATETIME2) AS t") -> {
+          timezone: 'Asia/Kolkata'
+          select: h is hour(t)
+        }
+      `).toEqualResult(tm, [{h: 8}]);
+      await expect(`
+        run: sqlserver.sql("SELECT CAST('2021-02-24 03:05:06' AS DATETIME2) AS t") -> {
+          timezone: 'Europe/Kyiv'
+          select: h is hour(t)
+        }
+      `).toEqualResult(tm, [{h: 5}]);
+    });
+
+    test('a literal written in a zone is that instant', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT 1 AS n") -> {
+          select: t is @2020-02-20 00:00:00[America/Mexico_City]
+        }
+      `).toMatchResult(tm, {t: new Date('2020-02-20T06:00:00Z')});
+    });
+  });
+
+  describe('joins', () => {
+    test('sums each side of a fan-out once', async () => {
+      await expect(`
+        source: facts is sqlserver.table('malloytest.state_facts')
+        run: facts extend { join_cross: other is facts on other.state = 'CA' | 'NY' } -> {
+          aggregate:
+            row_count is count(concat(state, other.state))
+            left_sum is airport_count.sum()
+            right_sum is other.airport_count.sum()
+        }
+      `).toMatchResult(tm, {row_count: 102, left_sum: 19701, right_sum: 1560});
+    });
+
+    test('joins and aggregates symmetrically', async () => {
+      await expect(`
+        source: carriers is sqlserver.table('malloytest.carriers') extend {
+          primary_key: code
+        }
+        source: flights is sqlserver.table('malloytest.flights') extend {
+          join_one: carriers with carrier
+        }
+        run: flights -> {
+          group_by: carriers.nickname
+          aggregate: flight_count is count(), carrier_count is carriers.count()
+          order_by: flight_count desc
+        }
+      `).toMatchResult(tm, {nickname: 'Southwest', carrier_count: 1});
+    });
+  });
+});

package/src/runtimes.ts

@@ -16,6 +16,7 @@ import {
   InMemoryURLReader,
   InMemoryModelCache,
   CacheManager,
+  getDialect,
 } from '@malloydata/malloy';
 import {createTestRuntime} from '@malloydata/malloy/test';
 import {BigQueryConnection} from '@malloydata/db-bigquery';
@@ -31,6 +32,10 @@ import {
   MySQLExecutor,
 } from '@malloydata/db-mysql/src/mysql_connection';
 import {DatabricksConnection} from '@malloydata/db-databricks/src/databricks_connection';
+import {
+  SQLServerConnection,
+  SQLServerExecutor,
+} from '@malloydata/db-sqlserver/src/sqlserver_connection';
 import {EventEmitter} from 'events';
 
 export class SnowflakeTestConnection extends SnowflakeConnection {
@@ -144,6 +149,21 @@ export class DuckDBWASMTestConnection extends DuckDBWASMConnection {
   }
 }
 
+export class SQLServerTestConnection extends SQLServerConnection {
+  public async runSQL(
+    sqlCommand: string,
+    options?: RunSQLOptions
+  ): Promise<MalloyQueryData> {
+    try {
+      return await super.runSQL(sqlCommand, options);
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.log(`Error in SQL:\n ${sqlCommand}`);
+      throw e;
+    }
+  }
+}
+
 export class TestCacheManager extends CacheManager {
   constructor(readonly _modelCache: ModelCache) {
     super(_modelCache);
@@ -203,15 +223,26 @@ export function runtimeFor(dbName: string): SingleConnectionRuntime {
         );
         break;
       case 'mssql_via_duckdb':
-        connection = new DuckDBTestConnection({
-          name: dbName,
-          additionalExtensions: ['mssql'],
-          setupSQL: [
-            // Must match test/mssql/connection_string.ts
-            "ATTACH 'Server=localhost;Port=1433;Database=malloytest;User Id=sa;Password=Malloy_Test_123;TrustServerCertificate=true' AS msdb (TYPE mssql)",
-            'USE msdb.malloytest',
-          ].join(';\n'),
-        });
+        {
+          const s = SQLServerExecutor.getConnectionOptionsFromEnv();
+          if (s.server === undefined) {
+            throw new Error(
+              'MSSQL_HOST is not set; see test/mssql/mssql_start.sh'
+            );
+          }
+          connection = new DuckDBTestConnection({
+            name: dbName,
+            additionalExtensions: ['mssql'],
+            setupSQL: [
+              // The same string test/mssql/connection_string.ts builds for the
+              // loader, written here because packages/malloy-render type-checks
+              // this file alone and admits no import beside it. `Server=host,port`:
+              // the extension reads no separate Port key.
+              `ATTACH 'Server=${s.server},${s.port ?? 1433};Database=${s.database};User Id=${s.user};Password=${s.password};TrustServerCertificate=${s.trustServerCertificate ?? false}' AS msdb (TYPE mssql)`,
+              `USE msdb.${s.database}`,
+            ].join(';\n'),
+          });
+        }
         break;
       case 'motherduck':
         connection = new DuckDBTestConnection({
@@ -247,6 +278,12 @@ export function runtimeFor(dbName: string): SingleConnectionRuntime {
           TrinoExecutor.getConnectionOptionsFromEnv(dbName) // they share configs.
         );
         break;
+      case 'sqlserver':
+        connection = new SQLServerTestConnection(
+          dbName,
+          SQLServerExecutor.getConnectionOptionsFromEnv()
+        );
+        break;
       case 'databricks':
         {
           const warehouseId = process.env['DATABRICKS_WAREHOUSE_ID'];
@@ -265,6 +302,9 @@ export function runtimeFor(dbName: string): SingleConnectionRuntime {
       default:
         throw new Error(`Unknown runtime "${dbName}`);
     }
+    // The shared suites carry no `##! experimental.dialect.NAME` lines. A
+    // dialect under test is accepted once, for the whole process, instead.
+    getDialect(connection.dialectName).acceptExperimental();
     return testRuntimeFor(connection);
   } catch (error) {
     throw new Error(
@@ -314,7 +354,6 @@ export class RuntimeList {
         database instanceof SingleConnectionRuntime
           ? database
           : runtimeFor(database);
-      rt.isTestRuntime = true;
       this.runtimeMap.set(rt.connection.name, rt);
       this.runtimeList.push([rt.connection.name, rt]);
     }

package/src/test-select.ts

@@ -521,21 +521,17 @@ export class TestSelect {
     const innerQuery = selects.join('\nUNION ALL ');
 
     // Generate ORDER BY based on dialect preference
-    let orderByClause: string;
-    if (this.dialect.orderByClause === 'ordinal') {
-      // ORDER BY position (column count + 1 since row_id is last)
-      orderByClause = `ORDER BY ${columnList.length + 1}`;
-    } else if (this.dialect.orderByClause === 'output_name') {
-      // ORDER BY column name
-      orderByClause = `ORDER BY ${rowIdColumn}`;
-    } else {
-      // ORDER BY expression - just use column name (qualified would be t_sorted.__ts_row_id__)
-      orderByClause = `ORDER BY ${rowIdColumn}`;
-    }
-    // Presto/Trino ignores ORDER BY on a subquery without LIMIT
-    orderByClause += ` LIMIT ${rows.length}`;
+    const orderTerm =
+      this.dialect.orderByClause === 'ordinal'
+        ? `${columnList.length + 1}`
+        : rowIdColumn;
+    // Presto/Trino ignores ORDER BY on a subquery without a row limit
+    const orderByClause = this.dialect.sqlOrderByLimit(
+      [orderTerm],
+      rows.length
+    );
 
-    const sql = `SELECT ${quotedColumns}\nFROM (\n  SELECT *\n  FROM (\n${innerQuery}\n  ) AS t_sorted\n  ${orderByClause}\n) AS t_result\n`;
+    const sql = `SELECT ${quotedColumns}\nFROM (\n  SELECT *\n  FROM (\n${innerQuery}\n  ) AS t_sorted\n  ${orderByClause}) AS t_result\n`;
 
     return sql;
   }

package/tsconfig.json

@@ -34,6 +34,9 @@
     {
       "path": "../packages/malloy-db-snowflake"
     },
+    {
+      "path": "../packages/malloy-db-sqlserver"
+    },
     {
       "path": "../packages/malloy-db-trino"
     },