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

package/dist/index.mjs

@@ -303,8 +303,137 @@ import { TransactionRollbackError } from "drizzle-orm/errors";
 
 // src/client.ts
 import {
-  listValue
+  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";
+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
+  };
+}
+function dateToMicros(value) {
+  if (value instanceof Date) {
+    return BigInt(value.getTime()) * 1000n;
+  }
+  let normalized = value;
+  if (!value.includes("T") && value.includes(" ")) {
+    normalized = value.replace(" ", "T");
+  }
+  if (!normalized.endsWith("Z") && !/[+-]\d{2}:?\d{2}$/.test(normalized)) {
+    normalized += "Z";
+  }
+  const date = new Date(normalized);
+  if (isNaN(date.getTime())) {
+    throw new Error(`Invalid timestamp string: ${value}`);
+  }
+  return BigInt(date.getTime()) * 1000n;
+}
+function toUint8Array(data) {
+  return data instanceof Uint8Array && !(data instanceof Buffer) ? data : new Uint8Array(data);
+}
+function convertStructEntries(data, toValue) {
+  const entries = {};
+  for (const [key, val] of Object.entries(data)) {
+    entries[key] = toValue(val);
+  }
+  return entries;
+}
+function convertMapEntries(data, toValue) {
+  return Object.entries(data).map(([key, val]) => ({
+    key,
+    value: toValue(val)
+  }));
+}
+function wrapperToNodeApiValue(wrapper, toValue) {
+  switch (wrapper.kind) {
+    case "list":
+      return listValue(wrapper.data.map(toValue));
+    case "array":
+      return arrayValue(wrapper.data.map(toValue));
+    case "struct":
+      return structValue(convertStructEntries(wrapper.data, toValue));
+    case "map":
+      return mapValue(convertMapEntries(wrapper.data, toValue));
+    case "timestamp":
+      return wrapper.withTimezone ? timestampTZValue(dateToMicros(wrapper.data)) : timestampValue(dateToMicros(wrapper.data));
+    case "blob":
+      return blobValue(toUint8Array(wrapper.data));
+    case "json":
+      return JSON.stringify(wrapper.data);
+    default: {
+      const _exhaustive = wrapper;
+      throw new Error(`Unknown wrapper kind: ${_exhaustive.kind}`);
+    }
+  }
+}
+
+// src/client.ts
 function isPgArrayLiteral(value) {
   return value.startsWith("{") && value.endsWith("}");
 }
@@ -333,30 +462,91 @@ function prepareParams(params, options = {}) {
   });
 }
 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 listValue(value.map((inner) => toNodeApiValue(inner)));
+    return listValue2(value.map((inner) => toNodeApiValue(inner)));
+  }
+  if (value instanceof Date) {
+    return timestampValue2(BigInt(value.getTime()) * 1000n);
   }
   return value;
 }
-async function executeOnClient(client, query, params) {
-  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.columnNames();
+function deduplicateColumns(columns) {
   const seen = {};
-  const uniqueColumns = columns.map((col) => {
+  return columns.map((col) => {
     const count = seen[col] ?? 0;
     seen[col] = count + 1;
     return count === 0 ? col : `${col}_${count}`;
   });
-  return (rows ?? []).map((vals) => {
+}
+function mapRowsToObjects(columns, rows) {
+  return rows.map((vals) => {
     const obj = {};
-    uniqueColumns.forEach((col, idx) => {
+    columns.forEach((col, idx) => {
       obj[col] = vals[idx];
     });
     return obj;
   });
 }
+async function closeClientConnection(connection) {
+  if ("close" in connection && typeof connection.close === "function") {
+    await connection.close();
+    return;
+  }
+  if ("closeSync" in connection && typeof connection.closeSync === "function") {
+    connection.closeSync();
+    return;
+  }
+  if ("disconnectSync" in connection && typeof connection.disconnectSync === "function") {
+    connection.disconnectSync();
+  }
+}
+async function executeOnClient(client, query, params) {
+  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) : [];
+}
+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);
+  let buffer = [];
+  for await (const chunk of result.yieldRowsJs()) {
+    const objects = mapRowsToObjects(uniqueColumns, chunk);
+    for (const row of objects) {
+      buffer.push(row);
+      if (buffer.length >= rowsPerChunk) {
+        yield buffer;
+        buffer = [];
+      }
+    }
+  }
+  if (buffer.length > 0) {
+    yield buffer;
+  }
+}
+async function executeArrowOnClient(client, query, params) {
+  const values = params.length > 0 ? params.map((param) => toNodeApiValue(param)) : undefined;
+  const result = await client.run(query, values);
+  const maybeArrow = result.toArrow ?? result.getArrowTable;
+  if (typeof maybeArrow === "function") {
+    return await maybeArrow.call(result);
+  }
+  return result.getColumnsObjectJS();
+}
 
 // src/session.ts
 class DuckDBPreparedQuery extends PgPreparedQuery {
@@ -397,11 +587,7 @@ class DuckDBPreparedQuery extends PgPreparedQuery {
       this.logger.logQuery(`[duckdb] original query before array rewrite: ${this.queryString}`, params);
     }
     this.logger.logQuery(rewrittenQuery, params);
-    const {
-      fields,
-      joinsNotNullableMap,
-      customResultMapper
-    } = this;
+    const { fields, joinsNotNullableMap, customResultMapper } = this;
     const rows = await executeOnClient(this.client, rewrittenQuery, params);
     if (rows.length === 0 || !fields) {
       return rows;
@@ -461,6 +647,32 @@ class DuckDBSession extends PgSession {
     this.logger.logQuery(`[duckdb] ${arrayLiteralWarning}
 query: ${query}`, []);
   };
+  executeBatches(query, options = {}) {
+    const builtQuery = this.dialect.sqlToQuery(query);
+    const params = prepareParams(builtQuery.params, {
+      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) {
+      this.logger.logQuery(`[duckdb] original query before array rewrite: ${builtQuery.sql}`, params);
+    }
+    this.logger.logQuery(rewrittenQuery, params);
+    return executeInBatches(this.client, rewrittenQuery, params, options);
+  }
+  async executeArrow(query) {
+    const builtQuery = this.dialect.sqlToQuery(query);
+    const params = prepareParams(builtQuery.params, {
+      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) {
+      this.logger.logQuery(`[duckdb] original query before array rewrite: ${builtQuery.sql}`, params);
+    }
+    this.logger.logQuery(rewrittenQuery, params);
+    return executeArrowOnClient(this.client, rewrittenQuery, params);
+  }
 }
 
 class DuckDBTransaction extends PgTransaction {
@@ -484,6 +696,12 @@ class DuckDBTransaction extends PgTransaction {
   setTransaction(config) {
     return this.session.execute(sql`set transaction ${this.getTransactionConfigSQL(config)}`);
   }
+  executeBatches(query, options = {}) {
+    return this.session.executeBatches(query, options);
+  }
+  executeArrow(query) {
+    return this.session.executeArrow(query);
+  }
   async transaction(transaction) {
     const nestedTx = new DuckDBTransaction(this.dialect, this.session, this.schema, this.nestedIndex + 1);
     return transaction(nestedTx);
@@ -582,13 +800,7 @@ import { PgViewBase } from "drizzle-orm/pg-core/view-base";
 import { SQL as SQL4 } from "drizzle-orm/sql/sql";
 
 // src/sql/selection.ts
-import {
-  Column as Column2,
-  SQL as SQL3,
-  getTableName as getTableName2,
-  is as is3,
-  sql as sql3
-} from "drizzle-orm";
+import { Column as Column2, SQL as SQL3, 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;
@@ -729,6 +941,12 @@ class DuckDBDatabase extends PgDatabase {
       dialect: this.dialect
     });
   }
+  executeBatches(query, options = {}) {
+    return this.session.executeBatches(query, options);
+  }
+  executeArrow(query) {
+    return this.session.executeArrow(query);
+  }
   async transaction(transaction) {
     return await this.session.transaction(transaction);
   }
@@ -797,19 +1015,12 @@ function buildStructLiteral(value, schema) {
   });
   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 buildListLiteral(value, elementType);
+    return wrapList(value, elementType);
   },
   fromDriver(value) {
     if (Array.isArray(value)) {
@@ -829,7 +1040,7 @@ var duckDbArray = (name, elementType, fixedLength) => customType({
     return fixedLength ? `${elementType}[${fixedLength}]` : `${elementType}[]`;
   },
   toDriver(value) {
-    return buildListLiteral(value, elementType);
+    return wrapArray(value, elementType, fixedLength);
   },
   fromDriver(value) {
     if (Array.isArray(value)) {
@@ -849,7 +1060,7 @@ var duckDbMap = (name, valueType) => customType({
     return `MAP (STRING, ${valueType})`;
   },
   toDriver(value) {
-    return buildMapLiteral(value, valueType);
+    return wrapMap(value, valueType);
   },
   fromDriver(value) {
     return value;
@@ -885,7 +1096,7 @@ var duckDbJson = (name) => customType({
     if (value !== null && typeof value === "object" && "queryChunks" in value) {
       return value;
     }
-    return JSON.stringify(value ?? null);
+    return wrapJson(value);
   },
   fromDriver(value) {
     if (typeof value !== "string") {
@@ -907,8 +1118,7 @@ var duckDbBlob = customType({
     return "BLOB";
   },
   toDriver(value) {
-    const hexString = value.toString("hex");
-    return sql4`from_hex(${hexString})`;
+    return wrapBlob(value);
   }
 });
 var duckDbInet = (name) => customType({
@@ -1311,7 +1521,9 @@ function mapDuckDbType(column, imports, options) {
   }
   if (upper === "BIGINT" || upper === "INT8" || upper === "UBIGINT") {
     imports.pgCore.add("bigint");
-    return { builder: `bigint(${columnName(column.name)})` };
+    return {
+      builder: `bigint(${columnName(column.name)}, { mode: 'number' })`
+    };
   }
   const decimalMatch = /^DECIMAL\((\d+),(\d+)\)/i.exec(upper);
   const numericMatch = /^NUMERIC\((\d+),(\d+)\)/i.exec(upper);
@@ -1558,9 +1770,140 @@ function renderImports(imports, importBasePath) {
   return lines.join(`
 `);
 }
+// src/olap.ts
+import { is as is5 } from "drizzle-orm/entity";
+import { sql as sql6 } from "drizzle-orm";
+import { SQL as SQL5 } 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, SQL5.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);
 export {
+  wrapperToNodeApiValue,
+  wrapTimestamp,
+  wrapStruct,
+  wrapMap,
+  wrapList,
+  wrapJson,
+  wrapBlob,
+  wrapArray,
+  sumN,
+  sumDistinctN,
+  rowNumber,
+  rank,
+  prepareParams,
+  percentileCont,
+  olap,
   migrate,
+  median,
+  lead,
+  lag,
+  isDuckDBWrapper,
   introspect,
+  executeOnClient,
+  executeInBatches,
+  executeArrowOnClient,
   duckDbTimestamp,
   duckDbTime,
   duckDbStruct,
@@ -1576,9 +1919,16 @@ export {
   duckDbArrayContained,
   duckDbArray,
   drizzle,
+  denseRank,
+  countN,
+  closeClientConnection,
+  avgN,
+  anyValue,
+  OlapBuilder,
   DuckDBTransaction,
   DuckDBSession,
   DuckDBPreparedQuery,
   DuckDBDriver,
-  DuckDBDatabase
+  DuckDBDatabase,
+  DUCKDB_VALUE_MARKER
 };

package/dist/olap.d.ts

@@ -0,0 +1,46 @@
+import { Subquery, type SQLWrapper } from 'drizzle-orm';
+import type { AnyPgColumn, PgTable } from 'drizzle-orm/pg-core';
+import type { PgViewBase } from 'drizzle-orm/pg-core/view-base';
+import { SQL } from 'drizzle-orm/sql/sql';
+import type { DuckDBDatabase } from './driver.ts';
+export declare const countN: (expr?: SQLWrapper) => SQL<number>;
+export declare const sumN: (expr: SQLWrapper) => SQL<number>;
+export declare const avgN: (expr: SQLWrapper) => SQL<number>;
+export declare const sumDistinctN: (expr: SQLWrapper) => SQL<number>;
+export declare const percentileCont: (p: number, expr: SQLWrapper) => SQL<number>;
+export declare const median: (expr: SQLWrapper) => SQL<number>;
+export declare const anyValue: <T = unknown>(expr: SQLWrapper) => SQL<T>;
+type PartitionOrder = {
+    partitionBy?: SQLWrapper | SQLWrapper[];
+    orderBy?: SQLWrapper | SQLWrapper[];
+} | undefined;
+export declare const rowNumber: (options?: PartitionOrder) => SQL<number>;
+export declare const rank: (options?: PartitionOrder) => SQL<number>;
+export declare const denseRank: (options?: PartitionOrder) => SQL<number>;
+export declare const lag: <T = unknown>(expr: SQLWrapper, offset?: number, defaultValue?: SQLWrapper, options?: PartitionOrder) => SQL<T>;
+export declare const lead: <T = unknown>(expr: SQLWrapper, offset?: number, defaultValue?: SQLWrapper, options?: PartitionOrder) => SQL<T>;
+type ValueExpr = SQL | SQL.Aliased | AnyPgColumn;
+type GroupKey = ValueExpr;
+type MeasureMap = Record<string, ValueExpr>;
+type NonAggMap = Record<string, ValueExpr>;
+export declare class OlapBuilder {
+    private db;
+    private source?;
+    private keys;
+    private measureMap;
+    private nonAggregates;
+    private wrapNonAggWithAnyValue;
+    private orderByClauses;
+    constructor(db: DuckDBDatabase);
+    from(source: PgTable | Subquery | PgViewBase | SQL): this;
+    groupBy(keys: GroupKey[]): this;
+    measures(measures: MeasureMap): this;
+    selectNonAggregates(fields: NonAggMap, options?: {
+        anyValue?: boolean;
+    }): this;
+    orderBy(...clauses: ValueExpr[]): this;
+    build(): any;
+    run(): any;
+}
+export declare const olap: (db: DuckDBDatabase) => OlapBuilder;
+export {};

package/dist/session.d.ts

@@ -9,6 +9,7 @@ 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';
 export type { DuckDBClientLike, RowData } from './client.ts';
 export declare class DuckDBPreparedQuery<T extends PreparedQueryConfig> extends PgPreparedQuery<T> {
     private client;
@@ -47,12 +48,16 @@ export declare class DuckDBSession<TFullSchema extends Record<string, unknown> =
     prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, name: string | undefined, isResponseInArrayMode: boolean, customResultMapper?: (rows: unknown[][]) => T['execute']): PgPreparedQuery<T>;
     transaction<T>(transaction: (tx: DuckDBTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T>;
     private warnOnStringArrayLiteral;
+    executeBatches<T extends RowData = RowData>(query: SQL, options?: ExecuteInBatchesOptions): AsyncGenerator<GenericRowData<T>[], void, void>;
+    executeArrow(query: SQL): Promise<unknown>;
 }
 export declare class DuckDBTransaction<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends PgTransaction<DuckDBQueryResultHKT, TFullSchema, TSchema> {
     static readonly [entityKind]: string;
     rollback(): never;
     getTransactionConfigSQL(config: PgTransactionConfig): SQL;
     setTransaction(config: PgTransactionConfig): Promise<void>;
+    executeBatches<T extends RowData = RowData>(query: SQL, options?: ExecuteInBatchesOptions): AsyncGenerator<GenericRowData<T>[], void, void>;
+    executeArrow(query: SQL): Promise<unknown>;
     transaction<T>(transaction: (tx: DuckDBTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T>;
 }
 export type GenericRowData<T extends RowData = RowData> = T;