@bytebase/dbhub 1.0.0 → 1.2.0

package/dist/{mariadb-72C2BNCG.js → mariadb-E33EXGJZ.js}

@@ -1,24 +1,25 @@
 import {
   MissingDatabaseError,
-  extractAffectedRows,
+  getMySQLFamilyHealthCheck,
   isTiDBVersion,
-  parseQueryResults,
+  parseQueryResultSets,
   requireDatabaseInDSN,
   withReadOnlyTransaction
-} from "./chunk-DUCNPMNW.js";
+} from "./chunk-QEFMUQJ2.js";
+import "./chunk-FU2ZJE4E.js";
 import {
   quoteIdentifier
 } from "./chunk-JFWX35TB.js";
 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/mariadb/index.ts
 import * as mariadb from "mariadb";
@@ -338,6 +339,13 @@ var MariaDBConnector = class _MariaDBConnector {
       return null;
     }
   }
+  async getHealthCheck() {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const pool = this.pool;
+    return getMySQLFamilyHealthCheck((sql) => pool.query(sql));
+  }
   async getStoredProcedures(schema, routineType) {
     if (!this.pool) {
       throw new Error("Not connected to database");
@@ -496,9 +504,9 @@ var MariaDBConnector = class _MariaDBConnector {
         options.readonly,
         this.supportsReadOnlyTransaction,
         async () => {
+          const statements = splitSQLStatements(sql, "mariadb");
           let processedSQL = sql;
           if (options.maxRows) {
-            const statements = splitSQLStatements(sql, "mariadb");
             const processedStatements = statements.map(
               (statement) => SQLRowLimiter.applyMaxRows(statement, options.maxRows)
             );
@@ -513,9 +521,8 @@ var MariaDBConnector = class _MariaDBConnector {
           } else {
             results = await conn.query(processedSQL);
           }
-          const rows = parseQueryResults(results);
-          const rowCount = extractAffectedRows(results);
-          return { rows, rowCount };
+          const resultSets = parseQueryResultSets(results, statements);
+          return { resultSets };
         }
       );
     } finally {

package/dist/{mysql-CDUKJMNN.js → mysql-RLDQI3SJ.js}

@@ -1,24 +1,26 @@
 import {
   MissingDatabaseError,
-  extractAffectedRows,
+  getMySQLFamilyHealthCheck,
+  isClientSideTimeout,
   isTiDBVersion,
-  parseQueryResults,
+  parseQueryResultSets,
   requireDatabaseInDSN,
   withReadOnlyTransaction
-} from "./chunk-DUCNPMNW.js";
+} from "./chunk-QEFMUQJ2.js";
+import "./chunk-FU2ZJE4E.js";
 import {
   quoteIdentifier
 } from "./chunk-JFWX35TB.js";
 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";
@@ -104,7 +106,7 @@ Expected: ${expectedFormat}`
     }
   }
 };
-var MySQLConnector = class _MySQLConnector {
+var _MySQLConnector = class _MySQLConnector {
   constructor() {
     this.id = "mysql";
     this.name = "MySQL";
@@ -343,6 +345,16 @@ var MySQLConnector = class _MySQLConnector {
       return null;
     }
   }
+  async getHealthCheck() {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const pool = this.pool;
+    return getMySQLFamilyHealthCheck(async (sql) => {
+      const [rows] = await pool.query(sql);
+      return rows;
+    });
+  }
   async getStoredProcedures(schema, routineType) {
     if (!this.pool) {
       throw new Error("Not connected to database");
@@ -495,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)
             );
@@ -519,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-YAYHDXVD.js → postgres-6XY2GPQV.js}

@@ -1,16 +1,19 @@
+import {
+  toNullableNumber
+} from "./chunk-FU2ZJE4E.js";
 import {
   quoteIdentifier
 } from "./chunk-JFWX35TB.js";
 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";
@@ -383,6 +386,64 @@ var PostgresConnector = class _PostgresConnector {
       client.release();
     }
   }
+  async getHealthCheck() {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const [connectionsResult, maxConnectionsResult, bufferCacheResult] = await Promise.all([
+        client.query(`
+          SELECT
+            count(*) AS total,
+            count(*) FILTER (WHERE state = 'active') AS active,
+            count(*) FILTER (WHERE state = 'idle') AS idle,
+            count(*) FILTER (WHERE state = 'idle in transaction') AS idle_in_transaction,
+            count(*) FILTER (WHERE state = 'idle in transaction (aborted)') AS idle_in_transaction_aborted,
+            max(EXTRACT(EPOCH FROM (now() - state_change)))
+              FILTER (WHERE state = 'idle in transaction') AS longest_idle_in_transaction_seconds,
+            max(EXTRACT(EPOCH FROM (now() - query_start)))
+              FILTER (WHERE state = 'active') AS longest_active_query_seconds
+          FROM pg_stat_activity
+          WHERE pid <> pg_backend_pid()
+        `),
+        client.query(`SHOW max_connections`),
+        client.query(
+          `
+          SELECT
+            blks_hit,
+            blks_read,
+            CASE WHEN (blks_hit + blks_read) = 0 THEN NULL
+                 ELSE round(100.0 * blks_hit / (blks_hit + blks_read), 2)
+            END AS hit_ratio_pct
+          FROM pg_stat_database
+          WHERE datname = current_database()
+        `
+        )
+      ]);
+      const conn = connectionsResult.rows[0];
+      const cache = bufferCacheResult.rows[0];
+      return {
+        connections: {
+          total: Number(conn.total),
+          active: Number(conn.active),
+          idle: Number(conn.idle),
+          idleInTransaction: Number(conn.idle_in_transaction),
+          idleInTransactionAborted: Number(conn.idle_in_transaction_aborted),
+          maxConnections: Number(maxConnectionsResult.rows[0].max_connections),
+          longestIdleInTransactionSeconds: toNullableNumber(conn.longest_idle_in_transaction_seconds),
+          longestActiveQuerySeconds: toNullableNumber(conn.longest_active_query_seconds)
+        },
+        bufferCache: {
+          hitRatioPct: toNullableNumber(cache.hit_ratio_pct),
+          blocksHit: Number(cache.blks_hit),
+          blocksRead: Number(cache.blks_read)
+        }
+      };
+    } finally {
+      client.release();
+    }
+  }
   async getStoredProcedures(schema, routineType) {
     if (!this.pool) {
       throw new Error("Not connected to database");
@@ -502,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");
@@ -517,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) {
@@ -544,7 +611,7 @@ var PostgresConnector = class _PostgresConnector {
           }
           throw error;
         }
-        return { rows: allRows, rowCount: totalRowCount };
+        return { resultSets };
       }
     } finally {
       client.release();