@malloydata/malloy-tests 0.0.309 → 0.0.311

package/package.json

@@ -21,14 +21,14 @@
   },
   "dependencies": {
     "@jest/globals": "^29.4.3",
-    "@malloydata/db-bigquery": "0.0.309",
-    "@malloydata/db-duckdb": "0.0.309",
-    "@malloydata/db-postgres": "0.0.309",
-    "@malloydata/db-snowflake": "0.0.309",
-    "@malloydata/db-trino": "0.0.309",
-    "@malloydata/malloy": "0.0.309",
-    "@malloydata/malloy-tag": "0.0.309",
-    "@malloydata/render": "0.0.309",
+    "@malloydata/db-bigquery": "0.0.311",
+    "@malloydata/db-duckdb": "0.0.311",
+    "@malloydata/db-postgres": "0.0.311",
+    "@malloydata/db-snowflake": "0.0.311",
+    "@malloydata/db-trino": "0.0.311",
+    "@malloydata/malloy": "0.0.311",
+    "@malloydata/malloy-tag": "0.0.311",
+    "@malloydata/render": "0.0.311",
     "events": "^3.3.0",
     "jsdom": "^22.1.0",
     "luxon": "^2.4.0",
@@ -38,5 +38,5 @@
     "@types/jsdom": "^21.1.1",
     "@types/luxon": "^2.4.0"
   },
-  "version": "0.0.309"
+  "version": "0.0.311"
 }

package/postgres/postgres_start.sh

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

package/postgres/postgres_stop.sh

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

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

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

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

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

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

@@ -0,0 +1,297 @@
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+
+import {RuntimeList, allDatabases} from '../../runtimes';
+import '../../util/db-jest-matchers';
+import {databasesFromEnvironmentOr} from '../../util';
+import {TestSelect} from '../../test-select';
+
+const runtimes = new RuntimeList(databasesFromEnvironmentOr(allDatabases));
+
+describe.each(runtimes.runtimeList)('TestSelect for %s', (db, runtime) => {
+  const d = runtime.dialect;
+  const ts = new TestSelect(runtime.dialect);
+
+  // Basic Type Tests
+  test(`${db} inferred basic types`, async () => {
+    const sql = ts.generate(
+      {t_int: 1, t_string: 'a', t_bool: d.resultBoolean(true), t_float: 1.5},
+      {t_int: 2, t_string: 'b', t_bool: d.resultBoolean(false), t_float: 2.5}
+    );
+    await expect(`run: ${db}.sql("""${sql}""")`).malloyResultMatches(runtime, [
+      {t_int: 1, t_string: 'a', t_bool: d.resultBoolean(true), t_float: 1.5},
+      {t_int: 2, t_string: 'b', t_bool: d.resultBoolean(false), t_float: 2.5},
+    ]);
+  });
+
+  test(`${db} explicit type hints`, async () => {
+    const sql = ts.generate({
+      t_int: ts.mk_int(1),
+      t_float: ts.mk_float(1.5),
+      t_string: ts.mk_string('hello'),
+      t_bool: ts.mk_bool(true),
+    });
+    await expect(`run: ${db}.sql("""${sql}""")`).malloyResultMatches(runtime, [
+      {
+        t_int: 1,
+        t_float: 1.5,
+        t_string: 'hello',
+        t_bool: d.resultBoolean(true),
+      },
+    ]);
+  });
+
+  test(`${db} NULL handling with typed nulls`, async () => {
+    const sql = ts.generate({
+      t_int: ts.mk_int(null),
+      t_string: ts.mk_string(null),
+      t_bool: ts.mk_bool(null),
+      t_float: ts.mk_float(null),
+    });
+    await expect(`run: ${db}.sql("""${sql}""")`).malloyResultMatches(runtime, [
+      {t_int: null, t_string: null, t_bool: null, t_float: null},
+    ]);
+  });
+
+  test(`${db} mixed nulls and values`, async () => {
+    const sql = ts.generate(
+      {a: 1, b: ts.mk_int(null), c: 'hello'},
+      {a: ts.mk_int(null), b: 2, c: 'world'},
+      {a: 3, b: 4, c: ts.mk_string(null)}
+    );
+    await expect(`run: ${db}.sql("""${sql}""")`).malloyResultMatches(runtime, [
+      {a: 1, b: null, c: 'hello'},
+      {a: null, b: 2, c: 'world'},
+      {a: 3, b: 4, c: null},
+    ]);
+  });
+
+  // Cast Behavior Tests
+  test(`${db} float casting`, async () => {
+    const sql = ts.generate({
+      f1: ts.mk_float(1.0),
+      f2: ts.mk_float(2.5),
+    });
+    // Verify SQL contains CAST for floats
+    expect(sql).toContain('CAST');
+  });
+
+  test(`${db} integer no unnecessary cast`, async () => {
+    const sql = ts.generate({
+      i1: ts.mk_int(1),
+      i2: ts.mk_int(2),
+    });
+    // Check that integers don't get unnecessary CAST (only in column alias)
+    const castCount = (sql.match(/CAST/g) || []).length;
+    expect(castCount).toBe(0);
+  });
+
+  // Edge Cases
+  test(`${db} single row`, async () => {
+    const sql = ts.generate({a: 1, b: 'test'});
+    await expect(`run: ${db}.sql("""${sql}""")`).malloyResultMatches(runtime, [
+      {a: 1, b: 'test'},
+    ]);
+  });
+
+  // Array Tests - Inferred
+  test(`${db} inferred arrays`, async () => {
+    const sql = ts.generate({
+      string_array: ['a', 'b', 'c'],
+      number_array: [1, 2, 3],
+    });
+    await expect(`run: ${db}.sql("""${sql}""")`).malloyResultMatches(runtime, [
+      {string_array: ['a', 'b', 'c'], number_array: [1, 2, 3]},
+    ]);
+  });
+
+  // Array Tests - Explicit mk_array
+  test(`${db} explicit array creation with mk_array`, async () => {
+    const sql = ts.generate({
+      string_arr: ts.mk_array(['a', 'b', 'c']),
+      number_arr: ts.mk_array([1, 2, 3]),
+      typed_arr: ts.mk_array([ts.mk_int(1), ts.mk_int(2), ts.mk_int(3)]),
+    });
+    await expect(`run: ${db}.sql("""${sql}""")`).malloyResultMatches(runtime, [
+      {
+        string_arr: ['a', 'b', 'c'],
+        number_arr: [1, 2, 3],
+        typed_arr: [1, 2, 3],
+      },
+    ]);
+  });
+
+  // mysql and postgres don't have literal records that Malloy can read
+  // so when reading a record, it will just see json
+  const testRecords = db !== 'mysql' && db !== 'postgres';
+
+  describe('tests involving records', () => {
+    // Record Tests - Inferred
+    test.when(testRecords)(`${db} simple inferred records`, async () => {
+      const sql = ts.generate({
+        person: {name: 'Alice', age: 30},
+      });
+      await expect(`run: ${db}.sql("""${sql}""")`).malloyResultMatches(
+        runtime,
+        {
+          'person/name': 'Alice',
+          'person/age': 30,
+        }
+      );
+    });
+
+    test.when(testRecords)(`${db} nested inferred records`, async () => {
+      const sql = ts.generate({
+        user: {
+          name: 'Bob',
+          address: {
+            street: '123 Main',
+            city: 'Boston',
+          },
+        },
+      });
+      await expect(`run: ${db}.sql("""${sql}""")`).matchesRows(runtime, {
+        user: {name: 'Bob', address: {street: '123 Main', city: 'Boston'}},
+      });
+    });
+
+    // Record Tests - Explicit mk_record
+    test.when(testRecords)(
+      `${db} explicit record creation with mk_record`,
+      async () => {
+        const sql = ts.generate({
+          person: ts.mk_record({
+            name: ts.mk_string('Alice'),
+            age: ts.mk_int(30),
+            active: ts.mk_bool(true),
+          }),
+        });
+        await expect(`run: ${db}.sql("""${sql}""")`).matchesRows(runtime, {
+          person: {name: 'Alice', age: 30, active: d.resultBoolean(true)},
+        });
+      }
+    );
+
+    test.when(testRecords)(`${db} nested records with mk_record`, async () => {
+      const sql = ts.generate({
+        user: ts.mk_record({
+          name: ts.mk_string('Bob'),
+          address: ts.mk_record({
+            street: ts.mk_string('123 Main'),
+            city: ts.mk_string('Boston'),
+            zip: ts.mk_int(12345),
+          }),
+        }),
+      });
+      await expect(`run: ${db}.sql("""${sql}""")`).matchesRows(runtime, {
+        user: {
+          name: 'Bob',
+          address: {street: '123 Main', city: 'Boston', zip: 12345},
+        },
+      });
+    });
+
+    test.when(testRecords)(`${db} records with arrays`, async () => {
+      const sql = ts.generate({
+        data: {
+          name: 'Test',
+          values: [1, 2, 3],
+        },
+      });
+      await expect(`run: ${db}.sql("""${sql}""")`).matchesRows(runtime, {
+        data: {name: 'Test', values: [1, 2, 3]},
+      });
+    });
+
+    // Array of Records Tests - Inferred
+    test.when(testRecords)(`${db} inferred repeated records`, async () => {
+      const sql = ts.generate({
+        items: [
+          {sku: 'ABC', qty: 2},
+          {sku: 'DEF', qty: 3},
+        ],
+      });
+      await expect(`run: ${db}.sql("""${sql}""")`).malloyResultMatches(
+        runtime,
+        [
+          {
+            items: [
+              {sku: 'ABC', qty: 2},
+              {sku: 'DEF', qty: 3},
+            ],
+          },
+        ]
+      );
+    });
+
+    // Array of Records Tests - Explicit
+    test.when(testRecords)(
+      `${db} array of records with mk_array and mk_record`,
+      async () => {
+        const sql = ts.generate({
+          items: ts.mk_array([
+            ts.mk_record({sku: ts.mk_string('ABC'), qty: ts.mk_int(2)}),
+            ts.mk_record({sku: ts.mk_string('DEF'), qty: ts.mk_int(3)}),
+          ]),
+        });
+        await expect(`run: ${db}.sql("""${sql}""")`).malloyResultMatches(
+          runtime,
+          [
+            {
+              items: [
+                {sku: 'ABC', qty: 2},
+                {sku: 'DEF', qty: 3},
+              ],
+            },
+          ]
+        );
+      }
+    );
+  });
+
+  // Date/Time Tests
+  test(`${db} date literals`, async () => {
+    const sql = ts.generate({
+      d1: ts.mk_date('2024-01-15'),
+      d2: ts.mk_date('2024-12-31'),
+    });
+    await expect(`run: ${db}.sql("""${sql}""")`).malloyResultMatches(runtime, [
+      {d1: new Date('2024-01-15'), d2: new Date('2024-12-31')},
+    ]);
+  });
+
+  test.when(db !== 'presto' && db !== 'trino')(
+    `${db} timestamp literals`,
+    async () => {
+      const sql = ts.generate({
+        ts1: ts.mk_timestamp('2024-01-15 10:30:00'),
+        ts2: ts.mk_timestamp('2024-12-31 23:59:59'),
+      });
+      await expect(`run: ${db}.sql("""${sql}""")`).malloyResultMatches(
+        runtime,
+        [
+          {
+            ts1: new Date('2024-01-15T10:30:00Z'),
+            ts2: new Date('2024-12-31T23:59:59Z'),
+          },
+        ]
+      );
+    }
+  );
+
+  test(`${db} null dates and timestamps`, async () => {
+    const sql = ts.generate({
+      d: ts.mk_date(null),
+      ts: ts.mk_timestamp(null),
+    });
+    await expect(`run: ${db}.sql("""${sql}""")`).malloyResultMatches(runtime, [
+      {d: null, ts: null},
+    ]);
+  });
+});
+
+afterAll(async () => {
+  await runtimes.closeAll();
+});

package/src/databases/duckdb/nested_source_table.spec.ts

@@ -21,9 +21,6 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-/* eslint-disable no-console */
-
 import '../../util/db-jest-matchers';
 import {RuntimeList} from '../../runtimes';
 import {describeIfDatabaseAvailable} from '../../util';

package/src/test-select.ts

@@ -0,0 +1,602 @@
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+
+import type {
+  Dialect,
+  QueryInfo,
+  AtomicTypeDef,
+  ArrayLiteralNode,
+  RecordLiteralNode,
+  Expr,
+  TypecastExpr,
+  FieldDef,
+} from '@malloydata/malloy';
+
+import {constantExprToSQL, mkFieldDef} from '@malloydata/malloy';
+
+interface TypedValue {
+  expr: Expr;
+  malloyType: AtomicTypeDef;
+  needsCast?: boolean;
+}
+
+// Valid value types for inferrable types
+type PrimitiveValue = string | number | boolean | null;
+
+// Test data value types
+type TestValue =
+  | PrimitiveValue
+  | TestValue[]
+  | {[key: string]: TestValue}
+  | TypedValue;
+
+const nullExpr: Expr = {node: 'null'};
+
+interface TestDataRow {
+  [columnName: string]: TestValue;
+}
+
+/**
+ * TestSelect - Generate dialect-specific SQL test data from JavaScript objects
+ *
+ * TestSelect provides a simple, type-safe way to generate SQL SELECT statements
+ * that produce test data across different SQL dialects. It handles dialect-specific
+ * differences in literal syntax, type casting, and complex types (arrays/records).
+ *
+ * @example Basic usage with inferred types
+ * ```typescript
+ * const ts = new TestSelect(dialect);
+ * const sql = ts.generate(
+ *   {id: 1, name: "Alice", active: true},
+ *   {id: 2, name: "Bob", active: false}
+ * );
+ * // Generates: SELECT 1 AS "id", 'Alice' AS "name", true AS "active"
+ * //           UNION ALL SELECT 2, 'Bob', false
+ * ```
+ *
+ * @example Explicit type hints for precision
+ * ```typescript
+ * const sql = ts.generate({
+ *   id: ts.mk_int(1),
+ *   score: ts.mk_float(95.5),    // Forces float type (gets CAST)
+ *   name: ts.mk_string("Test"),
+ *   active: ts.mk_bool(true),
+ *   created: ts.mk_timestamp('2024-01-15 10:30:00'),
+ *   birthday: ts.mk_date('1990-05-20')
+ * });
+ * ```
+ *
+ * @example Handling NULL values with proper typing
+ * ```typescript
+ * const sql = ts.generate({
+ *   id: ts.mk_int(1),
+ *   email: ts.mk_string(null),    // Typed NULL - generates CAST(NULL AS VARCHAR)
+ *   score: ts.mk_float(null)      // Typed NULL - generates CAST(NULL AS FLOAT)
+ * });
+ * ```
+ *
+ * @example Arrays and records (for dialects that support them)
+ * ```typescript
+ * const sql = ts.generate({
+ *   tags: ['red', 'blue', 'green'],              // Inferred array
+ *   scores: ts.mk_array([85, 90, 95]),          // Explicit array
+ *   address: {street: '123 Main', city: 'NYC'}, // Inferred record
+ *   user: ts.mk_record({                        // Explicit record
+ *     name: ts.mk_string('Alice'),
+ *     age: ts.mk_int(30)
+ *   })
+ * });
+ * ```
+ *
+ * @example Arrays of records (repeated records in Malloy)
+ * ```typescript
+ * const sql = ts.generate({
+ *   orders: [
+ *     {item: 'Widget', qty: 5, price: 10.00},
+ *     {item: 'Gadget', qty: 2, price: 25.00}
+ *   ]
+ * });
+ * ```
+ *
+ * Type inference rules:
+ * - JavaScript number → INTEGER if whole number, FLOAT if decimal
+ * - JavaScript string → VARCHAR/TEXT (dialect decides)
+ * - JavaScript boolean → BOOLEAN
+ * - JavaScript Date → TIMESTAMP
+ * - JavaScript array → ARRAY (if supported by dialect)
+ * - JavaScript object → RECORD/STRUCT (if supported by dialect)
+ * - null/undefined → defaults to STRING type (use mk_* functions for typed nulls)
+ *
+ * CAST behavior:
+ * - NULLs always get CAST to ensure proper typing
+ * - Floats always get CAST to ensure they're treated as floating point
+ * - Other types generally don't need CAST (dialect handles conversion)
+ *
+ * Important notes:
+ * - First row determines column types when using inference
+ * - Use mk_* functions for nulls in first row to ensure correct types
+ * - Not all dialects support arrays and records
+ * - Timestamps are generated in UTC by default
+ * - Large integers can be passed as strings: mk_int('9223372036854775807')
+ *
+ * @param dialect - The SQL dialect to generate for (from Malloy)
+ * @param queryTimezone - Timezone for timestamp literals (default: 'UTC')
+ */
+export class TestSelect {
+  private qi: QueryInfo;
+
+  constructor(
+    private dialect: Dialect,
+    queryTimezone = 'UTC'
+  ) {
+    this.qi = {queryTimezone};
+  }
+
+  // ============= Type hint methods =============
+
+  mk_int(value: number | string | null): TypedValue {
+    const malloyType: AtomicTypeDef = {type: 'number', numberType: 'integer'};
+
+    if (value === null) {
+      const castExpr: TypecastExpr = {
+        node: 'cast',
+        e: nullExpr,
+        dstType: {type: 'number', numberType: 'integer'},
+        safe: false,
+      };
+
+      return {
+        expr: castExpr,
+        malloyType,
+        needsCast: true,
+      };
+    }
+
+    return {
+      expr: {
+        node: 'numberLiteral',
+        literal: String(value),
+      },
+      malloyType,
+      needsCast: false,
+    };
+  }
+
+  mk_float(value: number | string | null): TypedValue {
+    const malloyType: AtomicTypeDef = {type: 'number', numberType: 'float'};
+
+    if (value === null) {
+      const castExpr: TypecastExpr = {
+        node: 'cast',
+        e: nullExpr,
+        dstType: {type: 'number', numberType: 'float'},
+        safe: false,
+      };
+
+      return {
+        expr: castExpr,
+        malloyType,
+        needsCast: true,
+      };
+    }
+
+    return {
+      expr: {
+        node: 'numberLiteral',
+        literal: String(value),
+      },
+      malloyType,
+      needsCast: true, // floats always need cast
+    };
+  }
+
+  mk_string(value: string | null): TypedValue {
+    const malloyType: AtomicTypeDef = {type: 'string'};
+
+    if (value === null) {
+      const castExpr: TypecastExpr = {
+        node: 'cast',
+        e: nullExpr,
+        dstType: {type: 'string'},
+        safe: false,
+      };
+
+      return {
+        expr: castExpr,
+        malloyType,
+        needsCast: true,
+      };
+    }
+
+    return {
+      expr: {
+        node: 'stringLiteral',
+        literal: value,
+      },
+      malloyType,
+      needsCast: false,
+    };
+  }
+
+  mk_bool(value: boolean | null): TypedValue {
+    const malloyType: AtomicTypeDef = {type: 'boolean'};
+
+    if (value === null) {
+      const castExpr: TypecastExpr = {
+        node: 'cast',
+        e: nullExpr,
+        dstType: {type: 'boolean'},
+        safe: false,
+      };
+
+      return {
+        expr: castExpr,
+        malloyType,
+        needsCast: true,
+      };
+    }
+
+    return {
+      expr: value ? {node: 'true'} : {node: 'false'},
+      malloyType,
+      needsCast: false,
+    };
+  }
+
+  mk_date(value: string | null): TypedValue {
+    const malloyType: AtomicTypeDef = {type: 'date'};
+
+    if (value === null) {
+      const castExpr: TypecastExpr = {
+        node: 'cast',
+        e: nullExpr,
+        dstType: {type: 'date'},
+        safe: false,
+      };
+
+      return {
+        expr: castExpr,
+        malloyType,
+        needsCast: true,
+      };
+    }
+
+    return {
+      expr: {
+        node: 'timeLiteral',
+        literal: value,
+        typeDef: {type: 'date'},
+      },
+      malloyType,
+      needsCast: false,
+    };
+  }
+
+  mk_timestamp(value: string | null): TypedValue {
+    const malloyType: AtomicTypeDef = {type: 'timestamp'};
+
+    if (value === null) {
+      const castExpr: TypecastExpr = {
+        node: 'cast',
+        e: nullExpr,
+        dstType: {type: 'timestamp'},
+        safe: false,
+      };
+
+      return {
+        expr: castExpr,
+        malloyType,
+        needsCast: true,
+      };
+    }
+
+    return {
+      expr: {
+        node: 'timeLiteral',
+        literal: value,
+        typeDef: {type: 'timestamp'},
+      },
+      malloyType,
+      needsCast: false,
+    };
+  }
+
+  mk_array(values: TestValue[]): TypedValue {
+    if (values.length === 0) {
+      throw new Error(
+        'Cannot create empty array - need at least one element to infer type'
+      );
+    }
+
+    // Convert all values to TypedValues
+    const typedValues = values.map(v => this.toTypedValue(v));
+    const firstElement = typedValues[0];
+
+    // Check if it's an array of records (repeated record)
+    if (firstElement.malloyType.type === 'record') {
+      // For repeated records, Malloy uses a special structure
+      const recordType = firstElement.malloyType;
+      if (!('fields' in recordType)) {
+        throw new Error('Record type missing fields');
+      }
+
+      const arrayExpr: ArrayLiteralNode = {
+        node: 'arrayLiteral',
+        kids: {values: typedValues.map(tv => tv.expr)},
+        typeDef: {
+          type: 'array',
+          elementTypeDef: {type: 'record_element'},
+          fields: recordType.fields,
+        },
+      };
+
+      return {
+        expr: arrayExpr,
+        malloyType: {
+          type: 'array',
+          elementTypeDef: {type: 'record_element'},
+          fields: recordType.fields,
+        },
+        needsCast: false,
+      };
+    } else {
+      // For basic arrays (non-record elements)
+      const elementType = firstElement.malloyType;
+
+      const arrayExpr: ArrayLiteralNode = {
+        node: 'arrayLiteral',
+        kids: {values: typedValues.map(tv => tv.expr)},
+        typeDef: {type: 'array', elementTypeDef: elementType},
+      };
+
+      return {
+        expr: arrayExpr,
+        malloyType: {type: 'array', elementTypeDef: elementType},
+        needsCast: false,
+      };
+    }
+  }
+
+  mk_record(value: Record<string, TestValue>): TypedValue {
+    const kids: Record<string, Expr> = {};
+    const fields: FieldDef[] = []; // Explicitly type the array
+
+    for (const [key, val] of Object.entries(value)) {
+      const typed = this.toTypedValue(val);
+      fields.push(mkFieldDef(typed.malloyType, key));
+      kids[key] = typed.expr;
+    }
+
+    const recordExpr: RecordLiteralNode = {
+      node: 'recordLiteral',
+      kids,
+      typeDef: {type: 'record', fields},
+    };
+
+    return {
+      expr: recordExpr,
+      malloyType: {type: 'record', fields},
+      needsCast: false,
+    };
+  }
+
+  // ============= Main generation method =============
+
+  /**
+   * Generate SQL from test data rows
+   */
+  generate(...rows: TestDataRow[]): string {
+    if (!Array.isArray(rows) || rows.length === 0) {
+      throw new Error('generate() requires a non-empty array of rows');
+    }
+
+    // Collect all column names from all rows (preserving order from first occurrence)
+    const columnList: string[] = [];
+    const columnSet = new Set<string>();
+    for (const row of rows) {
+      for (const colName of Object.keys(row)) {
+        if (!columnSet.has(colName)) {
+          columnList.push(colName);
+          columnSet.add(colName);
+        }
+      }
+    }
+
+    const needsOrdering = rows.length > 1;
+    // Two reasons to quote a column name, neither matter here:
+    // 1) snowflake uppercases unquoted names
+    // 2) it is a reserved word in the dialect
+    const rowIdColumn = '__ts_n__';
+
+    // Generate SELECT statements
+    const selects = rows.map((row, idx) => {
+      const fields: string[] = [];
+
+      for (const colName of columnList) {
+        const value = row[colName] ?? null;
+        const typedValue = this.toTypedValue(value);
+        const sql = this.exprToSQL(typedValue.expr);
+
+        if (idx === 0) {
+          // First row: include column aliases and explicit casts if needed
+          const quotedName = this.dialect.sqlMaybeQuoteIdentifier(colName);
+          if (typedValue.needsCast) {
+            const sqlType = this.dialect.malloyTypeToSQLType(
+              typedValue.malloyType
+            );
+            fields.push(`CAST(${sql} AS ${sqlType}) AS ${quotedName}`);
+          } else {
+            fields.push(`${sql} AS ${quotedName}`);
+          }
+        } else {
+          // Subsequent rows: just the values in same order
+          fields.push(sql);
+        }
+      }
+
+      // Add row ID at the end if we have multiple rows
+      if (needsOrdering) {
+        if (idx === 0) {
+          fields.push(`${idx} AS ${rowIdColumn}`);
+        } else {
+          fields.push(`${idx}`);
+        }
+      }
+
+      return `SELECT ${fields.join(', ')}`;
+    });
+
+    // Single row: just return the SELECT
+    if (!needsOrdering) {
+      return selects[0] + '\n';
+    }
+
+    // Multiple rows: double wrap - inner for sorting, outer for column selection
+    const quotedColumns = columnList
+      .map(col => this.dialect.sqlMaybeQuoteIdentifier(col))
+      .join(', ');
+    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 sql = `SELECT ${quotedColumns}\nFROM (\n  SELECT *\n  FROM (\n${innerQuery}\n  ) AS t_sorted\n  ${orderByClause}\n) AS t_result\n`;
+
+    return sql;
+  }
+
+  // ============= Private helper methods =============
+
+  private toTypedValue(value: TestValue): TypedValue {
+    // If already typed, return it
+    if (this.isTypedValue(value)) {
+      return value;
+    }
+
+    // Handle null/undefined
+    if (value === null) {
+      return {
+        expr: nullExpr,
+        malloyType: {type: 'sql native'}, // to ensure a cast happens
+        needsCast: true,
+      };
+    }
+
+    // Infer from JavaScript type
+    if (typeof value === 'string') {
+      return this.mk_string(value);
+    }
+
+    if (typeof value === 'boolean') {
+      return this.mk_bool(value);
+    }
+
+    if (typeof value === 'number') {
+      if (Number.isInteger(value)) {
+        return this.mk_int(value);
+      } else {
+        return this.mk_float(value);
+      }
+    }
+
+    if (Array.isArray(value)) {
+      return this.mk_array(value);
+    }
+
+    if (typeof value === 'object' && Object.keys(value).length > 0) {
+      return this.mk_record(value);
+    }
+
+    throw new Error(`Cannot convert value to TypedValue: ${value}`);
+  }
+
+  private exprToSQL(expr: Expr): string {
+    const result = constantExprToSQL(expr, this.dialect, {});
+    if (result.sql) {
+      return result.sql;
+    }
+    if (result.error) {
+      throw new Error(`Failed to generate SQL: ${result.error}`);
+    }
+    throw new Error(`Error in SQL generation for ${JSON.stringify(expr)}`);
+  }
+
+  private isTypedValue(value: unknown): value is TypedValue {
+    return (
+      value !== null &&
+      typeof value === 'object' &&
+      'expr' in value &&
+      'malloyType' in value
+    );
+  }
+}
+
+/*
+Example usage:
+
+const testSelect = new TestSelect(dialect);
+
+const userSQL = testSelect.generate([
+  {
+    id: testSelect.mk_int(1),
+    name: "bob",
+    email: "bob@example.com",
+    score: testSelect.mk_float(85.5),
+    is_active: testSelect.mk_bool(true),
+    created_at: testSelect.mk_timestamp('2024-01-15 14:30:00'),
+    signup_date: testSelect.mk_date('2024-01-15'),
+    tags: ["admin", "user"],  // Inferred as array
+    settings: {                // Inferred as record
+      theme: "dark",
+      notifications: true
+    }
+  },
+  {
+    id: testSelect.mk_int(2),
+    name: "alice",
+    email: testSelect.mk_string(null),  // Typed NULL
+    score: testSelect.mk_float(92.0),
+    is_active: testSelect.mk_bool(false),
+    created_at: testSelect.mk_timestamp('2024-01-16 09:00:00'),
+    signup_date: testSelect.mk_date('2024-01-16'),
+    tags: ["user"],
+    settings: {
+      theme: "light",
+      notifications: false
+    }
+  }
+]);
+
+const orderSQL = testSelect.generate([
+  {
+    id: 1,  // Inferred as integer
+    user_id: testSelect.mk_int(1),
+    amount: 99.99,  // Inferred as float
+    status: "pending",
+    items: [
+      {sku: "ABC", qty: 2, price: 10.00},
+      {sku: "DEF", qty: 1, price: 20.00}
+    ]
+  }
+]);
+
+// Use in Malloy:
+const malloySource = `
+  source: users is duckdb.sql("""${userSQL}""")
+  source: orders is duckdb.sql("""${orderSQL}""")
+`;
+*/