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

package/dist/index.mjs

@@ -1,4 +1,5 @@
 // src/driver.ts
+import { DuckDBInstance as DuckDBInstance2 } from "@duckdb/node-api";
 import { entityKind as entityKind3 } from "drizzle-orm/entity";
 import { DefaultLogger } from "drizzle-orm/logger";
 import { PgDatabase } from "drizzle-orm/pg-core/db";
@@ -15,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
-var tableIdPropSelectionRegex = new RegExp([
-  `("(.+)"\\."(.+)")`,
-  `(\\s+as\\s+'?(.+?)'?\\.'?(.+?)'?)?`
-].join(""), "i");
-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 === "'" && 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 (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)];
       }
+      if (char === "/" && next === "*") {
+        scrubbed += "  ";
+        i += 1;
+        state = "blockComment";
+        continue;
+      }
+      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 === "'" && 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;
 }
@@ -317,6 +394,8 @@ import {
   timestampValue,
   timestampTZValue
 } from "@duckdb/node-api";
+
+// src/value-wrappers-core.ts
 var DUCKDB_VALUE_MARKER = Symbol.for("drizzle-duckdb:value");
 function isDuckDBWrapper(value) {
   return value !== null && typeof value === "object" && DUCKDB_VALUE_MARKER in value && value[DUCKDB_VALUE_MARKER] === true;
@@ -377,10 +456,18 @@ function wrapJson(data) {
     data
   };
 }
+
+// src/value-wrappers.ts
 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");
@@ -434,6 +521,9 @@ function wrapperToNodeApiValue(wrapper, toValue) {
 }
 
 // src/client.ts
+function isPool(client) {
+  return typeof client.acquire === "function";
+}
 function isPgArrayLiteral(value) {
   return value.startsWith("{") && value.endsWith("}");
 }
@@ -445,18 +535,19 @@ function parsePgArrayLiteral(value) {
     return value;
   }
 }
-var warnedArrayLiteral = false;
 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 (!warnedArrayLiteral && options.warnOnStringArrayLiteral) {
-        warnedArrayLiteral = true;
-        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;
   });
@@ -510,6 +601,14 @@ async function closeClientConnection(connection) {
   }
 }
 async function executeOnClient(client, query, params) {
+  if (isPool(client)) {
+    const connection = await client.acquire();
+    try {
+      return await executeOnClient(connection, query, params);
+    } finally {
+      await client.release(connection);
+    }
+  }
   const values = params.length > 0 ? params.map((param) => toNodeApiValue(param)) : undefined;
   const result = await client.run(query, values);
   const rows = await result.getRowsJS();
@@ -518,6 +617,15 @@ async function executeOnClient(client, query, params) {
   return rows ? mapRowsToObjects(uniqueColumns, rows) : [];
 }
 async function* executeInBatches(client, query, params, options = {}) {
+  if (isPool(client)) {
+    const connection = await client.acquire();
+    try {
+      yield* executeInBatches(connection, query, params, options);
+      return;
+    } finally {
+      await client.release(connection);
+    }
+  }
   const rowsPerChunk = options.rowsPerChunk && options.rowsPerChunk > 0 ? options.rowsPerChunk : 1e5;
   const values = params.length > 0 ? params.map((param) => toNodeApiValue(param)) : undefined;
   const result = await client.stream(query, values);
@@ -539,6 +647,14 @@ async function* executeInBatches(client, query, params, options = {}) {
   }
 }
 async function executeArrowOnClient(client, query, params) {
+  if (isPool(client)) {
+    const connection = await client.acquire();
+    try {
+      return await executeArrowOnClient(connection, query, params);
+    } finally {
+      await client.release(connection);
+    }
+  }
   const values = params.length > 0 ? params.map((param) => toNodeApiValue(param)) : undefined;
   const result = await client.run(query, values);
   const maybeArrow = result.toArrow ?? result.getArrowTable;
@@ -549,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;
@@ -613,6 +736,7 @@ class DuckDBSession extends PgSession {
   rewriteArrays;
   rejectStringArrayLiterals;
   hasWarnedArrayLiteral = false;
+  rollbackOnly = false;
   constructor(client, dialect, schema, options = {}) {
     super(dialect);
     this.client = client;
@@ -626,17 +750,46 @@ 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) {
-    const session = new DuckDBSession(this.client, this.dialect, this.schema, this.options);
+  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;
+    if (isPool(this.client)) {
+      pool = this.client;
+      pinnedConnection = await pool.acquire();
+      clientForTx = pinnedConnection;
+    }
+    const session = new DuckDBSession(clientForTx, this.dialect, this.schema, this.options);
     const tx = new DuckDBTransaction(this.dialect, session, this.schema);
-    await tx.execute(sql`BEGIN TRANSACTION;`);
     try {
-      const result = await transaction(tx);
-      await tx.execute(sql`commit`);
-      return result;
-    } catch (error) {
-      await tx.execute(sql`rollback`);
-      throw error;
+      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) {
+        await tx.execute(sql`rollback`);
+        throw error;
+      }
+    } finally {
+      if (pinnedConnection && pool) {
+        await pool.release(pinnedConnection);
+      }
     }
   }
   warnOnStringArrayLiteral = (query) => {
@@ -648,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)
@@ -661,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)
@@ -673,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 {
@@ -703,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.";
@@ -726,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";
@@ -771,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)) {
@@ -884,6 +1100,179 @@ class DuckDBSelectBuilder extends PgSelectBuilder {
   }
 }
 
+// src/pool.ts
+import { DuckDBConnection } from "@duckdb/node-api";
+var POOL_PRESETS = {
+  pulse: 4,
+  standard: 6,
+  jumbo: 8,
+  mega: 12,
+  giga: 16,
+  local: 8,
+  memory: 4
+};
+function resolvePoolSize(pool) {
+  if (pool === false)
+    return false;
+  if (pool === undefined)
+    return 4;
+  if (typeof pool === "string")
+    return POOL_PRESETS[pool];
+  return pool.size ?? 4;
+}
+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");
+    }
+    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;
+      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, 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 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,
+      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.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,
+    release,
+    close,
+    size
+  };
+}
+
 // src/driver.ts
 class DuckDBDriver {
   client;
@@ -903,7 +1292,14 @@ class DuckDBDriver {
     });
   }
 }
-function drizzle(client, config = {}) {
+function isConfigObject(data) {
+  if (typeof data !== "object" || data === null)
+    return false;
+  if (data.constructor?.name !== "Object")
+    return false;
+  return "connection" in data || "client" in data || "pool" in data || "schema" in data || "logger" in data;
+}
+function createFromClient(client, config = {}, instance) {
   const dialect = new DuckDBDialect;
   const logger = config.logger === true ? new DefaultLogger : config.logger || undefined;
   let schema;
@@ -921,17 +1317,71 @@ function drizzle(client, config = {}) {
     rejectStringArrayLiterals: config.rejectStringArrayLiterals
   });
   const session = driver.createSession(schema);
-  return new DuckDBDatabase(dialect, session, schema);
+  const db = new DuckDBDatabase(dialect, session, schema, client, instance);
+  return db;
+}
+async function createFromConnectionString(path, instanceOptions, config = {}) {
+  const instance = await DuckDBInstance2.create(path, instanceOptions);
+  const poolSize = resolvePoolSize(config.pool);
+  if (poolSize === false) {
+    const connection = await instance.connect();
+    return createFromClient(connection, config, instance);
+  }
+  const pool = createDuckDBConnectionPool(instance, { size: poolSize });
+  return createFromClient(pool, config, instance);
+}
+function drizzle(clientOrConfigOrPath, config) {
+  if (typeof clientOrConfigOrPath === "string") {
+    return createFromConnectionString(clientOrConfigOrPath, undefined, config);
+  }
+  if (isConfigObject(clientOrConfigOrPath)) {
+    const configObj = clientOrConfigOrPath;
+    if ("connection" in configObj) {
+      const connConfig = configObj;
+      const { connection, ...restConfig } = connConfig;
+      if (typeof connection === "string") {
+        return createFromConnectionString(connection, undefined, restConfig);
+      }
+      return createFromConnectionString(connection.path, connection.options, restConfig);
+    }
+    if ("client" in configObj) {
+      const clientConfig = configObj;
+      const { client: clientValue, ...restConfig } = clientConfig;
+      return createFromClient(clientValue, restConfig);
+    }
+    throw new Error("Invalid drizzle config: either connection or client must be provided");
+  }
+  return createFromClient(clientOrConfigOrPath, config);
 }
 
 class DuckDBDatabase extends PgDatabase {
   dialect;
   session;
   static [entityKind3] = "DuckDBDatabase";
-  constructor(dialect, session, schema) {
+  $client;
+  $instance;
+  constructor(dialect, session, schema, client, instance) {
     super(dialect, session, schema);
     this.dialect = dialect;
     this.session = session;
+    this.$client = client;
+    this.$instance = instance;
+  }
+  async close() {
+    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;
@@ -1015,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}[]`;
@@ -1028,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({
@@ -1048,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({
@@ -1220,7 +1677,7 @@ async function migrate(db, config) {
 // src/introspect.ts
 import { sql as sql5 } from "drizzle-orm";
 var SYSTEM_SCHEMAS = new Set(["information_schema", "pg_catalog"]);
-var DEFAULT_IMPORT_BASE = "@leonardovida-md/drizzle-neo-duckdb";
+var DEFAULT_IMPORT_BASE = "@leonardovida-md/drizzle-neo-duckdb/helpers";
 async function introspect(db, opts = {}) {
   const database = await resolveDatabase(db, opts.database, opts.allDatabases);
   const schemas = await resolveSchemas(db, database, opts.schemas);
@@ -1556,6 +2013,22 @@ function mapDuckDbType(column, imports, options) {
     imports.pgCore.add("doublePrecision");
     return { builder: `doublePrecision(${columnName(column.name)})` };
   }
+  const arrayMatch = /^(.*)\[(\d+)\]$/.exec(upper);
+  if (arrayMatch) {
+    imports.local.add("duckDbArray");
+    const [, base, length] = arrayMatch;
+    return {
+      builder: `duckDbArray(${columnName(column.name)}, ${JSON.stringify(base)}, ${Number(length)})`
+    };
+  }
+  const listMatch = /^(.*)\[\]$/.exec(upper);
+  if (listMatch) {
+    imports.local.add("duckDbList");
+    const [, base] = listMatch;
+    return {
+      builder: `duckDbList(${columnName(column.name)}, ${JSON.stringify(base)})`
+    };
+  }
   if (upper.startsWith("CHAR(") || upper === "CHAR") {
     imports.pgCore.add("char");
     const length = column.characterLength;
@@ -1584,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)})` };
@@ -1596,22 +2083,6 @@ function mapDuckDbType(column, imports, options) {
     imports.local.add("duckDbBlob");
     return { builder: `duckDbBlob(${columnName(column.name)})` };
   }
-  const arrayMatch = /^(.*)\[(\d+)\]$/.exec(upper);
-  if (arrayMatch) {
-    imports.local.add("duckDbArray");
-    const [, base, length] = arrayMatch;
-    return {
-      builder: `duckDbArray(${columnName(column.name)}, ${JSON.stringify(base)}, ${Number(length)})`
-    };
-  }
-  const listMatch = /^(.*)\[\]$/.exec(upper);
-  if (listMatch) {
-    imports.local.add("duckDbList");
-    const [, base] = listMatch;
-    return {
-      builder: `duckDbList(${columnName(column.name)}, ${JSON.stringify(base)})`
-    };
-  }
   if (upper.startsWith("STRUCT")) {
     imports.local.add("duckDbStruct");
     const inner = upper.replace(/^STRUCT\s*\(/i, "").replace(/\)$/, "");
@@ -1665,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) {
@@ -1888,19 +2359,26 @@ export {
   wrapJson,
   wrapBlob,
   wrapArray,
+  toIdentifier,
   sumN,
   sumDistinctN,
+  splitTopLevel,
   rowNumber,
+  resolvePoolSize,
   rank,
   prepareParams,
   percentileCont,
+  parseStructFields,
+  parseMapValue,
   olap,
   migrate,
   median,
   lead,
   lag,
+  isPool,
   isDuckDBWrapper,
   introspect,
+  formatLiteral,
   executeOnClient,
   executeInBatches,
   executeArrowOnClient,
@@ -1920,15 +2398,23 @@ export {
   duckDbArray,
   drizzle,
   denseRank,
+  createDuckDBConnectionPool,
   countN,
+  coerceArrayString,
   closeClientConnection,
+  buildStructLiteral,
+  buildMapLiteral,
+  buildListLiteral,
+  buildDefault,
   avgN,
   anyValue,
+  POOL_PRESETS,
   OlapBuilder,
   DuckDBTransaction,
   DuckDBSession,
   DuckDBPreparedQuery,
   DuckDBDriver,
   DuckDBDatabase,
-  DUCKDB_VALUE_MARKER
+  DUCKDB_VALUE_MARKER,
+  DEFAULT_IMPORT_BASE
 };