@malloydata/malloy-tests 0.0.308 → 0.0.310

package/package.json

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

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/databases/postgres/postgres.spec.ts

@@ -120,6 +120,19 @@ describe('Postgres tests', () => {
     ).malloyResultMatches(runtime, {abc: 'a', abc3: 'a3'});
   });
 
+  it('can compute symmetric aggregates on double precisions numbers', async () => {
+    await expect(`source: values is postgres.sql("""
+        SELECT 1::DOUBLE PRECISION as val, 1 as id
+      """) extend { measure: total_value is val.sum() }
+    source: thing is postgres.sql(""" SELECT 1 as id """) extend {
+      join_one: values on values.id = id
+    }
+    run: thing -> {
+      group_by: id
+      aggregate: tenx is 10 * values.total_value
+    }
+    `).malloyResultMatches(runtime, {tenx: 10});
+  });
   describe('time', () => {
     const zone = 'America/Mexico_City'; // -06:00 no DST
     const zone_2020 = DateTime.fromObject(

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}""")
+`;
+*/