@duckdbfan/drizzle-duckdb 0.0.6 → 1.3.1

package/dist/index.mjs

@@ -1,42 +1,174 @@
 // src/driver.ts
-import { entityKind as entityKind3, is as is3 } from "drizzle-orm/entity";
+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";
-import {
-  getTableColumns
-} from "drizzle-orm/utils";
 
 // 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 as sql2 } from "drizzle-orm/sql/sql";
+import { fillPlaceholders, sql } from "drizzle-orm/sql/sql";
 
-// src/utils.ts
+// src/sql/result-mapper.ts
 import {
-  is,
   Column,
   SQL,
   getTableName,
-  sql
+  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((result2, { path, field }, columnIndex) => {
+  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 {
-      decoder = field.sql.decoder;
+      const col = field.sql.queryChunks.find((chunk) => is(chunk, Column));
+      if (is(col, PgCustomColumn)) {
+        decoder = col;
+      } else {
+        decoder = field.sql.decoder;
+      }
     }
-    let node = result2;
+    let node = acc;
     for (const [pathChunkIndex, pathChunk] of path.entries()) {
       if (pathChunkIndex < path.length - 1) {
         if (!(pathChunk in node)) {
@@ -45,8 +177,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         node = node[pathChunk];
         continue;
       }
-      const rawValue = row[columnIndex];
-      const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
+      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)) {
@@ -73,7 +205,7 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         continue;
       }
     }
-    return result2;
+    return acc;
   }, {});
   if (joinsNotNullableMap && Object.keys(nullifyMap).length > 0) {
     for (const [objectName, tableName] of Object.entries(nullifyMap)) {
@@ -84,87 +216,493 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
   }
   return result;
 }
-function aliasFields(fields, fullJoin = false) {
-  return Object.fromEntries(Object.entries(fields).filter(([key]) => key !== "enableRLS").map(([key, value]) => {
-    if (fullJoin && is(value, Column)) {
-      return [
-        key,
-        sql`${value}`.as(`${getTableName(value.table)}.${value.name}`)
-      ];
+
+// 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");
+function isDuckDBWrapper(value) {
+  return value !== null && typeof value === "object" && DUCKDB_VALUE_MARKER in value && value[DUCKDB_VALUE_MARKER] === true;
+}
+function wrapList(data, elementType) {
+  return {
+    [DUCKDB_VALUE_MARKER]: true,
+    kind: "list",
+    data,
+    elementType
+  };
+}
+function wrapArray(data, elementType, fixedLength) {
+  return {
+    [DUCKDB_VALUE_MARKER]: true,
+    kind: "array",
+    data,
+    elementType,
+    fixedLength
+  };
+}
+function wrapStruct(data, schema) {
+  return {
+    [DUCKDB_VALUE_MARKER]: true,
+    kind: "struct",
+    data,
+    schema
+  };
+}
+function wrapMap(data, valueType) {
+  return {
+    [DUCKDB_VALUE_MARKER]: true,
+    kind: "map",
+    data,
+    valueType
+  };
+}
+function wrapTimestamp(data, withTimezone, precision) {
+  return {
+    [DUCKDB_VALUE_MARKER]: true,
+    kind: "timestamp",
+    data,
+    withTimezone,
+    precision
+  };
+}
+function wrapBlob(data) {
+  return {
+    [DUCKDB_VALUE_MARKER]: true,
+    kind: "blob",
+    data
+  };
+}
+function wrapJson(data) {
+  return {
+    [DUCKDB_VALUE_MARKER]: true,
+    kind: "json",
+    data
+  };
+}
+
+// src/value-wrappers.ts
+function dateToMicros(value) {
+  if (value instanceof Date) {
+    return BigInt(value.getTime()) * 1000n;
+  }
+  if (typeof value === "bigint") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return BigInt(Math.trunc(value)) * 1000n;
+  }
+  let normalized = value;
+  if (!value.includes("T") && value.includes(" ")) {
+    normalized = value.replace(" ", "T");
+  }
+  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}`);
     }
-    if (fullJoin && is(value, SQL)) {
-      const col = value.getSQL().queryChunks.find((chunk) => is(chunk, Column));
-      const tableName = col?.table && getTableName(col?.table);
-      return [key, value.as(tableName ? `${tableName}.${key}` : key)];
+  }
+}
+
+// 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);
+        }
+      }
     }
-    if (is(value, SQL) || is(value, Column)) {
-      return [key, (is(value, SQL) ? value : sql`${value}`).as(key)];
+    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 (is(value, SQL.Aliased)) {
-      return [key, value];
+  }
+  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);
     }
-    if (typeof value === "object") {
-      const parentKey = key;
-      return [
-        key,
-        Object.fromEntries(Object.entries(value).filter(([childKey]) => childKey !== "enableRLS").map(([childKey, childValue]) => [
-          childKey,
-          (is(childValue, SQL) ? childValue : sql`${childValue}`).as(`${parentKey}.${childKey}`)
-        ]))
-      ];
+  }
+  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;
     }
-    return [key, value];
-  }));
+  }
+  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();
 }
-var tableIdPropSelectionRegex = new RegExp([
-  `("(.+)"\\."(.+)")`,
-  `(\\s+as\\s+'?(.+?)'?\\.'?(.+?)'?)?`
-].join(""), "i");
 
 // src/session.ts
-import { TransactionRollbackError } from "drizzle-orm/errors";
+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, queryString, params, logger, fields, _isResponseInArrayMode, customResultMapper) {
+  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 = {}) {
-    const params = fillPlaceholders(this.params, 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,
-      client,
-      joinsNotNullableMap,
-      customResultMapper,
-      queryString
-    } = this;
-    const rows = await client.all(queryString, ...params) ?? [];
-    if (rows.length === 0 || !fields) {
-      return rows;
-    }
-    const rowValues = rows.map((row) => Object.values(row));
-    return customResultMapper ? customResultMapper(rowValues) : rowValues.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
+    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 false;
+    return this._isResponseInArrayMode;
   }
 }
 
@@ -173,32 +711,117 @@ class DuckDBSession extends PgSession {
   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, query.sql, query.params, this.logger, fields, 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);
   }
-  async transaction(transaction) {
-    const connection = "connect" in this.client ? await this.client.connect() : this.client;
-    const session = new DuckDBSession(connection, this.dialect, this.schema, this.options);
+  execute(query) {
+    this.dialect.resetPgJsonFlag();
+    return super.execute(query);
+  }
+  all(query) {
+    this.dialect.resetPgJsonFlag();
+    return super.all(query);
+  }
+  async transaction(transaction, config) {
+    let pinnedConnection;
+    let pool;
+    let clientForTx = this.client;
+    if (isPool(this.client)) {
+      pool = this.client;
+      pinnedConnection = await pool.acquire();
+      clientForTx = pinnedConnection;
+    }
+    const session = new DuckDBSession(clientForTx, this.dialect, this.schema, this.options);
     const tx = new DuckDBTransaction(this.dialect, session, this.schema);
-    await tx.execute(sql2`BEGIN TRANSACTION;`);
     try {
-      const result = await transaction(tx);
-      await tx.execute(sql2`commit`);
-      return result;
-    } catch (error) {
-      await tx.execute(sql2`rollback`);
-      throw error;
+      await tx.execute(sql`BEGIN TRANSACTION;`);
+      if (config) {
+        await tx.setTransaction(config);
+      }
+      try {
+        const result = await transaction(tx);
+        if (session.isRollbackOnly()) {
+          await tx.execute(sql`rollback`);
+          throw new TransactionRollbackError;
+        }
+        await tx.execute(sql`commit`);
+        return result;
+      } catch (error) {
+        await tx.execute(sql`rollback`);
+        throw error;
+      }
     } finally {
-      await connection.close();
+      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;
   }
 }
 
@@ -218,117 +841,1299 @@ class DuckDBTransaction extends PgTransaction {
     if (typeof config.deferrable === "boolean") {
       chunks.push(config.deferrable ? "deferrable" : "not deferrable");
     }
-    return sql2.raw(chunks.join(" "));
+    return sql.raw(chunks.join(" "));
   }
   setTransaction(config) {
-    return this.session.execute(sql2`set transaction ${this.getTransactionConfigSQL(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 savepointName = `sp${this.nestedIndex + 1}`;
-    const tx = new DuckDBTransaction(this.dialect, this.session, this.schema, this.nestedIndex + 1);
-    await tx.execute(sql2.raw(`savepoint ${savepointName}`));
+    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(tx);
-      await tx.execute(sql2.raw(`release savepoint ${savepointName}`));
+      const result = await transaction(nestedTx);
+      if (createdSavepoint) {
+        await internals.session.execute(releaseSql);
+      }
       return result;
-    } catch (err) {
-      await tx.execute(sql2.raw(`rollback to savepoint ${savepointName}`));
-      throw err;
+    } 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,
-  PgDateString,
+  PgDate as PgDate2,
+  PgDateString as PgDateString2,
   PgDialect,
   PgJson,
   PgJsonb,
   PgNumeric,
-  PgTime,
-  PgTimestamp,
-  PgTimestampString,
+  PgTime as PgTime2,
+  PgTimestamp as PgTimestamp2,
+  PgTimestampString as PgTimestampString2,
   PgUUID
 } from "drizzle-orm/pg-core";
 import {
-  sql as sql3
+  sql as sql2
 } from "drizzle-orm";
 
-class DuckDBDialect extends PgDialect {
-  static [entityKind2] = "DuckDBPgDialect";
-  async migrate(migrations, session, config) {
-    const migrationsSchema = config.migrationsSchema ?? "drizzle";
-    const migrationsTable = config.migrationsTable ?? "__drizzle_migrations";
-    const migrationTableCreate = sql3`
-			CREATE TABLE IF NOT EXISTS ${sql3.identifier(migrationsSchema)}.${sql3.identifier(migrationsTable)} (
-				id integer PRIMARY KEY default nextval('migrations_pk_seq'),
-				hash text NOT NULL,
-				created_at bigint
-			)
-		`;
-    await session.execute(sql3.raw("CREATE SEQUENCE IF NOT EXISTS migrations_pk_seq"));
-    await session.execute(sql3`CREATE SCHEMA IF NOT EXISTS ${sql3.identifier(migrationsSchema)}`);
-    await session.execute(migrationTableCreate);
-    const dbMigrations = await session.all(sql3`select id, hash, created_at from ${sql3.identifier(migrationsSchema)}.${sql3.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(sql3.raw(stmt));
-          }
-          await tx.execute(sql3`insert into ${sql3.identifier(migrationsSchema)}.${sql3.identifier(migrationsTable)} ("hash", "created_at") values(${migration.hash}, ${migration.folderMillis})`);
+// 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;
       }
-    });
-  }
-  prepareTyping(encoder) {
-    if (is2(encoder, PgJsonb) || is2(encoder, PgJson)) {
-      throw new Error("JSON and JSONB types are not supported in DuckDB");
-    } else if (is2(encoder, PgNumeric)) {
-      return "decimal";
-    } else if (is2(encoder, PgTime)) {
-      return "time";
-    } else if (is2(encoder, PgTimestamp) || is2(encoder, PgTimestampString)) {
-      return "timestamp";
-    } else if (is2(encoder, PgDate) || is2(encoder, PgDateString)) {
-      return "date";
-    } else if (is2(encoder, PgUUID)) {
-      return "uuid";
+      transformed = true;
     } else {
-      return "none";
+      transformed = walkExpression(binary.left, binary, "left") || transformed;
+      transformed = walkExpression(binary.right, binary, "right") || transformed;
     }
   }
-}
-
-// src/driver.ts
-import {
-  PgSelectBase,
-  PgSelectBuilder
-} from "drizzle-orm/pg-core/query-builders";
-import { SQL as SQL3 } from "drizzle-orm/sql/sql";
-import { Subquery, ViewBaseConfig } from "drizzle-orm";
-import { PgViewBase } from "drizzle-orm/pg-core/view-base";
-class DuckDBDriver {
-  client;
-  dialect;
-  options;
-  static [entityKind3] = "DuckDBDriver";
-  constructor(client, dialect, options = {}) {
-    this.client = client;
-    this.dialect = dialect;
-    this.options = options;
+  if ("type" in expr && exprObj.type === "unary_expr") {
+    if ("expr" in exprObj) {
+      transformed = walkExpression(exprObj.expr, exprObj, "expr") || transformed;
+    }
   }
-  createSession(schema) {
-    return new DuckDBSession(this.client, this.dialect, schema, {
-      logger: this.options.logger
+  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 drizzle(client, config = {}) {
+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) {
@@ -339,98 +2144,1155 @@ function drizzle(client, config = {}) {
       tableNamesMap: tablesConfig.tableNamesMap
     };
   }
-  const driver = new DuckDBDriver(client, dialect, { logger });
+  const driver = new DuckDBDriver(client, dialect, {
+    logger,
+    rejectStringArrayLiterals: config.rejectStringArrayLiterals,
+    prepareCache
+  });
   const session = driver.createSession(schema);
-  return new DuckDBDatabase(dialect, session, schema);
+  const db = new DuckDBDatabase(dialect, session, schema, client, instance);
+  return db;
+}
+async function createFromConnectionString(path, instanceOptions, config = {}) {
+  const instance = await DuckDBInstance2.create(path, instanceOptions);
+  const poolSize = resolvePoolSize(config.pool);
+  if (poolSize === false) {
+    const connection = await instance.connect();
+    return createFromClient(connection, config, instance);
+  }
+  const pool = createDuckDBConnectionPool(instance, { size: poolSize });
+  return createFromClient(pool, config, instance);
+}
+function drizzle(clientOrConfigOrPath, config) {
+  if (typeof clientOrConfigOrPath === "string") {
+    return createFromConnectionString(clientOrConfigOrPath, undefined, config);
+  }
+  if (isConfigObject(clientOrConfigOrPath)) {
+    const configObj = clientOrConfigOrPath;
+    if ("connection" in configObj) {
+      const connConfig = configObj;
+      const { connection, ...restConfig } = connConfig;
+      if (typeof connection === "string") {
+        return createFromConnectionString(connection, undefined, restConfig);
+      }
+      return createFromConnectionString(connection.path, connection.options, restConfig);
+    }
+    if ("client" in configObj) {
+      const clientConfig = configObj;
+      const { client: clientValue, ...restConfig } = clientConfig;
+      return createFromClient(clientValue, restConfig);
+    }
+    throw new Error("Invalid drizzle config: either connection or client must be provided");
+  }
+  return createFromClient(clientOrConfigOrPath, config);
 }
 
 class DuckDBDatabase extends PgDatabase {
   dialect;
   session;
   static [entityKind3] = "DuckDBDatabase";
-  constructor(dialect, session, schema) {
+  $client;
+  $instance;
+  constructor(dialect, session, schema, client, instance) {
     super(dialect, session, schema);
     this.dialect = dialect;
     this.session = session;
+    this.$client = client;
+    this.$instance = instance;
   }
-  select(fields) {
-    if (!fields) {
-      return new DuckDBSelectBuilder({
-        fields: fields ?? undefined,
-        session: this.session,
-        dialect: this.dialect
-      });
+  async close() {
+    if (isPool(this.$client) && this.$client.close) {
+      await this.$client.close();
     }
-    const aliasedFields = aliasFields(fields);
+    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: aliasedFields,
+      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);
   }
 }
-
-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;
+// src/columns.ts
+import { sql as sql4 } from "drizzle-orm";
+import { customType } from "drizzle-orm/pg-core";
+function coerceArrayString(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return [];
+  }
+  if (trimmed.startsWith("[")) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return;
     }
-    this._distinct = config.distinct;
   }
-  from(source) {
-    const isPartialSelect = !!this._fields;
-    const src = source;
-    let fields;
-    if (this._fields) {
-      fields = this._fields;
-    } else if (is3(src, Subquery)) {
-      fields = Object.fromEntries(Object.keys(src._.selectedFields).map((key) => [
-        key,
-        src[key]
-      ]));
-    } else if (is3(src, PgViewBase)) {
-      fields = src[ViewBaseConfig]?.selectedFields;
-    } else if (is3(src, SQL3)) {
-      fields = {};
-    } else {
-      fields = aliasFields(getTableColumns(src), !isPartialSelect);
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+    try {
+      const json = trimmed.replace(/{/g, "[").replace(/}/g, "]");
+      return JSON.parse(json);
+    } catch {
+      return;
     }
-    return new PgSelectBase({
-      table: src,
-      fields,
-      isPartialSelect,
-      session: this._session,
-      dialect: this._dialect,
-      withList: this._withList,
-      distinct: this._distinct
-    });
   }
+  return;
+}
+function formatLiteral(value, typeHint) {
+  if (value === null || value === undefined) {
+    return "NULL";
+  }
+  const upperType = typeHint?.toUpperCase() ?? "";
+  if (value instanceof Date) {
+    return `'${value.toISOString()}'`;
+  }
+  if (typeof value === "number" || typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "boolean") {
+    return value ? "TRUE" : "FALSE";
+  }
+  const str = typeof value === "string" ? value : JSON.stringify(value) ?? String(value);
+  const escaped = str.replace(/'/g, "''");
+  if (upperType.includes("CHAR") || upperType.includes("TEXT") || upperType.includes("STRING") || upperType.includes("VARCHAR")) {
+    return `'${escaped}'`;
+  }
+  return `'${escaped}'`;
+}
+function buildListLiteral(values, elementType) {
+  if (values.length === 0) {
+    return sql4`[]`;
+  }
+  const chunks = values.map((v) => typeof v === "object" && !Array.isArray(v) ? sql4`${v}` : sql4.raw(formatLiteral(v, elementType)));
+  return sql4`list_value(${sql4.join(chunks, sql4.raw(", "))})`;
+}
+function buildStructLiteral(value, schema) {
+  const parts = Object.entries(value).map(([key, val]) => {
+    const typeHint = schema?.[key];
+    if (Array.isArray(val)) {
+      const inner = typeof typeHint === "string" && typeHint.endsWith("[]") ? typeHint.slice(0, -2) : undefined;
+      return sql4`${sql4.identifier(key)} := ${buildListLiteral(val, inner)}`;
+    }
+    return sql4`${sql4.identifier(key)} := ${val}`;
+  });
+  return sql4`struct_pack(${sql4.join(parts, sql4.raw(", "))})`;
+}
+function buildMapLiteral(value, valueType) {
+  const keys = Object.keys(value);
+  const vals = Object.values(value);
+  const keyList = buildListLiteral(keys, "TEXT");
+  const valList = buildListLiteral(vals, valueType?.endsWith("[]") ? valueType.slice(0, -2) : valueType);
+  return sql4`map(${keyList}, ${valList})`;
+}
+var duckDbList = (name, elementType) => customType({
+  dataType() {
+    return `${elementType}[]`;
+  },
+  toDriver(value) {
+    return wrapList(value, elementType);
+  },
+  fromDriver(value) {
+    if (Array.isArray(value)) {
+      return value;
+    }
+    if (typeof value === "string") {
+      const parsed = coerceArrayString(value);
+      if (parsed !== undefined) {
+        return parsed;
+      }
+    }
+    return value;
+  }
+})(name);
+var duckDbArray = (name, elementType, fixedLength) => customType({
+  dataType() {
+    return fixedLength ? `${elementType}[${fixedLength}]` : `${elementType}[]`;
+  },
+  toDriver(value) {
+    return wrapArray(value, elementType, fixedLength);
+  },
+  fromDriver(value) {
+    if (Array.isArray(value)) {
+      return value;
+    }
+    if (typeof value === "string") {
+      const parsed = coerceArrayString(value);
+      if (parsed !== undefined) {
+        return parsed;
+      }
+    }
+    return value;
+  }
+})(name);
+var duckDbMap = (name, valueType) => customType({
+  dataType() {
+    return `MAP (STRING, ${valueType})`;
+  },
+  toDriver(value) {
+    if (Object.keys(value).length === 0) {
+      return buildMapLiteral(value, valueType);
+    }
+    return wrapMap(value, valueType);
+  },
+  fromDriver(value) {
+    return value;
+  }
+})(name);
+var duckDbStruct = (name, schema) => customType({
+  dataType() {
+    const fields = Object.entries(schema).map(([key, type]) => `${key} ${type}`);
+    return `STRUCT (${fields.join(", ")})`;
+  },
+  toDriver(value) {
+    return buildStructLiteral(value, schema);
+  },
+  fromDriver(value) {
+    if (typeof value === "string") {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+    return value;
+  }
+})(name);
+var duckDbJson = (name) => customType({
+  dataType() {
+    return "JSON";
+  },
+  toDriver(value) {
+    if (typeof value === "string") {
+      return value;
+    }
+    if (value !== null && typeof value === "object" && "queryChunks" in value) {
+      return value;
+    }
+    return wrapJson(value);
+  },
+  fromDriver(value) {
+    if (typeof value !== "string") {
+      return value;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return value;
+    }
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return value;
+    }
+  }
+})(name);
+var duckDbBlob = customType({
+  dataType() {
+    return "BLOB";
+  },
+  toDriver(value) {
+    return wrapBlob(value);
+  }
+});
+var duckDbInet = (name) => customType({
+  dataType() {
+    return "INET";
+  },
+  toDriver(value) {
+    return value;
+  }
+})(name);
+var duckDbInterval = (name) => customType({
+  dataType() {
+    return "INTERVAL";
+  },
+  toDriver(value) {
+    return value;
+  }
+})(name);
+function shouldBindTimestamp(options) {
+  const bindMode = options.bindMode ?? "auto";
+  if (bindMode === "bind")
+    return true;
+  if (bindMode === "literal")
+    return false;
+  const isBun = typeof process !== "undefined" && typeof process.versions?.bun !== "undefined";
+  if (isBun)
+    return false;
+  const forceLiteral = typeof process !== "undefined" ? process.env.DRIZZLE_DUCKDB_FORCE_LITERAL_TIMESTAMPS : undefined;
+  if (forceLiteral && forceLiteral !== "0") {
+    return false;
+  }
+  return true;
+}
+var duckDbTimestamp = (name, options = {}) => customType({
+  dataType() {
+    if (options.withTimezone) {
+      return "TIMESTAMPTZ";
+    }
+    const precision = options.precision ? `(${options.precision})` : "";
+    return `TIMESTAMP${precision}`;
+  },
+  toDriver(value) {
+    if (shouldBindTimestamp(options)) {
+      return wrapTimestamp(value, options.withTimezone ?? false, options.precision);
+    }
+    const iso = value instanceof Date ? value.toISOString() : value;
+    const normalized = iso.replace("T", " ").replace("Z", "+00");
+    const typeKeyword = options.withTimezone ? "TIMESTAMPTZ" : "TIMESTAMP";
+    return sql4.raw(`${typeKeyword} '${normalized}'`);
+  },
+  fromDriver(value) {
+    if (value && typeof value === "object" && "kind" in value && value.kind === "timestamp") {
+      const wrapped = value;
+      return wrapped.data instanceof Date ? wrapped.data : typeof wrapped.data === "number" || typeof wrapped.data === "bigint" ? new Date(Number(wrapped.data) / 1000) : wrapped.data;
+    }
+    if (options.mode === "string") {
+      if (value instanceof Date) {
+        return value.toISOString().replace("T", " ").replace("Z", "+00");
+      }
+      return typeof value === "string" ? value : value.toString();
+    }
+    if (value instanceof Date) {
+      return value;
+    }
+    const stringValue = typeof value === "string" ? value : value.toString();
+    const hasOffset = stringValue.endsWith("Z") || /[+-]\d{2}:?\d{2}$/.test(stringValue);
+    const normalized = hasOffset ? stringValue.replace(" ", "T") : `${stringValue.replace(" ", "T")}Z`;
+    return new Date(normalized);
+  }
+})(name);
+var duckDbDate = (name) => customType({
+  dataType() {
+    return "DATE";
+  },
+  toDriver(value) {
+    return value;
+  },
+  fromDriver(value) {
+    const str = value instanceof Date ? value.toISOString().slice(0, 10) : value;
+    return str;
+  }
+})(name);
+var duckDbTime = (name) => customType({
+  dataType() {
+    return "TIME";
+  },
+  toDriver(value) {
+    return value;
+  },
+  fromDriver(value) {
+    if (typeof value === "bigint") {
+      const totalMillis = Number(value) / 1000;
+      const date = new Date(totalMillis);
+      return date.toISOString().split("T")[1].replace("Z", "");
+    }
+    return value;
+  }
+})(name);
+function toListValue(values) {
+  return buildListLiteral(values);
+}
+function duckDbArrayContains(column, values) {
+  const rhs = Array.isArray(values) ? toListValue(values) : values;
+  return sql4`array_has_all(${column}, ${rhs})`;
+}
+function duckDbArrayContained(column, values) {
+  const rhs = Array.isArray(values) ? toListValue(values) : values;
+  return sql4`array_has_all(${rhs}, ${column})`;
+}
+function duckDbArrayOverlaps(column, values) {
+  const rhs = Array.isArray(values) ? toListValue(values) : values;
+  return sql4`array_has_any(${column}, ${rhs})`;
 }
 // src/migrator.ts
 import { readMigrationFiles } from "drizzle-orm/migrator";
 async function migrate(db, config) {
-  const migrations = readMigrationFiles(config);
-  await db.dialect.migrate(migrations, db.session, config);
+  const migrationConfig = typeof config === "string" ? { migrationsFolder: config } : config;
+  const migrations = readMigrationFiles(migrationConfig);
+  await db.dialect.migrate(migrations, db.session, migrationConfig);
+}
+// src/introspect.ts
+import { sql as sql5 } from "drizzle-orm";
+var SYSTEM_SCHEMAS = new Set(["information_schema", "pg_catalog"]);
+var DEFAULT_IMPORT_BASE = "@leonardovida-md/drizzle-neo-duckdb/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(sql5`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 ? sql5`catalog_name = ${database}` : sql5`1 = 1`;
+  const rows = await db.execute(sql5`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) => sql5`${schema}`);
+  const databaseFilter = database ? sql5`table_catalog = ${database}` : sql5`1 = 1`;
+  return await db.execute(sql5`
+      SELECT table_schema as schema_name, table_name, table_type
+      FROM information_schema.tables
+      WHERE ${databaseFilter}
+      AND table_schema IN (${sql5.join(schemaFragments, sql5.raw(", "))})
+      AND ${includeViews ? sql5`1 = 1` : sql5`table_type = 'BASE TABLE'`}
+      ORDER BY table_schema, table_name
+    `);
+}
+async function loadColumns(db, database, schemas) {
+  const schemaFragments = schemas.map((schema) => sql5`${schema}`);
+  const databaseFilter = database ? sql5`database_name = ${database}` : sql5`1 = 1`;
+  return await db.execute(sql5`
+      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 (${sql5.join(schemaFragments, sql5.raw(", "))})
+      ORDER BY schema_name, table_name, column_index
+    `);
+}
+async function loadConstraints(db, database, schemas) {
+  const schemaFragments = schemas.map((schema) => sql5`${schema}`);
+  const databaseFilter = database ? sql5`database_name = ${database}` : sql5`1 = 1`;
+  return await db.execute(sql5`
+      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 (${sql5.join(schemaFragments, sql5.raw(", "))})
+      ORDER BY schema_name, table_name, constraint_index
+    `);
+}
+async function loadIndexes(db, database, schemas) {
+  const schemaFragments = schemas.map((schema) => sql5`${schema}`);
+  const databaseFilter = database ? sql5`database_name = ${database}` : sql5`1 = 1`;
+  return await db.execute(sql5`
+      SELECT
+        schema_name,
+        table_name,
+        index_name,
+        is_unique,
+        expressions
+      FROM duckdb_indexes()
+      WHERE ${databaseFilter}
+      AND schema_name IN (${sql5.join(schemaFragments, sql5.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/olap.ts
+import { is as is5 } from "drizzle-orm/entity";
+import { sql as sql6 } from "drizzle-orm";
+import { SQL as SQL6 } from "drizzle-orm/sql/sql";
+import { Column as Column3, getTableName as getTableName3 } from "drizzle-orm";
+var countN = (expr = sql6`*`) => sql6`count(${expr})`.mapWith(Number);
+var sumN = (expr) => sql6`sum(${expr})`.mapWith(Number);
+var avgN = (expr) => sql6`avg(${expr})`.mapWith(Number);
+var sumDistinctN = (expr) => sql6`sum(distinct ${expr})`.mapWith(Number);
+var percentileCont = (p, expr) => sql6`percentile_cont(${p}) within group (order by ${expr})`.mapWith(Number);
+var median = (expr) => percentileCont(0.5, expr);
+var anyValue = (expr) => sql6`any_value(${expr})`;
+function normalizeArray(value) {
+  if (!value)
+    return [];
+  return Array.isArray(value) ? value : [value];
+}
+function overClause(options) {
+  const partitions = normalizeArray(options?.partitionBy);
+  const orders = normalizeArray(options?.orderBy);
+  const chunks = [];
+  if (partitions.length > 0) {
+    chunks.push(sql6`partition by ${sql6.join(partitions, sql6`, `)}`);
+  }
+  if (orders.length > 0) {
+    chunks.push(sql6`order by ${sql6.join(orders, sql6`, `)}`);
+  }
+  if (chunks.length === 0) {
+    return sql6``;
+  }
+  return sql6`over (${sql6.join(chunks, sql6` `)})`;
+}
+var rowNumber = (options) => sql6`row_number() ${overClause(options)}`.mapWith(Number);
+var rank = (options) => sql6`rank() ${overClause(options)}`.mapWith(Number);
+var denseRank = (options) => sql6`dense_rank() ${overClause(options)}`.mapWith(Number);
+var lag = (expr, offset = 1, defaultValue, options) => defaultValue ? sql6`lag(${expr}, ${offset}, ${defaultValue}) ${overClause(options)}` : sql6`lag(${expr}, ${offset}) ${overClause(options)}`;
+var lead = (expr, offset = 1, defaultValue, options) => defaultValue ? sql6`lead(${expr}, ${offset}, ${defaultValue}) ${overClause(options)}` : sql6`lead(${expr}, ${offset}) ${overClause(options)}`;
+function keyAlias(key, fallback) {
+  if (is5(key, SQL6.Aliased)) {
+    return key.fieldAlias ?? fallback;
+  }
+  if (is5(key, Column3)) {
+    return `${getTableName3(key.table)}.${key.name}`;
+  }
+  return fallback;
+}
+
+class OlapBuilder {
+  db;
+  source;
+  keys = [];
+  measureMap = {};
+  nonAggregates = {};
+  wrapNonAggWithAnyValue = false;
+  orderByClauses = [];
+  constructor(db) {
+    this.db = db;
+  }
+  from(source) {
+    this.source = source;
+    return this;
+  }
+  groupBy(keys) {
+    this.keys = keys;
+    return this;
+  }
+  measures(measures) {
+    this.measureMap = measures;
+    return this;
+  }
+  selectNonAggregates(fields, options = {}) {
+    this.nonAggregates = fields;
+    this.wrapNonAggWithAnyValue = options.anyValue ?? false;
+    return this;
+  }
+  orderBy(...clauses) {
+    this.orderByClauses = clauses;
+    return this;
+  }
+  build() {
+    if (!this.source) {
+      throw new Error("olap: .from() is required");
+    }
+    if (this.keys.length === 0) {
+      throw new Error("olap: .groupBy() is required");
+    }
+    if (Object.keys(this.measureMap).length === 0) {
+      throw new Error("olap: .measures() is required");
+    }
+    const selection = {};
+    this.keys.forEach((key, idx) => {
+      const alias = keyAlias(key, `key_${idx}`);
+      selection[alias] = key;
+    });
+    Object.entries(this.nonAggregates).forEach(([alias, expr]) => {
+      selection[alias] = this.wrapNonAggWithAnyValue ? anyValue(expr) : expr;
+    });
+    Object.assign(selection, this.measureMap);
+    let query = this.db.select(selection).from(this.source).groupBy(...this.keys);
+    if (this.orderByClauses.length > 0) {
+      query = query.orderBy(...this.orderByClauses);
+    }
+    return query;
+  }
+  run() {
+    return this.build();
+  }
+}
+var olap = (db) => new OlapBuilder(db);
+// src/operators.ts
+import { sql as sql7 } from "drizzle-orm";
+function arrayHasAll(column, values) {
+  return sql7`array_has_all(${column}, ${values})`;
+}
+function arrayHasAny(column, values) {
+  return sql7`array_has_any(${column}, ${values})`;
+}
+function arrayContainedBy(column, values) {
+  return sql7`array_has_all(${values}, ${column})`;
 }
 export {
+  wrapperToNodeApiValue,
+  wrapTimestamp,
+  wrapStruct,
+  wrapMap,
+  wrapList,
+  wrapJson,
+  wrapBlob,
+  wrapArray,
+  toIdentifier,
+  sumN,
+  sumDistinctN,
+  splitTopLevel,
+  rowNumber,
+  resolvePrepareCacheOption,
+  resolvePoolSize,
+  rank,
+  prepareParams,
+  percentileCont,
+  parseStructFields,
+  parseMapValue,
+  olap,
   migrate,
+  median,
+  lead,
+  lag,
+  isPool,
+  isDuckDBWrapper,
+  introspect,
+  formatLiteral,
+  executeOnClient,
+  executeInBatchesRaw,
+  executeInBatches,
+  executeArrowOnClient,
+  executeArraysOnClient,
+  duckDbTimestamp,
+  duckDbTime,
+  duckDbStruct,
+  duckDbMap,
+  duckDbList,
+  duckDbJson,
+  duckDbInterval,
+  duckDbInet,
+  duckDbDate,
+  duckDbBlob,
+  duckDbArrayOverlaps,
+  duckDbArrayContains,
+  duckDbArrayContained,
+  duckDbArray,
   drizzle,
+  denseRank,
+  createDuckDBConnectionPool,
+  countN,
+  coerceArrayString,
+  closeClientConnection,
+  buildStructLiteral,
+  buildMapLiteral,
+  buildListLiteral,
+  buildDefault,
+  avgN,
+  arrayHasAny,
+  arrayHasAll,
+  arrayContainedBy,
+  anyValue,
+  POOL_PRESETS,
+  OlapBuilder,
   DuckDBTransaction,
   DuckDBSession,
-  DuckDBSelectBuilder,
   DuckDBPreparedQuery,
   DuckDBDriver,
-  DuckDBDatabase
+  DuckDBDatabase,
+  DUCKDB_VALUE_MARKER,
+  DEFAULT_IMPORT_BASE
 };