@flowblade/sqlduck 0.33.0 → 0.35.0

package/README.md

@@ -128,75 +128,79 @@ const queryResult = await dbDuckDbMemoryConn.query<{
 
 ## Benchmarks
 
-### Node 24.15
+### Node 24.19
 
 ```
- RUN  v4.1.5 /home/sebastien/github/flowblade/packages/sqlduck
+ RUN  v4.1.10 /home/sebastien/github/flowblade/packages/sqlduck
 
 
- ✓ bench/appender.bench.ts > appender benches 3477ms
-     name                                                        hz     min     max    mean     p75     p99    p995    p999      rme  samples
-   · duckdb appender memory, count: 100000, chunk size 2048  2.9578  336.81  339.37  338.09  339.37  339.37  339.37  339.37   ±4.82%        2
-   · duckdb appender file, count: 100000, chunk size 2048    1.5359  651.07  651.07  651.07  651.07  651.07  651.07  651.07   ±0.00%        1
-   · duckdb appender, count: 100000, chunk size 1024         2.8450  328.25  374.74  351.50  374.74  374.74  374.74  374.74  ±84.06%        2
+ ✓ bench/appender.bench.ts > appender benches 4702ms
+     name                                                             hz     min     max    mean     p75     p99    p995    p999       rme  samples
+   · duckdb appender memory, count: 100000, chunk size 2048       2.9565  297.19  379.28  338.23  379.28  379.28  379.28  379.28  ±154.25%        2
+   · duckdb appender file, count: 100000, chunk size 2048         3.2467  302.16  313.84  308.00  313.84  313.84  313.84  313.84   ±24.10%        2
+   · duckdb appender file no wal, count: 100000, chunk size 2048  3.5982  272.83  283.01  277.92  283.01  283.01  283.01  283.01   ±23.29%        2
+   · duckdb appender file no wal, count: 100000, chunk size 1024  3.1962  307.89  317.86  312.87  317.86  317.86  317.86  317.86   ±20.24%        2
+   · duckdb appender, count: 100000, chunk size 1024              3.9457  238.32  268.56  253.44  268.56  268.56  268.56  268.56   ±75.84%        2
 
- ✓ bench/stream.bench.ts > Bench rowsToColumnsChunks 3514ms
+ ✓ bench/stream.bench.ts > Bench rowsToColumnsChunks 2768ms
      name                                                                         hz      min     max     mean      p75     p99    p995    p999      rme  samples
-   · rowToColumnsChunk with chunkSize 2048 (count: 100000)                   10.6932  76.7549  197.03  93.5173  88.9991  197.03  197.03  197.03  ±28.09%       10
-   · rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)  10.2660  87.8295  141.15  97.4092  97.0299  141.15  141.15  141.15  ±11.56%       10
-   · mapFakeRowStream with chunkSize 2048 (count: 100000)                     8.3811   113.83  136.27   119.32   118.84  136.27  136.27  136.27   ±4.30%       10
+   · rowToColumnsChunk with chunkSize 2048 (count: 100000)                   14.7282  55.8866  117.44  67.8968  66.1927  117.44  117.44  117.44  ±18.84%       10
+   · rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)  12.1404  62.2024  138.60  82.3693  80.8803  138.60  138.60  138.60  ±26.30%       10
+   · mapFakeRowStream with chunkSize 2048 (count: 100000)                    11.5408  79.1225  102.85  86.6494  89.3379  102.85  102.85  102.85   ±5.60%       10
 
- ✓ bench/table-create.bench.ts > Bench getTableCreateFromZod 614ms
+ ✓ bench/table-create.bench.ts > Bench getTableCreateFromZod 613ms
      name                          hz     min     max    mean     p75     p99    p995    p999     rme  samples
-   · getTableCreateFromZod  20,399.65  0.0328  1.2897  0.0490  0.0425  0.1957  0.2681  0.6023  ±1.77%    10201
+   · getTableCreateFromZod  24,208.11  0.0247  5.2321  0.0413  0.0434  0.1512  0.2186  0.7364  ±2.68%    12105
 
  BENCH  Summary
 
-  duckdb appender memory, count: 100000, chunk size 2048 - bench/appender.bench.ts > appender benches
-    1.04x faster than duckdb appender, count: 100000, chunk size 1024
-    1.93x faster than duckdb appender file, count: 100000, chunk size 2048
+  duckdb appender, count: 100000, chunk size 1024 - bench/appender.bench.ts > appender benches
+    1.10x faster than duckdb appender file no wal, count: 100000, chunk size 2048
+    1.22x faster than duckdb appender file, count: 100000, chunk size 2048
+    1.23x faster than duckdb appender file no wal, count: 100000, chunk size 1024
+    1.33x faster than duckdb appender memory, count: 100000, chunk size 2048
 
   rowToColumnsChunk with chunkSize 2048 (count: 100000) - bench/stream.bench.ts > Bench rowsToColumnsChunks
-    1.04x faster than rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)
+    1.21x faster than rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)
     1.28x faster than mapFakeRowStream with chunkSize 2048 (count: 100000)
-
-  getTableCreateFromZod - bench/table-create.bench.ts > Bench getTableCreateFromZod
-
 ```
 
-### Bun 1.3.13
+### Bun 1.4.0-dev
 
 ```
- RUN  v4.1.5 /home/sebastien/github/flowblade/packages/sqlduck
+RUN  v4.1.10 /home/sebastien/github/flowblade/packages/sqlduck
 
 
- ✓ bench/appender.bench.ts > appender benches 3382ms
-     name                                                        hz     min     max    mean     p75     p99    p995    p999      rme  samples
-   · duckdb appender memory, count: 100000, chunk size 2048  3.0570  310.57  343.67  327.12  343.67  343.67  343.67  343.67  ±64.30%        2
-   · duckdb appender file, count: 100000, chunk size 2048    2.6163  377.75  386.70  382.22  386.70  386.70  386.70  386.70  ±14.88%        2
-   · duckdb appender, count: 100000, chunk size 1024         3.0427  319.38  337.93  328.65  337.93  337.93  337.93  337.93  ±35.86%        2
+ ✓ bench/appender.bench.ts > appender benches 4421ms
+     name                                                             hz     min     max    mean     p75     p99    p995    p999      rme  samples
+   · duckdb appender memory, count: 100000, chunk size 2048       3.6500  271.84  276.10  273.97  276.10  276.10  276.10  276.10   ±9.88%        2
+   · duckdb appender file, count: 100000, chunk size 2048         3.6469  272.29  276.12  274.21  276.12  276.12  276.12  276.12   ±8.88%        2
+   · duckdb appender file no wal, count: 100000, chunk size 2048  3.6858  271.23  271.39  271.31  271.39  271.39  271.39  271.39   ±0.36%        2
+   · duckdb appender file no wal, count: 100000, chunk size 1024  3.8828  245.82  269.28  257.55  269.28  269.28  269.28  269.28  ±57.90%        2
+   · duckdb appender, count: 100000, chunk size 1024              4.3164  228.90  233.35  231.68  233.35  233.35  233.35  233.35   ±2.60%        3
 
- ✓ bench/stream.bench.ts > Bench rowsToColumnsChunks 3075ms
-     name                                                                         hz      min      max     mean      p75      p99     p995     p999     rme  samples
-   · rowToColumnsChunk with chunkSize 2048 (count: 100000)                   12.5039  68.9091  89.8222  79.9751  84.4430  89.8222  89.8222  89.8222  ±5.45%       10
-   · rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)  10.9097  83.6090   124.66  91.6616  92.3154   124.66   124.66   124.66  ±9.42%       10
-   · mapFakeRowStream with chunkSize 2048 (count: 100000)                    10.2729  90.7410   104.18  97.3436   100.41   104.18   104.18   104.18  ±2.93%       10
+ ✓ bench/stream.bench.ts > Bench rowsToColumnsChunks 1944ms
+     name                                                                         hz      min      max     mean      p75      p99     p995     p999      rme  samples
+   · rowToColumnsChunk with chunkSize 2048 (count: 100000)                   23.3620  34.5897  57.6520  42.8045  46.5939  57.6520  57.6520  57.6520   ±9.96%       12
+   · rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)  19.9773  38.8665  71.6678  50.0569  51.5838  71.6678  71.6678  71.6678  ±14.39%       10
+   · mapFakeRowStream with chunkSize 2048 (count: 100000)                    19.0996  45.5100  66.2385  52.3572  53.0091  66.2385  66.2385  66.2385   ±7.43%       10
 
- ✓ bench/table-create.bench.ts > Bench getTableCreateFromZod 629ms
+ ✓ bench/table-create.bench.ts > Bench getTableCreateFromZod 634ms
      name                          hz     min     max    mean     p75     p99    p995    p999     rme  samples
-   · getTableCreateFromZod  20,285.23  0.0260  6.9886  0.0493  0.0466  0.1700  0.2249  2.6988  ±6.12%    10143
+   · getTableCreateFromZod  30,647.46  0.0177  4.5320  0.0326  0.0335  0.1058  0.1550  0.7740  ±4.73%    15324
 
  BENCH  Summary
 
   rowToColumnsChunk with chunkSize 2048 (count: 100000) - bench/stream.bench.ts > Bench rowsToColumnsChunks
-    1.15x faster than rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)
+    1.17x faster than rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)
     1.22x faster than mapFakeRowStream with chunkSize 2048 (count: 100000)
 
-  getTableCreateFromZod - bench/table-create.bench.ts > Bench getTableCreateFromZod
+  duckdb appender, count: 100000, chunk size 1024 - bench/appender.bench.ts > appender benches
+    1.11x faster than duckdb appender file no wal, count: 100000, chunk size 1024
+    1.17x faster than duckdb appender file no wal, count: 100000, chunk size 2048
+    1.18x faster than duckdb appender memory, count: 100000, chunk size 2048
+    1.18x faster than duckdb appender file, count: 100000, chunk size 2048
 
-  duckdb appender memory, count: 100000, chunk size 2048 - bench/appender.bench.ts > appender benches
-    1.00x faster than duckdb appender, count: 100000, chunk size 1024
-    1.17x faster than duckdb appender file, count: 100000, chunk size 2048
 ```
 
 ### Local scripts

package/dist/index.d.mts

@@ -274,14 +274,23 @@ declare const duckDatabaseManagerZodSchemas: {
   }, z.core.$strict>;
 };
 //#endregion
-//#region src/manager/database/commands/duck-database-attach-command.d.ts
-type Behaviour = 'OR REPLACE' | 'IF NOT EXISTS';
-type DuckDatabaseAttachCommandOptions = {
-  behaviour?: Behaviour;
-};
-//#endregion
 //#region src/manager/database/duck-database-manager.d.ts
 type GetDatabaseInfo = z.infer<typeof duckDatabaseManagerZodSchemas.getDatabases>;
+type AttachOptions = {
+  behaviour: 'OR REPLACE';
+  /**
+   * Since duckdb 1.5.4, the ATTACH OR REPLACE fails if the database is already attached.
+   * If this option is set to true, when an attachOrReplace fails with the already attached
+   * message, the database will be detached first with regular detach command an re-tried
+   *
+   * This option might be deprecated in the future as duckdb will fix the issue upstream
+   *
+   * @default false
+   */
+  runDetachIfAttachOrReplaceFailWithAlreadyAttached?: boolean;
+} | {
+  behaviour: 'IF NOT EXISTS';
+};
 declare class DuckDatabaseManager {
   #private;
   readonly className = "DuckDatabaseManager";
@@ -303,8 +312,39 @@ declare class DuckDatabaseManager {
    * console.log(database.alias); // 'mydb'
    * ```
    */
-  attach: (dbParams: DuckConnectionParams, options?: DuckDatabaseAttachCommandOptions) => Promise<Database>;
-  attachOrReplace: (dbParams: DuckConnectionParams) => Promise<Database>;
+  attach: (dbParams: DuckConnectionParams, options?: AttachOptions) => Promise<Database>;
+  /**
+   * Attach or replace a database to the current connection
+   *
+   * @example
+   * ```typescript
+   * const dbManager = new DuckDatabaseManager(conn);
+   * const database = dbManager.attachOrReplace({
+   *   type: 'memory', // can be 'filesystem'...
+   *   alias: 'mydb',
+   *   options: { COMPRESS: 'true' },
+   * }, {
+   *   // as tested on duckdb 1.5.5, the attach or replace might not work
+   *   // and complain about already attached database. Set this to true
+   *   // to implement a detach / attach if the attachOrReplace fails
+   *   runDetachIfAttachOrReplaceFailWithAlreadyAttached?: boolean;
+   * });
+   *
+   * console.log(database.alias); // 'mydb'
+   * ```
+   */
+  attachOrReplace: (dbParams: DuckConnectionParams, options?: {
+    /**
+     * Since duckdb 1.5.4, the ATTACH OR REPLACE fails if the database is already attached.
+     * If this option is set to true, when an attachOrReplace fails with the already attached
+     * message, the database will be detached first with regular detach command an re-tried
+     *
+     * This option might be deprecated in the future as duckdb will fix the issue upstream
+     *
+     * @default false
+     */
+    runDetachIfAttachOrReplaceFailWithAlreadyAttached?: boolean;
+  }) => Promise<Database>;
   attachIfNotExists: (dbParams: DuckConnectionParams) => Promise<Database>;
   /**
    * Check whether a specific database name / alias is currently attached
@@ -341,6 +381,14 @@ declare class DuckDatabaseManager {
   analyze: () => Promise<boolean>;
   checkpoint: (dbAlias: string) => Promise<boolean>;
   vacuum: () => Promise<boolean>;
+  getCurrentDatabase: () => Promise<string | null>;
+  getCurrentSchema: () => Promise<string | null>;
+  getCurrentCatalog: () => Promise<string | null>;
+  /**
+   * Set the default database to use
+   * @throws if the database alias does not exist
+   */
+  use: (dbAlias: string) => Promise<true>;
   /**
    * Helper to create an initial database file.
    */

package/dist/index.mjs

@@ -379,6 +379,23 @@ var DuckDatabaseAttachCommand = class {
 	};
 };
 //#endregion
+//#region src/manager/database/utils/get-already-attached-database-from-error.ts
+/**
+* Return the database name that is already attached to the error message
+*
+* Note duckdb might complain about already attached databases with a message like
+* Binder Error: Unique file handle conflict: Cannot attach "duckdb_second_attached_file" - the database file "/home/sebastien/github/flowblade/packages/sqlduck/tests/tmp/duckdb_test_reattachable_file.db" is already attached by database "duckdb_first_attached_file"
+*/
+const getAlreadyAttachedDatabaseFromError = (error) => {
+	if (!(error instanceof Error)) return { isAlreadyAttached: false };
+	const dbAlias = /Binder Error:.*Cannot attach.*already attached by database\s+['"“]?\b(?<dbAlias>[\w$]+)\b['"”]?/is.exec(error.message)?.groups?.dbAlias ?? null;
+	if (dbAlias === null || dbAlias.trim() === "") return { isAlreadyAttached: false };
+	return {
+		isAlreadyAttached: true,
+		dbAlias
+	};
+};
+//#endregion
 //#region src/manager/database/duck-database-manager.ts
 var DuckDatabaseManager = class {
 	#conn;
@@ -408,17 +425,61 @@ var DuckDatabaseManager = class {
 	*/
 	attach = async (dbParams, options) => {
 		const params = duckConnectionParamsZodSchema.parse(dbParams);
-		const rawSql = new DuckDatabaseAttachCommand(params, options).getRawSql();
-		const { behaviour } = options ?? {};
-		await this.#executor.getRowObjectsJS([
-			`attach(${params.alias}`,
-			behaviour ?? null,
-			")"
-		].filter(Boolean).join(","), rawSql);
+		const rawSql = new DuckDatabaseAttachCommand(params, { behaviour: options?.behaviour }).getRawSql();
+		const restoreCurrentDb = await this.getCurrentDatabase();
+		const tempDbNameHack = "temp_run_detach_if_attached_hack_db";
+		let isTempDbNameHackCreated = false;
+		try {
+			await this.#executor.getRowObjectsJS([`attach(${params.alias}`, options === void 0 ? null : JSON.stringify(options)].filter(Boolean).join(",") + ")", rawSql);
+		} catch (e) {
+			if (options?.behaviour === "OR REPLACE" && options?.runDetachIfAttachOrReplaceFailWithAlreadyAttached === true) {
+				const alreadyAttached = getAlreadyAttachedDatabaseFromError(e);
+				if (alreadyAttached.isAlreadyAttached === true) {
+					if (alreadyAttached.dbAlias === restoreCurrentDb) {
+						await this.attachIfNotExists({
+							type: "memory",
+							alias: tempDbNameHack
+						});
+						await this.use(tempDbNameHack);
+						isTempDbNameHackCreated = true;
+					}
+					await this.detachOrIgnore(alreadyAttached.dbAlias);
+					await this.attach(dbParams);
+				} else throw e;
+			} else throw e;
+		} finally {
+			if (restoreCurrentDb !== null && isTempDbNameHackCreated) {
+				await this.use(restoreCurrentDb);
+				await this.detachOrIgnore(tempDbNameHack);
+			}
+		}
 		return new Database({ alias: params.alias });
 	};
-	attachOrReplace = async (dbParams) => {
-		return this.attach(dbParams, { behaviour: "OR REPLACE" });
+	/**
+	* Attach or replace a database to the current connection
+	*
+	* @example
+	* ```typescript
+	* const dbManager = new DuckDatabaseManager(conn);
+	* const database = dbManager.attachOrReplace({
+	*   type: 'memory', // can be 'filesystem'...
+	*   alias: 'mydb',
+	*   options: { COMPRESS: 'true' },
+	* }, {
+	*   // as tested on duckdb 1.5.5, the attach or replace might not work
+	*   // and complain about already attached database. Set this to true
+	*   // to implement a detach / attach if the attachOrReplace fails
+	*   runDetachIfAttachOrReplaceFailWithAlreadyAttached?: boolean;
+	* });
+	*
+	* console.log(database.alias); // 'mydb'
+	* ```
+	*/
+	attachOrReplace = async (dbParams, options) => {
+		return this.attach(dbParams, {
+			behaviour: "OR REPLACE",
+			runDetachIfAttachOrReplaceFailWithAlreadyAttached: options?.runDetachIfAttachOrReplaceFailWithAlreadyAttached
+		});
 	};
 	attachIfNotExists = async (dbParams) => {
 		return this.attach(dbParams, { behaviour: "IF NOT EXISTS" });
@@ -526,6 +587,24 @@ var DuckDatabaseManager = class {
 		await this.#executor.getRowObjectsJS("vacuum()", "VACUUM");
 		return true;
 	};
+	getCurrentDatabase = async () => {
+		return (await this.#executor.getRowObjectsJS("getCurrentDatabase()", "SELECT current_database() as current_database"))[0]?.current_database ?? null;
+	};
+	getCurrentSchema = async () => {
+		return (await this.#executor.getRowObjectsJS("getCurrentSchema()", "SELECT current_schema() as current_schema"))?.[0]?.current_schema ?? null;
+	};
+	getCurrentCatalog = async () => {
+		return (await this.#executor.getRowObjectsJS("getCurrentCatalog()", "SELECT current_catalog() as current_catalog"))?.[0]?.current_catalog ?? null;
+	};
+	/**
+	* Set the default database to use
+	* @throws if the database alias does not exist
+	*/
+	use = async (dbAlias) => {
+		const safeAlias = duckValidatorsZod.aliasName.parse(dbAlias);
+		await this.#executor.getRowObjectsJS(`use(${safeAlias})`, `USE ${safeAlias}`);
+		return true;
+	};
 	/**
 	* Helper to create an initial database file.
 	*/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowblade/sqlduck",
-  "version": "0.33.0",
+  "version": "0.35.0",
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -69,10 +69,10 @@
     "@flowblade/core": "^0.2.29",
     "@flowblade/source-duckdb": "^0.27.0",
     "@flowblade/sql-tag": "^0.3.4",
-    "@httpx/assert": "^0.17.2",
-    "@httpx/dsn-parser": "^1.9.12",
-    "@httpx/plain-object": "^2.1.12",
-    "@logtape/logtape": "^2.3.0",
+    "@httpx/assert": "^0.18.0",
+    "@httpx/dsn-parser": "^1.10.0",
+    "@httpx/plain-object": "^2.2.0",
+    "@logtape/logtape": "^2.3.1",
     "@standard-schema/spec": "^1.1.0",
     "is-safe-filename": "0.1.1",
     "p-queue": "^9.3.3",
@@ -93,46 +93,46 @@
   },
   "devDependencies": {
     "@belgattitude/eslint-config-bases": "8.19.1",
-    "@dotenvx/dotenvx": "2.19.1",
-    "@duckdb/node-api": "1.5.5-r.3",
+    "@dotenvx/dotenvx": "2.21.0",
+    "@duckdb/node-api": "1.5.5-r.4",
     "@faker-js/faker": "10.5.0",
     "@flowblade/source-kysely": "^1.7.0",
-    "@httpx/assert": "0.17.2",
+    "@httpx/assert": "0.18.0",
     "@mitata/counters": "0.0.8",
     "@size-limit/esbuild": "13.0.3",
     "@size-limit/file": "13.0.3",
-    "@testcontainers/mssqlserver": "12.0.4",
+    "@testcontainers/mssqlserver": "12.1.0",
     "@total-typescript/ts-reset": "0.6.1",
-    "@types/node": "26.1.2",
-    "@typescript-eslint/eslint-plugin": "8.66.0",
-    "@typescript-eslint/parser": "8.66.0",
+    "@types/node": "26.2.0",
+    "@typescript-eslint/eslint-plugin": "8.67.0",
+    "@typescript-eslint/parser": "8.67.0",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "@vitest/coverage-v8": "4.1.10",
     "@vitest/ui": "4.1.10",
     "ansis": "4.3.1",
     "browserslist-to-esbuild": "2.1.1",
-    "core-js": "3.49.0",
+    "core-js": "3.50.0",
     "cross-env": "10.1.0",
     "es-check": "9.6.4",
     "es-toolkit": "1.50.0",
-    "esbuild": "0.28.1",
+    "esbuild": "0.28.2",
     "eslint": "8.57.1",
     "execa": "10.0.1",
     "is-in-ci": "2.0.0",
-    "kysely": "0.29.4",
+    "kysely": "0.29.5",
     "mitata": "1.0.34",
     "npm-run-all2": "9.0.3",
     "prettier": "3.9.6",
-    "publint": "0.3.22",
+    "publint": "0.3.23",
     "regexp.escape": "2.0.1",
     "rimraf": "6.1.3",
     "size-limit": "13.0.3",
     "sql-formatter": "15.8.2",
     "tarn": "3.1.2",
     "tedious": "20.0.0",
-    "testcontainers": "12.0.4",
+    "testcontainers": "12.1.0",
     "tsdown": "0.22.14",
-    "tsx": "4.23.5",
+    "tsx": "4.23.12",
     "typedoc": "0.28.20",
     "typedoc-plugin-markdown": "4.12.0",
     "typescript": "6.0.3",