@libredb/studio 0.9.7 → 0.9.13

package/dist/mysql-Y3MSA5QY.js

@@ -0,0 +1,833 @@
+'use strict';
+
+var chunkKV356UXJ_js = require('./chunk-KV356UXJ.js');
+var chunkPTIRB2JO_js = require('./chunk-PTIRB2JO.js');
+var chunkJZO5KRZN_js = require('./chunk-JZO5KRZN.js');
+var chunkQ6LRDBK7_js = require('./chunk-Q6LRDBK7.js');
+var mysql = require('mysql2/promise');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var mysql__default = /*#__PURE__*/_interopDefault(mysql);
+
+var _MySQLProvider = class _MySQLProvider extends chunkKV356UXJ_js.SQLBaseProvider {
+  // 5 minutes
+  constructor(config, options = {}) {
+    super(config, options);
+    this.pool = null;
+    // Transaction support: dedicated connection held outside pool
+    this.txConn = null;
+    this.txActive = false;
+    this.txTimeout = null;
+    // Track running query thread IDs for cancellation
+    this.runningQueryThreadIds = /* @__PURE__ */ new Map();
+    this.validate();
+  }
+  // ============================================================================
+  // Provider Metadata
+  // ============================================================================
+  getCapabilities() {
+    return chunkQ6LRDBK7_js.__spreadProps(chunkQ6LRDBK7_js.__spreadValues({}, super.getCapabilities()), {
+      defaultPort: 3306,
+      supportsExplain: true,
+      supportsConnectionString: true,
+      maintenanceOperations: ["analyze", "optimize", "check", "kill"]
+    });
+  }
+  // ============================================================================
+  // Validation
+  // ============================================================================
+  validate() {
+    super.validate();
+    if (!this.config.connectionString) {
+      if (!this.config.host) {
+        throw new chunkJZO5KRZN_js.DatabaseConfigError("Host is required for MySQL", "mysql");
+      }
+      if (!this.config.database) {
+        throw new chunkJZO5KRZN_js.DatabaseConfigError("Database name is required for MySQL", "mysql");
+      }
+    }
+  }
+  // ============================================================================
+  // Connection Management
+  // ============================================================================
+  async connect() {
+    if (this.pool) {
+      return;
+    }
+    try {
+      this.pool = mysql__default.default.createPool(this.buildPoolConfig());
+      const conn = await this.pool.getConnection();
+      conn.release();
+      this.setConnected(true);
+    } catch (error) {
+      this.setError(error instanceof Error ? error : new Error(String(error)));
+      throw new chunkJZO5KRZN_js.ConnectionError(
+        `Failed to connect to MySQL: ${error instanceof Error ? error.message : error}`,
+        "mysql",
+        this.config.host,
+        this.config.port
+      );
+    }
+  }
+  async disconnect() {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = null;
+      this.setConnected(false);
+    }
+  }
+  buildPoolConfig() {
+    var _a, _b;
+    const baseConfig = {
+      connectionLimit: this.poolConfig.max,
+      waitForConnections: true,
+      queueLimit: 0,
+      enableKeepAlive: true,
+      keepAliveInitialDelay: 1e4
+    };
+    if (this.config.connectionString) {
+      return chunkQ6LRDBK7_js.__spreadProps(chunkQ6LRDBK7_js.__spreadValues({}, baseConfig), {
+        uri: this.config.connectionString
+      });
+    }
+    return chunkQ6LRDBK7_js.__spreadProps(chunkQ6LRDBK7_js.__spreadValues({}, baseConfig), {
+      host: this.config.host,
+      port: (_a = this.config.port) != null ? _a : 3306,
+      user: this.config.user,
+      password: this.config.password,
+      database: this.config.database,
+      ssl: this.buildSSLConfig(),
+      timezone: (_b = this.options.timezone) != null ? _b : "Z"
+    });
+  }
+  buildSSLConfig() {
+    const connSSL = this.config.ssl;
+    if (connSSL) {
+      if (connSSL.mode === "disable") return void 0;
+      const ssl = {
+        rejectUnauthorized: connSSL.mode === "verify-ca" || connSSL.mode === "verify-full"
+      };
+      if (connSSL.caCert) ssl.ca = connSSL.caCert;
+      if (connSSL.clientCert) ssl.cert = connSSL.clientCert;
+      if (connSSL.clientKey) ssl.key = connSSL.clientKey;
+      return ssl;
+    }
+    if (this.shouldEnableSSL()) {
+      return { rejectUnauthorized: false };
+    }
+    return void 0;
+  }
+  // ============================================================================
+  // Query Execution
+  // ============================================================================
+  sanitizeRow(row) {
+    const sanitized = {};
+    for (const [key, value] of Object.entries(row)) {
+      if (Buffer.isBuffer(value)) {
+        sanitized[key] = value.length === 0 ? "" : `0x${value.toString("hex")}`;
+      } else {
+        sanitized[key] = value;
+      }
+    }
+    return sanitized;
+  }
+  async query(sql, params, queryId) {
+    this.ensureConnected();
+    return this.trackQuery(async () => {
+      var _a, _b;
+      const { result, executionTime } = await this.measureExecution(async () => {
+        const conn = await this.pool.getConnection();
+        try {
+          if (queryId) {
+            this.runningQueryThreadIds.set(queryId, conn.threadId);
+          }
+          const [rows, fields] = await conn.execute(sql, params);
+          return { rows, fields };
+        } catch (error) {
+          throw chunkJZO5KRZN_js.mapDatabaseError(error, "mysql", sql);
+        } finally {
+          if (queryId) this.runningQueryThreadIds.delete(queryId);
+          conn.release();
+        }
+      });
+      return {
+        rows: result.rows.map((row) => this.sanitizeRow(row)),
+        fields: (_b = (_a = result.fields) == null ? void 0 : _a.map((f) => f.name)) != null ? _b : [],
+        rowCount: Array.isArray(result.rows) ? result.rows.length : 0,
+        executionTime
+      };
+    });
+  }
+  async cancelQuery(queryId) {
+    const threadId = this.runningQueryThreadIds.get(queryId);
+    if (!threadId) return false;
+    try {
+      await this.pool.execute(`KILL QUERY ${threadId}`);
+      return true;
+    } catch (error) {
+      console.error("[MySQL] Failed to cancel query:", error);
+      return false;
+    }
+  }
+  // ============================================================================
+  // Transaction Support
+  // ============================================================================
+  clearTxTimeout() {
+    if (this.txTimeout) {
+      clearTimeout(this.txTimeout);
+      this.txTimeout = null;
+    }
+  }
+  /**
+   * Force-expire an active transaction (auto-rollback).
+   * Called by the timeout timer, but also available for testing.
+   */
+  async expireTransaction() {
+    if (this.txActive && this.txConn) {
+      console.warn("[MySQL] Transaction timed out, auto-rolling back");
+      try {
+        await this.txConn.rollback();
+      } catch (e) {
+      } finally {
+        this.txConn.release();
+        this.txConn = null;
+        this.txActive = false;
+        this.clearTxTimeout();
+      }
+    }
+  }
+  async beginTransaction() {
+    this.ensureConnected();
+    if (this.txActive) throw new chunkJZO5KRZN_js.QueryError("Transaction already active", "mysql");
+    this.txConn = await this.pool.getConnection();
+    await this.txConn.beginTransaction();
+    this.txActive = true;
+    this.txTimeout = setTimeout(() => {
+      this.expireTransaction();
+    }, _MySQLProvider.TX_TIMEOUT_MS);
+  }
+  async commitTransaction() {
+    if (!this.txConn || !this.txActive) throw new chunkJZO5KRZN_js.QueryError("No active transaction", "mysql");
+    this.clearTxTimeout();
+    try {
+      await this.txConn.commit();
+    } finally {
+      this.txConn.release();
+      this.txConn = null;
+      this.txActive = false;
+    }
+  }
+  async rollbackTransaction() {
+    if (!this.txConn || !this.txActive) throw new chunkJZO5KRZN_js.QueryError("No active transaction", "mysql");
+    this.clearTxTimeout();
+    try {
+      await this.txConn.rollback();
+    } finally {
+      this.txConn.release();
+      this.txConn = null;
+      this.txActive = false;
+    }
+  }
+  isInTransaction() {
+    return this.txActive;
+  }
+  async queryInTransaction(sql, params) {
+    if (!this.txConn || !this.txActive) throw new chunkJZO5KRZN_js.QueryError("No active transaction", "mysql");
+    return this.trackQuery(async () => {
+      var _a, _b;
+      const { result, executionTime } = await this.measureExecution(async () => {
+        try {
+          const [rows, fields] = await this.txConn.execute(sql, params);
+          return { rows, fields };
+        } catch (error) {
+          throw chunkJZO5KRZN_js.mapDatabaseError(error, "mysql", sql);
+        }
+      });
+      return {
+        rows: result.rows.map((row) => this.sanitizeRow(row)),
+        fields: (_b = (_a = result.fields) == null ? void 0 : _a.map((f) => f.name)) != null ? _b : [],
+        rowCount: Array.isArray(result.rows) ? result.rows.length : 0,
+        executionTime
+      };
+    });
+  }
+  // ============================================================================
+  // Schema Operations
+  // ============================================================================
+  async getSchema() {
+    this.ensureConnected();
+    const conn = await this.pool.getConnection();
+    try {
+      const [tablesRows] = await conn.execute(`
+        SELECT
+          TABLE_NAME as table_name,
+          TABLE_ROWS as row_count,
+          DATA_LENGTH + INDEX_LENGTH as total_size
+        FROM information_schema.TABLES
+        WHERE TABLE_SCHEMA = ?
+        AND TABLE_TYPE = 'BASE TABLE'
+        ORDER BY TABLE_NAME ASC;
+      `, [this.config.database]);
+      const schemas = [];
+      for (const row of tablesRows) {
+        const tableName = row.table_name;
+        const rowCount = parseInt(row.row_count || "0");
+        const sizeBytes = parseInt(row.total_size || "0");
+        const [columnsRows] = await conn.execute(`
+          SELECT
+            COLUMN_NAME as column_name,
+            DATA_TYPE as data_type,
+            IS_NULLABLE as is_nullable,
+            COLUMN_DEFAULT as column_default,
+            COLUMN_KEY as column_key
+          FROM information_schema.COLUMNS
+          WHERE TABLE_SCHEMA = ?
+          AND TABLE_NAME = ?
+          ORDER BY ORDINAL_POSITION
+          LIMIT 100;
+        `, [this.config.database, tableName]);
+        const [fkRows] = await conn.execute(`
+          SELECT
+            COLUMN_NAME as column_name,
+            REFERENCED_TABLE_NAME as referenced_table,
+            REFERENCED_COLUMN_NAME as referenced_column
+          FROM information_schema.KEY_COLUMN_USAGE
+          WHERE TABLE_SCHEMA = ?
+          AND TABLE_NAME = ?
+          AND REFERENCED_TABLE_NAME IS NOT NULL;
+        `, [this.config.database, tableName]);
+        const [indexRows] = await conn.execute(`
+          SELECT
+            INDEX_NAME as index_name,
+            GROUP_CONCAT(COLUMN_NAME ORDER BY SEQ_IN_INDEX) as columns,
+            NOT NON_UNIQUE as is_unique
+          FROM information_schema.STATISTICS
+          WHERE TABLE_SCHEMA = ?
+          AND TABLE_NAME = ?
+          GROUP BY INDEX_NAME, NON_UNIQUE;
+        `, [this.config.database, tableName]);
+        schemas.push({
+          name: tableName,
+          rowCount,
+          size: chunkPTIRB2JO_js.formatBytes(sizeBytes),
+          columns: columnsRows.map((col) => {
+            var _a;
+            return {
+              name: col.column_name,
+              type: col.data_type,
+              nullable: col.is_nullable === "YES",
+              isPrimary: col.column_key === "PRI",
+              defaultValue: (_a = col.column_default) != null ? _a : void 0
+            };
+          }),
+          indexes: indexRows.map((idx) => {
+            var _a, _b;
+            return {
+              name: idx.index_name,
+              columns: (_b = (_a = idx.columns) == null ? void 0 : _a.split(",")) != null ? _b : [],
+              unique: Boolean(idx.is_unique)
+            };
+          }),
+          foreignKeys: fkRows.map((fk) => ({
+            columnName: fk.column_name,
+            referencedTable: fk.referenced_table,
+            referencedColumn: fk.referenced_column
+          }))
+        });
+      }
+      return schemas;
+    } finally {
+      conn.release();
+    }
+  }
+  // ============================================================================
+  // Health & Monitoring
+  // ============================================================================
+  async getHealth() {
+    var _a, _b, _c;
+    this.ensureConnected();
+    const conn = await this.pool.getConnection();
+    try {
+      const [connRows] = await conn.execute(
+        "SHOW STATUS LIKE 'Threads_connected'"
+      );
+      const activeConnections = parseInt(((_a = connRows[0]) == null ? void 0 : _a.Value) || "0");
+      const [sizeRows] = await conn.execute(`
+        SELECT
+          ROUND(SUM(DATA_LENGTH + INDEX_LENGTH) / 1024 / 1024, 2) as size_mb
+        FROM information_schema.TABLES
+        WHERE TABLE_SCHEMA = ?;
+      `, [this.config.database]);
+      const databaseSize = `${((_b = sizeRows[0]) == null ? void 0 : _b.size_mb) || 0} MB`;
+      const [hitRows] = await conn.execute(`
+        SELECT
+          (1 - (
+            (SELECT VARIABLE_VALUE FROM performance_schema.global_status WHERE VARIABLE_NAME = 'Innodb_buffer_pool_reads') /
+            NULLIF((SELECT VARIABLE_VALUE FROM performance_schema.global_status WHERE VARIABLE_NAME = 'Innodb_buffer_pool_read_requests'), 0)
+          )) * 100 as hit_ratio;
+      `);
+      const cacheHitRatio = `${(((_c = hitRows[0]) == null ? void 0 : _c.hit_ratio) || 99).toFixed(1)}%`;
+      let slowQueries = [];
+      try {
+        const [slowRows] = await conn.execute(`
+          SELECT
+            LEFT(sql_text, 100) as query,
+            count_star as calls,
+            CONCAT(ROUND(avg_timer_wait / 1000000000, 2), 'ms') as avgTime
+          FROM performance_schema.events_statements_summary_by_digest
+          WHERE schema_name = ?
+          ORDER BY sum_timer_wait DESC
+          LIMIT 5;
+        `, [this.config.database]);
+        slowQueries = slowRows.map((r) => ({
+          query: r.query || "",
+          calls: parseInt(r.calls || "0"),
+          avgTime: r.avgTime || "N/A"
+        }));
+      } catch (e) {
+        slowQueries = [{ query: "Performance schema not available", calls: 0, avgTime: "N/A" }];
+      }
+      const [sessionRows] = await conn.execute(`
+        SELECT
+          ID as pid,
+          USER as user,
+          DB as \`database\`,
+          COMMAND as state,
+          LEFT(COALESCE(INFO, ''), 100) as query,
+          CONCAT(TIME, 's') as duration
+        FROM information_schema.PROCESSLIST
+        WHERE DB = ?
+        ORDER BY TIME DESC
+        LIMIT 10;
+      `, [this.config.database]);
+      const activeSessions = sessionRows.map((r) => ({
+        pid: r.pid,
+        user: r.user || "unknown",
+        database: r.database || "",
+        state: r.state || "unknown",
+        query: r.query || "",
+        duration: r.duration || "N/A"
+      }));
+      return {
+        activeConnections,
+        databaseSize,
+        cacheHitRatio,
+        slowQueries,
+        activeSessions
+      };
+    } finally {
+      conn.release();
+    }
+  }
+  // ============================================================================
+  // Maintenance Operations
+  // ============================================================================
+  async runMaintenance(type, target) {
+    this.ensureConnected();
+    const { result, executionTime } = await this.measureExecution(async () => {
+      const conn = await this.pool.getConnection();
+      try {
+        let sql = "";
+        switch (type) {
+          case "analyze":
+            sql = target ? `ANALYZE TABLE ${this.escapeIdentifier(target)}` : `ANALYZE TABLE ${await this.getAllTablesForMaintenance(conn)}`;
+            break;
+          case "optimize":
+            sql = target ? `OPTIMIZE TABLE ${this.escapeIdentifier(target)}` : `OPTIMIZE TABLE ${await this.getAllTablesForMaintenance(conn)}`;
+            break;
+          case "check":
+            sql = target ? `CHECK TABLE ${this.escapeIdentifier(target)}` : `CHECK TABLE ${await this.getAllTablesForMaintenance(conn)}`;
+            break;
+          case "kill":
+            if (!target) {
+              throw new chunkJZO5KRZN_js.QueryError("Target connection ID is required for kill operation", "mysql");
+            }
+            const connId = parseInt(target, 10);
+            if (isNaN(connId)) {
+              throw new chunkJZO5KRZN_js.QueryError("Invalid connection ID for kill operation", "mysql");
+            }
+            sql = `KILL ${connId}`;
+            break;
+          default:
+            throw new chunkJZO5KRZN_js.QueryError(`Unsupported maintenance type for MySQL: ${type}`, "mysql");
+        }
+        await conn.execute(sql);
+        return { success: true };
+      } finally {
+        conn.release();
+      }
+    });
+    return {
+      success: result.success,
+      executionTime,
+      message: `${type.toUpperCase()} completed successfully`
+    };
+  }
+  async getAllTablesForMaintenance(conn) {
+    const [rows] = await conn.execute(`
+      SELECT TABLE_NAME
+      FROM information_schema.TABLES
+      WHERE TABLE_SCHEMA = ?
+      AND TABLE_TYPE = 'BASE TABLE'
+      LIMIT 50;
+    `, [this.config.database]);
+    return rows.map((r) => this.escapeIdentifier(r.TABLE_NAME)).join(", ");
+  }
+  // ============================================================================
+  // Monitoring Operations
+  // ============================================================================
+  async getOverview() {
+    var _a, _b, _c, _d, _e, _f, _g;
+    this.ensureConnected();
+    const conn = await this.pool.getConnection();
+    try {
+      const [versionRows] = await conn.execute("SELECT VERSION() as version");
+      const version = ((_a = versionRows[0]) == null ? void 0 : _a.version) || "Unknown";
+      const [uptimeRows] = await conn.execute(
+        "SHOW STATUS LIKE 'Uptime'"
+      );
+      const uptimeSeconds = parseInt(((_b = uptimeRows[0]) == null ? void 0 : _b.Value) || "0");
+      const uptime = this.formatUptimeString(uptimeSeconds);
+      const [connRows] = await conn.execute(
+        "SHOW STATUS LIKE 'Threads_connected'"
+      );
+      const activeConnections = parseInt(((_c = connRows[0]) == null ? void 0 : _c.Value) || "0");
+      const [maxConnRows] = await conn.execute(
+        "SHOW VARIABLES LIKE 'max_connections'"
+      );
+      const maxConnections = parseInt(((_d = maxConnRows[0]) == null ? void 0 : _d.Value) || "151");
+      const [sizeRows] = await conn.execute(`
+        SELECT SUM(DATA_LENGTH + INDEX_LENGTH) as size_bytes
+        FROM information_schema.TABLES
+        WHERE TABLE_SCHEMA = ?;
+      `, [this.config.database]);
+      const databaseSizeBytes = parseInt(((_e = sizeRows[0]) == null ? void 0 : _e.size_bytes) || "0");
+      const [countRows] = await conn.execute(`
+        SELECT
+          COUNT(DISTINCT TABLE_NAME) as table_count,
+          COUNT(DISTINCT INDEX_NAME) as index_count
+        FROM information_schema.STATISTICS
+        WHERE TABLE_SCHEMA = ?;
+      `, [this.config.database]);
+      const [tableCountRows] = await conn.execute(`
+        SELECT COUNT(*) as cnt FROM information_schema.TABLES
+        WHERE TABLE_SCHEMA = ? AND TABLE_TYPE = 'BASE TABLE';
+      `, [this.config.database]);
+      return {
+        version: `MySQL ${version}`,
+        uptime,
+        startTime: new Date(Date.now() - uptimeSeconds * 1e3),
+        activeConnections,
+        maxConnections,
+        databaseSize: chunkPTIRB2JO_js.formatBytes(databaseSizeBytes),
+        databaseSizeBytes,
+        tableCount: parseInt(((_f = tableCountRows[0]) == null ? void 0 : _f.cnt) || "0"),
+        indexCount: parseInt(((_g = countRows[0]) == null ? void 0 : _g.index_count) || "0")
+      };
+    } finally {
+      conn.release();
+    }
+  }
+  async getPerformanceMetrics() {
+    var _a, _b, _c, _d, _e, _f;
+    this.ensureConnected();
+    const conn = await this.pool.getConnection();
+    try {
+      const [hitRows] = await conn.execute(`
+        SELECT
+          (1 - (
+            (SELECT VARIABLE_VALUE FROM performance_schema.global_status WHERE VARIABLE_NAME = 'Innodb_buffer_pool_reads') /
+            NULLIF((SELECT VARIABLE_VALUE FROM performance_schema.global_status WHERE VARIABLE_NAME = 'Innodb_buffer_pool_read_requests'), 0)
+          )) * 100 as hit_ratio;
+      `);
+      const cacheHitRatio = parseFloat(((_a = hitRows[0]) == null ? void 0 : _a.hit_ratio) || "99");
+      const [poolRows] = await conn.execute(`
+        SELECT
+          (SELECT VARIABLE_VALUE FROM performance_schema.global_status WHERE VARIABLE_NAME = 'Innodb_buffer_pool_pages_data') as data_pages,
+          (SELECT VARIABLE_VALUE FROM performance_schema.global_status WHERE VARIABLE_NAME = 'Innodb_buffer_pool_pages_total') as total_pages;
+      `);
+      const dataPages = parseInt(((_b = poolRows[0]) == null ? void 0 : _b.data_pages) || "0");
+      const totalPages = parseInt(((_c = poolRows[0]) == null ? void 0 : _c.total_pages) || "1");
+      const bufferPoolUsage = dataPages / totalPages * 100;
+      const [qpsRows] = await conn.execute(`
+        SELECT
+          (SELECT VARIABLE_VALUE FROM performance_schema.global_status WHERE VARIABLE_NAME = 'Queries') as queries,
+          (SELECT VARIABLE_VALUE FROM performance_schema.global_status WHERE VARIABLE_NAME = 'Uptime') as uptime;
+      `);
+      const queries = parseInt(((_d = qpsRows[0]) == null ? void 0 : _d.queries) || "0");
+      const uptime = parseInt(((_e = qpsRows[0]) == null ? void 0 : _e.uptime) || "1");
+      const queriesPerSecond = queries / uptime;
+      const [deadlockRows] = await conn.execute(
+        "SHOW STATUS LIKE 'Innodb_deadlocks'"
+      );
+      const deadlocks = parseInt(((_f = deadlockRows[0]) == null ? void 0 : _f.Value) || "0");
+      return {
+        cacheHitRatio: Math.min(100, Math.max(0, cacheHitRatio)),
+        queriesPerSecond: Math.round(queriesPerSecond * 100) / 100,
+        bufferPoolUsage: Math.round(bufferPoolUsage * 100) / 100,
+        deadlocks
+      };
+    } catch (e) {
+      return {
+        cacheHitRatio: 99,
+        queriesPerSecond: 0,
+        bufferPoolUsage: 0,
+        deadlocks: 0
+      };
+    } finally {
+      conn.release();
+    }
+  }
+  async getSlowQueries(options) {
+    var _a;
+    this.ensureConnected();
+    const limit = (_a = options == null ? void 0 : options.limit) != null ? _a : 10;
+    const conn = await this.pool.getConnection();
+    try {
+      const [rows] = await conn.execute(`
+        SELECT
+          DIGEST as query_id,
+          LEFT(DIGEST_TEXT, 500) as query,
+          COUNT_STAR as calls,
+          SUM_TIMER_WAIT / 1000000000 as total_time_ms,
+          AVG_TIMER_WAIT / 1000000000 as avg_time_ms,
+          MIN_TIMER_WAIT / 1000000000 as min_time_ms,
+          MAX_TIMER_WAIT / 1000000000 as max_time_ms,
+          SUM_ROWS_EXAMINED as rows_examined
+        FROM performance_schema.events_statements_summary_by_digest
+        WHERE SCHEMA_NAME = ?
+        ORDER BY SUM_TIMER_WAIT DESC
+        LIMIT ${Number(limit)};
+      `, [this.config.database]);
+      return rows.map((r) => ({
+        queryId: r.query_id || void 0,
+        query: r.query || "",
+        calls: parseInt(r.calls || "0"),
+        totalTime: parseFloat(r.total_time_ms || "0"),
+        avgTime: parseFloat(r.avg_time_ms || "0"),
+        minTime: parseFloat(r.min_time_ms || "0"),
+        maxTime: parseFloat(r.max_time_ms || "0"),
+        rows: parseInt(r.rows_examined || "0")
+      }));
+    } catch (e) {
+      return [];
+    } finally {
+      conn.release();
+    }
+  }
+  async getActiveSessions(options) {
+    var _a;
+    this.ensureConnected();
+    const limit = (_a = options == null ? void 0 : options.limit) != null ? _a : 50;
+    const conn = await this.pool.getConnection();
+    try {
+      const [rows] = await conn.execute(`
+        SELECT
+          ID as pid,
+          USER as user,
+          DB as database_name,
+          HOST as client_addr,
+          COMMAND as state,
+          LEFT(COALESCE(INFO, ''), 500) as query,
+          TIME as duration_seconds
+        FROM information_schema.PROCESSLIST
+        WHERE DB = ? OR DB IS NULL
+        ORDER BY TIME DESC
+        LIMIT ${Number(limit)};
+      `, [this.config.database]);
+      return rows.map((r) => {
+        var _a2;
+        const durationSeconds = parseInt(r.duration_seconds || "0");
+        return {
+          pid: r.pid,
+          user: r.user || "unknown",
+          database: r.database_name || "",
+          clientAddr: ((_a2 = r.client_addr) == null ? void 0 : _a2.split(":")[0]) || void 0,
+          state: r.state || "unknown",
+          query: r.query || "",
+          duration: this.formatDurationString(durationSeconds * 1e3),
+          durationMs: durationSeconds * 1e3
+        };
+      });
+    } finally {
+      conn.release();
+    }
+  }
+  async getTableStats(options) {
+    var _a;
+    this.ensureConnected();
+    const schema = (_a = options == null ? void 0 : options.schema) != null ? _a : this.config.database;
+    const conn = await this.pool.getConnection();
+    try {
+      const [rows] = await conn.execute(`
+        SELECT
+          TABLE_SCHEMA as schema_name,
+          TABLE_NAME as table_name,
+          TABLE_ROWS as row_count,
+          DATA_LENGTH as table_size_bytes,
+          INDEX_LENGTH as index_size_bytes,
+          DATA_LENGTH + INDEX_LENGTH as total_size_bytes,
+          DATA_FREE as free_space_bytes
+        FROM information_schema.TABLES
+        WHERE TABLE_SCHEMA = ?
+        AND TABLE_TYPE = 'BASE TABLE'
+        ORDER BY DATA_LENGTH + INDEX_LENGTH DESC
+        LIMIT 100;
+      `, [schema]);
+      return rows.map((r) => {
+        const tableSizeBytes = parseInt(r.table_size_bytes || "0");
+        const indexSizeBytes = parseInt(r.index_size_bytes || "0");
+        const totalSizeBytes = parseInt(r.total_size_bytes || "0");
+        const freeSpaceBytes = parseInt(r.free_space_bytes || "0");
+        const bloatRatio = totalSizeBytes > 0 ? freeSpaceBytes / totalSizeBytes * 100 : 0;
+        return {
+          schemaName: r.schema_name || schema || "",
+          tableName: r.table_name || "",
+          rowCount: parseInt(r.row_count || "0"),
+          tableSize: chunkPTIRB2JO_js.formatBytes(tableSizeBytes),
+          tableSizeBytes,
+          indexSize: chunkPTIRB2JO_js.formatBytes(indexSizeBytes),
+          totalSize: chunkPTIRB2JO_js.formatBytes(totalSizeBytes),
+          totalSizeBytes,
+          bloatRatio: Math.round(bloatRatio * 10) / 10
+        };
+      });
+    } finally {
+      conn.release();
+    }
+  }
+  async getIndexStats(options) {
+    var _a;
+    this.ensureConnected();
+    const schema = (_a = options == null ? void 0 : options.schema) != null ? _a : this.config.database;
+    const conn = await this.pool.getConnection();
+    try {
+      const [rows] = await conn.execute(`
+        SELECT
+          TABLE_SCHEMA as schema_name,
+          TABLE_NAME as table_name,
+          INDEX_NAME as index_name,
+          INDEX_TYPE as index_type,
+          GROUP_CONCAT(COLUMN_NAME ORDER BY SEQ_IN_INDEX) as columns,
+          NOT NON_UNIQUE as is_unique,
+          INDEX_NAME = 'PRIMARY' as is_primary,
+          MAX(CARDINALITY) as cardinality
+        FROM information_schema.STATISTICS
+        WHERE TABLE_SCHEMA = ?
+        GROUP BY TABLE_SCHEMA, TABLE_NAME, INDEX_NAME, INDEX_TYPE, NON_UNIQUE
+        ORDER BY TABLE_NAME, INDEX_NAME
+        LIMIT 200;
+      `, [schema]);
+      const indexSizes = {};
+      try {
+        const [sizeRows] = await conn.execute(`
+          SELECT
+            CONCAT(t.NAME) as full_name,
+            SUM(s.INDEX_SIZE * @@innodb_page_size) as size_bytes
+          FROM information_schema.INNODB_INDEXES i
+          JOIN information_schema.INNODB_TABLES t ON i.TABLE_ID = t.TABLE_ID
+          JOIN information_schema.INNODB_TABLESPACES s ON t.SPACE = s.SPACE
+          WHERE t.NAME LIKE ?
+          GROUP BY t.NAME, i.NAME;
+        `, [`${schema}/%`]);
+        for (const row of sizeRows) {
+          indexSizes[row.full_name] = parseInt(row.size_bytes || "0");
+        }
+      } catch (e) {
+      }
+      return rows.map((r) => {
+        var _a2;
+        const indexKey = `${r.schema_name}/${r.table_name}`;
+        const indexSizeBytes = indexSizes[indexKey] || 0;
+        return {
+          schemaName: r.schema_name || schema || "",
+          tableName: r.table_name || "",
+          indexName: r.index_name || "",
+          indexType: r.index_type || "BTREE",
+          columns: ((_a2 = r.columns) == null ? void 0 : _a2.split(",")) || [],
+          isUnique: Boolean(r.is_unique),
+          isPrimary: Boolean(r.is_primary),
+          indexSize: chunkPTIRB2JO_js.formatBytes(indexSizeBytes),
+          indexSizeBytes,
+          scans: parseInt(r.cardinality || "0")
+        };
+      });
+    } finally {
+      conn.release();
+    }
+  }
+  async getStorageStats() {
+    this.ensureConnected();
+    const conn = await this.pool.getConnection();
+    try {
+      const stats = [];
+      const [dbRows] = await conn.execute(`
+        SELECT
+          TABLE_SCHEMA as name,
+          SUM(DATA_LENGTH + INDEX_LENGTH) as size_bytes
+        FROM information_schema.TABLES
+        WHERE TABLE_SCHEMA = ?
+        GROUP BY TABLE_SCHEMA;
+      `, [this.config.database]);
+      if (dbRows.length > 0) {
+        const sizeBytes = parseInt(dbRows[0].size_bytes || "0");
+        stats.push({
+          name: "Data",
+          location: this.config.database || "default",
+          size: chunkPTIRB2JO_js.formatBytes(sizeBytes),
+          sizeBytes
+        });
+      }
+      try {
+        const [binlogRows] = await conn.execute("SHOW BINARY LOGS");
+        const binlogSize = binlogRows.reduce((sum, r) => sum + parseInt(r.File_size || "0"), 0);
+        if (binlogSize > 0) {
+          stats.push({
+            name: "Binary Logs",
+            size: chunkPTIRB2JO_js.formatBytes(binlogSize),
+            sizeBytes: binlogSize
+          });
+        }
+      } catch (e) {
+      }
+      try {
+        const [innodbRows] = await conn.execute(
+          "SHOW VARIABLES LIKE 'innodb_data_file_path'"
+        );
+        if (innodbRows.length > 0) {
+          stats.push({
+            name: "InnoDB",
+            location: innodbRows[0].Value || "ibdata1",
+            size: "N/A",
+            sizeBytes: 0
+          });
+        }
+      } catch (e) {
+      }
+      return stats;
+    } finally {
+      conn.release();
+    }
+  }
+  formatUptimeString(seconds) {
+    const days = Math.floor(seconds / 86400);
+    const hours = Math.floor(seconds % 86400 / 3600);
+    const minutes = Math.floor(seconds % 3600 / 60);
+    if (days > 0) return `${days}d ${hours}h`;
+    if (hours > 0) return `${hours}h ${minutes}m`;
+    return `${minutes}m`;
+  }
+  formatDurationString(ms) {
+    if (ms < 1e3) return `${ms}ms`;
+    if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+    if (ms < 36e5) return `${Math.floor(ms / 6e4)}m ${Math.floor(ms % 6e4 / 1e3)}s`;
+    return `${Math.floor(ms / 36e5)}h ${Math.floor(ms % 36e5 / 6e4)}m`;
+  }
+};
+_MySQLProvider.TX_TIMEOUT_MS = 5 * 60 * 1e3;
+var MySQLProvider = _MySQLProvider;
+
+exports.MySQLProvider = MySQLProvider;
+//# sourceMappingURL=mysql-Y3MSA5QY.js.map
+//# sourceMappingURL=mysql-Y3MSA5QY.js.map