@malloydata/malloy-tests 0.0.434 → 0.0.436

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`; 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).
 
@@ -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. 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/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.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",
@@ -42,5 +43,5 @@
   "overrides": {
     "typescript": "^6.0.3"
   },
-  "version": "0.0.434"
+  "version": "0.0.436"
 }

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/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');
+    });
+  });
 });