@bytebase/dbhub 1.1.0 → 1.2.0

package/dist/{mysql-265M3KBD.js → mysql-RLDQI3SJ.js}

@@ -1,12 +1,12 @@
 import {
   MissingDatabaseError,
-  extractAffectedRows,
   getMySQLFamilyHealthCheck,
+  isClientSideTimeout,
   isTiDBVersion,
-  parseQueryResults,
+  parseQueryResultSets,
   requireDatabaseInDSN,
   withReadOnlyTransaction
-} from "./chunk-NIILHXTG.js";
+} from "./chunk-QEFMUQJ2.js";
 import "./chunk-FU2ZJE4E.js";
 import {
   quoteIdentifier
@@ -14,13 +14,13 @@ import {
 import {
   SQLRowLimiter,
   closeQuietly
-} from "./chunk-S2V6RZ3C.js";
+} from "./chunk-RSB7DPO2.js";
 import {
   ConnectorRegistry,
   SafeURL,
   obfuscateDSNPassword,
   splitSQLStatements
-} from "./chunk-JEZZN2YZ.js";
+} from "./chunk-WIQ4DWGY.js";
 
 // src/connectors/mysql/index.ts
 import mysql from "mysql2/promise";
@@ -106,7 +106,7 @@ Expected: ${expectedFormat}`
     }
   }
 };
-var MySQLConnector = class _MySQLConnector {
+var _MySQLConnector = class _MySQLConnector {
   constructor() {
     this.id = "mysql";
     this.name = "MySQL";
@@ -507,15 +507,17 @@ var MySQLConnector = class _MySQLConnector {
       throw new Error("Not connected to database");
     }
     const conn = await this.pool.getConnection();
+    const threadId = conn.threadId;
+    let isConnectionPoisoned = false;
     try {
       return await withReadOnlyTransaction(
         conn,
         options.readonly,
         this.supportsReadOnlyTransaction,
         async () => {
+          const statements = splitSQLStatements(sql, "mysql");
           let processedSQL = sql;
           if (options.maxRows) {
-            const statements = splitSQLStatements(sql, "mysql");
             const processedStatements = statements.map(
               (statement) => SQLRowLimiter.applyMaxRows(statement, options.maxRows)
             );
@@ -531,16 +533,59 @@ var MySQLConnector = class _MySQLConnector {
             results = await conn.query({ sql: processedSQL, timeout: this.queryTimeoutMs });
           }
           const [firstResult] = results;
-          const rows = parseQueryResults(firstResult);
-          const rowCount = extractAffectedRows(firstResult);
-          return { rows, rowCount };
+          const resultSets = parseQueryResultSets(firstResult, statements);
+          return { resultSets };
         }
       );
+    } catch (error) {
+      if (isClientSideTimeout(error)) {
+        isConnectionPoisoned = true;
+        await this.killQuery(threadId);
+      }
+      throw error;
+    } finally {
+      if (isConnectionPoisoned) {
+        conn.destroy();
+      } else {
+        conn.release();
+      }
+    }
+  }
+  /**
+   * Best-effort server-side kill for a query abandoned by mysql2's client-side
+   * timeout. Uses a separate connection: the original connection's command
+   * queue is stuck behind the abandoned statement (see isClientSideTimeout)
+   * and cannot itself be used to send KILL QUERY.
+   *
+   * Bounded by its own short timeout, independent of the user's (possibly
+   * long or unset) query_timeout — KILL QUERY is metadata-only and should
+   * return almost immediately on a healthy server, so cleanup must not stall
+   * indefinitely if it doesn't.
+   */
+  async killQuery(threadId) {
+    if (!this.pool) return;
+    let killer;
+    let killerPoisoned = false;
+    try {
+      killer = await this.pool.getConnection();
+      await killer.query({ sql: `KILL QUERY ${threadId}`, timeout: _MySQLConnector.KILL_QUERY_TIMEOUT_MS });
+    } catch (error) {
+      killerPoisoned = isClientSideTimeout(error);
     } finally {
-      conn.release();
+      if (killer) {
+        if (killerPoisoned) {
+          killer.destroy();
+        } else {
+          killer.release();
+        }
+      }
     }
   }
 };
+// Bounds the KILL QUERY cleanup call issued after a client-side query
+// timeout; see killQuery.
+_MySQLConnector.KILL_QUERY_TIMEOUT_MS = 5e3;
+var MySQLConnector = _MySQLConnector;
 var mysqlConnector = new MySQLConnector();
 ConnectorRegistry.register(mysqlConnector);
 export {

package/dist/{postgres-5ZOFYV6X.js → postgres-6XY2GPQV.js}

@@ -7,13 +7,13 @@ import {
 import {
   SQLRowLimiter,
   closeQuietly
-} from "./chunk-S2V6RZ3C.js";
+} from "./chunk-RSB7DPO2.js";
 import {
   ConnectorRegistry,
   SafeURL,
   obfuscateDSNPassword,
   splitSQLStatements
-} from "./chunk-JEZZN2YZ.js";
+} from "./chunk-WIQ4DWGY.js";
 
 // src/connectors/postgres/index.ts
 import fs from "fs";
@@ -563,7 +563,11 @@ var PostgresConnector = class _PostgresConnector {
           try {
             const result2 = parameters && parameters.length > 0 ? await client.query(processedStatement, parameters) : await client.query(processedStatement);
             await client.query("COMMIT");
-            return { rows: result2.rows, rowCount: result2.rowCount ?? result2.rows.length };
+            return {
+              resultSets: [
+                { sql: statements[0], rows: result2.rows, rowCount: result2.rowCount ?? result2.rows.length }
+              ]
+            };
           } catch (error) {
             try {
               await client.query("ROLLBACK");
@@ -578,24 +582,26 @@ var PostgresConnector = class _PostgresConnector {
         } else {
           result = await client.query(processedStatement);
         }
-        return { rows: result.rows, rowCount: result.rowCount ?? result.rows.length };
+        return {
+          resultSets: [
+            { sql: statements[0], rows: result.rows, rowCount: result.rowCount ?? result.rows.length }
+          ]
+        };
       } else {
         if (parameters && parameters.length > 0) {
           throw new Error("Parameters are not supported for multi-statement queries in PostgreSQL");
         }
-        let allRows = [];
-        let totalRowCount = 0;
+        const resultSets = [];
         await client.query(options.readonly ? "BEGIN READ ONLY" : "BEGIN");
         try {
           for (let statement of statements) {
             const processedStatement = SQLRowLimiter.applyMaxRows(statement, options.maxRows);
             const result = await client.query(processedStatement);
-            if (result.rows && result.rows.length > 0) {
-              allRows.push(...result.rows);
-            }
-            if (result.rowCount) {
-              totalRowCount += result.rowCount;
-            }
+            resultSets.push({
+              sql: statement,
+              rows: result.rows ?? [],
+              rowCount: result.rowCount ?? result.rows?.length ?? 0
+            });
           }
           await client.query("COMMIT");
         } catch (error) {
@@ -605,7 +611,7 @@ var PostgresConnector = class _PostgresConnector {
           }
           throw error;
         }
-        return { rows: allRows, rowCount: totalRowCount };
+        return { resultSets };
       }
     } finally {
       client.release();