@leonardovida-md/drizzle-neo-duckdb 1.1.0 → 1.1.1

package/dist/index.mjs

@@ -16,83 +16,159 @@ import { PgPreparedQuery, PgSession } from "drizzle-orm/pg-core/session";
 import { fillPlaceholders, sql } from "drizzle-orm/sql/sql";
 
 // src/sql/query-rewriters.ts
-function adaptArrayOperators(query) {
-  const operators = [
-    { token: "@>", fn: "array_has_all" },
-    { token: "<@", fn: "array_has_all", swap: true },
-    { token: "&&", fn: "array_has_any" }
-  ];
-  const isWhitespace = (char) => char !== undefined && /\s/.test(char);
-  const walkLeft = (source, start) => {
-    let idx = start;
-    while (idx >= 0 && isWhitespace(source[idx])) {
-      idx--;
-    }
-    let depth = 0;
-    let inString = false;
-    for (;idx >= 0; idx--) {
-      const ch = source[idx];
-      if (ch === undefined)
-        break;
-      if (ch === "'" && source[idx - 1] !== "\\") {
-        inString = !inString;
+var OPERATORS = [
+  { token: "@>", fn: "array_has_all" },
+  { token: "<@", fn: "array_has_all", swap: true },
+  { token: "&&", fn: "array_has_any" }
+];
+var isWhitespace = (char) => char !== undefined && /\s/.test(char);
+function scrubForRewrite(query) {
+  let scrubbed = "";
+  let state = "code";
+  for (let i = 0;i < query.length; i += 1) {
+    const char = query[i];
+    const next = query[i + 1];
+    if (state === "code") {
+      if (char === "'") {
+        scrubbed += "'";
+        state = "single";
+        continue;
       }
-      if (inString)
+      if (char === '"') {
+        scrubbed += '"';
+        state = "double";
+        continue;
+      }
+      if (char === "-" && next === "-") {
+        scrubbed += "  ";
+        i += 1;
+        state = "lineComment";
+        continue;
+      }
+      if (char === "/" && next === "*") {
+        scrubbed += "  ";
+        i += 1;
+        state = "blockComment";
         continue;
-      if (ch === ")" || ch === "]") {
-        depth++;
-      } else if (ch === "(" || ch === "[") {
-        depth--;
-        if (depth < 0) {
-          return [idx + 1, source.slice(idx + 1, start + 1)];
-        }
-      } else if (depth === 0 && isWhitespace(ch)) {
-        return [idx + 1, source.slice(idx + 1, start + 1)];
       }
+      scrubbed += char;
+      continue;
     }
-    return [0, source.slice(0, start + 1)];
-  };
-  const walkRight = (source, start) => {
-    let idx = start;
-    while (idx < source.length && isWhitespace(source[idx])) {
-      idx++;
-    }
-    let depth = 0;
-    let inString = false;
-    for (;idx < source.length; idx++) {
-      const ch = source[idx];
-      if (ch === undefined)
-        break;
-      if (ch === "'" && source[idx - 1] !== "\\") {
-        inString = !inString;
+    if (state === "single") {
+      if (char === "'" && next === "'") {
+        scrubbed += "''";
+        i += 1;
+        continue;
+      }
+      scrubbed += char === "'" ? "'" : ".";
+      if (char === "'") {
+        state = "code";
       }
-      if (inString)
+      continue;
+    }
+    if (state === "double") {
+      if (char === '"' && next === '"') {
+        scrubbed += '""';
+        i += 1;
         continue;
-      if (ch === "(" || ch === "[") {
-        depth++;
-      } else if (ch === ")" || ch === "]") {
-        depth--;
-        if (depth < 0) {
-          return [idx, source.slice(start, idx)];
-        }
-      } else if (depth === 0 && isWhitespace(ch)) {
+      }
+      scrubbed += char === '"' ? '"' : ".";
+      if (char === '"') {
+        state = "code";
+      }
+      continue;
+    }
+    if (state === "lineComment") {
+      scrubbed += char === `
+` ? `
+` : " ";
+      if (char === `
+`) {
+        state = "code";
+      }
+      continue;
+    }
+    if (state === "blockComment") {
+      if (char === "*" && next === "/") {
+        scrubbed += "  ";
+        i += 1;
+        state = "code";
+      } else {
+        scrubbed += " ";
+      }
+    }
+  }
+  return scrubbed;
+}
+function findNextOperator(scrubbed, start) {
+  for (let idx = start;idx < scrubbed.length; idx += 1) {
+    for (const operator of OPERATORS) {
+      if (scrubbed.startsWith(operator.token, idx)) {
+        return { index: idx, operator };
+      }
+    }
+  }
+  return null;
+}
+function walkLeft(source, scrubbed, start) {
+  let idx = start;
+  while (idx >= 0 && isWhitespace(scrubbed[idx])) {
+    idx -= 1;
+  }
+  let depth = 0;
+  for (;idx >= 0; idx -= 1) {
+    const ch = scrubbed[idx];
+    if (ch === ")" || ch === "]") {
+      depth += 1;
+    } else if (ch === "(" || ch === "[") {
+      if (depth === 0) {
+        return [idx + 1, source.slice(idx + 1, start + 1)];
+      }
+      depth = Math.max(0, depth - 1);
+    } else if (depth === 0 && isWhitespace(ch)) {
+      return [idx + 1, source.slice(idx + 1, start + 1)];
+    }
+  }
+  return [0, source.slice(0, start + 1)];
+}
+function walkRight(source, scrubbed, start) {
+  let idx = start;
+  while (idx < scrubbed.length && isWhitespace(scrubbed[idx])) {
+    idx += 1;
+  }
+  let depth = 0;
+  for (;idx < scrubbed.length; idx += 1) {
+    const ch = scrubbed[idx];
+    if (ch === "(" || ch === "[") {
+      depth += 1;
+    } else if (ch === ")" || ch === "]") {
+      if (depth === 0) {
         return [idx, source.slice(start, idx)];
       }
+      depth = Math.max(0, depth - 1);
+    } else if (depth === 0 && isWhitespace(ch)) {
+      return [idx, source.slice(start, idx)];
     }
-    return [source.length, source.slice(start)];
-  };
+  }
+  return [scrubbed.length, source.slice(start)];
+}
+function adaptArrayOperators(query) {
   let rewritten = query;
-  for (const { token, fn, swap } of operators) {
-    let idx = rewritten.indexOf(token);
-    while (idx !== -1) {
-      const [leftStart, leftExpr] = walkLeft(rewritten, idx - 1);
-      const [rightEnd, rightExpr] = walkRight(rewritten, idx + token.length);
-      const left = leftExpr.trim();
-      const right = rightExpr.trim();
-      const replacement = `${fn}(${swap ? right : left}, ${swap ? left : right})`;
-      rewritten = rewritten.slice(0, leftStart) + replacement + rewritten.slice(rightEnd);
-      idx = rewritten.indexOf(token, leftStart + replacement.length);
-    }
+  let scrubbed = scrubForRewrite(query);
+  let searchStart = 0;
+  while (true) {
+    const next = findNextOperator(scrubbed, searchStart);
+    if (!next)
+      break;
+    const { index, operator } = next;
+    const [leftStart, leftExpr] = walkLeft(rewritten, scrubbed, index - 1);
+    const [rightEnd, rightExpr] = walkRight(rewritten, scrubbed, index + operator.token.length);
+    const left = leftExpr.trim();
+    const right = rightExpr.trim();
+    const replacement = `${operator.fn}(${operator.swap ? right : left}, ${operator.swap ? left : right})`;
+    rewritten = rewritten.slice(0, leftStart) + replacement + rewritten.slice(rightEnd);
+    scrubbed = scrubForRewrite(rewritten);
+    searchStart = leftStart + replacement.length;
   }
   return rewritten;
 }
@@ -386,6 +462,12 @@ function dateToMicros(value) {
   if (value instanceof Date) {
     return BigInt(value.getTime()) * 1000n;
   }
+  if (typeof value === "bigint") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return BigInt(Math.trunc(value)) * 1000n;
+  }
   let normalized = value;
   if (!value.includes("T") && value.includes(" ")) {
     normalized = value.replace(" ", "T");
@@ -455,14 +537,17 @@ function parsePgArrayLiteral(value) {
 }
 function prepareParams(params, options = {}) {
   return params.map((param) => {
-    if (typeof param === "string" && isPgArrayLiteral(param)) {
-      if (options.rejectStringArrayLiterals) {
-        throw new Error("Stringified array literals are not supported. Use duckDbList()/duckDbArray() or pass native arrays.");
-      }
-      if (options.warnOnStringArrayLiteral) {
-        options.warnOnStringArrayLiteral();
+    if (typeof param === "string") {
+      const trimmed = param.trim();
+      if (trimmed && isPgArrayLiteral(trimmed)) {
+        if (options.rejectStringArrayLiterals) {
+          throw new Error("Stringified array literals are not supported. Use duckDbList()/duckDbArray() or pass native arrays.");
+        }
+        if (options.warnOnStringArrayLiteral) {
+          options.warnOnStringArrayLiteral();
+        }
+        return parsePgArrayLiteral(trimmed);
       }
-      return parsePgArrayLiteral(param);
     }
     return param;
   });
@@ -580,6 +665,13 @@ async function executeArrowOnClient(client, query, params) {
 }
 
 // src/session.ts
+function isSavepointSyntaxError(error) {
+  if (!(error instanceof Error) || !error.message) {
+    return false;
+  }
+  return error.message.toLowerCase().includes("savepoint") && error.message.toLowerCase().includes("syntax error");
+}
+
 class DuckDBPreparedQuery extends PgPreparedQuery {
   client;
   dialect;
@@ -644,6 +736,7 @@ class DuckDBSession extends PgSession {
   rewriteArrays;
   rejectStringArrayLiterals;
   hasWarnedArrayLiteral = false;
+  rollbackOnly = false;
   constructor(client, dialect, schema, options = {}) {
     super(dialect);
     this.client = client;
@@ -657,7 +750,15 @@ class DuckDBSession extends PgSession {
   prepareQuery(query, fields, name, isResponseInArrayMode, customResultMapper) {
     return new DuckDBPreparedQuery(this.client, this.dialect, query.sql, query.params, this.logger, fields, isResponseInArrayMode, customResultMapper, this.rewriteArrays, this.rejectStringArrayLiterals, this.rejectStringArrayLiterals ? undefined : this.warnOnStringArrayLiteral);
   }
-  async transaction(transaction) {
+  execute(query) {
+    this.dialect.resetPgJsonFlag();
+    return super.execute(query);
+  }
+  all(query) {
+    this.dialect.resetPgJsonFlag();
+    return super.all(query);
+  }
+  async transaction(transaction, config) {
     let pinnedConnection;
     let pool;
     let clientForTx = this.client;
@@ -670,8 +771,15 @@ class DuckDBSession extends PgSession {
     const tx = new DuckDBTransaction(this.dialect, session, this.schema);
     try {
       await tx.execute(sql`BEGIN TRANSACTION;`);
+      if (config) {
+        await tx.setTransaction(config);
+      }
       try {
         const result = await transaction(tx);
+        if (session.isRollbackOnly()) {
+          await tx.execute(sql`rollback`);
+          throw new TransactionRollbackError;
+        }
         await tx.execute(sql`commit`);
         return result;
       } catch (error) {
@@ -693,7 +801,9 @@ class DuckDBSession extends PgSession {
 query: ${query}`, []);
   };
   executeBatches(query, options = {}) {
+    this.dialect.resetPgJsonFlag();
     const builtQuery = this.dialect.sqlToQuery(query);
+    this.dialect.assertNoPgJsonColumns();
     const params = prepareParams(builtQuery.params, {
       rejectStringArrayLiterals: this.rejectStringArrayLiterals,
       warnOnStringArrayLiteral: this.rejectStringArrayLiterals ? undefined : () => this.warnOnStringArrayLiteral(builtQuery.sql)
@@ -706,7 +816,9 @@ query: ${query}`, []);
     return executeInBatches(this.client, rewrittenQuery, params, options);
   }
   async executeArrow(query) {
+    this.dialect.resetPgJsonFlag();
     const builtQuery = this.dialect.sqlToQuery(query);
+    this.dialect.assertNoPgJsonColumns();
     const params = prepareParams(builtQuery.params, {
       rejectStringArrayLiterals: this.rejectStringArrayLiterals,
       warnOnStringArrayLiteral: this.rejectStringArrayLiterals ? undefined : () => this.warnOnStringArrayLiteral(builtQuery.sql)
@@ -718,6 +830,12 @@ query: ${query}`, []);
     this.logger.logQuery(rewrittenQuery, params);
     return executeArrowOnClient(this.client, rewrittenQuery, params);
   }
+  markRollbackOnly() {
+    this.rollbackOnly = true;
+  }
+  isRollbackOnly() {
+    return this.rollbackOnly;
+  }
 }
 
 class DuckDBTransaction extends PgTransaction {
@@ -748,8 +866,46 @@ class DuckDBTransaction extends PgTransaction {
     return this.session.executeArrow(query);
   }
   async transaction(transaction) {
-    const nestedTx = new DuckDBTransaction(this.dialect, this.session, this.schema, this.nestedIndex + 1);
-    return transaction(nestedTx);
+    const internals = this;
+    const savepoint = `drizzle_savepoint_${this.nestedIndex + 1}`;
+    const savepointSql = sql.raw(`savepoint ${savepoint}`);
+    const releaseSql = sql.raw(`release savepoint ${savepoint}`);
+    const rollbackSql = sql.raw(`rollback to savepoint ${savepoint}`);
+    const nestedTx = new DuckDBTransaction(internals.dialect, internals.session, this.schema, this.nestedIndex + 1);
+    if (internals.dialect.areSavepointsUnsupported()) {
+      return this.runNestedWithoutSavepoint(transaction, nestedTx, internals);
+    }
+    let createdSavepoint = false;
+    try {
+      await internals.session.execute(savepointSql);
+      internals.dialect.markSavepointsSupported();
+      createdSavepoint = true;
+    } catch (error) {
+      if (!isSavepointSyntaxError(error)) {
+        throw error;
+      }
+      internals.dialect.markSavepointsUnsupported();
+      return this.runNestedWithoutSavepoint(transaction, nestedTx, internals);
+    }
+    try {
+      const result = await transaction(nestedTx);
+      if (createdSavepoint) {
+        await internals.session.execute(releaseSql);
+      }
+      return result;
+    } catch (error) {
+      if (createdSavepoint) {
+        await internals.session.execute(rollbackSql);
+      }
+      internals.session.markRollbackOnly();
+      throw error;
+    }
+  }
+  runNestedWithoutSavepoint(transaction, nestedTx, internals) {
+    return transaction(nestedTx).catch((error) => {
+      internals.session.markRollbackOnly();
+      throw error;
+    });
   }
 }
 var arrayLiteralWarning = "Received a stringified Postgres-style array literal. Use duckDbList()/duckDbArray() or pass native arrays instead. You can also set rejectStringArrayLiterals=true to throw.";
@@ -771,15 +927,30 @@ import {
 import {
   sql as sql2
 } from "drizzle-orm";
-
 class DuckDBDialect extends PgDialect {
   static [entityKind2] = "DuckDBPgDialect";
   hasPgJsonColumn = false;
+  savepointsSupported = 0 /* Unknown */;
+  resetPgJsonFlag() {
+    this.hasPgJsonColumn = false;
+  }
+  markPgJsonDetected() {
+    this.hasPgJsonColumn = true;
+  }
   assertNoPgJsonColumns() {
     if (this.hasPgJsonColumn) {
-      throw new Error("Pg JSON/JSONB columns are not supported in DuckDB. Replace them with duckDbJson() to use DuckDB’s native JSON type.");
+      throw new Error("Pg JSON/JSONB columns are not supported in DuckDB. Replace them with duckDbJson() to use DuckDB's native JSON type.");
     }
   }
+  areSavepointsUnsupported() {
+    return this.savepointsSupported === 2 /* No */;
+  }
+  markSavepointsSupported() {
+    this.savepointsSupported = 1 /* Yes */;
+  }
+  markSavepointsUnsupported() {
+    this.savepointsSupported = 2 /* No */;
+  }
   async migrate(migrations, session, config) {
     const migrationConfig = typeof config === "string" ? { migrationsFolder: config } : config;
     const migrationsSchema = migrationConfig.migrationsSchema ?? "drizzle";
@@ -816,8 +987,8 @@ class DuckDBDialect extends PgDialect {
   }
   prepareTyping(encoder) {
     if (is2(encoder, PgJsonb) || is2(encoder, PgJson)) {
-      this.hasPgJsonColumn = true;
-      return "none";
+      this.markPgJsonDetected();
+      throw new Error("Pg JSON/JSONB columns are not supported in DuckDB. Replace them with duckDbJson() to use DuckDB's native JSON type.");
     } else if (is2(encoder, PgNumeric)) {
       return "decimal";
     } else if (is2(encoder, PgTime2)) {
@@ -951,41 +1122,148 @@ function resolvePoolSize(pool) {
 }
 function createDuckDBConnectionPool(instance, options = {}) {
   const size = options.size && options.size > 0 ? options.size : 4;
+  const acquireTimeout = options.acquireTimeout ?? 30000;
+  const maxWaitingRequests = options.maxWaitingRequests ?? 100;
+  const maxLifetimeMs = options.maxLifetimeMs;
+  const idleTimeoutMs = options.idleTimeoutMs;
+  const metadata = new WeakMap;
   const idle = [];
   const waiting = [];
   let total = 0;
   let closed = false;
+  let pendingAcquires = 0;
+  const shouldRecycle = (conn, now) => {
+    if (maxLifetimeMs !== undefined && now - conn.createdAt >= maxLifetimeMs) {
+      return true;
+    }
+    if (idleTimeoutMs !== undefined && now - conn.lastUsedAt >= idleTimeoutMs) {
+      return true;
+    }
+    return false;
+  };
   const acquire = async () => {
     if (closed) {
       throw new Error("DuckDB connection pool is closed");
     }
-    if (idle.length > 0) {
-      return idle.pop();
+    while (idle.length > 0) {
+      const pooled = idle.pop();
+      const now = Date.now();
+      if (shouldRecycle(pooled, now)) {
+        await closeClientConnection(pooled.connection);
+        total = Math.max(0, total - 1);
+        metadata.delete(pooled.connection);
+        continue;
+      }
+      pooled.lastUsedAt = now;
+      metadata.set(pooled.connection, {
+        createdAt: pooled.createdAt,
+        lastUsedAt: pooled.lastUsedAt
+      });
+      return pooled.connection;
     }
     if (total < size) {
+      pendingAcquires += 1;
       total += 1;
-      return await DuckDBConnection.create(instance);
+      try {
+        const connection = await DuckDBConnection.create(instance);
+        if (closed) {
+          await closeClientConnection(connection);
+          total -= 1;
+          throw new Error("DuckDB connection pool is closed");
+        }
+        const now = Date.now();
+        metadata.set(connection, { createdAt: now, lastUsedAt: now });
+        return connection;
+      } catch (error) {
+        total -= 1;
+        throw error;
+      } finally {
+        pendingAcquires -= 1;
+      }
+    }
+    if (waiting.length >= maxWaitingRequests) {
+      throw new Error(`DuckDB connection pool queue is full (max ${maxWaitingRequests} waiting requests)`);
     }
-    return await new Promise((resolve) => {
-      waiting.push(resolve);
+    return await new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        const idx = waiting.findIndex((w) => w.timeoutId === timeoutId);
+        if (idx !== -1) {
+          waiting.splice(idx, 1);
+        }
+        reject(new Error(`DuckDB connection pool acquire timeout after ${acquireTimeout}ms`));
+      }, acquireTimeout);
+      waiting.push({ resolve, reject, timeoutId });
     });
   };
   const release = async (connection) => {
+    const waiter = waiting.shift();
+    if (waiter) {
+      clearTimeout(waiter.timeoutId);
+      const now2 = Date.now();
+      const meta = metadata.get(connection) ?? { createdAt: now2, lastUsedAt: now2 };
+      const expired = maxLifetimeMs !== undefined && now2 - meta.createdAt >= maxLifetimeMs;
+      if (closed) {
+        await closeClientConnection(connection);
+        total = Math.max(0, total - 1);
+        metadata.delete(connection);
+        waiter.reject(new Error("DuckDB connection pool is closed"));
+        return;
+      }
+      if (expired) {
+        await closeClientConnection(connection);
+        total = Math.max(0, total - 1);
+        metadata.delete(connection);
+        try {
+          const replacement = await acquire();
+          waiter.resolve(replacement);
+        } catch (error) {
+          waiter.reject(error);
+        }
+        return;
+      }
+      meta.lastUsedAt = now2;
+      metadata.set(connection, meta);
+      waiter.resolve(connection);
+      return;
+    }
     if (closed) {
       await closeClientConnection(connection);
+      metadata.delete(connection);
+      total = Math.max(0, total - 1);
       return;
     }
-    const waiter = waiting.shift();
-    if (waiter) {
-      waiter(connection);
+    const now = Date.now();
+    const existingMeta = metadata.get(connection) ?? { createdAt: now, lastUsedAt: now };
+    existingMeta.lastUsedAt = now;
+    metadata.set(connection, existingMeta);
+    if (maxLifetimeMs !== undefined && now - existingMeta.createdAt >= maxLifetimeMs) {
+      await closeClientConnection(connection);
+      total -= 1;
+      metadata.delete(connection);
       return;
     }
-    idle.push(connection);
+    idle.push({
+      connection,
+      createdAt: existingMeta.createdAt,
+      lastUsedAt: existingMeta.lastUsedAt
+    });
   };
   const close = async () => {
     closed = true;
+    const waiters = waiting.splice(0, waiting.length);
+    for (const waiter of waiters) {
+      clearTimeout(waiter.timeoutId);
+      waiter.reject(new Error("DuckDB connection pool is closed"));
+    }
     const toClose = idle.splice(0, idle.length);
-    await Promise.all(toClose.map((conn) => closeClientConnection(conn)));
+    await Promise.allSettled(toClose.map((item) => closeClientConnection(item.connection)));
+    total = Math.max(0, total - toClose.length);
+    toClose.forEach((item) => metadata.delete(item.connection));
+    const maxWait = 5000;
+    const start = Date.now();
+    while (pendingAcquires > 0 && Date.now() - start < maxWait) {
+      await new Promise((r) => setTimeout(r, 10));
+    }
   };
   return {
     acquire,
@@ -1093,6 +1371,17 @@ class DuckDBDatabase extends PgDatabase {
     if (isPool(this.$client) && this.$client.close) {
       await this.$client.close();
     }
+    if (!isPool(this.$client)) {
+      await closeClientConnection(this.$client);
+    }
+    if (this.$instance) {
+      const maybeClosable = this.$instance;
+      if (typeof maybeClosable.close === "function") {
+        await maybeClosable.close();
+      } else if (typeof maybeClosable.closeSync === "function") {
+        maybeClosable.closeSync();
+      }
+    }
   }
   select(fields) {
     const selectedFields = fields ? aliasFields(fields) : undefined;
@@ -1176,6 +1465,13 @@ function buildStructLiteral(value, schema) {
   });
   return sql4`struct_pack(${sql4.join(parts, sql4.raw(", "))})`;
 }
+function buildMapLiteral(value, valueType) {
+  const keys = Object.keys(value);
+  const vals = Object.values(value);
+  const keyList = buildListLiteral(keys, "TEXT");
+  const valList = buildListLiteral(vals, valueType?.endsWith("[]") ? valueType.slice(0, -2) : valueType);
+  return sql4`map(${keyList}, ${valList})`;
+}
 var duckDbList = (name, elementType) => customType({
   dataType() {
     return `${elementType}[]`;
@@ -1189,11 +1485,11 @@ var duckDbList = (name, elementType) => customType({
     }
     if (typeof value === "string") {
       const parsed = coerceArrayString(value);
-      if (parsed) {
+      if (parsed !== undefined) {
         return parsed;
       }
     }
-    return [];
+    return value;
   }
 })(name);
 var duckDbArray = (name, elementType, fixedLength) => customType({
@@ -1209,11 +1505,11 @@ var duckDbArray = (name, elementType, fixedLength) => customType({
     }
     if (typeof value === "string") {
       const parsed = coerceArrayString(value);
-      if (parsed) {
+      if (parsed !== undefined) {
         return parsed;
       }
     }
-    return [];
+    return value;
   }
 })(name);
 var duckDbMap = (name, valueType) => customType({
@@ -1761,6 +2057,20 @@ function mapDuckDbType(column, imports, options) {
     imports.pgCore.add("text");
     return { builder: `text(${columnName(column.name)}) /* JSON */` };
   }
+  if (upper.startsWith("ENUM")) {
+    imports.pgCore.add("text");
+    const enumLiteral = raw.replace(/^ENUM\s*/i, "").trim();
+    return {
+      builder: `text(${columnName(column.name)}) /* ENUM ${enumLiteral} */`
+    };
+  }
+  if (upper.startsWith("UNION")) {
+    imports.pgCore.add("text");
+    const unionLiteral = raw.replace(/^UNION\s*/i, "").trim();
+    return {
+      builder: `text(${columnName(column.name)}) /* UNION ${unionLiteral} */`
+    };
+  }
   if (upper === "INET") {
     imports.local.add("duckDbInet");
     return { builder: `duckDbInet(${columnName(column.name)})` };
@@ -1826,7 +2136,7 @@ function mapDuckDbType(column, imports, options) {
   }
   imports.pgCore.add("text");
   return {
-    builder: `text(${columnName(column.name)}) /* TODO: verify type ${upper} */`
+    builder: `text(${columnName(column.name)}) /* unsupported DuckDB type: ${upper} */`
   };
 }
 function parseStructFields(inner) {
@@ -2049,13 +2359,17 @@ export {
   wrapJson,
   wrapBlob,
   wrapArray,
+  toIdentifier,
   sumN,
   sumDistinctN,
+  splitTopLevel,
   rowNumber,
   resolvePoolSize,
   rank,
   prepareParams,
   percentileCont,
+  parseStructFields,
+  parseMapValue,
   olap,
   migrate,
   median,
@@ -2064,6 +2378,7 @@ export {
   isPool,
   isDuckDBWrapper,
   introspect,
+  formatLiteral,
   executeOnClient,
   executeInBatches,
   executeArrowOnClient,
@@ -2085,7 +2400,12 @@ export {
   denseRank,
   createDuckDBConnectionPool,
   countN,
+  coerceArrayString,
   closeClientConnection,
+  buildStructLiteral,
+  buildMapLiteral,
+  buildListLiteral,
+  buildDefault,
   avgN,
   anyValue,
   POOL_PRESETS,