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

package/dist/introspect.d.ts

@@ -61,5 +61,14 @@ export interface IntrospectResult {
         relationsTs?: string;
     };
 }
+export declare const DEFAULT_IMPORT_BASE = "@leonardovida-md/drizzle-neo-duckdb/helpers";
 export declare function introspect(db: DuckDBDatabase, opts?: IntrospectOptions): Promise<IntrospectResult>;
+export declare function buildDefault(defaultValue: string | null): string;
+export declare function parseStructFields(inner: string): Array<{
+    name: string;
+    type: string;
+}>;
+export declare function parseMapValue(raw: string): string;
+export declare function splitTopLevel(input: string, delimiter: string): string[];
+export declare function toIdentifier(name: string): string;
 export {};

package/dist/pool.d.ts

@@ -0,0 +1,30 @@
+import { DuckDBInstance } from '@duckdb/node-api';
+import { type DuckDBConnectionPool } from './client.ts';
+/** Pool size presets for different MotherDuck instance types */
+export type PoolPreset = 'pulse' | 'standard' | 'jumbo' | 'mega' | 'giga' | 'local' | 'memory';
+/** Pool sizes optimized for each MotherDuck instance type */
+export declare const POOL_PRESETS: Record<PoolPreset, number>;
+export interface DuckDBPoolConfig {
+    /** Maximum concurrent connections. Defaults to 4. */
+    size?: number;
+}
+/**
+ * Resolve pool configuration to a concrete size.
+ * Returns false if pooling is disabled.
+ */
+export declare function resolvePoolSize(pool: DuckDBPoolConfig | PoolPreset | false | undefined): number | false;
+export interface DuckDBConnectionPoolOptions {
+    /** Maximum concurrent connections. Defaults to 4. */
+    size?: number;
+    /** Timeout in milliseconds to wait for a connection. Defaults to 30000 (30s). */
+    acquireTimeout?: number;
+    /** Maximum number of requests waiting for a connection. Defaults to 100. */
+    maxWaitingRequests?: number;
+    /** Max time (ms) a connection may live before being recycled. */
+    maxLifetimeMs?: number;
+    /** Max idle time (ms) before an idle connection is discarded. */
+    idleTimeoutMs?: number;
+}
+export declare function createDuckDBConnectionPool(instance: DuckDBInstance, options?: DuckDBConnectionPoolOptions): DuckDBConnectionPool & {
+    size: number;
+};

package/dist/session.d.ts

@@ -44,12 +44,17 @@ export declare class DuckDBSession<TFullSchema extends Record<string, unknown> =
     private rewriteArrays;
     private rejectStringArrayLiterals;
     private hasWarnedArrayLiteral;
+    private rollbackOnly;
     constructor(client: DuckDBClientLike, dialect: DuckDBDialect, schema: RelationalSchemaConfig<TSchema> | undefined, options?: DuckDBSessionOptions);
     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>;
+    execute<T>(query: SQL): Promise<T>;
+    all<T = unknown>(query: SQL): Promise<T[]>;
+    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>;
     executeArrow(query: SQL): Promise<unknown>;
+    markRollbackOnly(): void;
+    isRollbackOnly(): boolean;
 }
 export declare class DuckDBTransaction<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends PgTransaction<DuckDBQueryResultHKT, TFullSchema, TSchema> {
     static readonly [entityKind]: string;
@@ -59,6 +64,7 @@ export declare class DuckDBTransaction<TFullSchema extends Record<string, unknow
     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>;
+    private runNestedWithoutSavepoint;
 }
 export type GenericRowData<T extends RowData = RowData> = T;
 export type GenericTableData<T = RowData> = T[];

package/dist/sql/query-rewriters.d.ts

@@ -1,2 +1,2 @@
+export declare function scrubForRewrite(query: string): string;
 export declare function adaptArrayOperators(query: string): string;
-export declare function queryAdapter(query: string): string;

package/dist/sql/result-mapper.d.ts

@@ -1,2 +1,9 @@
 import { type AnyColumn, type SelectedFieldsOrdered } from 'drizzle-orm';
+export declare function normalizeInet(value: unknown): unknown;
+export declare function normalizeTimestampString(value: unknown, withTimezone: boolean): string | unknown;
+export declare function normalizeTimestamp(value: unknown, withTimezone: boolean): Date | unknown;
+export declare function normalizeDateString(value: unknown): string | unknown;
+export declare function normalizeDateValue(value: unknown): Date | unknown;
+export declare function normalizeTime(value: unknown): string | unknown;
+export declare function normalizeInterval(value: unknown): string | unknown;
 export declare function mapResultRow<TResult>(columns: SelectedFieldsOrdered<AnyColumn>, row: unknown[], joinsNotNullableMap: Record<string, boolean> | undefined): TResult;

package/dist/utils.d.ts

@@ -1,3 +1,3 @@
 export { aliasFields } from './sql/selection.ts';
-export { adaptArrayOperators, queryAdapter } from './sql/query-rewriters.ts';
+export { adaptArrayOperators } from './sql/query-rewriters.ts';
 export { mapResultRow } from './sql/result-mapper.ts';

package/dist/value-wrappers-core.d.ts

@@ -0,0 +1,42 @@
+/**
+ * DuckDB wrapper value helpers that are safe for client-side bundles.
+ * These utilities only tag values; conversion to native bindings lives
+ * in value-wrappers.ts to avoid pulling @duckdb/node-api into browsers.
+ */
+export declare const DUCKDB_VALUE_MARKER: unique symbol;
+export type DuckDBValueKind = 'list' | 'array' | 'struct' | 'map' | 'timestamp' | 'blob' | 'json';
+export interface DuckDBValueWrapper<TKind extends DuckDBValueKind = DuckDBValueKind, TData = unknown> {
+    readonly [DUCKDB_VALUE_MARKER]: true;
+    readonly kind: TKind;
+    readonly data: TData;
+}
+export interface ListValueWrapper extends DuckDBValueWrapper<'list', unknown[]> {
+    readonly elementType?: string;
+}
+export interface ArrayValueWrapper extends DuckDBValueWrapper<'array', unknown[]> {
+    readonly elementType?: string;
+    readonly fixedLength?: number;
+}
+export interface StructValueWrapper extends DuckDBValueWrapper<'struct', Record<string, unknown>> {
+    readonly schema?: Record<string, string>;
+}
+export interface MapValueWrapper extends DuckDBValueWrapper<'map', Record<string, unknown>> {
+    readonly valueType?: string;
+}
+export interface TimestampValueWrapper extends DuckDBValueWrapper<'timestamp', Date | string | number | bigint> {
+    readonly withTimezone: boolean;
+    readonly precision?: number;
+}
+export interface BlobValueWrapper extends DuckDBValueWrapper<'blob', Buffer | Uint8Array> {
+}
+export interface JsonValueWrapper extends DuckDBValueWrapper<'json', unknown> {
+}
+export type AnyDuckDBValueWrapper = ListValueWrapper | ArrayValueWrapper | StructValueWrapper | MapValueWrapper | TimestampValueWrapper | BlobValueWrapper | JsonValueWrapper;
+export declare function isDuckDBWrapper(value: unknown): value is AnyDuckDBValueWrapper;
+export declare function wrapList(data: unknown[], elementType?: string): ListValueWrapper;
+export declare function wrapArray(data: unknown[], elementType?: string, fixedLength?: number): ArrayValueWrapper;
+export declare function wrapStruct(data: Record<string, unknown>, schema?: Record<string, string>): StructValueWrapper;
+export declare function wrapMap(data: Record<string, unknown>, valueType?: string): MapValueWrapper;
+export declare function wrapTimestamp(data: Date | string | number | bigint, withTimezone: boolean, precision?: number): TimestampValueWrapper;
+export declare function wrapBlob(data: Buffer | Uint8Array): BlobValueWrapper;
+export declare function wrapJson(data: unknown): JsonValueWrapper;

package/dist/value-wrappers.d.ts

@@ -1,104 +1,8 @@
 import { type DuckDBValue } from '@duckdb/node-api';
-/**
- * Symbol used to identify wrapped DuckDB values for native binding.
- * Uses Symbol.for() to ensure cross-module compatibility.
- */
-export declare const DUCKDB_VALUE_MARKER: unique symbol;
-/**
- * Type identifier for each wrapper kind.
- */
-export type DuckDBValueKind = 'list' | 'array' | 'struct' | 'map' | 'timestamp' | 'blob' | 'json';
-/**
- * Base interface for all tagged DuckDB value wrappers.
- */
-export interface DuckDBValueWrapper<TKind extends DuckDBValueKind = DuckDBValueKind, TData = unknown> {
-    readonly [DUCKDB_VALUE_MARKER]: true;
-    readonly kind: TKind;
-    readonly data: TData;
-}
-/**
- * List wrapper - maps to DuckDBListValue
- */
-export interface ListValueWrapper extends DuckDBValueWrapper<'list', unknown[]> {
-    readonly elementType?: string;
-}
-/**
- * Array wrapper (fixed size) - maps to DuckDBArrayValue
- */
-export interface ArrayValueWrapper extends DuckDBValueWrapper<'array', unknown[]> {
-    readonly elementType?: string;
-    readonly fixedLength?: number;
-}
-/**
- * Struct wrapper - maps to DuckDBStructValue
- */
-export interface StructValueWrapper extends DuckDBValueWrapper<'struct', Record<string, unknown>> {
-    readonly schema?: Record<string, string>;
-}
-/**
- * Map wrapper - maps to DuckDBMapValue
- */
-export interface MapValueWrapper extends DuckDBValueWrapper<'map', Record<string, unknown>> {
-    readonly valueType?: string;
-}
-/**
- * Timestamp wrapper - maps to DuckDBTimestampValue or DuckDBTimestampTZValue
- */
-export interface TimestampValueWrapper extends DuckDBValueWrapper<'timestamp', Date | string> {
-    readonly withTimezone: boolean;
-    readonly precision?: number;
-}
-/**
- * Blob wrapper - maps to DuckDBBlobValue
- */
-export interface BlobValueWrapper extends DuckDBValueWrapper<'blob', Buffer | Uint8Array> {
-}
-/**
- * JSON wrapper - delays JSON.stringify() to binding time.
- * DuckDB stores JSON as VARCHAR internally.
- */
-export interface JsonValueWrapper extends DuckDBValueWrapper<'json', unknown> {
-}
-/**
- * Union of all wrapper types for exhaustive type checking.
- */
-export type AnyDuckDBValueWrapper = ListValueWrapper | ArrayValueWrapper | StructValueWrapper | MapValueWrapper | TimestampValueWrapper | BlobValueWrapper | JsonValueWrapper;
-/**
- * Type guard to check if a value is a tagged DuckDB wrapper.
- * Optimized for fast detection in the hot path.
- */
-export declare function isDuckDBWrapper(value: unknown): value is AnyDuckDBValueWrapper;
-/**
- * Create a list wrapper for variable-length lists.
- */
-export declare function wrapList(data: unknown[], elementType?: string): ListValueWrapper;
-/**
- * Create an array wrapper for fixed-length arrays.
- */
-export declare function wrapArray(data: unknown[], elementType?: string, fixedLength?: number): ArrayValueWrapper;
-/**
- * Create a struct wrapper for named field structures.
- */
-export declare function wrapStruct(data: Record<string, unknown>, schema?: Record<string, string>): StructValueWrapper;
-/**
- * Create a map wrapper for key-value maps.
- */
-export declare function wrapMap(data: Record<string, unknown>, valueType?: string): MapValueWrapper;
-/**
- * Create a timestamp wrapper.
- */
-export declare function wrapTimestamp(data: Date | string, withTimezone: boolean, precision?: number): TimestampValueWrapper;
-/**
- * Create a blob wrapper for binary data.
- */
-export declare function wrapBlob(data: Buffer | Uint8Array): BlobValueWrapper;
-/**
- * Create a JSON wrapper that delays JSON.stringify() to binding time.
- * This ensures consistent handling with other wrapped types.
- */
-export declare function wrapJson(data: unknown): JsonValueWrapper;
+import { type AnyDuckDBValueWrapper } from './value-wrappers-core.ts';
 /**
  * Convert a wrapper to a DuckDB Node API value.
  * Uses exhaustive switch for compile-time safety.
  */
 export declare function wrapperToNodeApiValue(wrapper: AnyDuckDBValueWrapper, toValue: (v: unknown) => DuckDBValue): DuckDBValue;
+export { DUCKDB_VALUE_MARKER, isDuckDBWrapper, wrapArray, wrapBlob, wrapJson, wrapList, wrapMap, wrapStruct, wrapTimestamp, type AnyDuckDBValueWrapper, type DuckDBValueWrapper, type ArrayValueWrapper, type BlobValueWrapper, type JsonValueWrapper, type ListValueWrapper, type MapValueWrapper, type StructValueWrapper, type TimestampValueWrapper, type DuckDBValueKind, } from './value-wrappers-core.ts';

package/package.json

@@ -3,11 +3,11 @@
   "module": "./dist/index.mjs",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
-  "version": "1.0.3",
+  "version": "1.1.1",
   "description": "A drizzle ORM client for use with DuckDB. Based on drizzle's Postgres client.",
   "type": "module",
   "scripts": {
-    "build": "bun build --target=node ./src/index.ts --outfile=./dist/index.mjs --packages=external && bun build --target=node ./src/bin/duckdb-introspect.ts --outfile=./dist/duckdb-introspect.mjs --packages=external && bun run build:declarations",
+    "build": "bun build --target=node ./src/index.ts --outfile=./dist/index.mjs --packages=external && bun build --target=node ./src/helpers.ts --outfile=./dist/helpers.mjs --packages=external && bun build --target=node ./src/bin/duckdb-introspect.ts --outfile=./dist/duckdb-introspect.mjs --packages=external && bun run build:declarations",
     "build:declarations": "tsc --emitDeclarationOnly --project tsconfig.types.json",
     "test": "vitest",
     "t": "vitest --watch --ui",
@@ -48,6 +48,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs"
     },
+    "./helpers": {
+      "types": "./dist/helpers.d.ts",
+      "import": "./dist/helpers.mjs"
+    },
     "./package.json": "./package.json"
   },
   "sideEffects": false,

package/src/bin/duckdb-introspect.ts

@@ -12,6 +12,7 @@ interface CliOptions {
   allDatabases: boolean;
   schemas?: string[];
   outFile: string;
+  outMeta?: string;
   includeViews: boolean;
   useCustomTimeTypes: boolean;
   importBasePath?: string;
@@ -20,6 +21,7 @@ interface CliOptions {
 function parseArgs(argv: string[]): CliOptions {
   const options: CliOptions = {
     outFile: path.resolve(process.cwd(), 'drizzle/schema.ts'),
+    outMeta: undefined,
     allDatabases: false,
     includeViews: false,
     useCustomTimeTypes: true,
@@ -52,6 +54,14 @@ function parseArgs(argv: string[]): CliOptions {
           argv[++i] ?? 'drizzle/schema.ts'
         );
         break;
+      case '--out-json':
+      case '--outJson':
+      case '--json':
+        options.outMeta = path.resolve(
+          process.cwd(),
+          argv[++i] ?? 'drizzle/schema.meta.json'
+        );
+        break;
       case '--include-views':
       case '--includeViews':
         options.includeViews = true;
@@ -88,6 +98,7 @@ Options:
   --all-databases  Introspect all attached databases (not just current)
   --schema         Comma separated schema list (defaults to all non-system schemas)
   --out            Output file (default: ./drizzle/schema.ts)
+  --json           Optional JSON metadata output (default: ./drizzle/schema.meta.json)
   --include-views  Include views in the generated schema
   --use-pg-time    Use pg-core timestamp/date/time instead of DuckDB custom helpers
   --import-base    Override import path for duckdb helpers (default: package name)
@@ -136,8 +147,19 @@ async function main() {
 
     await mkdir(path.dirname(options.outFile), { recursive: true });
     await writeFile(options.outFile, result.files.schemaTs, 'utf8');
+    if (options.outMeta) {
+      await mkdir(path.dirname(options.outMeta), { recursive: true });
+      await writeFile(
+        options.outMeta,
+        JSON.stringify(result.files.metaJson, null, 2),
+        'utf8'
+      );
+    }
 
     console.log(`Wrote schema to ${options.outFile}`);
+    if (options.outMeta) {
+      console.log(`Wrote metadata to ${options.outMeta}`);
+    }
   } finally {
     if (
       'closeSync' in connection &&
@@ -145,6 +167,11 @@ async function main() {
     ) {
       connection.closeSync();
     }
+    if ('closeSync' in instance && typeof instance.closeSync === 'function') {
+      instance.closeSync();
+    } else if ('close' in instance && typeof instance.close === 'function') {
+      await instance.close();
+    }
   }
 }
 

package/src/client.ts

@@ -10,9 +10,21 @@ import {
   type AnyDuckDBValueWrapper,
 } from './value-wrappers.ts';
 
-export type DuckDBClientLike = DuckDBConnection;
+export type DuckDBClientLike = DuckDBConnection | DuckDBConnectionPool;
 export type RowData = Record<string, unknown>;
 
+export interface DuckDBConnectionPool {
+  acquire(): Promise<DuckDBConnection>;
+  release(connection: DuckDBConnection): void | Promise<void>;
+  close?(): Promise<void> | void;
+}
+
+export function isPool(
+  client: DuckDBClientLike
+): client is DuckDBConnectionPool {
+  return typeof (client as DuckDBConnectionPool).acquire === 'function';
+}
+
 export interface PrepareParamsOptions {
   rejectStringArrayLiterals?: boolean;
   warnOnStringArrayLiteral?: () => void;
@@ -32,25 +44,25 @@ function parsePgArrayLiteral(value: string): unknown {
   }
 }
 
-let warnedArrayLiteral = false;
-
 export function prepareParams(
   params: unknown[],
   options: PrepareParamsOptions = {}
 ): unknown[] {
   return params.map((param) => {
-    if (typeof param === 'string' && isPgArrayLiteral(param)) {
-      if (options.rejectStringArrayLiterals) {
-        throw new Error(
-          'Stringified array literals are not supported. Use duckDbList()/duckDbArray() or pass native arrays.'
-        );
-      }
+    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 (!warnedArrayLiteral && options.warnOnStringArrayLiteral) {
-        warnedArrayLiteral = true;
-        options.warnOnStringArrayLiteral();
+        if (options.warnOnStringArrayLiteral) {
+          options.warnOnStringArrayLiteral();
+        }
+        return parsePgArrayLiteral(trimmed);
       }
-      return parsePgArrayLiteral(param);
     }
     return param;
   });
@@ -138,6 +150,15 @@ export async function executeOnClient(
   query: string,
   params: unknown[]
 ): Promise<RowData[]> {
+  if (isPool(client)) {
+    const connection = await client.acquire();
+    try {
+      return await executeOnClient(connection, query, params);
+    } finally {
+      await client.release(connection);
+    }
+  }
+
   const values =
     params.length > 0
       ? (params.map((param) => toNodeApiValue(param)) as DuckDBValue[])
@@ -165,6 +186,16 @@ export async function* executeInBatches(
   params: unknown[],
   options: ExecuteInBatchesOptions = {}
 ): AsyncGenerator<RowData[], void, void> {
+  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
@@ -207,12 +238,22 @@ export async function executeArrowOnClient(
   query: string,
   params: unknown[]
 ): Promise<unknown> {
+  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)) as DuckDBValue[])
       : undefined;
   const result = await client.run(query, values);
 
+  // Runtime detection for Arrow API support (optional method, not in base type)
   const maybeArrow =
     (result as unknown as { toArrow?: () => Promise<unknown> }).toArrow ??
     (result as unknown as { getArrowTable?: () => Promise<unknown> })

package/src/columns.ts

@@ -12,7 +12,7 @@ import {
   type MapValueWrapper,
   type BlobValueWrapper,
   type JsonValueWrapper,
-} from './value-wrappers.ts';
+} from './value-wrappers-core.ts';
 
 type IntColType =
   | 'SMALLINT'
@@ -63,7 +63,7 @@ type StructColType = `STRUCT (${string})`;
 
 type Primitive = AnyColType | ListColType | ArrayColType | StructColType;
 
-function coerceArrayString(value: string): unknown[] | undefined {
+export function coerceArrayString(value: string): unknown[] | undefined {
   const trimmed = value.trim();
   if (!trimmed) {
     return [];
@@ -86,7 +86,7 @@ function coerceArrayString(value: string): unknown[] | undefined {
   return undefined;
 }
 
-function formatLiteral(value: unknown, typeHint?: string): string {
+export function formatLiteral(value: unknown, typeHint?: string): string {
   if (value === null || value === undefined) {
     return 'NULL';
   }
@@ -123,7 +123,7 @@ function formatLiteral(value: unknown, typeHint?: string): string {
   return `'${escaped}'`;
 }
 
-function buildListLiteral(values: unknown[], elementType?: string): SQL {
+export function buildListLiteral(values: unknown[], elementType?: string): SQL {
   if (values.length === 0) {
     return sql`[]`;
   }
@@ -135,7 +135,7 @@ function buildListLiteral(values: unknown[], elementType?: string): SQL {
   return sql`list_value(${sql.join(chunks, sql.raw(', '))})`;
 }
 
-function buildStructLiteral(
+export function buildStructLiteral(
   value: Record<string, unknown>,
   schema?: Record<string, Primitive>
 ): SQL {
@@ -154,7 +154,7 @@ function buildStructLiteral(
   return sql`struct_pack(${sql.join(parts, sql.raw(', '))})`;
 }
 
-function buildMapLiteral(
+export function buildMapLiteral(
   value: Record<string, unknown>,
   valueType?: string
 ): SQL {
@@ -188,11 +188,11 @@ export const duckDbList = <TData = unknown>(
       }
       if (typeof value === 'string') {
         const parsed = coerceArrayString(value);
-        if (parsed) {
+        if (parsed !== undefined) {
           return parsed as TData[];
         }
       }
-      return [] as TData[];
+      return value as unknown as TData[];
     },
   })(name);
 
@@ -219,11 +219,11 @@ export const duckDbArray = <TData = unknown>(
       }
       if (typeof value === 'string') {
         const parsed = coerceArrayString(value);
-        if (parsed) {
+        if (parsed !== undefined) {
           return parsed as TData[];
         }
       }
-      return [] as TData[];
+      return value as unknown as TData[];
     },
   })(name);
 

package/src/dialect.ts

@@ -19,18 +19,64 @@ import {
   type QueryTypingsValue,
 } from 'drizzle-orm';
 
+const enum SavepointSupport {
+  Unknown = 0,
+  Yes = 1,
+  No = 2,
+}
+
 export class DuckDBDialect extends PgDialect {
   static readonly [entityKind]: string = 'DuckDBPgDialect';
+  // Track if PG JSON columns were detected during the current query preparation.
+  // Reset before each query via DuckDBSession to keep detection per-query.
   private hasPgJsonColumn = false;
+  // Track savepoint support per-dialect instance to avoid cross-contamination
+  // when multiple database connections with different capabilities exist.
+  private savepointsSupported: SavepointSupport = SavepointSupport.Unknown;
+
+  /**
+   * Reset the PG JSON detection flag. Should be called before preparing a new query.
+   */
+  resetPgJsonFlag(): void {
+    this.hasPgJsonColumn = false;
+  }
+
+  /**
+   * Mark that a PG JSON/JSONB column was detected during query preparation.
+   */
+  markPgJsonDetected(): void {
+    this.hasPgJsonColumn = true;
+  }
 
   assertNoPgJsonColumns(): void {
     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.'
+        "Pg JSON/JSONB columns are not supported in DuckDB. Replace them with duckDbJson() to use DuckDB's native JSON type."
       );
     }
   }
 
+  /**
+   * Check if savepoints are known to be unsupported for this dialect instance.
+   */
+  areSavepointsUnsupported(): boolean {
+    return this.savepointsSupported === SavepointSupport.No;
+  }
+
+  /**
+   * Mark that savepoints are supported for this dialect instance.
+   */
+  markSavepointsSupported(): void {
+    this.savepointsSupported = SavepointSupport.Yes;
+  }
+
+  /**
+   * Mark that savepoints are not supported for this dialect instance.
+   */
+  markSavepointsUnsupported(): void {
+    this.savepointsSupported = SavepointSupport.No;
+  }
+
   override async migrate(
     migrations: MigrationMeta[],
     session: PgSession,
@@ -117,8 +163,10 @@ export class DuckDBDialect extends PgDialect {
     encoder: DriverValueEncoder<unknown, unknown>
   ): QueryTypingsValue {
     if (is(encoder, PgJsonb) || is(encoder, PgJson)) {
-      this.hasPgJsonColumn = true;
-      return 'none';
+      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 (is(encoder, PgNumeric)) {
       return 'decimal';
     } else if (is(encoder, PgTime)) {