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

package/dist/duckdb-introspect.mjs

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 
 // src/bin/duckdb-introspect.ts
-import { DuckDBInstance } from "@duckdb/node-api";
+import { DuckDBInstance as DuckDBInstance3 } from "@duckdb/node-api";
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
 
 // 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";
@@ -23,83 +24,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 (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 = "lineComment";
+        continue;
+      }
+      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;
 }
@@ -325,11 +402,21 @@ import {
   timestampValue,
   timestampTZValue
 } from "@duckdb/node-api";
+
+// src/value-wrappers-core.ts
 var DUCKDB_VALUE_MARKER = Symbol.for("drizzle-duckdb:value");
+
+// 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");
@@ -383,6 +470,9 @@ function wrapperToNodeApiValue(wrapper, toValue) {
 }
 
 // src/client.ts
+function isPool(client) {
+  return typeof client.acquire === "function";
+}
 function isPgArrayLiteral(value) {
   return value.startsWith("{") && value.endsWith("}");
 }
@@ -394,18 +484,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;
   });
@@ -445,7 +536,28 @@ function mapRowsToObjects(columns, rows) {
     return obj;
   });
 }
+async function closeClientConnection(connection) {
+  if ("close" in connection && typeof connection.close === "function") {
+    await connection.close();
+    return;
+  }
+  if ("closeSync" in connection && typeof connection.closeSync === "function") {
+    connection.closeSync();
+    return;
+  }
+  if ("disconnectSync" in connection && typeof connection.disconnectSync === "function") {
+    connection.disconnectSync();
+  }
+}
 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();
@@ -454,6 +566,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);
@@ -475,6 +596,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;
@@ -485,6 +614,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;
@@ -549,6 +685,7 @@ class DuckDBSession extends PgSession {
   rewriteArrays;
   rejectStringArrayLiterals;
   hasWarnedArrayLiteral = false;
+  rollbackOnly = false;
   constructor(client, dialect, schema, options = {}) {
     super(dialect);
     this.client = client;
@@ -562,17 +699,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) => {
@@ -584,7 +750,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)
@@ -597,7 +765,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)
@@ -609,6 +779,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 {
@@ -639,8 +815,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.";
@@ -662,15 +876,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";
@@ -707,8 +936,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)) {
@@ -820,6 +1049,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;
@@ -839,7 +1241,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;
@@ -857,17 +1266,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;
@@ -891,7 +1354,7 @@ class DuckDBDatabase extends PgDatabase {
 // src/introspect.ts
 import { sql as sql4 } 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);
@@ -1227,6 +1690,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;
@@ -1255,6 +1734,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)})` };
@@ -1267,22 +1760,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(/\)$/, "");
@@ -1336,7 +1813,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) {
@@ -1446,6 +1923,7 @@ function renderImports(imports, importBasePath) {
 function parseArgs(argv) {
   const options = {
     outFile: path.resolve(process.cwd(), "drizzle/schema.ts"),
+    outMeta: undefined,
     allDatabases: false,
     includeViews: false,
     useCustomTimeTypes: true
@@ -1471,6 +1949,11 @@ function parseArgs(argv) {
       case "--outFile":
         options.outFile = path.resolve(process.cwd(), argv[++i] ?? "drizzle/schema.ts");
         break;
+      case "--out-json":
+      case "--outJson":
+      case "--json":
+        options.outMeta = path.resolve(process.cwd(), argv[++i] ?? "drizzle/schema.meta.json");
+        break;
       case "--include-views":
       case "--includeViews":
         options.includeViews = true;
@@ -1505,6 +1988,7 @@ Options:
   --all-databases  Introspect all attached databases (not just current)
   --schema         Comma separated schema list (defaults to all non-system schemas)
   --out            Output file (default: ./drizzle/schema.ts)
+  --json           Optional JSON metadata output (default: ./drizzle/schema.meta.json)
   --include-views  Include views in the generated schema
   --use-pg-time    Use pg-core timestamp/date/time instead of DuckDB custom helpers
   --import-base    Override import path for duckdb helpers (default: package name)
@@ -1531,7 +2015,7 @@ async function main() {
     throw new Error("Missing required --url");
   }
   const instanceOptions = options.url.startsWith("md:") && process.env.MOTHERDUCK_TOKEN ? { motherduck_token: process.env.MOTHERDUCK_TOKEN } : undefined;
-  const instance = await DuckDBInstance.create(options.url, instanceOptions);
+  const instance = await DuckDBInstance3.create(options.url, instanceOptions);
   const connection = await instance.connect();
   const db = drizzle(connection);
   try {
@@ -1545,11 +2029,23 @@ async function main() {
     });
     await mkdir(path.dirname(options.outFile), { recursive: true });
     await writeFile(options.outFile, result.files.schemaTs, "utf8");
+    if (options.outMeta) {
+      await mkdir(path.dirname(options.outMeta), { recursive: true });
+      await writeFile(options.outMeta, JSON.stringify(result.files.metaJson, null, 2), "utf8");
+    }
     console.log(`Wrote schema to ${options.outFile}`);
+    if (options.outMeta) {
+      console.log(`Wrote metadata to ${options.outMeta}`);
+    }
   } finally {
     if ("closeSync" in connection && typeof connection.closeSync === "function") {
       connection.closeSync();
     }
+    if ("closeSync" in instance && typeof instance.closeSync === "function") {
+      instance.closeSync();
+    } else if ("close" in instance && typeof instance.close === "function") {
+      await instance.close();
+    }
   }
 }
 main().catch((err) => {