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

package/dist/index.mjs

@@ -153,6 +153,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;
@@ -524,6 +527,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("}");
 }
@@ -537,16 +541,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;
@@ -571,13 +579,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 = {};
@@ -588,6 +704,7 @@ function mapRowsToObjects(columns, rows) {
   });
 }
 async function closeClientConnection(connection) {
+  clearPreparedCache(connection);
   if ("close" in connection && typeof connection.close === "function") {
     await connection.close();
     return;
@@ -600,27 +717,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);
@@ -629,21 +770,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) {
@@ -671,6 +811,13 @@ 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 };
+  }
+  const rewritten = adaptArrayOperators(query);
+  return { sql: rewritten, rewritten: rewritten !== query };
+}
 
 class DuckDBPreparedQuery extends PgPreparedQuery {
   client;
@@ -681,11 +828,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;
@@ -695,8 +843,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 = {}) {
@@ -705,18 +854,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);
@@ -733,8 +887,9 @@ class DuckDBSession extends PgSession {
   static [entityKind] = "DuckDBSession";
   dialect;
   logger;
-  rewriteArrays;
+  rewriteArraysMode;
   rejectStringArrayLiterals;
+  prepareCache;
   hasWarnedArrayLiteral = false;
   rollbackOnly = false;
   constructor(client, dialect, schema, options = {}) {
@@ -744,11 +899,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();
@@ -808,13 +969,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);
@@ -823,8 +999,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);
@@ -862,6 +1038,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);
   }
@@ -1273,6 +1452,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;
@@ -1287,8 +1492,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
     });
   }
 }
@@ -1301,6 +1507,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) {
@@ -1313,8 +1521,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);
@@ -1394,6 +1603,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);
   }
@@ -1594,6 +1806,21 @@ var duckDbInterval = (name) => customType({
     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) {
@@ -1603,12 +1830,19 @@ var duckDbTimestamp = (name, options = {}) => customType({
     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");
@@ -2364,6 +2598,8 @@ export {
   sumDistinctN,
   splitTopLevel,
   rowNumber,
+  resolveRewriteArraysOption,
+  resolvePrepareCacheOption,
   resolvePoolSize,
   rank,
   prepareParams,
@@ -2380,8 +2616,10 @@ export {
   introspect,
   formatLiteral,
   executeOnClient,
+  executeInBatchesRaw,
   executeInBatches,
   executeArrowOnClient,
+  executeArraysOnClient,
   duckDbTimestamp,
   duckDbTime,
   duckDbStruct,

package/dist/options.d.ts

@@ -0,0 +1,10 @@
+export type RewriteArraysMode = 'auto' | 'always' | 'never';
+export type RewriteArraysOption = boolean | RewriteArraysMode;
+export declare function resolveRewriteArraysOption(value?: RewriteArraysOption): RewriteArraysMode;
+export type PrepareCacheOption = boolean | number | {
+    size?: number;
+};
+export interface PreparedStatementCacheConfig {
+    size: number;
+}
+export declare function resolvePrepareCacheOption(option?: PrepareCacheOption): PreparedStatementCacheConfig | undefined;

package/dist/session.d.ts

@@ -9,7 +9,8 @@ import { type Query, SQL } from 'drizzle-orm/sql/sql';
 import type { Assume } from 'drizzle-orm/utils';
 import type { DuckDBDialect } from './dialect.ts';
 import type { DuckDBClientLike, RowData } from './client.ts';
-import { type ExecuteInBatchesOptions } from './client.ts';
+import { type ExecuteBatchesRawChunk, type ExecuteInBatchesOptions } from './client.ts';
+import type { PreparedStatementCacheConfig, RewriteArraysMode } from './options.ts';
 export type { DuckDBClientLike, RowData } from './client.ts';
 export declare class DuckDBPreparedQuery<T extends PreparedQueryConfig> extends PgPreparedQuery<T> {
     private client;
@@ -20,19 +21,21 @@ export declare class DuckDBPreparedQuery<T extends PreparedQueryConfig> extends
     private fields;
     private _isResponseInArrayMode;
     private customResultMapper;
-    private rewriteArrays;
+    private rewriteArraysMode;
     private rejectStringArrayLiterals;
+    private prepareCache;
     private warnOnStringArrayLiteral?;
     static readonly [entityKind]: string;
-    constructor(client: DuckDBClientLike, dialect: DuckDBDialect, queryString: string, params: unknown[], logger: Logger, fields: SelectedFieldsOrdered | undefined, _isResponseInArrayMode: boolean, customResultMapper: ((rows: unknown[][]) => T['execute']) | undefined, rewriteArrays: boolean, rejectStringArrayLiterals: boolean, warnOnStringArrayLiteral?: ((sql: string) => void) | undefined);
+    constructor(client: DuckDBClientLike, dialect: DuckDBDialect, queryString: string, params: unknown[], logger: Logger, fields: SelectedFieldsOrdered | undefined, _isResponseInArrayMode: boolean, customResultMapper: ((rows: unknown[][]) => T['execute']) | undefined, rewriteArraysMode: RewriteArraysMode, rejectStringArrayLiterals: boolean, prepareCache: PreparedStatementCacheConfig | undefined, warnOnStringArrayLiteral?: ((sql: string) => void) | undefined);
     execute(placeholderValues?: Record<string, unknown> | undefined): Promise<T['execute']>;
     all(placeholderValues?: Record<string, unknown> | undefined): Promise<T['all']>;
     isResponseInArrayMode(): boolean;
 }
 export interface DuckDBSessionOptions {
     logger?: Logger;
-    rewriteArrays?: boolean;
+    rewriteArrays?: RewriteArraysMode;
     rejectStringArrayLiterals?: boolean;
+    prepareCache?: PreparedStatementCacheConfig;
 }
 export declare class DuckDBSession<TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = Record<string, never>> extends PgSession<DuckDBQueryResultHKT, TFullSchema, TSchema> {
     private client;
@@ -41,8 +44,9 @@ export declare class DuckDBSession<TFullSchema extends Record<string, unknown> =
     static readonly [entityKind]: string;
     protected dialect: DuckDBDialect;
     private logger;
-    private rewriteArrays;
+    private rewriteArraysMode;
     private rejectStringArrayLiterals;
+    private prepareCache;
     private hasWarnedArrayLiteral;
     private rollbackOnly;
     constructor(client: DuckDBClientLike, dialect: DuckDBDialect, schema: RelationalSchemaConfig<TSchema> | undefined, options?: DuckDBSessionOptions);
@@ -52,6 +56,7 @@ export declare class DuckDBSession<TFullSchema extends Record<string, unknown> =
     transaction<T>(transaction: (tx: DuckDBTransaction<TFullSchema, TSchema>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
     private warnOnStringArrayLiteral;
     executeBatches<T extends RowData = RowData>(query: SQL, options?: ExecuteInBatchesOptions): AsyncGenerator<GenericRowData<T>[], void, void>;
+    executeBatchesRaw(query: SQL, options?: ExecuteInBatchesOptions): AsyncGenerator<ExecuteBatchesRawChunk, void, void>;
     executeArrow(query: SQL): Promise<unknown>;
     markRollbackOnly(): void;
     isRollbackOnly(): boolean;
@@ -62,6 +67,7 @@ export declare class DuckDBTransaction<TFullSchema extends Record<string, unknow
     getTransactionConfigSQL(config: PgTransactionConfig): SQL;
     setTransaction(config: PgTransactionConfig): Promise<void>;
     executeBatches<T extends RowData = RowData>(query: SQL, options?: ExecuteInBatchesOptions): AsyncGenerator<GenericRowData<T>[], void, void>;
+    executeBatchesRaw(query: SQL, options?: ExecuteInBatchesOptions): AsyncGenerator<ExecuteBatchesRawChunk, void, void>;
     executeArrow(query: SQL): Promise<unknown>;
     transaction<T>(transaction: (tx: DuckDBTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T>;
     private runNestedWithoutSavepoint;

package/package.json

@@ -3,7 +3,7 @@
   "module": "./dist/index.mjs",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "A drizzle ORM client for use with DuckDB. Based on drizzle's Postgres client.",
   "type": "module",
   "scripts": {