@duckdbfan/drizzle-duckdb 0.0.7 → 1.3.2

package/dist/duckdb-introspect.mjs

@@ -0,0 +1,2890 @@
+#!/usr/bin/env node
+
+// src/bin/duckdb-introspect.ts
+import { DuckDBInstance as DuckDBInstance3 } from "@duckdb/node-api";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import process2 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";
+import {
+  createTableRelationsHelpers,
+  extractTablesRelationalConfig
+} from "drizzle-orm/relations";
+
+// src/session.ts
+import { entityKind } from "drizzle-orm/entity";
+import { NoopLogger } from "drizzle-orm/logger";
+import { PgTransaction } from "drizzle-orm/pg-core";
+import { PgPreparedQuery, PgSession } from "drizzle-orm/pg-core/session";
+import { fillPlaceholders, sql } from "drizzle-orm/sql/sql";
+
+// src/sql/result-mapper.ts
+import {
+  Column,
+  SQL,
+  getTableName,
+  is
+} from "drizzle-orm";
+import {
+  PgCustomColumn,
+  PgDate,
+  PgDateString,
+  PgInterval,
+  PgTime,
+  PgTimestamp,
+  PgTimestampString
+} from "drizzle-orm/pg-core";
+function toDecoderInput(decoder, value) {
+  return value;
+}
+function normalizeInet(value) {
+  if (value && typeof value === "object" && "address" in value && typeof value.address !== "undefined") {
+    const { address, mask } = value;
+    if (typeof address === "bigint" || typeof address === "number") {
+      const inet = typeof address === "number" ? BigInt(address) : address;
+      const maxIpv4 = (1n << 32n) - 1n;
+      if (inet >= 0 && inet <= maxIpv4) {
+        const num = Number(inet);
+        const octets = [
+          num >>> 24 & 255,
+          num >>> 16 & 255,
+          num >>> 8 & 255,
+          num & 255
+        ];
+        const suffix = typeof mask === "number" && mask !== 32 ? `/${mask}` : "";
+        return `${octets.join(".")}${suffix}`;
+      }
+    }
+    const fallback = value.toString?.();
+    if (fallback && fallback !== "[object Object]") {
+      return fallback;
+    }
+  }
+  return value;
+}
+function normalizeTimestampString(value, withTimezone) {
+  if (value instanceof Date) {
+    const iso = value.toISOString().replace("T", " ");
+    return withTimezone ? iso.replace("Z", "+00") : iso.replace("Z", "");
+  }
+  if (typeof value === "string") {
+    const normalized = value.replace("T", " ");
+    if (withTimezone) {
+      return normalized.includes("+") ? normalized : `${normalized}+00`;
+    }
+    return normalized.replace(/\+00$/, "");
+  }
+  return value;
+}
+function normalizeTimestamp(value, withTimezone) {
+  if (value instanceof Date) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const hasOffset = value.endsWith("Z") || /[+-]\d{2}:?\d{2}$/.test(value.trim());
+    const spaced = value.replace(" ", "T");
+    const normalized = withTimezone || hasOffset ? spaced : `${spaced}+00`;
+    return new Date(normalized);
+  }
+  return value;
+}
+function normalizeDateString(value) {
+  if (value instanceof Date) {
+    return value.toISOString().slice(0, 10);
+  }
+  if (typeof value === "string") {
+    return value.slice(0, 10);
+  }
+  return value;
+}
+function normalizeDateValue(value) {
+  if (value instanceof Date) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return new Date(`${value.slice(0, 10)}T00:00:00Z`);
+  }
+  return value;
+}
+function normalizeTime(value) {
+  if (typeof value === "bigint") {
+    const totalMillis = Number(value) / 1000;
+    const date = new Date(totalMillis);
+    return date.toISOString().split("T")[1].replace("Z", "");
+  }
+  if (value instanceof Date) {
+    return value.toISOString().split("T")[1].replace("Z", "");
+  }
+  return value;
+}
+function normalizeInterval(value) {
+  if (value && typeof value === "object" && "days" in value && "months" in value) {
+    const { months, days, micros } = value;
+    if (months === 0 && days !== undefined) {
+      if (micros && Number(micros) !== 0) {
+        const seconds = Number(micros) / 1e6;
+        return `${days} day${days === 1 ? "" : "s"} ${seconds} seconds`.trim();
+      }
+      return `${days} day${days === 1 ? "" : "s"}`;
+    }
+  }
+  return value;
+}
+function mapDriverValue(decoder, rawValue) {
+  if (is(decoder, PgTimestampString)) {
+    return decoder.mapFromDriverValue(toDecoderInput(decoder, normalizeTimestampString(rawValue, decoder.withTimezone)));
+  }
+  if (is(decoder, PgTimestamp)) {
+    const normalized = normalizeTimestamp(rawValue, decoder.withTimezone);
+    if (normalized instanceof Date) {
+      return normalized;
+    }
+    return decoder.mapFromDriverValue(toDecoderInput(decoder, normalized));
+  }
+  if (is(decoder, PgDateString)) {
+    return decoder.mapFromDriverValue(toDecoderInput(decoder, normalizeDateString(rawValue)));
+  }
+  if (is(decoder, PgDate)) {
+    return decoder.mapFromDriverValue(toDecoderInput(decoder, normalizeDateValue(rawValue)));
+  }
+  if (is(decoder, PgTime)) {
+    return decoder.mapFromDriverValue(toDecoderInput(decoder, normalizeTime(rawValue)));
+  }
+  if (is(decoder, PgInterval)) {
+    return decoder.mapFromDriverValue(toDecoderInput(decoder, normalizeInterval(rawValue)));
+  }
+  return decoder.mapFromDriverValue(toDecoderInput(decoder, rawValue));
+}
+function mapResultRow(columns, row, joinsNotNullableMap) {
+  const nullifyMap = {};
+  const result = columns.reduce((acc, { path, field }, columnIndex) => {
+    let decoder;
+    if (is(field, Column)) {
+      decoder = field;
+    } else if (is(field, SQL)) {
+      decoder = field.decoder;
+    } else {
+      const col = field.sql.queryChunks.find((chunk) => is(chunk, Column));
+      if (is(col, PgCustomColumn)) {
+        decoder = col;
+      } else {
+        decoder = field.sql.decoder;
+      }
+    }
+    let node = acc;
+    for (const [pathChunkIndex, pathChunk] of path.entries()) {
+      if (pathChunkIndex < path.length - 1) {
+        if (!(pathChunk in node)) {
+          node[pathChunk] = {};
+        }
+        node = node[pathChunk];
+        continue;
+      }
+      const rawValue = normalizeInet(row[columnIndex]);
+      const value = node[pathChunk] = rawValue === null ? null : mapDriverValue(decoder, rawValue);
+      if (joinsNotNullableMap && is(field, Column) && path.length === 2) {
+        const objectName = path[0];
+        if (!(objectName in nullifyMap)) {
+          nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
+        } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
+          nullifyMap[objectName] = false;
+        }
+        continue;
+      }
+      if (joinsNotNullableMap && is(field, SQL.Aliased) && path.length === 2) {
+        const col = field.sql.queryChunks.find((chunk) => is(chunk, Column));
+        const tableName = col?.table && getTableName(col?.table);
+        if (!tableName) {
+          continue;
+        }
+        const objectName = path[0];
+        if (!(objectName in nullifyMap)) {
+          nullifyMap[objectName] = value === null ? tableName : false;
+          continue;
+        }
+        if (nullifyMap[objectName] && nullifyMap[objectName] !== tableName) {
+          nullifyMap[objectName] = false;
+        }
+        continue;
+      }
+    }
+    return acc;
+  }, {});
+  if (joinsNotNullableMap && Object.keys(nullifyMap).length > 0) {
+    for (const [objectName, tableName] of Object.entries(nullifyMap)) {
+      if (typeof tableName === "string" && !joinsNotNullableMap[tableName]) {
+        result[objectName] = null;
+      }
+    }
+  }
+  return result;
+}
+
+// src/session.ts
+import { TransactionRollbackError } from "drizzle-orm/errors";
+
+// src/client.ts
+import {
+  listValue as listValue2,
+  timestampValue as timestampValue2
+} from "@duckdb/node-api";
+
+// src/value-wrappers.ts
+import {
+  listValue,
+  arrayValue,
+  structValue,
+  mapValue,
+  blobValue,
+  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");
+  }
+  if (!normalized.endsWith("Z") && !/[+-]\d{2}:?\d{2}$/.test(normalized)) {
+    normalized += "Z";
+  }
+  const date = new Date(normalized);
+  if (isNaN(date.getTime())) {
+    throw new Error(`Invalid timestamp string: ${value}`);
+  }
+  return BigInt(date.getTime()) * 1000n;
+}
+function toUint8Array(data) {
+  return data instanceof Uint8Array && !(data instanceof Buffer) ? data : new Uint8Array(data);
+}
+function convertStructEntries(data, toValue) {
+  const entries = {};
+  for (const [key, val] of Object.entries(data)) {
+    entries[key] = toValue(val);
+  }
+  return entries;
+}
+function convertMapEntries(data, toValue) {
+  return Object.entries(data).map(([key, val]) => ({
+    key,
+    value: toValue(val)
+  }));
+}
+function wrapperToNodeApiValue(wrapper, toValue) {
+  switch (wrapper.kind) {
+    case "list":
+      return listValue(wrapper.data.map(toValue));
+    case "array":
+      return arrayValue(wrapper.data.map(toValue));
+    case "struct":
+      return structValue(convertStructEntries(wrapper.data, toValue));
+    case "map":
+      return mapValue(convertMapEntries(wrapper.data, toValue));
+    case "timestamp":
+      return wrapper.withTimezone ? timestampTZValue(dateToMicros(wrapper.data)) : timestampValue(dateToMicros(wrapper.data));
+    case "blob":
+      return blobValue(toUint8Array(wrapper.data));
+    case "json":
+      return JSON.stringify(wrapper.data);
+    default: {
+      const _exhaustive = wrapper;
+      throw new Error(`Unknown wrapper kind: ${_exhaustive.kind}`);
+    }
+  }
+}
+
+// src/client.ts
+function isPool(client) {
+  return typeof client.acquire === "function";
+}
+var PREPARED_CACHE = Symbol.for("drizzle-duckdb:prepared-cache");
+function isPgArrayLiteral(value) {
+  return value.startsWith("{") && value.endsWith("}");
+}
+function parsePgArrayLiteral(value) {
+  const json = value.replace(/{/g, "[").replace(/}/g, "]");
+  try {
+    return JSON.parse(json);
+  } catch {
+    return value;
+  }
+}
+function prepareParams(params, options = {}) {
+  return params.map((param) => {
+    if (typeof param === "string" && param.length > 0) {
+      const firstChar = param[0];
+      const maybeArrayLiteral = firstChar === "{" || firstChar === "[" || firstChar === " " || firstChar === "\t";
+      if (maybeArrayLiteral) {
+        const trimmed = firstChar === "{" || firstChar === "[" ? param : 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 param;
+  });
+}
+function toNodeApiValue(value) {
+  if (value == null)
+    return null;
+  const t = typeof value;
+  if (t === "string" || t === "number" || t === "bigint" || t === "boolean") {
+    return value;
+  }
+  if (t === "object" && DUCKDB_VALUE_MARKER in value) {
+    return wrapperToNodeApiValue(value, toNodeApiValue);
+  }
+  if (Array.isArray(value)) {
+    return listValue2(value.map((inner) => toNodeApiValue(inner)));
+  }
+  if (value instanceof Date) {
+    return timestampValue2(BigInt(value.getTime()) * 1000n);
+  }
+  return value;
+}
+function deduplicateColumns(columns) {
+  const counts = new Map;
+  let hasDuplicates = false;
+  for (const column of columns) {
+    const next = (counts.get(column) ?? 0) + 1;
+    counts.set(column, next);
+    if (next > 1) {
+      hasDuplicates = true;
+      break;
+    }
+  }
+  if (!hasDuplicates) {
+    return columns;
+  }
+  counts.clear();
+  return columns.map((column) => {
+    const count = counts.get(column) ?? 0;
+    counts.set(column, count + 1);
+    return count === 0 ? column : `${column}_${count}`;
+  });
+}
+function destroyPreparedStatement(entry) {
+  if (!entry)
+    return;
+  try {
+    entry.statement.destroySync();
+  } catch {}
+}
+function getPreparedCache(connection, size) {
+  const store = connection;
+  const existing = store[PREPARED_CACHE];
+  if (existing) {
+    existing.size = size;
+    return existing;
+  }
+  const cache = { size, entries: new Map };
+  store[PREPARED_CACHE] = cache;
+  return cache;
+}
+function evictOldest(cache) {
+  const oldest = cache.entries.keys().next();
+  if (!oldest.done) {
+    const key = oldest.value;
+    const entry = cache.entries.get(key);
+    cache.entries.delete(key);
+    destroyPreparedStatement(entry);
+  }
+}
+function evictCacheEntry(cache, key) {
+  const entry = cache.entries.get(key);
+  cache.entries.delete(key);
+  destroyPreparedStatement(entry);
+}
+async function getOrPrepareStatement(connection, query, cacheConfig) {
+  const cache = getPreparedCache(connection, cacheConfig.size);
+  const cached = cache.entries.get(query);
+  if (cached) {
+    cache.entries.delete(query);
+    cache.entries.set(query, cached);
+    return cached.statement;
+  }
+  const statement = await connection.prepare(query);
+  cache.entries.set(query, { statement });
+  while (cache.entries.size > cache.size) {
+    evictOldest(cache);
+  }
+  return statement;
+}
+async function materializeResultRows(result) {
+  const rows = await result.getRowsJS() ?? [];
+  const baseColumns = typeof result.deduplicatedColumnNames === "function" ? result.deduplicatedColumnNames() : result.columnNames();
+  const columns = typeof result.deduplicatedColumnNames === "function" ? baseColumns : deduplicateColumns(baseColumns);
+  return { columns, rows };
+}
+async function materializeRows(client, query, params, options = {}) {
+  if (isPool(client)) {
+    const connection2 = await client.acquire();
+    try {
+      return await materializeRows(connection2, query, params, options);
+    } finally {
+      await client.release(connection2);
+    }
+  }
+  const values = params.length > 0 ? params.map((param) => toNodeApiValue(param)) : undefined;
+  const connection = client;
+  if (options.prepareCache && typeof connection.prepare === "function") {
+    const cache = getPreparedCache(connection, options.prepareCache.size);
+    try {
+      const statement = await getOrPrepareStatement(connection, query, options.prepareCache);
+      if (values) {
+        statement.bind(values);
+      } else {
+        statement.clearBindings?.();
+      }
+      const result2 = await statement.run();
+      cache.entries.delete(query);
+      cache.entries.set(query, { statement });
+      return await materializeResultRows(result2);
+    } catch (error) {
+      evictCacheEntry(cache, query);
+      throw error;
+    }
+  }
+  const result = await connection.run(query, values);
+  return await materializeResultRows(result);
+}
+function clearPreparedCache(connection) {
+  const store = connection;
+  const cache = store[PREPARED_CACHE];
+  if (!cache)
+    return;
+  for (const entry of cache.entries.values()) {
+    destroyPreparedStatement(entry);
+  }
+  cache.entries.clear();
+}
+function mapRowsToObjects(columns, rows) {
+  return rows.map((vals) => {
+    const obj = {};
+    columns.forEach((col, idx) => {
+      obj[col] = vals[idx];
+    });
+    return obj;
+  });
+}
+async function closeClientConnection(connection) {
+  clearPreparedCache(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, options = {}) {
+  const { columns, rows } = await materializeRows(client, query, params, options);
+  if (!rows || rows.length === 0) {
+    return [];
+  }
+  return mapRowsToObjects(columns, rows);
+}
+async function executeArraysOnClient(client, query, params, options = {}) {
+  return await materializeRows(client, query, params, options);
+}
+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);
+  const rawColumns = typeof result.deduplicatedColumnNames === "function" ? result.deduplicatedColumnNames() : result.columnNames();
+  const columns = typeof result.deduplicatedColumnNames === "function" ? rawColumns : deduplicateColumns(rawColumns);
+  let buffer = [];
+  for await (const chunk of result.yieldRowsJs()) {
+    const objects = mapRowsToObjects(columns, chunk);
+    for (const row of objects) {
+      buffer.push(row);
+      if (buffer.length >= rowsPerChunk) {
+        yield buffer;
+        buffer = [];
+      }
+    }
+  }
+  if (buffer.length > 0) {
+    yield buffer;
+  }
+}
+async function* executeInBatchesRaw(client, query, params, options = {}) {
+  if (isPool(client)) {
+    const connection = await client.acquire();
+    try {
+      yield* executeInBatchesRaw(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);
+  const rawColumns = typeof result.deduplicatedColumnNames === "function" ? result.deduplicatedColumnNames() : result.columnNames();
+  const columns = typeof result.deduplicatedColumnNames === "function" ? rawColumns : deduplicateColumns(rawColumns);
+  let buffer = [];
+  for await (const chunk of result.yieldRowsJs()) {
+    for (const row of chunk) {
+      buffer.push(row);
+      if (buffer.length >= rowsPerChunk) {
+        yield { columns, rows: buffer };
+        buffer = [];
+      }
+    }
+  }
+  if (buffer.length > 0) {
+    yield { columns, rows: buffer };
+  }
+}
+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;
+  if (typeof maybeArrow === "function") {
+    return await maybeArrow.call(result);
+  }
+  return result.getColumnsObjectJS();
+}
+
+// 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;
+  queryString;
+  params;
+  logger;
+  fields;
+  _isResponseInArrayMode;
+  customResultMapper;
+  rejectStringArrayLiterals;
+  prepareCache;
+  warnOnStringArrayLiteral;
+  static [entityKind] = "DuckDBPreparedQuery";
+  constructor(client, dialect, queryString, params, logger, fields, _isResponseInArrayMode, customResultMapper, rejectStringArrayLiterals, prepareCache, warnOnStringArrayLiteral) {
+    super({ sql: queryString, params });
+    this.client = client;
+    this.dialect = dialect;
+    this.queryString = queryString;
+    this.params = params;
+    this.logger = logger;
+    this.fields = fields;
+    this._isResponseInArrayMode = _isResponseInArrayMode;
+    this.customResultMapper = customResultMapper;
+    this.rejectStringArrayLiterals = rejectStringArrayLiterals;
+    this.prepareCache = prepareCache;
+    this.warnOnStringArrayLiteral = warnOnStringArrayLiteral;
+  }
+  async execute(placeholderValues = {}) {
+    this.dialect.assertNoPgJsonColumns();
+    const params = prepareParams(fillPlaceholders(this.params, placeholderValues), {
+      rejectStringArrayLiterals: this.rejectStringArrayLiterals,
+      warnOnStringArrayLiteral: this.warnOnStringArrayLiteral ? () => this.warnOnStringArrayLiteral?.(this.queryString) : undefined
+    });
+    this.logger.logQuery(this.queryString, params);
+    const { fields, joinsNotNullableMap, customResultMapper } = this;
+    if (fields) {
+      const { rows: rows2 } = await executeArraysOnClient(this.client, this.queryString, params, { prepareCache: this.prepareCache });
+      if (rows2.length === 0) {
+        return [];
+      }
+      return customResultMapper ? customResultMapper(rows2) : rows2.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
+    }
+    const rows = await executeOnClient(this.client, this.queryString, params, {
+      prepareCache: this.prepareCache
+    });
+    return rows;
+  }
+  all(placeholderValues = {}) {
+    return this.execute(placeholderValues);
+  }
+  isResponseInArrayMode() {
+    return this._isResponseInArrayMode;
+  }
+}
+
+class DuckDBSession extends PgSession {
+  client;
+  schema;
+  options;
+  static [entityKind] = "DuckDBSession";
+  dialect;
+  logger;
+  rejectStringArrayLiterals;
+  prepareCache;
+  hasWarnedArrayLiteral = false;
+  rollbackOnly = false;
+  constructor(client, dialect, schema, options = {}) {
+    super(dialect);
+    this.client = client;
+    this.schema = schema;
+    this.options = options;
+    this.dialect = dialect;
+    this.logger = options.logger ?? new NoopLogger;
+    this.rejectStringArrayLiterals = options.rejectStringArrayLiterals ?? false;
+    this.prepareCache = options.prepareCache;
+    this.options = {
+      ...options,
+      prepareCache: this.prepareCache
+    };
+  }
+  prepareQuery(query, fields, name, isResponseInArrayMode, customResultMapper) {
+    return new DuckDBPreparedQuery(this.client, this.dialect, query.sql, query.params, this.logger, fields, isResponseInArrayMode, customResultMapper, this.rejectStringArrayLiterals, this.prepareCache, this.rejectStringArrayLiterals ? undefined : this.warnOnStringArrayLiteral);
+  }
+  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);
+    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) {
+        await tx.execute(sql`rollback`);
+        throw error;
+      }
+    } finally {
+      if (pinnedConnection && pool) {
+        await pool.release(pinnedConnection);
+      }
+    }
+  }
+  warnOnStringArrayLiteral = (query) => {
+    if (this.hasWarnedArrayLiteral) {
+      return;
+    }
+    this.hasWarnedArrayLiteral = true;
+    this.logger.logQuery(`[duckdb] ${arrayLiteralWarning}
+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)
+    });
+    this.logger.logQuery(builtQuery.sql, params);
+    return executeInBatches(this.client, builtQuery.sql, params, options);
+  }
+  executeBatchesRaw(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)
+    });
+    this.logger.logQuery(builtQuery.sql, params);
+    return executeInBatchesRaw(this.client, builtQuery.sql, 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)
+    });
+    this.logger.logQuery(builtQuery.sql, params);
+    return executeArrowOnClient(this.client, builtQuery.sql, params);
+  }
+  markRollbackOnly() {
+    this.rollbackOnly = true;
+  }
+  isRollbackOnly() {
+    return this.rollbackOnly;
+  }
+}
+
+class DuckDBTransaction extends PgTransaction {
+  static [entityKind] = "DuckDBTransaction";
+  rollback() {
+    throw new TransactionRollbackError;
+  }
+  getTransactionConfigSQL(config) {
+    const chunks = [];
+    if (config.isolationLevel) {
+      chunks.push(`isolation level ${config.isolationLevel}`);
+    }
+    if (config.accessMode) {
+      chunks.push(config.accessMode);
+    }
+    if (typeof config.deferrable === "boolean") {
+      chunks.push(config.deferrable ? "deferrable" : "not deferrable");
+    }
+    return sql.raw(chunks.join(" "));
+  }
+  setTransaction(config) {
+    return this.session.execute(sql`set transaction ${this.getTransactionConfigSQL(config)}`);
+  }
+  executeBatches(query, options = {}) {
+    return this.session.executeBatches(query, options);
+  }
+  executeBatchesRaw(query, options = {}) {
+    return this.session.executeBatchesRaw(query, options);
+  }
+  executeArrow(query) {
+    return this.session.executeArrow(query);
+  }
+  async transaction(transaction) {
+    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.";
+
+// src/dialect.ts
+import { entityKind as entityKind2, is as is2 } from "drizzle-orm/entity";
+import {
+  PgDate as PgDate2,
+  PgDateString as PgDateString2,
+  PgDialect,
+  PgJson,
+  PgJsonb,
+  PgNumeric,
+  PgTime as PgTime2,
+  PgTimestamp as PgTimestamp2,
+  PgTimestampString as PgTimestampString2,
+  PgUUID
+} from "drizzle-orm/pg-core";
+import {
+  sql as sql2
+} from "drizzle-orm";
+
+// src/sql/ast-transformer.ts
+import nodeSqlParser from "node-sql-parser";
+
+// src/sql/visitors/array-operators.ts
+var OPERATOR_MAP = {
+  "@>": { fn: "array_has_all" },
+  "<@": { fn: "array_has_all", swap: true },
+  "&&": { fn: "array_has_any" }
+};
+function walkExpression(expr, parent, key) {
+  if (!expr || typeof expr !== "object")
+    return false;
+  let transformed = false;
+  const exprObj = expr;
+  if ("type" in expr && exprObj.type === "binary_expr") {
+    const binary = expr;
+    const mapping = OPERATOR_MAP[binary.operator];
+    if (mapping) {
+      const fnExpr = {
+        type: "function",
+        name: { name: [{ type: "default", value: mapping.fn }] },
+        args: {
+          type: "expr_list",
+          value: mapping.swap ? [binary.right, binary.left] : [binary.left, binary.right]
+        }
+      };
+      if (parent && key) {
+        parent[key] = fnExpr;
+      }
+      transformed = true;
+    } else {
+      transformed = walkExpression(binary.left, binary, "left") || transformed;
+      transformed = walkExpression(binary.right, binary, "right") || transformed;
+    }
+  }
+  if ("type" in expr && exprObj.type === "unary_expr") {
+    if ("expr" in exprObj) {
+      transformed = walkExpression(exprObj.expr, exprObj, "expr") || transformed;
+    }
+  }
+  if ("type" in expr && exprObj.type === "case") {
+    if ("expr" in exprObj && exprObj.expr) {
+      transformed = walkExpression(exprObj.expr, exprObj, "expr") || transformed;
+    }
+    if ("args" in exprObj && Array.isArray(exprObj.args)) {
+      for (let i = 0;i < exprObj.args.length; i++) {
+        const whenClause = exprObj.args[i];
+        if (whenClause.cond) {
+          transformed = walkExpression(whenClause.cond, whenClause, "cond") || transformed;
+        }
+        if (whenClause.result) {
+          transformed = walkExpression(whenClause.result, whenClause, "result") || transformed;
+        }
+      }
+    }
+  }
+  if ("args" in expr && exprObj.args) {
+    const args = exprObj.args;
+    if ("value" in args && Array.isArray(args.value)) {
+      for (let i = 0;i < args.value.length; i++) {
+        transformed = walkExpression(args.value[i], args.value, String(i)) || transformed;
+      }
+    } else if ("expr" in args) {
+      transformed = walkExpression(args.expr, args, "expr") || transformed;
+    }
+  }
+  if ("ast" in exprObj && exprObj.ast) {
+    const subAst = exprObj.ast;
+    if (subAst.type === "select") {
+      transformed = walkSelectImpl(subAst) || transformed;
+    }
+  }
+  if ("type" in expr && exprObj.type === "expr_list") {
+    if ("value" in exprObj && Array.isArray(exprObj.value)) {
+      for (let i = 0;i < exprObj.value.length; i++) {
+        transformed = walkExpression(exprObj.value[i], exprObj.value, String(i)) || transformed;
+      }
+    }
+  }
+  return transformed;
+}
+function walkFrom(from) {
+  if (!from || !Array.isArray(from))
+    return false;
+  let transformed = false;
+  for (const f of from) {
+    if ("join" in f) {
+      const join = f;
+      transformed = walkExpression(join.on, join, "on") || transformed;
+    }
+    if ("expr" in f && f.expr && "ast" in f.expr) {
+      transformed = walkSelectImpl(f.expr.ast) || transformed;
+    }
+  }
+  return transformed;
+}
+function walkSelectImpl(select) {
+  let transformed = false;
+  if (select.with) {
+    for (const cte of select.with) {
+      const cteSelect = cte.stmt?.ast ?? cte.stmt;
+      if (cteSelect && cteSelect.type === "select") {
+        transformed = walkSelectImpl(cteSelect) || transformed;
+      }
+    }
+  }
+  if (Array.isArray(select.from)) {
+    transformed = walkFrom(select.from) || transformed;
+  }
+  transformed = walkExpression(select.where, select, "where") || transformed;
+  if (select.having) {
+    if (Array.isArray(select.having)) {
+      for (let i = 0;i < select.having.length; i++) {
+        transformed = walkExpression(select.having[i], select.having, String(i)) || transformed;
+      }
+    } else {
+      transformed = walkExpression(select.having, select, "having") || transformed;
+    }
+  }
+  if (Array.isArray(select.columns)) {
+    for (const col of select.columns) {
+      if ("expr" in col) {
+        transformed = walkExpression(col.expr, col, "expr") || transformed;
+      }
+    }
+  }
+  if (select._next) {
+    transformed = walkSelectImpl(select._next) || transformed;
+  }
+  return transformed;
+}
+function transformArrayOperators(ast) {
+  const statements = Array.isArray(ast) ? ast : [ast];
+  let transformed = false;
+  for (const stmt of statements) {
+    if (stmt.type === "select") {
+      transformed = walkSelectImpl(stmt) || transformed;
+    }
+  }
+  return transformed;
+}
+
+// src/sql/visitors/column-qualifier.ts
+function getTableSource(from) {
+  if ("table" in from && from.table) {
+    return {
+      name: from.table,
+      alias: from.as ?? null,
+      schema: "db" in from ? from.db ?? null : null
+    };
+  }
+  if ("expr" in from && from.as) {
+    return {
+      name: from.as,
+      alias: from.as,
+      schema: null
+    };
+  }
+  return null;
+}
+function getQualifier(source) {
+  return {
+    table: source.alias ?? source.name,
+    schema: source.schema
+  };
+}
+function isUnqualifiedColumnRef(expr) {
+  return typeof expr === "object" && expr !== null && "type" in expr && expr.type === "column_ref" && (!("table" in expr) || !expr.table);
+}
+function isQualifiedColumnRef(expr) {
+  return typeof expr === "object" && expr !== null && "type" in expr && expr.type === "column_ref" && "table" in expr && !!expr.table;
+}
+function getColumnName(col) {
+  if (typeof col.column === "string") {
+    return col.column;
+  }
+  if (col.column && "expr" in col.column && col.column.expr?.value) {
+    return String(col.column.expr.value);
+  }
+  return null;
+}
+function applyQualifier(col, qualifier) {
+  col.table = qualifier.table;
+  if (!("schema" in col) || !col.schema) {
+    col.schema = qualifier.schema;
+  }
+}
+function unwrapColumnRef(expr) {
+  if (!expr || typeof expr !== "object")
+    return null;
+  if ("type" in expr && expr.type === "column_ref") {
+    return expr;
+  }
+  if ("expr" in expr && expr.expr) {
+    return unwrapColumnRef(expr.expr);
+  }
+  if ("ast" in expr && expr.ast && typeof expr.ast === "object") {
+    return null;
+  }
+  if ("args" in expr && expr.args) {
+    const args = expr.args;
+    if (args.expr) {
+      return unwrapColumnRef(args.expr);
+    }
+    if (args.value && args.value.length === 1) {
+      return unwrapColumnRef(args.value[0]);
+    }
+  }
+  return null;
+}
+function isBinaryExpr(expr) {
+  return !!expr && typeof expr === "object" && "type" in expr && expr.type === "binary_expr";
+}
+function walkOnClause(expr, leftQualifier, rightQualifier, ambiguousColumns) {
+  if (!expr || typeof expr !== "object")
+    return false;
+  let transformed = false;
+  if (isBinaryExpr(expr)) {
+    const left = expr.left;
+    const right = expr.right;
+    const leftCol = unwrapColumnRef(left);
+    const rightCol = unwrapColumnRef(right);
+    const leftUnqualified = leftCol ? isUnqualifiedColumnRef(leftCol) : false;
+    const rightUnqualified = rightCol ? isUnqualifiedColumnRef(rightCol) : false;
+    const leftQualified = leftCol ? isQualifiedColumnRef(leftCol) : false;
+    const rightQualified = rightCol ? isQualifiedColumnRef(rightCol) : false;
+    const leftColName = leftCol ? getColumnName(leftCol) : null;
+    const rightColName = rightCol ? getColumnName(rightCol) : null;
+    if (expr.operator === "=" && leftColName && rightColName && leftColName === rightColName) {
+      if (leftUnqualified && rightUnqualified) {
+        applyQualifier(leftCol, leftQualifier);
+        applyQualifier(rightCol, rightQualifier);
+        ambiguousColumns.add(leftColName);
+        transformed = true;
+      } else if (leftQualified && rightUnqualified) {
+        applyQualifier(rightCol, rightQualifier);
+        ambiguousColumns.add(rightColName);
+        transformed = true;
+      } else if (leftUnqualified && rightQualified) {
+        applyQualifier(leftCol, leftQualifier);
+        ambiguousColumns.add(leftColName);
+        transformed = true;
+      }
+    }
+    if (expr.operator === "=" && leftCol && rightCol && leftColName && rightColName && leftColName !== rightColName) {
+      if (leftQualified && rightUnqualified && !rightColName.includes(".")) {
+        applyQualifier(rightCol, rightQualifier);
+        transformed = true;
+      } else if (leftUnqualified && rightQualified && !leftColName.includes(".")) {
+        applyQualifier(leftCol, leftQualifier);
+        transformed = true;
+      }
+    }
+    transformed = walkOnClause(isBinaryExpr(expr.left) ? expr.left : expr.left, leftQualifier, rightQualifier, ambiguousColumns) || transformed;
+    transformed = walkOnClause(isBinaryExpr(expr.right) ? expr.right : expr.right, leftQualifier, rightQualifier, ambiguousColumns) || transformed;
+  }
+  return transformed;
+}
+function qualifyAmbiguousInExpression(expr, defaultQualifier, ambiguousColumns) {
+  if (!expr || typeof expr !== "object")
+    return false;
+  let transformed = false;
+  if (isUnqualifiedColumnRef(expr)) {
+    const colName = getColumnName(expr);
+    if (colName && ambiguousColumns.has(colName)) {
+      applyQualifier(expr, defaultQualifier);
+      transformed = true;
+    }
+    return transformed;
+  }
+  if (isBinaryExpr(expr)) {
+    const binary = expr;
+    transformed = qualifyAmbiguousInExpression(binary.left, defaultQualifier, ambiguousColumns) || transformed;
+    transformed = qualifyAmbiguousInExpression(binary.right, defaultQualifier, ambiguousColumns) || transformed;
+    return transformed;
+  }
+  if ("args" in expr && expr.args) {
+    const args = expr.args;
+    if (args.value && Array.isArray(args.value)) {
+      for (const arg of args.value) {
+        transformed = qualifyAmbiguousInExpression(arg, defaultQualifier, ambiguousColumns) || transformed;
+      }
+    }
+    if (args.expr) {
+      transformed = qualifyAmbiguousInExpression(args.expr, defaultQualifier, ambiguousColumns) || transformed;
+    }
+  }
+  if ("over" in expr && expr.over && typeof expr.over === "object") {
+    const over = expr.over;
+    if (Array.isArray(over.partition)) {
+      for (const part of over.partition) {
+        transformed = qualifyAmbiguousInExpression(part, defaultQualifier, ambiguousColumns) || transformed;
+      }
+    }
+    if (Array.isArray(over.orderby)) {
+      for (const order of over.orderby) {
+        transformed = qualifyAmbiguousInExpression(order, defaultQualifier, ambiguousColumns) || transformed;
+      }
+    }
+  }
+  return transformed;
+}
+function hasUnqualifiedColumns(expr) {
+  if (!expr || typeof expr !== "object")
+    return false;
+  if ("type" in expr && expr.type === "binary_expr") {
+    const left = expr.left;
+    const right = expr.right;
+    const leftCol = unwrapColumnRef(left);
+    const rightCol = unwrapColumnRef(right);
+    if (isUnqualifiedColumnRef(left) || isUnqualifiedColumnRef(right) || leftCol && isUnqualifiedColumnRef(leftCol) || rightCol && isUnqualifiedColumnRef(rightCol)) {
+      return true;
+    }
+    if (isBinaryExpr(expr.left) && hasUnqualifiedColumns(expr.left))
+      return true;
+    if (isBinaryExpr(expr.right) && hasUnqualifiedColumns(expr.right))
+      return true;
+  }
+  if ("args" in expr && expr.args) {
+    const args = expr.args;
+    if (args.expr && isUnqualifiedColumnRef(args.expr))
+      return true;
+    if (args.value) {
+      for (const arg of args.value) {
+        if (isUnqualifiedColumnRef(arg))
+          return true;
+      }
+    }
+  }
+  return false;
+}
+function walkSelect(select) {
+  let transformed = false;
+  const ambiguousColumns = new Set;
+  if (Array.isArray(select.from) && select.from.length >= 2) {
+    const firstSource = getTableSource(select.from[0]);
+    const defaultQualifier = firstSource ? getQualifier(firstSource) : null;
+    let prevSource = firstSource;
+    let hasAnyUnqualified = false;
+    for (const from of select.from) {
+      if ("join" in from) {
+        const join = from;
+        if (join.on && hasUnqualifiedColumns(join.on)) {
+          hasAnyUnqualified = true;
+          break;
+        }
+      }
+    }
+    if (!hasAnyUnqualified) {
+      for (const from of select.from) {
+        if ("expr" in from && from.expr && "ast" in from.expr) {
+          transformed = walkSelect(from.expr.ast) || transformed;
+        }
+      }
+    } else {
+      for (const from of select.from) {
+        if ("join" in from) {
+          const join = from;
+          const currentSource = getTableSource(join);
+          if (join.on && prevSource && currentSource) {
+            const leftQualifier = getQualifier(prevSource);
+            const rightQualifier = getQualifier(currentSource);
+            transformed = walkOnClause(join.on, leftQualifier, rightQualifier, ambiguousColumns) || transformed;
+          }
+          if (join.using && prevSource && currentSource) {
+            for (const usingCol of join.using) {
+              if (typeof usingCol === "string") {
+                ambiguousColumns.add(usingCol);
+              } else if ("value" in usingCol) {
+                ambiguousColumns.add(String(usingCol.value));
+              }
+            }
+          }
+          prevSource = currentSource;
+        } else {
+          const source = getTableSource(from);
+          if (source) {
+            prevSource = source;
+          }
+        }
+        if ("expr" in from && from.expr && "ast" in from.expr) {
+          transformed = walkSelect(from.expr.ast) || transformed;
+        }
+      }
+      if (ambiguousColumns.size > 0 && defaultQualifier) {
+        if (Array.isArray(select.columns)) {
+          for (const col of select.columns) {
+            if ("expr" in col) {
+              transformed = qualifyAmbiguousInExpression(col.expr, defaultQualifier, ambiguousColumns) || transformed;
+            }
+          }
+        }
+        transformed = qualifyAmbiguousInExpression(select.where, defaultQualifier, ambiguousColumns) || transformed;
+        if (Array.isArray(select.orderby)) {
+          for (const order of select.orderby) {
+            if (order.expr) {
+              transformed = qualifyAmbiguousInExpression(order.expr, defaultQualifier, ambiguousColumns) || transformed;
+            }
+          }
+        }
+      }
+    }
+  }
+  if (select.with) {
+    for (const cte of select.with) {
+      const cteSelect = cte.stmt?.ast ?? cte.stmt;
+      if (cteSelect && cteSelect.type === "select") {
+        transformed = walkSelect(cteSelect) || transformed;
+      }
+    }
+  }
+  if (select._next) {
+    transformed = walkSelect(select._next) || transformed;
+  }
+  return transformed;
+}
+function qualifyJoinColumns(ast) {
+  const statements = Array.isArray(ast) ? ast : [ast];
+  let transformed = false;
+  for (const stmt of statements) {
+    if (stmt.type === "select") {
+      transformed = walkSelect(stmt) || transformed;
+    } else if (stmt.type === "insert") {
+      const insert = stmt;
+      if (insert.values && typeof insert.values === "object" && "type" in insert.values && insert.values.type === "select") {
+        transformed = walkSelect(insert.values) || transformed;
+      }
+    } else if (stmt.type === "update") {
+      const update = stmt;
+      const mainSource = update.table?.[0] ? getTableSource(update.table[0]) : null;
+      const defaultQualifier = mainSource ? getQualifier(mainSource) : null;
+      const fromSources = update.from ?? [];
+      const firstFrom = fromSources[0] ? getTableSource(fromSources[0]) : null;
+      if (update.where && defaultQualifier && firstFrom) {
+        const ambiguous = new Set;
+        transformed = walkOnClause(update.where, defaultQualifier, getQualifier(firstFrom), ambiguous) || transformed;
+        transformed = qualifyAmbiguousInExpression(update.where, defaultQualifier, ambiguous) || transformed;
+      }
+      if (Array.isArray(update.returning) && defaultQualifier) {
+        for (const ret of update.returning) {
+          transformed = qualifyAmbiguousInExpression(ret, defaultQualifier, new Set) || transformed;
+        }
+      }
+    } else if (stmt.type === "delete") {
+      const del = stmt;
+      const mainSource = del.table?.[0] ? getTableSource(del.table[0]) : null;
+      const defaultQualifier = mainSource ? getQualifier(mainSource) : null;
+      const fromSources = del.from ?? [];
+      const firstFrom = fromSources[0] ? getTableSource(fromSources[0]) : null;
+      if (del.where && defaultQualifier && firstFrom) {
+        const ambiguous = new Set;
+        transformed = walkOnClause(del.where, defaultQualifier, getQualifier(firstFrom), ambiguous) || transformed;
+        transformed = qualifyAmbiguousInExpression(del.where, defaultQualifier, ambiguous) || transformed;
+      } else if (del.where && defaultQualifier) {
+        transformed = qualifyAmbiguousInExpression(del.where, defaultQualifier, new Set) || transformed;
+      }
+    }
+  }
+  return transformed;
+}
+
+// src/sql/visitors/generate-series-alias.ts
+function getColumnName2(col) {
+  if (typeof col.column === "string") {
+    return col.column;
+  }
+  if (col.column && "expr" in col.column && col.column.expr?.value) {
+    return String(col.column.expr.value);
+  }
+  return null;
+}
+function isColumnRef(expr) {
+  return typeof expr === "object" && expr !== null && "type" in expr && expr.type === "column_ref";
+}
+function isBinaryExpr2(expr) {
+  return !!expr && typeof expr === "object" && "type" in expr && expr.type === "binary_expr";
+}
+function getGenerateSeriesAliases(from) {
+  const aliases = new Set;
+  if (!from || !Array.isArray(from))
+    return aliases;
+  for (const f of from) {
+    if ("expr" in f && f.expr && typeof f.expr === "object") {
+      const exprObj = f.expr;
+      if (exprObj.type === "function" && "name" in exprObj) {
+        const nameObj = exprObj.name;
+        const nameParts = nameObj?.name;
+        const fnName = nameParts?.[0]?.value;
+        if (typeof fnName === "string" && fnName.toLowerCase() === "generate_series") {
+          const alias = typeof f.as === "string" ? f.as : null;
+          if (alias && !alias.includes("(")) {
+            aliases.add(alias);
+          }
+        }
+      }
+    }
+  }
+  return aliases;
+}
+function rewriteAliasColumnRef(col, alias) {
+  col.table = alias;
+  col.column = { expr: { type: "default", value: "generate_series" } };
+}
+function walkExpression2(expr, aliases) {
+  if (!expr || typeof expr !== "object")
+    return false;
+  let transformed = false;
+  const exprObj = expr;
+  if (isColumnRef(expr)) {
+    if (!("table" in expr) || !expr.table) {
+      const colName = getColumnName2(expr);
+      if (colName && aliases.has(colName)) {
+        rewriteAliasColumnRef(expr, colName);
+        transformed = true;
+      }
+    }
+    return transformed;
+  }
+  if (isBinaryExpr2(expr)) {
+    const binary = expr;
+    transformed = walkExpression2(binary.left, aliases) || transformed;
+    transformed = walkExpression2(binary.right, aliases) || transformed;
+    return transformed;
+  }
+  if (exprObj.type === "unary_expr" && exprObj.expr) {
+    transformed = walkExpression2(exprObj.expr, aliases) || transformed;
+  }
+  if (exprObj.type === "cast" && exprObj.expr) {
+    transformed = walkExpression2(exprObj.expr, aliases) || transformed;
+  }
+  if (exprObj.type === "case") {
+    if (exprObj.expr) {
+      transformed = walkExpression2(exprObj.expr, aliases) || transformed;
+    }
+    if (Array.isArray(exprObj.args)) {
+      for (const whenClause of exprObj.args) {
+        if (whenClause.cond) {
+          transformed = walkExpression2(whenClause.cond, aliases) || transformed;
+        }
+        if (whenClause.result) {
+          transformed = walkExpression2(whenClause.result, aliases) || transformed;
+        }
+      }
+    }
+  }
+  if ("args" in exprObj && exprObj.args) {
+    const args = exprObj.args;
+    if (Array.isArray(args.value)) {
+      for (const arg of args.value) {
+        transformed = walkExpression2(arg, aliases) || transformed;
+      }
+    } else if (args.expr) {
+      transformed = walkExpression2(args.expr, aliases) || transformed;
+    }
+  }
+  if ("over" in exprObj && exprObj.over && typeof exprObj.over === "object") {
+    const over = exprObj.over;
+    if (Array.isArray(over.partition)) {
+      for (const part of over.partition) {
+        transformed = walkExpression2(part, aliases) || transformed;
+      }
+    }
+    if (Array.isArray(over.orderby)) {
+      for (const order of over.orderby) {
+        transformed = walkExpression2(order, aliases) || transformed;
+      }
+    }
+  }
+  if ("ast" in exprObj && exprObj.ast) {
+    const subAst = exprObj.ast;
+    if (subAst.type === "select") {
+      transformed = walkSelect2(subAst) || transformed;
+    }
+  }
+  if (exprObj.type === "expr_list" && Array.isArray(exprObj.value)) {
+    for (const item of exprObj.value) {
+      transformed = walkExpression2(item, aliases) || transformed;
+    }
+  }
+  return transformed;
+}
+function walkFrom2(from, aliases) {
+  if (!from || !Array.isArray(from))
+    return false;
+  let transformed = false;
+  for (const f of from) {
+    if ("join" in f) {
+      const join = f;
+      transformed = walkExpression2(join.on, aliases) || transformed;
+    }
+    if ("expr" in f && f.expr && "ast" in f.expr) {
+      transformed = walkSelect2(f.expr.ast) || transformed;
+    }
+  }
+  return transformed;
+}
+function walkSelect2(select) {
+  let transformed = false;
+  const aliases = getGenerateSeriesAliases(select.from);
+  if (select.with) {
+    for (const cte of select.with) {
+      const cteSelect = cte.stmt?.ast ?? cte.stmt;
+      if (cteSelect && cteSelect.type === "select") {
+        transformed = walkSelect2(cteSelect) || transformed;
+      }
+    }
+  }
+  transformed = walkFrom2(select.from, aliases) || transformed;
+  transformed = walkExpression2(select.where, aliases) || transformed;
+  if (select.having) {
+    if (Array.isArray(select.having)) {
+      for (const h of select.having) {
+        transformed = walkExpression2(h, aliases) || transformed;
+      }
+    } else {
+      transformed = walkExpression2(select.having, aliases) || transformed;
+    }
+  }
+  if (Array.isArray(select.columns)) {
+    for (const col of select.columns) {
+      if ("expr" in col) {
+        transformed = walkExpression2(col.expr, aliases) || transformed;
+      }
+    }
+  }
+  if (Array.isArray(select.groupby)) {
+    for (const g of select.groupby) {
+      transformed = walkExpression2(g, aliases) || transformed;
+    }
+  }
+  if (Array.isArray(select.orderby)) {
+    for (const order of select.orderby) {
+      if (order.expr) {
+        transformed = walkExpression2(order.expr, aliases) || transformed;
+      }
+    }
+  }
+  if (select._orderby) {
+    for (const order of select._orderby) {
+      if (order.expr) {
+        transformed = walkExpression2(order.expr, aliases) || transformed;
+      }
+    }
+  }
+  if (select._next) {
+    transformed = walkSelect2(select._next) || transformed;
+  }
+  return transformed;
+}
+function rewriteGenerateSeriesAliases(ast) {
+  const statements = Array.isArray(ast) ? ast : [ast];
+  let transformed = false;
+  for (const stmt of statements) {
+    if (stmt.type === "select") {
+      transformed = walkSelect2(stmt) || transformed;
+    }
+  }
+  return transformed;
+}
+
+// src/sql/visitors/union-with-hoister.ts
+function getCteName(cte) {
+  const nameObj = cte.name;
+  if (!nameObj)
+    return null;
+  const value = nameObj.value;
+  if (typeof value === "string")
+    return value;
+  return null;
+}
+function hoistWithInSelect(select) {
+  if (!select.set_op || !select._next)
+    return false;
+  const arms = [];
+  let current = select;
+  while (current && current.type === "select") {
+    arms.push(current);
+    current = current._next;
+  }
+  const mergedWith = [];
+  const seen = new Set;
+  let hasWithBeyondFirst = false;
+  for (const arm of arms) {
+    if (arm.with && arm.with.length > 0) {
+      if (arm !== arms[0]) {
+        hasWithBeyondFirst = true;
+      }
+      for (const cte of arm.with) {
+        const cteName = getCteName(cte);
+        if (!cteName)
+          return false;
+        if (seen.has(cteName)) {
+          return false;
+        }
+        seen.add(cteName);
+        mergedWith.push(cte);
+      }
+    }
+  }
+  if (!hasWithBeyondFirst)
+    return false;
+  arms[0].with = mergedWith;
+  if ("parentheses_symbol" in arms[0]) {
+    arms[0].parentheses_symbol = false;
+  }
+  for (let i = 1;i < arms.length; i++) {
+    arms[i].with = null;
+  }
+  return true;
+}
+function walkSelect3(select) {
+  let transformed = false;
+  if (select.with) {
+    for (const cte of select.with) {
+      const cteSelect = cte.stmt?.ast ?? cte.stmt;
+      if (cteSelect && cteSelect.type === "select") {
+        transformed = walkSelect3(cteSelect) || transformed;
+      }
+    }
+  }
+  if (Array.isArray(select.from)) {
+    for (const from of select.from) {
+      if ("expr" in from && from.expr && "ast" in from.expr) {
+        transformed = walkSelect3(from.expr.ast) || transformed;
+      }
+    }
+  }
+  transformed = hoistWithInSelect(select) || transformed;
+  if (select._next) {
+    transformed = walkSelect3(select._next) || transformed;
+  }
+  return transformed;
+}
+function hoistUnionWith(ast) {
+  const statements = Array.isArray(ast) ? ast : [ast];
+  let transformed = false;
+  for (const stmt of statements) {
+    if (stmt.type === "select") {
+      transformed = walkSelect3(stmt) || transformed;
+    }
+  }
+  return transformed;
+}
+
+// src/sql/ast-transformer.ts
+var { Parser } = nodeSqlParser;
+var parser = new Parser;
+var CACHE_SIZE = 500;
+var transformCache = new Map;
+function getCachedOrTransform(query, transform) {
+  const cached = transformCache.get(query);
+  if (cached) {
+    transformCache.delete(query);
+    transformCache.set(query, cached);
+    return cached;
+  }
+  const result = transform();
+  if (transformCache.size >= CACHE_SIZE) {
+    const oldestKey = transformCache.keys().next().value;
+    if (oldestKey) {
+      transformCache.delete(oldestKey);
+    }
+  }
+  transformCache.set(query, result);
+  return result;
+}
+var DEBUG_ENV = "DRIZZLE_DUCKDB_DEBUG_AST";
+function hasJoin(query) {
+  return /\bjoin\b/i.test(query);
+}
+function debugLog(message, payload) {
+  if (process?.env?.[DEBUG_ENV]) {
+    console.debug("[duckdb-ast]", message, payload ?? "");
+  }
+}
+function transformSQL(query) {
+  const needsArrayTransform = query.includes("@>") || query.includes("<@") || query.includes("&&");
+  const needsJoinTransform = hasJoin(query) || /\bupdate\b/i.test(query) || /\bdelete\b/i.test(query);
+  const needsUnionTransform = /\bunion\b/i.test(query) || /\bintersect\b/i.test(query) || /\bexcept\b/i.test(query);
+  const needsGenerateSeriesTransform = /\bgenerate_series\b/i.test(query);
+  if (!needsArrayTransform && !needsJoinTransform && !needsUnionTransform && !needsGenerateSeriesTransform) {
+    return { sql: query, transformed: false };
+  }
+  return getCachedOrTransform(query, () => {
+    try {
+      const ast = parser.astify(query, { database: "PostgreSQL" });
+      let transformed = false;
+      if (needsArrayTransform) {
+        transformed = transformArrayOperators(ast) || transformed;
+      }
+      if (needsJoinTransform) {
+        transformed = qualifyJoinColumns(ast) || transformed;
+      }
+      if (needsGenerateSeriesTransform) {
+        transformed = rewriteGenerateSeriesAliases(ast) || transformed;
+      }
+      if (needsUnionTransform) {
+        transformed = hoistUnionWith(ast) || transformed;
+      }
+      if (!transformed) {
+        debugLog("AST parsed but no transformation applied", {
+          join: needsJoinTransform
+        });
+        return { sql: query, transformed: false };
+      }
+      const transformedSql = parser.sqlify(ast, { database: "PostgreSQL" });
+      return { sql: transformedSql, transformed: true };
+    } catch (err) {
+      debugLog("AST transform failed; returning original SQL", {
+        error: err.message
+      });
+      return { sql: query, transformed: false };
+    }
+  });
+}
+
+// src/dialect.ts
+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.");
+    }
+  }
+  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";
+    const migrationsTable = migrationConfig.migrationsTable ?? "__drizzle_migrations";
+    const migrationsSequence = `${migrationsTable}_id_seq`;
+    const legacySequence = "migrations_pk_seq";
+    const escapeIdentifier = (value) => value.replace(/"/g, '""');
+    const sequenceLiteral = `"${escapeIdentifier(migrationsSchema)}"."${escapeIdentifier(migrationsSequence)}"`;
+    const migrationTableCreate = sql2`
+      CREATE TABLE IF NOT EXISTS ${sql2.identifier(migrationsSchema)}.${sql2.identifier(migrationsTable)} (
+        id integer PRIMARY KEY default nextval('${sql2.raw(sequenceLiteral)}'),
+        hash text NOT NULL,
+        created_at bigint
+      )
+    `;
+    await session.execute(sql2`CREATE SCHEMA IF NOT EXISTS ${sql2.identifier(migrationsSchema)}`);
+    await session.execute(sql2`CREATE SEQUENCE IF NOT EXISTS ${sql2.identifier(migrationsSchema)}.${sql2.identifier(migrationsSequence)}`);
+    if (legacySequence !== migrationsSequence) {
+      await session.execute(sql2`CREATE SEQUENCE IF NOT EXISTS ${sql2.identifier(migrationsSchema)}.${sql2.identifier(legacySequence)}`);
+    }
+    await session.execute(migrationTableCreate);
+    const dbMigrations = await session.all(sql2`select id, hash, created_at from ${sql2.identifier(migrationsSchema)}.${sql2.identifier(migrationsTable)} order by created_at desc limit 1`);
+    const lastDbMigration = dbMigrations[0];
+    await session.transaction(async (tx) => {
+      for await (const migration of migrations) {
+        if (!lastDbMigration || Number(lastDbMigration.created_at) < migration.folderMillis) {
+          for (const stmt of migration.sql) {
+            await tx.execute(sql2.raw(stmt));
+          }
+          await tx.execute(sql2`insert into ${sql2.identifier(migrationsSchema)}.${sql2.identifier(migrationsTable)} ("hash", "created_at") values(${migration.hash}, ${migration.folderMillis})`);
+        }
+      }
+    });
+  }
+  prepareTyping(encoder) {
+    if (is2(encoder, PgJsonb) || is2(encoder, PgJson)) {
+      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)) {
+      return "time";
+    } else if (is2(encoder, PgTimestamp2) || is2(encoder, PgTimestampString2)) {
+      return "timestamp";
+    } else if (is2(encoder, PgDate2) || is2(encoder, PgDateString2)) {
+      return "date";
+    } else if (is2(encoder, PgUUID)) {
+      return "uuid";
+    } else {
+      return "none";
+    }
+  }
+  sqlToQuery(sqlObj, invokeSource) {
+    const result = super.sqlToQuery(sqlObj, invokeSource);
+    const transformed = transformSQL(result.sql);
+    return {
+      ...result,
+      sql: transformed.sql
+    };
+  }
+}
+
+// src/select-builder.ts
+import { is as is4 } from "drizzle-orm/entity";
+import {
+  PgSelectBase,
+  PgSelectBuilder
+} from "drizzle-orm/pg-core/query-builders";
+import { Subquery, ViewBaseConfig } from "drizzle-orm";
+import { PgViewBase } from "drizzle-orm/pg-core/view-base";
+import { SQL as SQL5 } from "drizzle-orm/sql/sql";
+
+// src/sql/selection.ts
+import { Column as Column2, SQL as SQL4, getTableName as getTableName2, is as is3, sql as sql3 } from "drizzle-orm";
+function mapEntries(obj, prefix, fullJoin = false) {
+  return Object.fromEntries(Object.entries(obj).filter(([key]) => key !== "enableRLS").map(([key, value]) => {
+    const qualified = prefix ? `${prefix}.${key}` : key;
+    if (fullJoin && is3(value, Column2)) {
+      return [
+        key,
+        sql3`${value}`.mapWith(value).as(`${getTableName2(value.table)}.${value.name}`)
+      ];
+    }
+    if (fullJoin && is3(value, SQL4)) {
+      const col = value.getSQL().queryChunks.find((chunk) => is3(chunk, Column2));
+      const tableName = col?.table && getTableName2(col?.table);
+      return [key, value.as(tableName ? `${tableName}.${key}` : key)];
+    }
+    if (is3(value, SQL4) || is3(value, Column2)) {
+      const aliased = is3(value, SQL4) ? value : sql3`${value}`.mapWith(value);
+      return [key, aliased.as(qualified)];
+    }
+    if (is3(value, SQL4.Aliased)) {
+      return [key, value];
+    }
+    if (typeof value === "object" && value !== null) {
+      return [
+        key,
+        mapEntries(value, qualified, fullJoin)
+      ];
+    }
+    return [key, value];
+  }));
+}
+function aliasFields(fields, fullJoin = false) {
+  return mapEntries(fields, undefined, fullJoin);
+}
+
+// src/select-builder.ts
+import { getTableColumns } from "drizzle-orm/utils";
+
+class DuckDBSelectBuilder extends PgSelectBuilder {
+  _fields;
+  _session;
+  _dialect;
+  _withList = [];
+  _distinct;
+  constructor(config) {
+    super(config);
+    this._fields = config.fields;
+    this._session = config.session;
+    this._dialect = config.dialect;
+    if (config.withList) {
+      this._withList = config.withList;
+    }
+    this._distinct = config.distinct;
+  }
+  from(source) {
+    const isPartialSelect = !!this._fields;
+    const src = source;
+    let fields;
+    if (this._fields) {
+      fields = this._fields;
+    } else if (is4(src, Subquery)) {
+      fields = Object.fromEntries(Object.keys(src._.selectedFields).map((key) => [
+        key,
+        src[key]
+      ]));
+    } else if (is4(src, PgViewBase)) {
+      fields = src[ViewBaseConfig]?.selectedFields;
+    } else if (is4(src, SQL5)) {
+      fields = {};
+    } else {
+      fields = aliasFields(getTableColumns(src), !isPartialSelect);
+    }
+    return new PgSelectBase({
+      table: src,
+      fields,
+      isPartialSelect,
+      session: this._session,
+      dialect: this._dialect,
+      withList: this._withList,
+      distinct: this._distinct
+    });
+  }
+}
+
+// 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/options.ts
+var DEFAULT_PREPARED_CACHE_SIZE = 32;
+function resolvePrepareCacheOption(option) {
+  if (!option)
+    return;
+  if (option === true) {
+    return { size: DEFAULT_PREPARED_CACHE_SIZE };
+  }
+  if (typeof option === "number") {
+    const size2 = Math.max(1, Math.floor(option));
+    return { size: size2 };
+  }
+  const size = option.size ?? DEFAULT_PREPARED_CACHE_SIZE;
+  return { size: Math.max(1, Math.floor(size)) };
+}
+
+// src/driver.ts
+class DuckDBDriver {
+  client;
+  dialect;
+  options;
+  static [entityKind3] = "DuckDBDriver";
+  constructor(client, dialect, options = {}) {
+    this.client = client;
+    this.dialect = dialect;
+    this.options = options;
+  }
+  createSession(schema) {
+    return new DuckDBSession(this.client, this.dialect, schema, {
+      logger: this.options.logger,
+      rejectStringArrayLiterals: this.options.rejectStringArrayLiterals,
+      prepareCache: this.options.prepareCache
+    });
+  }
+}
+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 prepareCache = resolvePrepareCacheOption(config.prepareCache);
+  const logger = config.logger === true ? new DefaultLogger : config.logger || undefined;
+  let schema;
+  if (config.schema) {
+    const tablesConfig = extractTablesRelationalConfig(config.schema, createTableRelationsHelpers);
+    schema = {
+      fullSchema: config.schema,
+      schema: tablesConfig.tables,
+      tableNamesMap: tablesConfig.tableNamesMap
+    };
+  }
+  const driver = new DuckDBDriver(client, dialect, {
+    logger,
+    rejectStringArrayLiterals: config.rejectStringArrayLiterals,
+    prepareCache
+  });
+  const session = driver.createSession(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";
+  $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;
+    return new DuckDBSelectBuilder({
+      fields: selectedFields ?? undefined,
+      session: this.session,
+      dialect: this.dialect
+    });
+  }
+  executeBatches(query, options = {}) {
+    return this.session.executeBatches(query, options);
+  }
+  executeBatchesRaw(query, options = {}) {
+    return this.session.executeBatchesRaw(query, options);
+  }
+  executeArrow(query) {
+    return this.session.executeArrow(query);
+  }
+  async transaction(transaction) {
+    return await this.session.transaction(transaction);
+  }
+}
+
+// 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/helpers";
+async function introspect(db, opts = {}) {
+  const database = await resolveDatabase(db, opts.database, opts.allDatabases);
+  const schemas = await resolveSchemas(db, database, opts.schemas);
+  const includeViews = opts.includeViews ?? false;
+  const tables = await loadTables(db, database, schemas, includeViews);
+  const columns = await loadColumns(db, database, schemas);
+  const constraints = await loadConstraints(db, database, schemas);
+  const indexes = await loadIndexes(db, database, schemas);
+  const grouped = buildTables(tables, columns, constraints, indexes);
+  const schemaTs = emitSchema(grouped, {
+    useCustomTimeTypes: opts.useCustomTimeTypes ?? true,
+    mapJsonAsDuckDbJson: opts.mapJsonAsDuckDbJson ?? true,
+    importBasePath: opts.importBasePath ?? DEFAULT_IMPORT_BASE
+  });
+  return {
+    files: {
+      schemaTs,
+      metaJson: grouped
+    }
+  };
+}
+async function resolveDatabase(db, targetDatabase, allDatabases) {
+  if (allDatabases) {
+    return null;
+  }
+  if (targetDatabase) {
+    return targetDatabase;
+  }
+  const rows = await db.execute(sql4`SELECT current_database() as current_database`);
+  return rows[0]?.current_database ?? null;
+}
+async function resolveSchemas(db, database, targetSchemas) {
+  if (targetSchemas?.length) {
+    return targetSchemas;
+  }
+  const databaseFilter = database ? sql4`catalog_name = ${database}` : sql4`1 = 1`;
+  const rows = await db.execute(sql4`SELECT schema_name FROM information_schema.schemata WHERE ${databaseFilter}`);
+  return rows.map((row) => row.schema_name).filter((name) => !SYSTEM_SCHEMAS.has(name));
+}
+async function loadTables(db, database, schemas, includeViews) {
+  const schemaFragments = schemas.map((schema) => sql4`${schema}`);
+  const databaseFilter = database ? sql4`table_catalog = ${database}` : sql4`1 = 1`;
+  return await db.execute(sql4`
+      SELECT table_schema as schema_name, table_name, table_type
+      FROM information_schema.tables
+      WHERE ${databaseFilter}
+      AND table_schema IN (${sql4.join(schemaFragments, sql4.raw(", "))})
+      AND ${includeViews ? sql4`1 = 1` : sql4`table_type = 'BASE TABLE'`}
+      ORDER BY table_schema, table_name
+    `);
+}
+async function loadColumns(db, database, schemas) {
+  const schemaFragments = schemas.map((schema) => sql4`${schema}`);
+  const databaseFilter = database ? sql4`database_name = ${database}` : sql4`1 = 1`;
+  return await db.execute(sql4`
+      SELECT
+        schema_name,
+        table_name,
+        column_name,
+        column_index,
+        column_default,
+        is_nullable,
+        data_type,
+        character_maximum_length,
+        numeric_precision,
+        numeric_scale,
+        internal
+      FROM duckdb_columns()
+      WHERE ${databaseFilter}
+      AND schema_name IN (${sql4.join(schemaFragments, sql4.raw(", "))})
+      ORDER BY schema_name, table_name, column_index
+    `);
+}
+async function loadConstraints(db, database, schemas) {
+  const schemaFragments = schemas.map((schema) => sql4`${schema}`);
+  const databaseFilter = database ? sql4`database_name = ${database}` : sql4`1 = 1`;
+  return await db.execute(sql4`
+      SELECT
+        schema_name,
+        table_name,
+        constraint_name,
+        constraint_type,
+        constraint_text,
+        constraint_column_names,
+        referenced_table,
+        referenced_column_names
+      FROM duckdb_constraints()
+      WHERE ${databaseFilter}
+      AND schema_name IN (${sql4.join(schemaFragments, sql4.raw(", "))})
+      ORDER BY schema_name, table_name, constraint_index
+    `);
+}
+async function loadIndexes(db, database, schemas) {
+  const schemaFragments = schemas.map((schema) => sql4`${schema}`);
+  const databaseFilter = database ? sql4`database_name = ${database}` : sql4`1 = 1`;
+  return await db.execute(sql4`
+      SELECT
+        schema_name,
+        table_name,
+        index_name,
+        is_unique,
+        expressions
+      FROM duckdb_indexes()
+      WHERE ${databaseFilter}
+      AND schema_name IN (${sql4.join(schemaFragments, sql4.raw(", "))})
+      ORDER BY schema_name, table_name, index_name
+    `);
+}
+function buildTables(tables, columns, constraints, indexes) {
+  const byTable = {};
+  for (const table of tables) {
+    const key = tableKey(table.schema_name, table.table_name);
+    byTable[key] = {
+      schema: table.schema_name,
+      name: table.table_name,
+      kind: table.table_type === "VIEW" ? "view" : "table",
+      columns: [],
+      constraints: [],
+      indexes: []
+    };
+  }
+  for (const column of columns) {
+    if (column.internal) {
+      continue;
+    }
+    const key = tableKey(column.schema_name, column.table_name);
+    const table = byTable[key];
+    if (!table) {
+      continue;
+    }
+    table.columns.push({
+      name: column.column_name,
+      dataType: column.data_type,
+      columnDefault: column.column_default,
+      nullable: column.is_nullable,
+      characterLength: column.character_maximum_length,
+      numericPrecision: column.numeric_precision,
+      numericScale: column.numeric_scale
+    });
+  }
+  for (const constraint of constraints) {
+    const key = tableKey(constraint.schema_name, constraint.table_name);
+    const table = byTable[key];
+    if (!table) {
+      continue;
+    }
+    if (!constraint.constraint_column_names?.length) {
+      continue;
+    }
+    table.constraints.push({
+      name: constraint.constraint_name,
+      type: constraint.constraint_type,
+      columns: constraint.constraint_column_names ?? [],
+      referencedTable: constraint.referenced_table && constraint.referenced_column_names ? {
+        schema: constraint.schema_name,
+        name: constraint.referenced_table,
+        columns: constraint.referenced_column_names
+      } : undefined,
+      rawExpression: constraint.constraint_text
+    });
+  }
+  for (const index of indexes) {
+    const key = tableKey(index.schema_name, index.table_name);
+    const table = byTable[key];
+    if (!table) {
+      continue;
+    }
+    table.indexes.push(index);
+  }
+  return Object.values(byTable);
+}
+function emitSchema(catalog, options) {
+  const imports = {
+    drizzle: new Set,
+    pgCore: new Set,
+    local: new Set
+  };
+  imports.pgCore.add("pgSchema");
+  const sorted = [...catalog].sort((a, b) => a.schema === b.schema ? a.name.localeCompare(b.name) : a.schema.localeCompare(b.schema));
+  const lines = [];
+  for (const schema of uniqueSchemas(sorted)) {
+    imports.pgCore.add("pgSchema");
+    const schemaVar = toSchemaIdentifier(schema);
+    lines.push(`export const ${schemaVar} = pgSchema(${JSON.stringify(schema)});`, "");
+    const tables = sorted.filter((table) => table.schema === schema);
+    for (const table of tables) {
+      lines.push(...emitTable(schemaVar, table, imports, options));
+      lines.push("");
+    }
+  }
+  const importsBlock = renderImports(imports, options.importBasePath);
+  return [importsBlock, ...lines].join(`
+`).trim() + `
+`;
+}
+function emitTable(schemaVar, table, imports, options) {
+  const tableVar = toIdentifier(table.name);
+  const columnLines = [];
+  for (const column of table.columns) {
+    columnLines.push(`  ${columnProperty(column.name)}: ${emitColumn(column, imports, options)},`);
+  }
+  const constraintBlock = emitConstraints(table, imports);
+  const tableLines = [];
+  tableLines.push(`export const ${tableVar} = ${schemaVar}.table(${JSON.stringify(table.name)}, {`);
+  tableLines.push(...columnLines);
+  tableLines.push(`}${constraintBlock ? "," : ""}${constraintBlock ? ` ${constraintBlock}` : ""});`);
+  return tableLines;
+}
+function emitConstraints(table, imports) {
+  const constraints = table.constraints.filter((constraint) => ["PRIMARY KEY", "FOREIGN KEY", "UNIQUE"].includes(constraint.type));
+  if (!constraints.length) {
+    return "";
+  }
+  const entries = [];
+  for (const constraint of constraints) {
+    const key = toIdentifier(constraint.name || `${table.name}_constraint`);
+    if (constraint.type === "PRIMARY KEY") {
+      imports.pgCore.add("primaryKey");
+      entries.push(`${key}: primaryKey({ columns: [${constraint.columns.map((col) => `t.${toIdentifier(col)}`).join(", ")}], name: ${JSON.stringify(constraint.name)} })`);
+    } else if (constraint.type === "UNIQUE" && constraint.columns.length > 1) {
+      imports.pgCore.add("unique");
+      entries.push(`${key}: unique(${JSON.stringify(constraint.name)}).on(${constraint.columns.map((col) => `t.${toIdentifier(col)}`).join(", ")})`);
+    } else if (constraint.type === "FOREIGN KEY" && constraint.referencedTable) {
+      imports.pgCore.add("foreignKey");
+      const targetTable = toIdentifier(constraint.referencedTable.name);
+      entries.push(`${key}: foreignKey({ columns: [${constraint.columns.map((col) => `t.${toIdentifier(col)}`).join(", ")}], foreignColumns: [${constraint.referencedTable.columns.map((col) => `${targetTable}.${toIdentifier(col)}`).join(", ")}], name: ${JSON.stringify(constraint.name)} })`);
+    } else if (constraint.type === "UNIQUE" && constraint.columns.length === 1) {
+      const columnName = constraint.columns[0];
+      entries.push(`${key}: t.${toIdentifier(columnName)}.unique(${JSON.stringify(constraint.name)})`);
+    }
+  }
+  if (!entries.length) {
+    return "";
+  }
+  const lines = ["(t) => ({"];
+  for (const entry of entries) {
+    lines.push(`  ${entry},`);
+  }
+  lines.push("})");
+  return lines.join(`
+`);
+}
+function emitColumn(column, imports, options) {
+  const mapping = mapDuckDbType(column, imports, options);
+  let builder = mapping.builder;
+  if (!column.nullable) {
+    builder += ".notNull()";
+  }
+  const defaultFragment = buildDefault(column.columnDefault);
+  if (defaultFragment) {
+    imports.drizzle.add("sql");
+    builder += defaultFragment;
+  }
+  return builder;
+}
+function buildDefault(defaultValue) {
+  if (!defaultValue) {
+    return "";
+  }
+  const trimmed = defaultValue.trim();
+  if (!trimmed || trimmed.toUpperCase() === "NULL") {
+    return "";
+  }
+  if (/^nextval\(/i.test(trimmed)) {
+    return `.default(sql\`${trimmed}\`)`;
+  }
+  if (/^current_timestamp(?:\(\))?$/i.test(trimmed) || /^now\(\)$/i.test(trimmed)) {
+    return `.defaultNow()`;
+  }
+  if (trimmed === "true" || trimmed === "false") {
+    return `.default(${trimmed})`;
+  }
+  const numberValue = Number(trimmed);
+  if (!Number.isNaN(numberValue)) {
+    return `.default(${trimmed})`;
+  }
+  const stringLiteralMatch = /^'(.*)'$/.exec(trimmed);
+  if (stringLiteralMatch) {
+    const value = stringLiteralMatch[1]?.replace(/''/g, "'");
+    return `.default(${JSON.stringify(value)})`;
+  }
+  return "";
+}
+function mapDuckDbType(column, imports, options) {
+  const raw = column.dataType.trim();
+  const upper = raw.toUpperCase();
+  if (upper === "BOOLEAN" || upper === "BOOL") {
+    imports.pgCore.add("boolean");
+    return { builder: `boolean(${columnName(column.name)})` };
+  }
+  if (upper === "SMALLINT" || upper === "INT2" || upper === "INT16" || upper === "TINYINT") {
+    imports.pgCore.add("integer");
+    return { builder: `integer(${columnName(column.name)})` };
+  }
+  if (upper === "INTEGER" || upper === "INT" || upper === "INT4" || upper === "SIGNED") {
+    imports.pgCore.add("integer");
+    return { builder: `integer(${columnName(column.name)})` };
+  }
+  if (upper === "BIGINT" || upper === "INT8" || upper === "UBIGINT") {
+    imports.pgCore.add("bigint");
+    return {
+      builder: `bigint(${columnName(column.name)}, { mode: 'number' })`
+    };
+  }
+  const decimalMatch = /^DECIMAL\((\d+),(\d+)\)/i.exec(upper);
+  const numericMatch = /^NUMERIC\((\d+),(\d+)\)/i.exec(upper);
+  if (decimalMatch || numericMatch) {
+    imports.pgCore.add("numeric");
+    const [, precision, scale] = decimalMatch ?? numericMatch;
+    return {
+      builder: `numeric(${columnName(column.name)}, { precision: ${precision}, scale: ${scale} })`
+    };
+  }
+  if (upper.startsWith("DECIMAL") || upper.startsWith("NUMERIC")) {
+    imports.pgCore.add("numeric");
+    const precision = column.numericPrecision;
+    const scale = column.numericScale;
+    const options2 = [];
+    if (precision !== null && precision !== undefined) {
+      options2.push(`precision: ${precision}`);
+    }
+    if (scale !== null && scale !== undefined) {
+      options2.push(`scale: ${scale}`);
+    }
+    const suffix = options2.length ? `, { ${options2.join(", ")} }` : "";
+    return { builder: `numeric(${columnName(column.name)}${suffix})` };
+  }
+  if (upper === "REAL" || upper === "FLOAT4") {
+    imports.pgCore.add("real");
+    return { builder: `real(${columnName(column.name)})` };
+  }
+  if (upper === "DOUBLE" || upper === "DOUBLE PRECISION" || upper === "FLOAT") {
+    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;
+    const lengthPart = typeof length === "number" ? `, { length: ${length} }` : "";
+    return { builder: `char(${columnName(column.name)}${lengthPart})` };
+  }
+  if (upper.startsWith("VARCHAR")) {
+    imports.pgCore.add("varchar");
+    const length = column.characterLength;
+    const lengthPart = typeof length === "number" ? `, { length: ${length} }` : "";
+    return { builder: `varchar(${columnName(column.name)}${lengthPart})` };
+  }
+  if (upper === "TEXT" || upper === "STRING") {
+    imports.pgCore.add("text");
+    return { builder: `text(${columnName(column.name)})` };
+  }
+  if (upper === "UUID") {
+    imports.pgCore.add("uuid");
+    return { builder: `uuid(${columnName(column.name)})` };
+  }
+  if (upper === "JSON") {
+    if (options.mapJsonAsDuckDbJson) {
+      imports.local.add("duckDbJson");
+      return { builder: `duckDbJson(${columnName(column.name)})` };
+    }
+    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)})` };
+  }
+  if (upper === "INTERVAL") {
+    imports.local.add("duckDbInterval");
+    return { builder: `duckDbInterval(${columnName(column.name)})` };
+  }
+  if (upper === "BLOB" || upper === "BYTEA" || upper === "VARBINARY") {
+    imports.local.add("duckDbBlob");
+    return { builder: `duckDbBlob(${columnName(column.name)})` };
+  }
+  if (upper.startsWith("STRUCT")) {
+    imports.local.add("duckDbStruct");
+    const inner = upper.replace(/^STRUCT\s*\(/i, "").replace(/\)$/, "");
+    const fields = parseStructFields(inner);
+    const entries = fields.map(({ name, type }) => `${JSON.stringify(name)}: ${JSON.stringify(type)}`);
+    return {
+      builder: `duckDbStruct(${columnName(column.name)}, { ${entries.join(", ")} })`
+    };
+  }
+  if (upper.startsWith("MAP(")) {
+    imports.local.add("duckDbMap");
+    const valueType = parseMapValue(upper);
+    return {
+      builder: `duckDbMap(${columnName(column.name)}, ${JSON.stringify(valueType)})`
+    };
+  }
+  if (upper.startsWith("TIMESTAMP WITH TIME ZONE")) {
+    if (options.useCustomTimeTypes) {
+      imports.local.add("duckDbTimestamp");
+    } else {
+      imports.pgCore.add("timestamp");
+    }
+    const factory = options.useCustomTimeTypes ? `duckDbTimestamp(${columnName(column.name)}, { withTimezone: true })` : `timestamp(${columnName(column.name)}, { withTimezone: true })`;
+    return { builder: factory };
+  }
+  if (upper.startsWith("TIMESTAMP")) {
+    if (options.useCustomTimeTypes) {
+      imports.local.add("duckDbTimestamp");
+      return {
+        builder: `duckDbTimestamp(${columnName(column.name)})`
+      };
+    }
+    imports.pgCore.add("timestamp");
+    return { builder: `timestamp(${columnName(column.name)})` };
+  }
+  if (upper === "TIME") {
+    if (options.useCustomTimeTypes) {
+      imports.local.add("duckDbTime");
+      return { builder: `duckDbTime(${columnName(column.name)})` };
+    }
+    imports.pgCore.add("time");
+    return { builder: `time(${columnName(column.name)})` };
+  }
+  if (upper === "DATE") {
+    if (options.useCustomTimeTypes) {
+      imports.local.add("duckDbDate");
+      return { builder: `duckDbDate(${columnName(column.name)})` };
+    }
+    imports.pgCore.add("date");
+    return { builder: `date(${columnName(column.name)})` };
+  }
+  imports.pgCore.add("text");
+  return {
+    builder: `text(${columnName(column.name)}) /* unsupported DuckDB type: ${upper} */`
+  };
+}
+function parseStructFields(inner) {
+  const result = [];
+  for (const part of splitTopLevel(inner, ",")) {
+    const trimmed = part.trim();
+    if (!trimmed)
+      continue;
+    const match = /^"?([^"]+)"?\s+(.*)$/i.exec(trimmed);
+    if (!match) {
+      continue;
+    }
+    const [, name, type] = match;
+    result.push({ name, type: type.trim() });
+  }
+  return result;
+}
+function parseMapValue(raw) {
+  const inner = raw.replace(/^MAP\(/i, "").replace(/\)$/, "");
+  const parts = splitTopLevel(inner, ",");
+  if (parts.length < 2) {
+    return "TEXT";
+  }
+  return parts[1]?.trim() ?? "TEXT";
+}
+function splitTopLevel(input, delimiter) {
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  for (let i = 0;i < input.length; i += 1) {
+    const char = input[i];
+    if (char === "(")
+      depth += 1;
+    if (char === ")")
+      depth = Math.max(0, depth - 1);
+    if (char === delimiter && depth === 0) {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current) {
+    parts.push(current);
+  }
+  return parts;
+}
+function tableKey(schema, table) {
+  return `${schema}.${table}`;
+}
+function toIdentifier(name) {
+  const cleaned = name.replace(/[^A-Za-z0-9_]/g, "_");
+  const parts = cleaned.split("_").filter(Boolean);
+  const base = parts.map((part, index) => index === 0 ? part.toLowerCase() : capitalize(part.toLowerCase())).join("");
+  const candidate = base || "item";
+  return /^[A-Za-z_]/.test(candidate) ? candidate : `t${candidate}`;
+}
+function toSchemaIdentifier(schema) {
+  const base = toIdentifier(schema);
+  return base.endsWith("Schema") ? base : `${base}Schema`;
+}
+function columnProperty(column) {
+  if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(column)) {
+    return toIdentifier(column);
+  }
+  return JSON.stringify(column);
+}
+function columnName(name) {
+  return JSON.stringify(name);
+}
+function capitalize(value) {
+  if (!value)
+    return value;
+  return value[0].toUpperCase() + value.slice(1);
+}
+function uniqueSchemas(tables) {
+  const seen = new Set;
+  const result = [];
+  for (const table of tables) {
+    if (!seen.has(table.schema)) {
+      seen.add(table.schema);
+      result.push(table.schema);
+    }
+  }
+  return result;
+}
+function renderImports(imports, importBasePath) {
+  const lines = [];
+  const drizzle2 = [...imports.drizzle];
+  if (drizzle2.length) {
+    lines.push(`import { ${drizzle2.sort().join(", ")} } from 'drizzle-orm';`);
+  }
+  const pgCore = [...imports.pgCore];
+  if (pgCore.length) {
+    lines.push(`import { ${pgCore.sort().join(", ")} } from 'drizzle-orm/pg-core';`);
+  }
+  const local = [...imports.local];
+  if (local.length) {
+    lines.push(`import { ${local.sort().join(", ")} } from '${importBasePath}';`);
+  }
+  lines.push("");
+  return lines.join(`
+`);
+}
+
+// src/bin/duckdb-introspect.ts
+function parseArgs(argv) {
+  const options = {
+    outFile: path.resolve(process2.cwd(), "drizzle/schema.ts"),
+    outMeta: undefined,
+    allDatabases: false,
+    includeViews: false,
+    useCustomTimeTypes: true
+  };
+  for (let i = 0;i < argv.length; i += 1) {
+    const arg = argv[i];
+    switch (arg) {
+      case "--url":
+        options.url = argv[++i];
+        break;
+      case "--database":
+      case "--db":
+        options.database = argv[++i];
+        break;
+      case "--all-databases":
+        options.allDatabases = true;
+        break;
+      case "--schema":
+      case "--schemas":
+        options.schemas = argv[++i]?.split(",").map((s) => s.trim()).filter(Boolean);
+        break;
+      case "--out":
+      case "--outFile":
+        options.outFile = path.resolve(process2.cwd(), argv[++i] ?? "drizzle/schema.ts");
+        break;
+      case "--out-json":
+      case "--outJson":
+      case "--json":
+        options.outMeta = path.resolve(process2.cwd(), argv[++i] ?? "drizzle/schema.meta.json");
+        break;
+      case "--include-views":
+      case "--includeViews":
+        options.includeViews = true;
+        break;
+      case "--use-pg-time":
+        options.useCustomTimeTypes = false;
+        break;
+      case "--import-base":
+        options.importBasePath = argv[++i];
+        break;
+      case "--help":
+      case "-h":
+        printHelp();
+        process2.exit(0);
+      default:
+        if (arg.startsWith("-")) {
+          console.warn(`Unknown option ${arg}`);
+        }
+    }
+  }
+  return options;
+}
+function printHelp() {
+  console.log(`duckdb-introspect
+
+Usage:
+  bun x duckdb-introspect --url <duckdb path|md:> [--schema my_schema] [--out ./drizzle/schema.ts]
+
+Options:
+  --url            DuckDB database path (e.g. :memory:, ./local.duckdb, md:)
+  --database, --db Database/catalog to introspect (default: current database)
+  --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)
+
+Database Filtering:
+  By default, only tables from the current database are introspected. This prevents
+  returning tables from all attached databases in MotherDuck workspaces.
+
+  Use --database to specify a different database, or --all-databases to introspect
+  all attached databases.
+
+Examples:
+  # Local DuckDB file
+  bun x duckdb-introspect --url ./my-database.duckdb --out ./schema.ts
+
+  # MotherDuck (requires MOTHERDUCK_TOKEN env var)
+  MOTHERDUCK_TOKEN=xxx bun x duckdb-introspect --url md: --database my_cloud_db --out ./schema.ts
+`);
+}
+async function main() {
+  const options = parseArgs(process2.argv.slice(2));
+  if (!options.url) {
+    printHelp();
+    throw new Error("Missing required --url");
+  }
+  const instanceOptions = options.url.startsWith("md:") && process2.env.MOTHERDUCK_TOKEN ? { motherduck_token: process2.env.MOTHERDUCK_TOKEN } : undefined;
+  const instance = await DuckDBInstance3.create(options.url, instanceOptions);
+  const connection = await instance.connect();
+  const db = drizzle(connection);
+  try {
+    const result = await introspect(db, {
+      database: options.database,
+      allDatabases: options.allDatabases,
+      schemas: options.schemas,
+      includeViews: options.includeViews,
+      useCustomTimeTypes: options.useCustomTimeTypes,
+      importBasePath: options.importBasePath
+    });
+    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) => {
+  console.error(err instanceof Error ? err.message : err);
+  process2.exit(1);
+});