@avidian/duckdb-bun 0.0.0-stage → 1.0.0

package/vendor/node-api/src/createValue.ts

@@ -0,0 +1,355 @@
+import duckdb, { Value } from "../../../src/bindings/index.ts";
+import { DuckDBType } from './DuckDBType';
+import { DuckDBTypeId } from './DuckDBTypeId';
+import { typeForValue } from './typeForValue';
+import {
+  DuckDBArrayValue,
+  DuckDBBitValue,
+  DuckDBBlobValue,
+  DuckDBDateValue,
+  DuckDBDecimalValue,
+  DuckDBGeometryValue,
+  DuckDBIntervalValue,
+  DuckDBListValue,
+  DuckDBMapValue,
+  DuckDBStructValue,
+  DuckDBTimeNSValue,
+  DuckDBTimestampMillisecondsValue,
+  DuckDBTimestampNanosecondsValue,
+  DuckDBTimestampSecondsValue,
+  DuckDBTimestampTZValue,
+  DuckDBTimestampTZNanosecondsValue,
+  DuckDBTimestampValue,
+  DuckDBTimeTZValue,
+  DuckDBTimeValue,
+  DuckDBTupleValue,
+  DuckDBUnionValue,
+  DuckDBUUIDValue,
+  DuckDBValue,
+  DuckDBVariantValue,
+} from './values';
+
+export function createValue(type: DuckDBType, input: DuckDBValue): Value {
+  if (input === null) {
+    return duckdb.create_null_value();
+  }
+  const { typeId } = type;
+  switch (typeId) {
+    case DuckDBTypeId.BOOLEAN:
+      if (typeof input === 'boolean') {
+        return duckdb.create_bool(input);
+      }
+      throw new Error(`input is not a boolean`);
+    case DuckDBTypeId.TINYINT:
+      if (typeof input === 'number') {
+        return duckdb.create_int8(input);
+      }
+      throw new Error(`input is not a number`);
+    case DuckDBTypeId.SMALLINT:
+      if (typeof input === 'number') {
+        return duckdb.create_int16(input);
+      }
+      throw new Error(`input is not a number`);
+    case DuckDBTypeId.INTEGER:
+      if (typeof input === 'number') {
+        return duckdb.create_int32(input);
+      }
+      throw new Error(`input is not a number`);
+    case DuckDBTypeId.BIGINT:
+      if (typeof input === 'bigint' || typeof input === 'number') {
+        return duckdb.create_int64(BigInt(input));
+      }
+      throw new Error(`input is not a bigint`);
+    case DuckDBTypeId.UTINYINT:
+      if (typeof input === 'number') {
+        return duckdb.create_uint8(input);
+      }
+      throw new Error(`input is not a number`);
+    case DuckDBTypeId.USMALLINT:
+      if (typeof input === 'number') {
+        return duckdb.create_uint16(input);
+      }
+      throw new Error(`input is not a number`);
+    case DuckDBTypeId.UINTEGER:
+      if (typeof input === 'number') {
+        return duckdb.create_uint32(input);
+      }
+      throw new Error(`input is not a number`);
+    case DuckDBTypeId.UBIGINT:
+      if (typeof input === 'bigint' || typeof input === 'number') {
+        return duckdb.create_uint64(BigInt(input));
+      }
+      throw new Error(`input is not a bigint`);
+    case DuckDBTypeId.FLOAT:
+      if (typeof input === 'number') {
+        return duckdb.create_float(input);
+      }
+      throw new Error(`input is not a number`);
+    case DuckDBTypeId.DOUBLE:
+      if (typeof input === 'number') {
+        return duckdb.create_double(input);
+      }
+      throw new Error(`input is not a number`);
+    case DuckDBTypeId.TIMESTAMP:
+      if (input instanceof DuckDBTimestampValue) {
+        return duckdb.create_timestamp(input);
+      }
+      throw new Error(`input is not a DuckDBTimestampValue`);
+    case DuckDBTypeId.DATE:
+      if (input instanceof DuckDBDateValue) {
+        return duckdb.create_date(input);
+      }
+      throw new Error(`input is not a DuckDBDateValue`);
+    case DuckDBTypeId.TIME:
+      if (input instanceof DuckDBTimeValue) {
+        return duckdb.create_time(input);
+      }
+      throw new Error(`input is not a DuckDBTimeValue`);
+    case DuckDBTypeId.INTERVAL:
+      if (input instanceof DuckDBIntervalValue) {
+        return duckdb.create_interval(input);
+      }
+      throw new Error(`input is not a DuckDBIntervalValue`);
+    case DuckDBTypeId.HUGEINT:
+      if (typeof input === 'bigint') {
+        return duckdb.create_hugeint(input);
+      }
+      throw new Error(`input is not a bigint`);
+    case DuckDBTypeId.UHUGEINT:
+      if (typeof input === 'bigint') {
+        return duckdb.create_uhugeint(input);
+      }
+      throw new Error(`input is not a bigint`);
+    case DuckDBTypeId.VARCHAR:
+      if (typeof input === 'string') {
+        return duckdb.create_varchar(input);
+      }
+      throw new Error(`input is not a string`);
+    case DuckDBTypeId.BLOB:
+      if (input instanceof DuckDBBlobValue) {
+        return duckdb.create_blob(input.bytes);
+      }
+      throw new Error(`input is not a DuckDBBlobValue`);
+    case DuckDBTypeId.DECIMAL:
+      if (input instanceof DuckDBDecimalValue) {
+        return duckdb.create_decimal(input);
+      }
+      throw new Error(`input is not a DuckDBDecimalValue`);
+    case DuckDBTypeId.TIMESTAMP_S:
+      if (input instanceof DuckDBTimestampSecondsValue) {
+        return duckdb.create_timestamp_s(input);
+      }
+      throw new Error(`input is not a DuckDBTimestampSecondsValue`);
+    case DuckDBTypeId.TIMESTAMP_MS:
+      if (input instanceof DuckDBTimestampMillisecondsValue) {
+        return duckdb.create_timestamp_ms(input);
+      }
+      throw new Error(`input is not a DuckDBTimestampMillisecondsValue`);
+    case DuckDBTypeId.TIMESTAMP_NS:
+      if (input instanceof DuckDBTimestampNanosecondsValue) {
+        return duckdb.create_timestamp_ns(input);
+      }
+      throw new Error(`input is not a DuckDBTimestampNanosecondsValue`);
+    case DuckDBTypeId.ENUM:
+      if (typeof input === 'string') {
+        return duckdb.create_enum_value(
+          type.toLogicalType().logical_type,
+          type.indexForValue(input)
+        );
+      }
+      throw new Error(`input is not a string`);
+    case DuckDBTypeId.LIST:
+      if (input instanceof DuckDBListValue) {
+        if (type.valueType.typeId === DuckDBTypeId.ANY) {
+          throw new Error(
+            'Cannot create lists with item type of ANY. Specify a specific type.'
+          );
+        }
+        return duckdb.create_list_value(
+          type.valueType.toLogicalType().logical_type,
+          input.items.map((item) => createValue(type.valueType, item))
+        );
+      }
+      throw new Error(`input is not a DuckDBListValue`);
+    case DuckDBTypeId.STRUCT:
+      if (type.isTuple) {
+        if (input instanceof DuckDBTupleValue) {
+          if (
+            type.entryTypes.find(
+              (entryType) => entryType.typeId === DuckDBTypeId.ANY
+            )
+          ) {
+            throw new Error(
+              'Cannot create tuples with an entry type of ANY. Specify a specific type.'
+            );
+          }
+          if (input.items.length !== type.entryCount) {
+            throw new Error(
+              `Expected ${type.entryCount} items for ${type}, got ${input.items.length}`
+            );
+          }
+          return duckdb.create_struct_value(
+            type.toLogicalType().logical_type,
+            input.items.map((item, i) => createValue(type.entryTypes[i], item))
+          );
+        }
+        throw new Error(`input is not a DuckDBTupleValue`);
+      }
+      if (input instanceof DuckDBStructValue) {
+        if (
+          type.entryTypes.find(
+            (entryType) => entryType.typeId === DuckDBTypeId.ANY
+          )
+        ) {
+          throw new Error(
+            'Cannot create structs with an entry type of ANY. Specify a specific type.'
+          );
+        }
+        // Pair entries by name rather than positionally so that
+        // `structValue({b: 'x', a: 1})` against `STRUCT({a: INTEGER, b:
+        // VARCHAR})` doesn't silently mispair when the value's insertion
+        // order differs from the type's declared field order.
+        return duckdb.create_struct_value(
+          type.toLogicalType().logical_type,
+          type.entryNames.map((name, i) => {
+            if (!(name in input.entries)) {
+              throw new Error(
+                `STRUCT entry '${name}' is missing from input`
+              );
+            }
+            return createValue(type.entryTypes[i], input.entries[name]);
+          })
+        );
+      }
+      throw new Error(`input is not a DuckDBStructValue`);
+    case DuckDBTypeId.MAP:
+      if (input instanceof DuckDBMapValue) {
+        if (type.keyType.typeId === DuckDBTypeId.ANY) {
+          throw new Error(
+            'Cannot create maps with key type of ANY. Specify a specific type.'
+          );
+        }
+        if (type.valueType.typeId === DuckDBTypeId.ANY) {
+          throw new Error(
+            'Cannot create maps with value type of ANY. Specify a specific type.'
+          );
+        }
+        return duckdb.create_map_value(
+          type.toLogicalType().logical_type,
+          input.entries.map((entry) => createValue(type.keyType, entry.key)),
+          input.entries.map((entry) => createValue(type.valueType, entry.value))
+        );
+      }
+      throw new Error(`input is not a DuckDBMapValue`);
+    case DuckDBTypeId.ARRAY:
+      if (input instanceof DuckDBArrayValue) {
+        if (type.valueType.typeId === DuckDBTypeId.ANY) {
+          throw new Error(
+            'Cannot create arrays with item type of ANY. Specify a specific type.'
+          );
+        }
+        return duckdb.create_array_value(
+          type.valueType.toLogicalType().logical_type,
+          input.items.map((item) => createValue(type.valueType, item))
+        );
+      }
+      throw new Error(`input is not a DuckDBArrayValue`);
+    case DuckDBTypeId.UUID:
+      if (input instanceof DuckDBUUIDValue) {
+        return duckdb.create_uuid(input.toUint128());
+      }
+      throw new Error(`input is not a bigint`);
+    case DuckDBTypeId.UNION:
+      if (input instanceof DuckDBUnionValue) {
+        const tagIndex = type.memberIndexForTag(input.tag);
+        const memberType = type.memberTypes[tagIndex];
+        if (memberType.typeId === DuckDBTypeId.ANY) {
+          throw new Error('Cannot create union values with type of ANY.');
+        }
+        return duckdb.create_union_value(
+          type.toLogicalType().logical_type,
+          tagIndex,
+          createValue(memberType, input.value)
+        );
+      }
+      throw new Error(`input is not a DuckDBUnionValue`);
+    case DuckDBTypeId.BIT:
+      if (input instanceof DuckDBBitValue) {
+        return duckdb.create_bit(input.data);
+      }
+      throw new Error(`input is not a DuckDBBitValue`);
+    case DuckDBTypeId.TIME_TZ:
+      if (input instanceof DuckDBTimeTZValue) {
+        return duckdb.create_time_tz_value(input);
+      }
+      throw new Error(`input is not a DuckDBTimeTZValue`);
+    case DuckDBTypeId.TIMESTAMP_TZ:
+      if (input instanceof DuckDBTimestampTZValue) {
+        return duckdb.create_timestamp_tz(input);
+      }
+      throw new Error(`input is not a DuckDBTimestampTZValue`);
+    case DuckDBTypeId.TIMESTAMP_TZ_NS:
+      if (input instanceof DuckDBTimestampTZNanosecondsValue) {
+        return duckdb.create_timestamp_tz_ns(input);
+      }
+      throw new Error(`input is not a DuckDBTimestampTZNanosecondsValue`);
+    case DuckDBTypeId.ANY:
+      throw new Error(
+        `Cannot create values of type ANY. Specify a specific type.`
+      );
+    case DuckDBTypeId.BIGNUM:
+      if (typeof input === 'bigint') {
+        return duckdb.create_bignum(input);
+      }
+      throw new Error(`input is not a bigint`);
+    case DuckDBTypeId.SQLNULL:
+      return duckdb.create_null_value();
+    case DuckDBTypeId.STRING_LITERAL:
+      throw new Error(`Cannot create values of type STRING_LITERAL.`);
+    case DuckDBTypeId.INTEGER_LITERAL:
+      throw new Error(`Cannot create values of type INTEGER_LITERAL.`);
+    case DuckDBTypeId.TIME_NS:
+      if (input instanceof DuckDBTimeNSValue) {
+        return duckdb.create_time_ns(input);
+      }
+      throw new Error(`input is not a DuckDBTimeNSValue`);
+    case DuckDBTypeId.GEOMETRY:
+      if (input instanceof DuckDBGeometryValue) {
+        throw new Error(`Creating values of type GEOMETRY is not yet supported.`);
+        // TODO: create_geometry doesn't exist; create_blob results in Failed to cast value: Unimplemented type for cast (BLOB -> GEOMETRY)
+        // return duckdb.create_blob(input.bytes);
+      }
+      throw new Error(`input is not a DuckDBGeometryValue`);
+    case DuckDBTypeId.VARIANT: {
+      // VARIANT has no direct create primitive in the C API; DuckDB
+      // implicitly casts from any compatible type when the target column
+      // or parameter is VARIANT. Recurse on the input's natural type so
+      // we hand DuckDB a Value it can cast.
+      //
+      // If the input is a DuckDBVariantValue, prefer its embedded `.type`
+      // (set by the decoder from the on-disk variant tag) so heterogeneous
+      // content round-trips faithfully. Fall back to `typeForValue` when
+      // no type hint is attached. The recursion is wrapped so a
+      // mismatched wrapper (e.g. `variantValue('hello', INTEGER)`)
+      // surfaces a VARIANT-flavored error rather than a confusing
+      // `input is not a number` from a sibling case.
+      const inner =
+        input instanceof DuckDBVariantValue ? input.value : input;
+      const innerType =
+        input instanceof DuckDBVariantValue && input.type
+          ? input.type
+          : typeForValue(inner);
+      try {
+        return createValue(innerType, inner);
+      } catch (err) {
+        throw new Error(
+          `Failed to create VARIANT value (inner type ${innerType}): ${
+            (err as Error).message
+          }`
+        );
+      }
+    }
+    default:
+      throw new Error(`unrecognized type id ${typeId}`);
+  }
+}

package/vendor/node-api/src/duckdb.ts

@@ -0,0 +1,51 @@
+export {
+  double_to_hugeint,
+  double_to_uhugeint,
+  hugeint_to_double,
+  uhugeint_to_double
+} from "../../../src/bindings/index.ts";
+export * from './configurationOptionDescriptions';
+export * from './createDuckDBValueConverter';
+export * from './DuckDBAppender';
+export * from './DuckDBClientContext';
+export * from './DuckDBConnection';
+export * from './DuckDBDataChunk';
+export * from './DuckDBDataChunkWriter';
+export * from './DuckDBExtractedStatements';
+export * from './DuckDBInstance';
+export * from './DuckDBInstanceCache';
+export * from './DuckDBLogicalType';
+export * from './DuckDBMaterializedResult';
+export * from './DuckDBPendingResult';
+export * from './DuckDBPreparedStatement';
+export * from './DuckDBPreparedStatementCollection';
+export * from './DuckDBResult';
+export * from './DuckDBResultReader';
+export * from './DuckDBScalarFunction';
+export * from './DuckDBScalarFunctionBindInfo';
+export * from './DuckDBScalarFunctionInfo';
+export * from './DuckDBScalarFunctionInitInfo';
+export * from './DuckDBTableFunction';
+export * from './DuckDBTableFunctionBindInfo';
+export * from './DuckDBTableFunctionInfo';
+export * from './DuckDBTableFunctionInitInfo';
+export * from './DuckDBType';
+export * from './DuckDBTypeId';
+export * from './DuckDBValueConverter';
+export * from './DuckDBValueConverters';
+export * from './DuckDBVector';
+export * from './ToDuckDBValueConverter';
+export * from './ToDuckDBValueConverters';
+export * from './enums';
+export * from './JS';
+export * from './JSDuckDBValueConverter';
+export * from './JSInputTypeForTypeId';
+export * from './JSToDuckDBValueConverter';
+export * from './JSTypeForTypeId';
+export * from './Json';
+export * from './JsonDuckDBValueConverter';
+export * from './JsonTypeForTypeId';
+export * from './readValue';
+export * from './sql';
+export * from './values';
+export * from './version';

package/vendor/node-api/src/enums.ts

@@ -0,0 +1,7 @@
+import duckdb from "../../../src/bindings/index.ts";
+
+export type ResultReturnType = duckdb.ResultType;
+export const ResultReturnType = duckdb.ResultType;
+
+export type StatementType = duckdb.StatementType;
+export const StatementType = duckdb.StatementType;

package/vendor/node-api/src/getColumnsFromChunks.ts

@@ -0,0 +1,13 @@
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBValue } from './values';
+
+export function getColumnsFromChunks(
+  chunks: readonly DuckDBDataChunk[],
+  columnCount: number
+): DuckDBValue[][] {
+  const columns: DuckDBValue[][] = Array.from({ length: columnCount }, () => []);
+  for (const chunk of chunks) {
+    chunk.appendToColumns(columns);
+  }
+  return columns;
+}

package/vendor/node-api/src/getColumnsObjectFromChunks.ts

@@ -0,0 +1,16 @@
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBValue } from './values';
+
+export function getColumnsObjectFromChunks(
+  chunks: readonly DuckDBDataChunk[],
+  columnNames: readonly string[]
+): Record<string, DuckDBValue[]> {
+  const columnsObject: Record<string, DuckDBValue[]> = {};
+  for (const columnName of columnNames) {
+    columnsObject[columnName] = [];
+  }
+  for (const chunk of chunks) {
+    chunk.appendToColumnsObject(columnNames, columnsObject);
+  }
+  return columnsObject;
+}

package/vendor/node-api/src/getRowObjectsFromChunks.ts

@@ -0,0 +1,13 @@
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBValue } from './values';
+
+export function getRowObjectsFromChunks(
+  chunks: readonly DuckDBDataChunk[],
+  columnNames: readonly string[]
+): Record<string, DuckDBValue>[] {
+  const rowObjects: Record<string, DuckDBValue>[] = [];
+  for (const chunk of chunks) {
+    chunk.appendToRowObjects(columnNames, rowObjects);
+  }
+  return rowObjects;
+}

package/vendor/node-api/src/getRowsFromChunks.ts

@@ -0,0 +1,12 @@
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBValue } from './values';
+
+export function getRowsFromChunks(
+  chunks: readonly DuckDBDataChunk[]
+): DuckDBValue[][] {
+  const rows: DuckDBValue[][] = [];
+  for (const chunk of chunks) {
+    chunk.appendToRows(rows);
+  }
+  return rows;
+}

package/vendor/node-api/src/index.ts

@@ -0,0 +1,3 @@
+import * as duckdb from './duckdb';
+export default duckdb;
+export * from './duckdb';

package/vendor/node-api/src/readValue.ts

@@ -0,0 +1,31 @@
+import duckdb, { Value } from "../../../src/bindings/index.ts";
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValue } from './values';
+
+/**
+ * Converts a `duckdb.Value` into a `DuckDBValue`.
+ *
+ * Results normally arrive as vectors rather than values, so this is for the
+ * places that hand back a value instead: table function parameters, and
+ * `duckdb_get_table_names`.
+ *
+ * It works by referencing the value into a vector of its own and reading the one
+ * element back, which reuses the vector reading path rather than duplicating it.
+ * That matters for more than tidiness: the value accessors cannot reach inside an
+ * ARRAY or a UNION at all, because `duckdb_get_list_child` and
+ * `duckdb_get_struct_child` guard on the exact logical type id and return null
+ * for both. Going through a vector covers every type, and leaves one
+ * implementation of how each type is represented rather than two that can drift.
+ *
+ * The cost is roughly an extra microsecond per scalar value, which is fine here
+ * and would not be in a per-row path. Per-row data already arrives as vectors and
+ * never comes through here.
+ */
+export function readValue(value: Value): DuckDBValue {
+  // Capacity of one: the vector exists only to hold this single value. It is
+  // destroyed when collected, and getItem materializes what it returns, so
+  // nothing handed back keeps a reference to the vector's memory.
+  const vector = duckdb.create_vector(duckdb.get_value_type(value), 1);
+  duckdb.vector_reference_value(vector, value);
+  return DuckDBVector.create(vector, 1).getItem(0);
+}

package/vendor/node-api/src/sleep.ts

@@ -0,0 +1,5 @@
+export async function sleep(ms: number) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}

package/vendor/node-api/src/sql.ts

@@ -0,0 +1,7 @@
+export function quotedString(input: string): string {
+  return `'${input.replaceAll(`'`, `''`)}'`;
+}
+
+export function quotedIdentifier(input: string): string {
+  return `"${input.replaceAll(`"`, `""`)}"`;
+}

package/vendor/node-api/src/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.library.json",
+  "compilerOptions": {
+    "outDir": "../pkgs/@duckdb/node-api/lib",
+    "types": ["node"]
+  }
+}

package/vendor/node-api/src/typeForValue.ts

@@ -0,0 +1,144 @@
+import {
+  ANY,
+  ARRAY,
+  BIGINT,
+  BIT,
+  BLOB,
+  BOOLEAN,
+  DATE,
+  DECIMAL,
+  DOUBLE,
+  DuckDBType,
+  HUGEINT,
+  INTEGER,
+  INTERVAL,
+  LIST,
+  MAP,
+  SQLNULL,
+  STRUCT,
+  TIME,
+  TIME_NS,
+  TIMESTAMP,
+  TIMESTAMP_MS,
+  TIMESTAMP_NS,
+  TIMESTAMP_S,
+  TIMESTAMPTZ,
+  TIMESTAMPTZ_NS,
+  TIMETZ,
+  TUPLE,
+  UNION,
+  UUID,
+  VARCHAR,
+  VARIANT,
+} from './DuckDBType';
+import {
+  DuckDBArrayValue,
+  DuckDBBitValue,
+  DuckDBBlobValue,
+  DuckDBDateValue,
+  DuckDBDecimalValue,
+  DuckDBIntervalValue,
+  DuckDBListValue,
+  DuckDBMapValue,
+  DuckDBStructValue,
+  DuckDBTimeNSValue,
+  DuckDBTimestampMillisecondsValue,
+  DuckDBTimestampNanosecondsValue,
+  DuckDBTimestampSecondsValue,
+  DuckDBTimestampTZValue,
+  DuckDBTimestampTZNanosecondsValue,
+  DuckDBTimestampValue,
+  DuckDBTimeTZValue,
+  DuckDBTimeValue,
+  DuckDBTupleValue,
+  DuckDBUnionValue,
+  DuckDBUUIDValue,
+  DuckDBValue,
+  DuckDBVariantValue,
+} from './values';
+
+export function typeForValue(value: DuckDBValue): DuckDBType {
+  if (value === null) {
+    return SQLNULL;
+  } else {
+    switch (typeof value) {
+      case 'boolean':
+        return BOOLEAN;
+      case 'number':
+        if (Number.isInteger(value)) {
+          if (value >= -2_147_483_648 && value <= 2_147_483_647) {
+            return INTEGER;
+          }
+          return BIGINT;
+        } else {
+          return DOUBLE;
+        }
+      case 'bigint':
+        return HUGEINT;
+      case 'string':
+        return VARCHAR;
+      case 'object':
+        if (value instanceof DuckDBArrayValue) {
+          return ARRAY(typeForValue(value.items[0]), value.items.length);
+        } else if (value instanceof DuckDBBitValue) {
+          return BIT;
+        } else if (value instanceof DuckDBBlobValue) {
+          return BLOB;
+        } else if (value instanceof DuckDBDateValue) {
+          return DATE;
+        } else if (value instanceof DuckDBDecimalValue) {
+          return DECIMAL(value.width, value.scale);
+        } else if (value instanceof DuckDBIntervalValue) {
+          return INTERVAL;
+        } else if (value instanceof DuckDBListValue) {
+          return LIST(typeForValue(value.items[0]));
+        } else if (value instanceof DuckDBMapValue) {
+          if (value.entries.length === 0) {
+            // An empty map carries no entries to infer key/value types from.
+            // Mirror the empty-list path (LIST(ANY)) so createValue raises the
+            // same "Cannot create maps with key type of ANY" error, instead of
+            // a cryptic "Cannot read properties of undefined (reading 'key')".
+            return MAP(ANY, ANY);
+          }
+          return MAP(
+            typeForValue(value.entries[0].key),
+            typeForValue(value.entries[0].value)
+          );
+        } else if (value instanceof DuckDBStructValue) {
+          const entryTypes: Record<string, DuckDBType> = {};
+          for (const key in value.entries) {
+            entryTypes[key] = typeForValue(value.entries[key]);
+          }
+          return STRUCT(entryTypes);
+        } else if (value instanceof DuckDBTimestampMillisecondsValue) {
+          return TIMESTAMP_MS;
+        } else if (value instanceof DuckDBTimestampNanosecondsValue) {
+          return TIMESTAMP_NS;
+        } else if (value instanceof DuckDBTimestampSecondsValue) {
+          return TIMESTAMP_S;
+        } else if (value instanceof DuckDBTimestampTZValue) {
+          return TIMESTAMPTZ;
+        } else if (value instanceof DuckDBTimestampTZNanosecondsValue) {
+          return TIMESTAMPTZ_NS;
+        } else if (value instanceof DuckDBTimestampValue) {
+          return TIMESTAMP;
+        } else if (value instanceof DuckDBTimeTZValue) {
+          return TIMETZ;
+        } else if (value instanceof DuckDBTimeValue) {
+          return TIME;
+        } else if (value instanceof DuckDBTimeNSValue) {
+          return TIME_NS;
+        } else if (value instanceof DuckDBTupleValue) {
+          return TUPLE(value.items.map(typeForValue));
+        } else if (value instanceof DuckDBUnionValue) {
+          return UNION({ [value.tag]: typeForValue(value.value) });
+        } else if (value instanceof DuckDBUUIDValue) {
+          return UUID;
+        } else if (value instanceof DuckDBVariantValue) {
+          return VARIANT;
+        }
+        break;
+    }
+  }
+  return ANY;
+}