velocious 1.0.551 → 1.0.554

package/src/database/drivers/mssql/index.js

@@ -23,6 +23,17 @@ import Upsert from "./sql/upsert.js"
 import Update from "./sql/update.js"
 import UUID from "pure-uuid"
 
+/**
+ * SQL Server error number raised by `sp_releaseapplock` when the current
+ * session does not hold the requested application lock. Releasing a lock the
+ * session no longer holds is a normal race (a shared connection's final
+ * check-in may already have auto-released it), which the cross-driver
+ * `releaseAdvisoryLock` contract models by resolving to `false`. We translate
+ * this specific error into that result rather than letting it escape.
+ * @type {number}
+ */
+const APPLOCK_NOT_HELD_ERROR_NUMBER = 1223
+
 export default class VelociousDatabaseDriversMssql extends Base{
   async connect() {
     const args = this.getArgs()
@@ -640,18 +651,56 @@ export default class VelociousDatabaseDriversMssql extends Base{
 
   /**
    * Runs release advisory lock.
+   *
+   * `sp_releaseapplock` returns 0 when the lock was released, but SQL Server
+   * raises error {@link APPLOCK_NOT_HELD_ERROR_NUMBER} instead of returning a
+   * failure code when the session does not currently hold the lock. That
+   * error aborts the batch before the trailing `SELECT` can run, so we catch
+   * it and resolve to `false` to honor the cross-driver contract for an
+   * already-unheld lock.
    * @param {string} name - Lock name.
    * @returns {Promise<boolean>} - True if the lock was held by this session and has now been released.
    */
   async _releaseAdvisoryLock(name) {
-    const rows = await this.query(
-      `DECLARE @velocious_advisory_lock_result INT; EXEC @velocious_advisory_lock_result = sp_releaseapplock @Resource = ${this.quote(name)}, @LockOwner = 'Session'; SELECT @velocious_advisory_lock_result AS velocious_advisory_lock_result`
-    )
+    let rows
+
+    try {
+      rows = await this.query(
+        `DECLARE @velocious_advisory_lock_result INT; EXEC @velocious_advisory_lock_result = sp_releaseapplock @Resource = ${this.quote(name)}, @LockOwner = 'Session'; SELECT @velocious_advisory_lock_result AS velocious_advisory_lock_result`
+      )
+    } catch (error) {
+      if (this._isApplockNotHeldError(error)) return false
+
+      throw error
+    }
+
     const result = Number(rows?.[0]?.velocious_advisory_lock_result)
 
     return result === 0
   }
 
+  /**
+   * Detects the SQL Server "application lock is not currently held" error
+   * raised by `sp_releaseapplock`. It walks the wrapped-error cause chain
+   * because `query` re-wraps the driver's `RequestError` in a plain `Error`,
+   * and matches on the stable numeric error number rather than the message.
+   * @param {unknown} error - Error thrown while releasing the lock.
+   * @returns {boolean} - True if the error means the lock was not held by this session.
+   */
+  _isApplockNotHeldError(error) {
+    let current = error
+
+    while (current instanceof Error) {
+      const errorNumber = /** @type {{number?: unknown}} */ (current).number
+
+      if (typeof errorNumber === "number" && errorNumber === APPLOCK_NOT_HELD_ERROR_NUMBER) return true
+
+      current = current.cause
+    }
+
+    return false
+  }
+
   /**
    * Returns true if any session currently holds the application lock.
    *

package/src/database/drivers/mysql/index.js

@@ -190,6 +190,10 @@ export default class VelociousDatabaseDriversMysql extends Base{
 
     if ("username" in args) connectArgs["user"] = args["username"]
     if ("charset" in args) connectArgs["charset"] = args["charset"]
+    // Opt-in only. Lets a whole structure SQL dump run in one round-trip via
+    // {@link execStructureScript}; off by default so ordinary queries keep rejecting
+    // stacked statements.
+    if ("multipleStatements" in args) connectArgs["multipleStatements"] = Boolean(digg(args, "multipleStatements"))
 
     return connectArgs
   }
@@ -417,6 +421,36 @@ export default class VelociousDatabaseDriversMysql extends Base{
     })
   }
 
+  /**
+   * Executes a full multi-statement structure SQL script in one round-trip when the
+   * connection was configured with `multipleStatements: true`. Runs on the pooled
+   * connection so the caller's `SET FOREIGN_KEY_CHECKS = 0` applies. Returns false so
+   * the caller runs statements individually when multi-statement queries are off.
+   * @param {string} structureSql - Full multi-statement structure SQL.
+   * @returns {Promise<boolean>} - Whether the script was executed as one batch.
+   */
+  async execStructureScript(structureSql) {
+    if (!this.getArgs().multipleStatements) return false
+
+    // The batched pool call below bypasses Base#query, so re-run the same read-only
+    // write guard the per-statement path applies before executing the dump.
+    this._assertWritableQuery(structureSql)
+
+    if (!this.pool) await this.connect()
+    if (!this.pool) throw new Error("MySQL pool failed to initialize")
+
+    const pool = this.pool
+
+    await new Promise((resolve, reject) => {
+      pool.query(structureSql, (error) => {
+        if (error) reject(error)
+        else resolve(undefined)
+      })
+    })
+
+    return true
+  }
+
   /**
    * Runs query to sql.
    * @param {import("../../query/index.js").default} query - Query instance.

package/src/database/structure-sql-loader.js

@@ -31,17 +31,23 @@ export default class StructureSqlLoader {
     await db.disableForeignKeys()
 
     try {
-      if (executableConnection) {
-        await executableConnection.exec(structureSql)
-      } else {
-        for (const statement of statements) {
-          await db.query(statement)
+      // Prefer a single round-trip for the whole dump: a driver-native multi-statement
+      // batch (e.g. MySQL with `multipleStatements`) first, then a native `exec`
+      // connection (e.g. SQLite), and finally per-statement execution. Running the
+      // whole dump at once is far faster than issuing every CREATE separately.
+      if (!await db.execStructureScript(structureSql)) {
+        if (executableConnection) {
+          await executableConnection.exec(structureSql)
+        } else {
+          for (const statement of statements) {
+            await db.query(statement)
+          }
         }
       }
     } finally {
       await db.enableForeignKeys()
 
-      // The native `exec` path mutates the schema outside `Base#query`, so the
+      // The batch / native `exec` paths mutate the schema outside `Base#query`, so the
       // usual post-DDL schema-cache invalidation never runs. Clear it here so a
       // caller that read schema metadata before provisioning (e.g. an empty table
       // list) does not keep seeing the pre-load schema afterwards. Harmless for the