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

package/dist/duckdb-introspect.mjs

@@ -161,6 +161,9 @@ function walkRight(source, scrubbed, start) {
   return [scrubbed.length, source.slice(start)];
 }
 function adaptArrayOperators(query) {
+  if (query.indexOf("@>") === -1 && query.indexOf("<@") === -1 && query.indexOf("&&") === -1) {
+    return query;
+  }
   let rewritten = query;
   let scrubbed = scrubForRewrite(query);
   let searchStart = 0;
@@ -180,6 +183,328 @@ function adaptArrayOperators(query) {
   }
   return rewritten;
 }
+function extractQuotedIdentifier(original, start) {
+  if (original[start] !== '"') {
+    return null;
+  }
+  let pos = start + 1;
+  while (pos < original.length && original[pos] !== '"') {
+    if (original[pos] === '"' && original[pos + 1] === '"') {
+      pos += 2;
+      continue;
+    }
+    pos++;
+  }
+  if (pos >= original.length) {
+    return null;
+  }
+  return {
+    name: original.slice(start + 1, pos),
+    end: pos + 1
+  };
+}
+function findMainFromClause(scrubbed) {
+  const lowerScrubbed = scrubbed.toLowerCase();
+  let searchStart = 0;
+  const withMatch = /\bwith\s+/i.exec(lowerScrubbed);
+  if (withMatch) {
+    let depth = 0;
+    let pos = withMatch.index + withMatch[0].length;
+    while (pos < scrubbed.length) {
+      const char = scrubbed[pos];
+      if (char === "(") {
+        depth++;
+      } else if (char === ")") {
+        depth--;
+      } else if (depth === 0) {
+        const remaining = lowerScrubbed.slice(pos);
+        if (/^\s*select\s+/i.test(remaining)) {
+          searchStart = pos;
+          break;
+        }
+      }
+      pos++;
+    }
+  }
+  const fromPattern = /\bfrom\s+/gi;
+  fromPattern.lastIndex = searchStart;
+  const fromMatch = fromPattern.exec(lowerScrubbed);
+  return fromMatch ? fromMatch.index + fromMatch[0].length : -1;
+}
+function parseTableSources(original, scrubbed) {
+  const sources = [];
+  const lowerScrubbed = scrubbed.toLowerCase();
+  const fromPos = findMainFromClause(scrubbed);
+  if (fromPos < 0) {
+    return sources;
+  }
+  const fromTable = parseTableRef(original, scrubbed, fromPos);
+  if (fromTable) {
+    sources.push(fromTable);
+  }
+  const joinPattern = /\b(left\s+|right\s+|inner\s+|full\s+|cross\s+)?join\s+/gi;
+  joinPattern.lastIndex = fromPos;
+  let joinMatch;
+  while ((joinMatch = joinPattern.exec(lowerScrubbed)) !== null) {
+    const tableStart = joinMatch.index + joinMatch[0].length;
+    const joinTable = parseTableRef(original, scrubbed, tableStart);
+    if (joinTable) {
+      sources.push(joinTable);
+    }
+  }
+  return sources;
+}
+function parseTableRef(original, scrubbed, start) {
+  let pos = start;
+  while (pos < scrubbed.length && isWhitespace(scrubbed[pos])) {
+    pos++;
+  }
+  if (original[pos] !== '"') {
+    return null;
+  }
+  const nameStart = pos;
+  const firstIdent = extractQuotedIdentifier(original, pos);
+  if (!firstIdent) {
+    return null;
+  }
+  let name = firstIdent.name;
+  pos = firstIdent.end;
+  let afterName = pos;
+  while (afterName < scrubbed.length && isWhitespace(scrubbed[afterName])) {
+    afterName++;
+  }
+  if (scrubbed[afterName] === ".") {
+    afterName++;
+    while (afterName < scrubbed.length && isWhitespace(scrubbed[afterName])) {
+      afterName++;
+    }
+    if (original[afterName] === '"') {
+      const tableIdent = extractQuotedIdentifier(original, afterName);
+      if (tableIdent) {
+        name = tableIdent.name;
+        pos = tableIdent.end;
+      }
+    }
+  }
+  let alias;
+  let aliasPos = pos;
+  while (aliasPos < scrubbed.length && isWhitespace(scrubbed[aliasPos])) {
+    aliasPos++;
+  }
+  const afterTable = scrubbed.slice(aliasPos).toLowerCase();
+  if (afterTable.startsWith("as ")) {
+    aliasPos += 3;
+    while (aliasPos < scrubbed.length && isWhitespace(scrubbed[aliasPos])) {
+      aliasPos++;
+    }
+  }
+  if (original[aliasPos] === '"' && !afterTable.startsWith("on ") && !afterTable.startsWith("left ") && !afterTable.startsWith("right ") && !afterTable.startsWith("inner ") && !afterTable.startsWith("full ") && !afterTable.startsWith("cross ") && !afterTable.startsWith("join ") && !afterTable.startsWith("where ") && !afterTable.startsWith("group ") && !afterTable.startsWith("order ") && !afterTable.startsWith("limit ") && !afterTable.startsWith("as ")) {
+    const aliasIdent = extractQuotedIdentifier(original, aliasPos);
+    if (aliasIdent) {
+      alias = aliasIdent.name;
+    }
+  }
+  return {
+    name,
+    alias,
+    position: nameStart
+  };
+}
+function findJoinClauses(original, scrubbed, sources) {
+  const clauses = [];
+  const lowerScrubbed = scrubbed.toLowerCase();
+  const joinPattern = /\b(left\s+|right\s+|inner\s+|full\s+|cross\s+)?join\s+"[^"]*"(\s*\.\s*"[^"]*")?(\s+as)?(\s+"[^"]*")?\s+on\s+/gi;
+  let match;
+  let sourceIndex = 1;
+  while ((match = joinPattern.exec(lowerScrubbed)) !== null) {
+    const joinType = (match[1] || "").trim().toLowerCase();
+    const joinKeywordEnd = match.index + (match[1] || "").length + "join".length;
+    let tableStart = joinKeywordEnd;
+    while (tableStart < original.length && isWhitespace(original[tableStart])) {
+      tableStart++;
+    }
+    const tableIdent = extractQuotedIdentifier(original, tableStart);
+    if (!tableIdent)
+      continue;
+    let tableName = tableIdent.name;
+    let afterTable = tableIdent.end;
+    let checkPos = afterTable;
+    while (checkPos < scrubbed.length && isWhitespace(scrubbed[checkPos])) {
+      checkPos++;
+    }
+    if (scrubbed[checkPos] === ".") {
+      checkPos++;
+      while (checkPos < scrubbed.length && isWhitespace(scrubbed[checkPos])) {
+        checkPos++;
+      }
+      const realTableIdent = extractQuotedIdentifier(original, checkPos);
+      if (realTableIdent) {
+        tableName = realTableIdent.name;
+        afterTable = realTableIdent.end;
+      }
+    }
+    let tableAlias;
+    let aliasPos = afterTable;
+    while (aliasPos < scrubbed.length && isWhitespace(scrubbed[aliasPos])) {
+      aliasPos++;
+    }
+    const afterTableStr = scrubbed.slice(aliasPos).toLowerCase();
+    if (afterTableStr.startsWith("as ")) {
+      aliasPos += 3;
+      while (aliasPos < scrubbed.length && isWhitespace(scrubbed[aliasPos])) {
+        aliasPos++;
+      }
+    }
+    if (original[aliasPos] === '"' && !afterTableStr.startsWith("on ")) {
+      const aliasIdent = extractQuotedIdentifier(original, aliasPos);
+      if (aliasIdent) {
+        tableAlias = aliasIdent.name;
+      }
+    }
+    const onStart = match.index + match[0].length;
+    const endPattern = /\b(left\s+join|right\s+join|inner\s+join|full\s+join|cross\s+join|join|where|group\s+by|order\s+by|limit|$)/i;
+    const remaining = lowerScrubbed.slice(onStart);
+    const endMatch = endPattern.exec(remaining);
+    const onEnd = endMatch ? onStart + endMatch.index : scrubbed.length;
+    let leftSource = "";
+    if (sourceIndex > 0 && sourceIndex <= sources.length) {
+      const prev = sources[sourceIndex - 1];
+      leftSource = prev?.alias || prev?.name || "";
+    }
+    const rightSource = tableAlias || tableName;
+    clauses.push({
+      joinType,
+      tableName,
+      tableAlias,
+      onStart,
+      onEnd,
+      leftSource,
+      rightSource
+    });
+    sourceIndex++;
+  }
+  return clauses;
+}
+function qualifyJoinColumns(query) {
+  const lowerQuery = query.toLowerCase();
+  if (!lowerQuery.includes("join")) {
+    return query;
+  }
+  const scrubbed = scrubForRewrite(query);
+  const sources = parseTableSources(query, scrubbed);
+  if (sources.length < 2) {
+    return query;
+  }
+  const joinClauses = findJoinClauses(query, scrubbed, sources);
+  if (joinClauses.length === 0) {
+    return query;
+  }
+  let result = query;
+  let offset = 0;
+  for (const join of joinClauses) {
+    const scrubbedOnClause = scrubbed.slice(join.onStart, join.onEnd);
+    const originalOnClause = query.slice(join.onStart, join.onEnd);
+    let clauseResult = originalOnClause;
+    let clauseOffset = 0;
+    let eqPos = -1;
+    while ((eqPos = scrubbedOnClause.indexOf("=", eqPos + 1)) !== -1) {
+      let lhsEnd = eqPos - 1;
+      while (lhsEnd >= 0 && isWhitespace(scrubbedOnClause[lhsEnd])) {
+        lhsEnd--;
+      }
+      if (scrubbedOnClause[lhsEnd] !== '"')
+        continue;
+      let lhsStartPos = lhsEnd - 1;
+      while (lhsStartPos >= 0 && scrubbedOnClause[lhsStartPos] !== '"') {
+        lhsStartPos--;
+      }
+      if (lhsStartPos < 0)
+        continue;
+      const lhsIsQualified = lhsStartPos > 0 && scrubbedOnClause[lhsStartPos - 1] === ".";
+      let rhsStartPos = eqPos + 1;
+      while (rhsStartPos < scrubbedOnClause.length && isWhitespace(scrubbedOnClause[rhsStartPos])) {
+        rhsStartPos++;
+      }
+      const rhsChar = originalOnClause[rhsStartPos];
+      const rhsIsParam = rhsChar === "$";
+      const rhsIsStringLiteral = rhsChar === "'";
+      const rhsIsColumn = rhsChar === '"';
+      if (!rhsIsParam && !rhsIsStringLiteral && !rhsIsColumn)
+        continue;
+      const rhsIsQualified = !rhsIsColumn || rhsStartPos > 0 && scrubbedOnClause[rhsStartPos - 1] === ".";
+      if (lhsIsQualified || rhsIsQualified)
+        continue;
+      const lhsIdent = extractQuotedIdentifier(originalOnClause, lhsStartPos);
+      if (!lhsIdent)
+        continue;
+      let rhsIdent = null;
+      let rhsValue = "";
+      let rhsEnd = rhsStartPos;
+      if (rhsIsParam) {
+        let paramEnd = rhsStartPos + 1;
+        while (paramEnd < originalOnClause.length && /\d/.test(originalOnClause[paramEnd])) {
+          paramEnd++;
+        }
+        rhsValue = originalOnClause.slice(rhsStartPos, paramEnd);
+        rhsEnd = paramEnd;
+      } else if (rhsIsStringLiteral) {
+        let literalEnd = rhsStartPos + 1;
+        while (literalEnd < originalOnClause.length) {
+          if (originalOnClause[literalEnd] === "'") {
+            if (originalOnClause[literalEnd + 1] === "'") {
+              literalEnd += 2;
+              continue;
+            }
+            break;
+          }
+          literalEnd++;
+        }
+        rhsValue = originalOnClause.slice(rhsStartPos, literalEnd + 1);
+        rhsEnd = literalEnd + 1;
+      } else if (rhsIsColumn) {
+        rhsIdent = extractQuotedIdentifier(originalOnClause, rhsStartPos);
+        if (rhsIdent) {
+          if (rhsIdent.end < scrubbedOnClause.length && scrubbedOnClause[rhsIdent.end] === ".") {
+            continue;
+          }
+          rhsValue = `"${rhsIdent.name}"`;
+          rhsEnd = rhsIdent.end;
+        }
+      }
+      if (!rhsValue)
+        continue;
+      if (!rhsIsColumn || !rhsIdent || lhsIdent.name !== rhsIdent.name) {
+        continue;
+      }
+      const lhsOriginal = `"${lhsIdent.name}"`;
+      let newLhs = lhsOriginal;
+      let newRhs = rhsValue;
+      if (!lhsIsQualified && join.leftSource) {
+        newLhs = `"${join.leftSource}"."${lhsIdent.name}"`;
+      }
+      if (!rhsIsQualified && rhsIsColumn && rhsIdent && join.rightSource) {
+        newRhs = `"${join.rightSource}"."${rhsIdent.name}"`;
+      }
+      if (newLhs !== lhsOriginal || newRhs !== rhsValue) {
+        const opStart = lhsIdent.end;
+        let opEnd = opStart;
+        while (opEnd < rhsEnd && (isWhitespace(originalOnClause[opEnd]) || originalOnClause[opEnd] === "=")) {
+          opEnd++;
+        }
+        const operator = originalOnClause.slice(opStart, opEnd);
+        const newExpr = `${newLhs}${operator}${newRhs}`;
+        const oldExprLength = rhsEnd - lhsStartPos;
+        clauseResult = clauseResult.slice(0, lhsStartPos + clauseOffset) + newExpr + clauseResult.slice(lhsStartPos + oldExprLength + clauseOffset);
+        clauseOffset += newExpr.length - oldExprLength;
+      }
+    }
+    if (clauseResult !== originalOnClause) {
+      result = result.slice(0, join.onStart + offset) + clauseResult + result.slice(join.onEnd + offset);
+      offset += clauseResult.length - originalOnClause.length;
+    }
+  }
+  return result;
+}
 
 // src/sql/result-mapper.ts
 import {
@@ -473,6 +798,7 @@ function wrapperToNodeApiValue(wrapper, toValue) {
 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("}");
 }
@@ -486,16 +812,20 @@ function parsePgArrayLiteral(value) {
 }
 function prepareParams(params, options = {}) {
   return params.map((param) => {
-    if (typeof param === "string") {
-      const trimmed = param.trim();
-      if (trimmed && isPgArrayLiteral(trimmed)) {
-        if (options.rejectStringArrayLiterals) {
-          throw new Error("Stringified array literals are not supported. Use duckDbList()/duckDbArray() or pass native arrays.");
-        }
-        if (options.warnOnStringArrayLiteral) {
-          options.warnOnStringArrayLiteral();
+    if (typeof param === "string" && param.length > 0) {
+      const firstChar = param[0];
+      const maybeArrayLiteral = firstChar === "{" || firstChar === "[" || firstChar === " " || firstChar === "\t";
+      if (maybeArrayLiteral) {
+        const trimmed = firstChar === "{" || firstChar === "[" ? param : param.trim();
+        if (trimmed && isPgArrayLiteral(trimmed)) {
+          if (options.rejectStringArrayLiterals) {
+            throw new Error("Stringified array literals are not supported. Use duckDbList()/duckDbArray() or pass native arrays.");
+          }
+          if (options.warnOnStringArrayLiteral) {
+            options.warnOnStringArrayLiteral();
+          }
+          return parsePgArrayLiteral(trimmed);
         }
-        return parsePgArrayLiteral(trimmed);
       }
     }
     return param;
@@ -520,13 +850,121 @@ function toNodeApiValue(value) {
   return value;
 }
 function deduplicateColumns(columns) {
-  const seen = {};
-  return columns.map((col) => {
-    const count = seen[col] ?? 0;
-    seen[col] = count + 1;
-    return count === 0 ? col : `${col}_${count}`;
+  const counts = new Map;
+  let hasDuplicates = false;
+  for (const column of columns) {
+    const next = (counts.get(column) ?? 0) + 1;
+    counts.set(column, next);
+    if (next > 1) {
+      hasDuplicates = true;
+      break;
+    }
+  }
+  if (!hasDuplicates) {
+    return columns;
+  }
+  counts.clear();
+  return columns.map((column) => {
+    const count = counts.get(column) ?? 0;
+    counts.set(column, count + 1);
+    return count === 0 ? column : `${column}_${count}`;
   });
 }
+function destroyPreparedStatement(entry) {
+  if (!entry)
+    return;
+  try {
+    entry.statement.destroySync();
+  } catch {}
+}
+function getPreparedCache(connection, size) {
+  const store = connection;
+  const existing = store[PREPARED_CACHE];
+  if (existing) {
+    existing.size = size;
+    return existing;
+  }
+  const cache = { size, entries: new Map };
+  store[PREPARED_CACHE] = cache;
+  return cache;
+}
+function evictOldest(cache) {
+  const oldest = cache.entries.keys().next();
+  if (!oldest.done) {
+    const key = oldest.value;
+    const entry = cache.entries.get(key);
+    cache.entries.delete(key);
+    destroyPreparedStatement(entry);
+  }
+}
+function evictCacheEntry(cache, key) {
+  const entry = cache.entries.get(key);
+  cache.entries.delete(key);
+  destroyPreparedStatement(entry);
+}
+async function getOrPrepareStatement(connection, query, cacheConfig) {
+  const cache = getPreparedCache(connection, cacheConfig.size);
+  const cached = cache.entries.get(query);
+  if (cached) {
+    cache.entries.delete(query);
+    cache.entries.set(query, cached);
+    return cached.statement;
+  }
+  const statement = await connection.prepare(query);
+  cache.entries.set(query, { statement });
+  while (cache.entries.size > cache.size) {
+    evictOldest(cache);
+  }
+  return statement;
+}
+async function materializeResultRows(result) {
+  const rows = await result.getRowsJS() ?? [];
+  const baseColumns = typeof result.deduplicatedColumnNames === "function" ? result.deduplicatedColumnNames() : result.columnNames();
+  const columns = typeof result.deduplicatedColumnNames === "function" ? baseColumns : deduplicateColumns(baseColumns);
+  return { columns, rows };
+}
+async function materializeRows(client, query, params, options = {}) {
+  if (isPool(client)) {
+    const connection2 = await client.acquire();
+    try {
+      return await materializeRows(connection2, query, params, options);
+    } finally {
+      await client.release(connection2);
+    }
+  }
+  const values = params.length > 0 ? params.map((param) => toNodeApiValue(param)) : undefined;
+  const connection = client;
+  if (options.prepareCache && typeof connection.prepare === "function") {
+    const cache = getPreparedCache(connection, options.prepareCache.size);
+    try {
+      const statement = await getOrPrepareStatement(connection, query, options.prepareCache);
+      if (values) {
+        statement.bind(values);
+      } else {
+        statement.clearBindings?.();
+      }
+      const result2 = await statement.run();
+      cache.entries.delete(query);
+      cache.entries.set(query, { statement });
+      return await materializeResultRows(result2);
+    } catch (error) {
+      evictCacheEntry(cache, query);
+      throw error;
+    }
+  }
+  const result = await connection.run(query, values);
+  return await materializeResultRows(result);
+}
+function clearPreparedCache(connection) {
+  const store = connection;
+  const cache = store[PREPARED_CACHE];
+  if (!cache)
+    return;
+  for (const entry of cache.entries.values()) {
+    destroyPreparedStatement(entry);
+  }
+  cache.entries.clear();
+}
 function mapRowsToObjects(columns, rows) {
   return rows.map((vals) => {
     const obj = {};
@@ -537,6 +975,7 @@ function mapRowsToObjects(columns, rows) {
   });
 }
 async function closeClientConnection(connection) {
+  clearPreparedCache(connection);
   if ("close" in connection && typeof connection.close === "function") {
     await connection.close();
     return;
@@ -549,27 +988,51 @@ async function closeClientConnection(connection) {
     connection.disconnectSync();
   }
 }
-async function executeOnClient(client, query, params) {
+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 {
-      return await executeOnClient(connection, query, params);
+      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.run(query, values);
-  const rows = await result.getRowsJS();
-  const columns = result.deduplicatedColumnNames?.() ?? result.columnNames();
-  const uniqueColumns = deduplicateColumns(columns);
-  return rows ? mapRowsToObjects(uniqueColumns, rows) : [];
+  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* executeInBatches(client, query, params, options = {}) {
+async function* executeInBatchesRaw(client, query, params, options = {}) {
   if (isPool(client)) {
     const connection = await client.acquire();
     try {
-      yield* executeInBatches(connection, query, params, options);
+      yield* executeInBatchesRaw(connection, query, params, options);
       return;
     } finally {
       await client.release(connection);
@@ -578,21 +1041,20 @@ async function* executeInBatches(client, query, params, options = {}) {
   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 columns = result.deduplicatedColumnNames?.() ?? result.columnNames();
-  const uniqueColumns = deduplicateColumns(columns);
+  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(uniqueColumns, chunk);
-    for (const row of objects) {
+    for (const row of chunk) {
       buffer.push(row);
       if (buffer.length >= rowsPerChunk) {
-        yield buffer;
+        yield { columns, rows: buffer };
         buffer = [];
       }
     }
   }
   if (buffer.length > 0) {
-    yield buffer;
+    yield { columns, rows: buffer };
   }
 }
 async function executeArrowOnClient(client, query, params) {
@@ -620,6 +1082,24 @@ function isSavepointSyntaxError(error) {
   }
   return error.message.toLowerCase().includes("savepoint") && error.message.toLowerCase().includes("syntax error");
 }
+function rewriteQuery(mode, query) {
+  if (mode === "never") {
+    return { sql: query, rewritten: false };
+  }
+  let result = query;
+  let wasRewritten = false;
+  const arrayRewritten = adaptArrayOperators(result);
+  if (arrayRewritten !== result) {
+    result = arrayRewritten;
+    wasRewritten = true;
+  }
+  const joinQualified = qualifyJoinColumns(result);
+  if (joinQualified !== result) {
+    result = joinQualified;
+    wasRewritten = true;
+  }
+  return { sql: result, rewritten: wasRewritten };
+}
 
 class DuckDBPreparedQuery extends PgPreparedQuery {
   client;
@@ -630,11 +1110,12 @@ class DuckDBPreparedQuery extends PgPreparedQuery {
   fields;
   _isResponseInArrayMode;
   customResultMapper;
-  rewriteArrays;
+  rewriteArraysMode;
   rejectStringArrayLiterals;
+  prepareCache;
   warnOnStringArrayLiteral;
   static [entityKind] = "DuckDBPreparedQuery";
-  constructor(client, dialect, queryString, params, logger, fields, _isResponseInArrayMode, customResultMapper, rewriteArrays, rejectStringArrayLiterals, warnOnStringArrayLiteral) {
+  constructor(client, dialect, queryString, params, logger, fields, _isResponseInArrayMode, customResultMapper, rewriteArraysMode, rejectStringArrayLiterals, prepareCache, warnOnStringArrayLiteral) {
     super({ sql: queryString, params });
     this.client = client;
     this.dialect = dialect;
@@ -644,8 +1125,9 @@ class DuckDBPreparedQuery extends PgPreparedQuery {
     this.fields = fields;
     this._isResponseInArrayMode = _isResponseInArrayMode;
     this.customResultMapper = customResultMapper;
-    this.rewriteArrays = rewriteArrays;
+    this.rewriteArraysMode = rewriteArraysMode;
     this.rejectStringArrayLiterals = rejectStringArrayLiterals;
+    this.prepareCache = prepareCache;
     this.warnOnStringArrayLiteral = warnOnStringArrayLiteral;
   }
   async execute(placeholderValues = {}) {
@@ -654,18 +1136,23 @@ class DuckDBPreparedQuery extends PgPreparedQuery {
       rejectStringArrayLiterals: this.rejectStringArrayLiterals,
       warnOnStringArrayLiteral: this.warnOnStringArrayLiteral ? () => this.warnOnStringArrayLiteral?.(this.queryString) : undefined
     });
-    const rewrittenQuery = this.rewriteArrays ? adaptArrayOperators(this.queryString) : this.queryString;
-    if (this.rewriteArrays && rewrittenQuery !== this.queryString) {
+    const { sql: rewrittenQuery, rewritten: didRewrite } = rewriteQuery(this.rewriteArraysMode, this.queryString);
+    if (didRewrite) {
       this.logger.logQuery(`[duckdb] original query before array rewrite: ${this.queryString}`, params);
     }
     this.logger.logQuery(rewrittenQuery, params);
     const { fields, joinsNotNullableMap, customResultMapper } = this;
-    const rows = await executeOnClient(this.client, rewrittenQuery, params);
-    if (rows.length === 0 || !fields) {
-      return rows;
+    if (fields) {
+      const { rows: rows2 } = await executeArraysOnClient(this.client, rewrittenQuery, params, { prepareCache: this.prepareCache });
+      if (rows2.length === 0) {
+        return [];
+      }
+      return customResultMapper ? customResultMapper(rows2) : rows2.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
     }
-    const rowValues = rows.map((row) => Object.values(row));
-    return customResultMapper ? customResultMapper(rowValues) : rowValues.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
+    const rows = await executeOnClient(this.client, rewrittenQuery, params, {
+      prepareCache: this.prepareCache
+    });
+    return rows;
   }
   all(placeholderValues = {}) {
     return this.execute(placeholderValues);
@@ -682,8 +1169,9 @@ class DuckDBSession extends PgSession {
   static [entityKind] = "DuckDBSession";
   dialect;
   logger;
-  rewriteArrays;
+  rewriteArraysMode;
   rejectStringArrayLiterals;
+  prepareCache;
   hasWarnedArrayLiteral = false;
   rollbackOnly = false;
   constructor(client, dialect, schema, options = {}) {
@@ -693,11 +1181,17 @@ class DuckDBSession extends PgSession {
     this.options = options;
     this.dialect = dialect;
     this.logger = options.logger ?? new NoopLogger;
-    this.rewriteArrays = options.rewriteArrays ?? true;
+    this.rewriteArraysMode = options.rewriteArrays ?? "auto";
     this.rejectStringArrayLiterals = options.rejectStringArrayLiterals ?? false;
+    this.prepareCache = options.prepareCache;
+    this.options = {
+      ...options,
+      rewriteArrays: this.rewriteArraysMode,
+      prepareCache: this.prepareCache
+    };
   }
   prepareQuery(query, fields, name, isResponseInArrayMode, customResultMapper) {
-    return new DuckDBPreparedQuery(this.client, this.dialect, query.sql, query.params, this.logger, fields, isResponseInArrayMode, customResultMapper, this.rewriteArrays, this.rejectStringArrayLiterals, this.rejectStringArrayLiterals ? undefined : this.warnOnStringArrayLiteral);
+    return new DuckDBPreparedQuery(this.client, this.dialect, query.sql, query.params, this.logger, fields, isResponseInArrayMode, customResultMapper, this.rewriteArraysMode, this.rejectStringArrayLiterals, this.prepareCache, this.rejectStringArrayLiterals ? undefined : this.warnOnStringArrayLiteral);
   }
   execute(query) {
     this.dialect.resetPgJsonFlag();
@@ -757,13 +1251,28 @@ query: ${query}`, []);
       rejectStringArrayLiterals: this.rejectStringArrayLiterals,
       warnOnStringArrayLiteral: this.rejectStringArrayLiterals ? undefined : () => this.warnOnStringArrayLiteral(builtQuery.sql)
     });
-    const rewrittenQuery = this.rewriteArrays ? adaptArrayOperators(builtQuery.sql) : builtQuery.sql;
-    if (this.rewriteArrays && rewrittenQuery !== builtQuery.sql) {
+    const { sql: rewrittenQuery, rewritten: didRewrite } = rewriteQuery(this.rewriteArraysMode, builtQuery.sql);
+    if (didRewrite) {
       this.logger.logQuery(`[duckdb] original query before array rewrite: ${builtQuery.sql}`, params);
     }
     this.logger.logQuery(rewrittenQuery, params);
     return executeInBatches(this.client, rewrittenQuery, 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)
+    });
+    const { sql: rewrittenQuery, rewritten: didRewrite } = rewriteQuery(this.rewriteArraysMode, builtQuery.sql);
+    if (didRewrite) {
+      this.logger.logQuery(`[duckdb] original query before array rewrite: ${builtQuery.sql}`, params);
+    }
+    this.logger.logQuery(rewrittenQuery, params);
+    return executeInBatchesRaw(this.client, rewrittenQuery, params, options);
+  }
   async executeArrow(query) {
     this.dialect.resetPgJsonFlag();
     const builtQuery = this.dialect.sqlToQuery(query);
@@ -772,8 +1281,8 @@ query: ${query}`, []);
       rejectStringArrayLiterals: this.rejectStringArrayLiterals,
       warnOnStringArrayLiteral: this.rejectStringArrayLiterals ? undefined : () => this.warnOnStringArrayLiteral(builtQuery.sql)
     });
-    const rewrittenQuery = this.rewriteArrays ? adaptArrayOperators(builtQuery.sql) : builtQuery.sql;
-    if (this.rewriteArrays && rewrittenQuery !== builtQuery.sql) {
+    const { sql: rewrittenQuery, rewritten: didRewrite } = rewriteQuery(this.rewriteArraysMode, builtQuery.sql);
+    if (didRewrite) {
       this.logger.logQuery(`[duckdb] original query before array rewrite: ${builtQuery.sql}`, params);
     }
     this.logger.logQuery(rewrittenQuery, params);
@@ -811,6 +1320,9 @@ class DuckDBTransaction extends PgTransaction {
   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);
   }
@@ -1222,6 +1734,32 @@ function createDuckDBConnectionPool(instance, options = {}) {
   };
 }
 
+// src/options.ts
+var DEFAULT_REWRITE_ARRAYS_MODE = "auto";
+function resolveRewriteArraysOption(value) {
+  if (value === undefined)
+    return DEFAULT_REWRITE_ARRAYS_MODE;
+  if (value === true)
+    return "auto";
+  if (value === false)
+    return "never";
+  return value;
+}
+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;
@@ -1236,8 +1774,9 @@ class DuckDBDriver {
   createSession(schema) {
     return new DuckDBSession(this.client, this.dialect, schema, {
       logger: this.options.logger,
-      rewriteArrays: this.options.rewriteArrays,
-      rejectStringArrayLiterals: this.options.rejectStringArrayLiterals
+      rewriteArrays: this.options.rewriteArrays ?? "auto",
+      rejectStringArrayLiterals: this.options.rejectStringArrayLiterals,
+      prepareCache: this.options.prepareCache
     });
   }
 }
@@ -1250,6 +1789,8 @@ function isConfigObject(data) {
 }
 function createFromClient(client, config = {}, instance) {
   const dialect = new DuckDBDialect;
+  const rewriteArraysMode = resolveRewriteArraysOption(config.rewriteArrays);
+  const prepareCache = resolvePrepareCacheOption(config.prepareCache);
   const logger = config.logger === true ? new DefaultLogger : config.logger || undefined;
   let schema;
   if (config.schema) {
@@ -1262,8 +1803,9 @@ function createFromClient(client, config = {}, instance) {
   }
   const driver = new DuckDBDriver(client, dialect, {
     logger,
-    rewriteArrays: config.rewriteArrays,
-    rejectStringArrayLiterals: config.rejectStringArrayLiterals
+    rewriteArrays: rewriteArraysMode,
+    rejectStringArrayLiterals: config.rejectStringArrayLiterals,
+    prepareCache
   });
   const session = driver.createSession(schema);
   const db = new DuckDBDatabase(dialect, session, schema, client, instance);
@@ -1343,6 +1885,9 @@ class DuckDBDatabase extends PgDatabase {
   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);
   }