@libredb/studio 0.9.7 → 0.9.13

package/dist/mssql-PMOU4D36.js

@@ -0,0 +1,916 @@
+'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 mssql = require('mssql');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var mssql__default = /*#__PURE__*/_interopDefault(mssql);
+
+var MSSQLProvider = class extends chunkKV356UXJ_js.SQLBaseProvider {
+  constructor(config, options = {}) {
+    super(config, options);
+    this.pool = null;
+    // Transaction support
+    this.txTransaction = null;
+    this.txActive = false;
+    // Track running requests for cancellation
+    this.runningRequests = /* @__PURE__ */ new Map();
+    this.validate();
+  }
+  // ============================================================================
+  // Provider Metadata
+  // ============================================================================
+  getCapabilities() {
+    return chunkQ6LRDBK7_js.__spreadProps(chunkQ6LRDBK7_js.__spreadValues({}, super.getCapabilities()), {
+      defaultPort: 1433,
+      supportsExplain: true,
+      supportsConnectionString: true,
+      maintenanceOperations: ["analyze", "check", "optimize", "kill"]
+    });
+  }
+  getLabels() {
+    return chunkQ6LRDBK7_js.__spreadProps(chunkQ6LRDBK7_js.__spreadValues({}, super.getLabels()), {
+      analyzeAction: "Update Statistics",
+      vacuumAction: "Rebuild Indexes",
+      analyzeGlobalLabel: "Update Stats",
+      analyzeGlobalTitle: "Update Statistics",
+      analyzeGlobalDesc: "Updates query optimizer statistics for all tables to improve query performance.",
+      vacuumGlobalLabel: "Rebuild Indexes",
+      vacuumGlobalTitle: "Rebuild All Indexes",
+      vacuumGlobalDesc: "Rebuilds all indexes to reclaim space and reduce fragmentation."
+    });
+  }
+  // ============================================================================
+  // SQL Dialect Overrides
+  // ============================================================================
+  escapeIdentifier(identifier) {
+    const escaped = identifier.replace(/\]/g, "]]");
+    return `[${escaped}]`;
+  }
+  // ============================================================================
+  // Validation
+  // ============================================================================
+  validate() {
+    super.validate();
+    if (!this.config.connectionString) {
+      if (!this.config.host) {
+        throw new chunkJZO5KRZN_js.DatabaseConfigError("Host is required for SQL Server", "mssql");
+      }
+      if (!this.config.database) {
+        throw new chunkJZO5KRZN_js.DatabaseConfigError("Database name is required for SQL Server", "mssql");
+      }
+    }
+  }
+  // ============================================================================
+  // Connection Management
+  // ============================================================================
+  buildConfig() {
+    const host = this.config.host || "localhost";
+    const port = this.config.port || 1433;
+    const isAzure = host.endsWith(".database.windows.net");
+    const sslConfig = this.config.ssl;
+    let encrypt = true;
+    let trustServerCertificate = !isAzure;
+    if (sslConfig) {
+      if (sslConfig.mode === "disable") {
+        encrypt = false;
+      } else {
+        encrypt = true;
+        trustServerCertificate = sslConfig.mode === "require";
+      }
+    }
+    const config = {
+      user: this.config.user,
+      password: this.config.password,
+      server: host,
+      port,
+      database: this.config.database,
+      pool: {
+        min: this.poolConfig.min,
+        max: this.poolConfig.max,
+        idleTimeoutMillis: this.poolConfig.idleTimeout
+      },
+      options: {
+        encrypt,
+        trustServerCertificate,
+        connectTimeout: this.poolConfig.acquireTimeout,
+        requestTimeout: this.queryTimeout
+      }
+    };
+    if (this.config.instanceName) {
+      config.options = chunkQ6LRDBK7_js.__spreadProps(chunkQ6LRDBK7_js.__spreadValues({}, config.options), {
+        instanceName: this.config.instanceName
+      });
+      delete config.port;
+    }
+    return config;
+  }
+  async connect() {
+    if (this.pool) {
+      return;
+    }
+    try {
+      const config = this.buildConfig();
+      this.pool = new mssql__default.default.ConnectionPool(config);
+      await this.pool.connect();
+      await this.pool.request().query("SELECT 1 AS test");
+      this.setConnected(true);
+    } catch (error) {
+      this.setError(error instanceof Error ? error : new Error(String(error)));
+      throw new chunkJZO5KRZN_js.ConnectionError(
+        `Failed to connect to SQL Server: ${error instanceof Error ? error.message : error}`,
+        "mssql",
+        this.config.host,
+        this.config.port
+      );
+    }
+  }
+  async disconnect() {
+    if (this.pool) {
+      try {
+        await this.pool.close();
+      } catch (e) {
+      }
+      this.pool = null;
+      this.setConnected(false);
+    }
+  }
+  // ============================================================================
+  // Query Execution
+  // ============================================================================
+  async query(sql, params, queryId) {
+    this.ensureConnected();
+    return this.trackQuery(async () => {
+      var _a, _b;
+      const { result, executionTime } = await this.measureExecution(async () => {
+        try {
+          const request = this.pool.request();
+          if (queryId) {
+            this.runningRequests.set(queryId, request);
+          }
+          if (params && params.length > 0) {
+            params.forEach((p, i) => {
+              request.input(`p${i + 1}`, p);
+            });
+          }
+          const res = await request.query(sql);
+          return res;
+        } catch (error) {
+          throw chunkJZO5KRZN_js.mapDatabaseError(error, "mssql", sql);
+        } finally {
+          if (queryId) this.runningRequests.delete(queryId);
+        }
+      });
+      const recordset = result.recordset || [];
+      const fields = recordset.columns ? Object.keys(recordset.columns) : recordset.length > 0 ? Object.keys(recordset[0]) : [];
+      return {
+        rows: recordset,
+        fields,
+        rowCount: (_b = (_a = result.rowsAffected) == null ? void 0 : _a[0]) != null ? _b : recordset.length,
+        executionTime
+      };
+    });
+  }
+  async cancelQuery(queryId) {
+    const request = this.runningRequests.get(queryId);
+    if (!request) return false;
+    try {
+      request.cancel();
+      return true;
+    } catch (error) {
+      console.error("[MSSQL] Failed to cancel query:", error);
+      return false;
+    }
+  }
+  // ============================================================================
+  // Query Preparation (MSSQL TOP / OFFSET FETCH)
+  // ============================================================================
+  prepareQuery(query, options = {}) {
+    const { limit = chunkKV356UXJ_js.DEFAULT_QUERY_LIMIT, offset = 0, unlimited = false } = options;
+    const effectiveLimit = unlimited ? chunkKV356UXJ_js.MAX_UNLIMITED_ROWS : limit;
+    const queryInfo = chunkKV356UXJ_js.analyzeQuery(query);
+    if (queryInfo.type === "SELECT" && !queryInfo.hasLimit) {
+      let modifiedSql = query.trim();
+      const hasSemicolon = modifiedSql.endsWith(";");
+      if (hasSemicolon) modifiedSql = modifiedSql.slice(0, -1).trim();
+      if (offset > 0) {
+        const hasOrderBy = /\bORDER\s+BY\b/i.test(modifiedSql);
+        if (!hasOrderBy) {
+          modifiedSql = `${modifiedSql} ORDER BY (SELECT NULL)`;
+        }
+        modifiedSql = `${modifiedSql} OFFSET ${offset} ROWS FETCH NEXT ${effectiveLimit} ROWS ONLY`;
+      } else {
+        modifiedSql = modifiedSql.replace(
+          /^(\s*SELECT\s+)(DISTINCT\s+)?/i,
+          `$1$2TOP ${effectiveLimit} `
+        );
+      }
+      if (hasSemicolon) modifiedSql += ";";
+      return {
+        query: modifiedSql,
+        wasLimited: true,
+        limit: effectiveLimit,
+        offset
+      };
+    }
+    return { query, wasLimited: false, limit: effectiveLimit, offset };
+  }
+  // ============================================================================
+  // Transaction Support
+  // ============================================================================
+  async beginTransaction() {
+    this.ensureConnected();
+    if (this.txActive) throw new chunkJZO5KRZN_js.QueryError("Transaction already active", "mssql");
+    this.txTransaction = new mssql__default.default.Transaction(this.pool);
+    await this.txTransaction.begin();
+    this.txActive = true;
+  }
+  async commitTransaction() {
+    if (!this.txTransaction || !this.txActive) throw new chunkJZO5KRZN_js.QueryError("No active transaction", "mssql");
+    try {
+      await this.txTransaction.commit();
+    } finally {
+      this.txTransaction = null;
+      this.txActive = false;
+    }
+  }
+  async rollbackTransaction() {
+    if (!this.txTransaction || !this.txActive) throw new chunkJZO5KRZN_js.QueryError("No active transaction", "mssql");
+    try {
+      await this.txTransaction.rollback();
+    } finally {
+      this.txTransaction = null;
+      this.txActive = false;
+    }
+  }
+  isInTransaction() {
+    return this.txActive;
+  }
+  async queryInTransaction(sql, params) {
+    if (!this.txTransaction || !this.txActive) throw new chunkJZO5KRZN_js.QueryError("No active transaction", "mssql");
+    return this.trackQuery(async () => {
+      var _a, _b;
+      const { result, executionTime } = await this.measureExecution(async () => {
+        try {
+          const request = new mssql__default.default.Request(this.txTransaction);
+          if (params && params.length > 0) {
+            params.forEach((p, i) => {
+              request.input(`p${i + 1}`, p);
+            });
+          }
+          return await request.query(sql);
+        } catch (error) {
+          throw chunkJZO5KRZN_js.mapDatabaseError(error, "mssql", sql);
+        }
+      });
+      const recordset = result.recordset || [];
+      const fields = recordset.length > 0 ? Object.keys(recordset[0]) : [];
+      return {
+        rows: recordset,
+        fields,
+        rowCount: (_b = (_a = result.rowsAffected) == null ? void 0 : _a[0]) != null ? _b : recordset.length,
+        executionTime
+      };
+    });
+  }
+  // ============================================================================
+  // Schema Operations
+  // ============================================================================
+  async getSchema() {
+    this.ensureConnected();
+    try {
+      const tablesRes = await this.pool.request().query(`
+        SELECT
+          s.name AS schema_name,
+          t.name AS table_name,
+          SUM(p.rows) AS row_count
+        FROM sys.tables t
+        JOIN sys.schemas s ON t.schema_id = s.schema_id
+        LEFT JOIN sys.partitions p ON t.object_id = p.object_id AND p.index_id IN (0, 1)
+        WHERE t.type = 'U'
+        GROUP BY s.name, t.name
+        ORDER BY s.name, t.name
+      `);
+      const tables = tablesRes.recordset || [];
+      const colsRes = await this.pool.request().query(`
+        SELECT
+          TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, DATA_TYPE,
+          IS_NULLABLE, COLUMN_DEFAULT, ORDINAL_POSITION
+        FROM INFORMATION_SCHEMA.COLUMNS
+        ORDER BY TABLE_SCHEMA, TABLE_NAME, ORDINAL_POSITION
+      `);
+      const allCols = colsRes.recordset || [];
+      const pkRes = await this.pool.request().query(`
+        SELECT
+          s.name AS schema_name,
+          t.name AS table_name,
+          c.name AS column_name
+        FROM sys.indexes i
+        JOIN sys.index_columns ic ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+        JOIN sys.columns c ON ic.object_id = c.object_id AND ic.column_id = c.column_id
+        JOIN sys.tables t ON i.object_id = t.object_id
+        JOIN sys.schemas s ON t.schema_id = s.schema_id
+        WHERE i.is_primary_key = 1
+      `);
+      const pkMap = /* @__PURE__ */ new Map();
+      for (const row of pkRes.recordset || []) {
+        const key = `${row.schema_name}.${row.table_name}`;
+        if (!pkMap.has(key)) pkMap.set(key, /* @__PURE__ */ new Set());
+        pkMap.get(key).add(row.column_name);
+      }
+      const fkRes = await this.pool.request().query(`
+        SELECT
+          OBJECT_SCHEMA_NAME(fk.parent_object_id) AS schema_name,
+          OBJECT_NAME(fk.parent_object_id) AS table_name,
+          COL_NAME(fkc.parent_object_id, fkc.parent_column_id) AS column_name,
+          OBJECT_NAME(fk.referenced_object_id) AS ref_table,
+          COL_NAME(fkc.referenced_object_id, fkc.referenced_column_id) AS ref_column
+        FROM sys.foreign_keys fk
+        JOIN sys.foreign_key_columns fkc ON fk.object_id = fkc.constraint_object_id
+      `);
+      const fksByTable = /* @__PURE__ */ new Map();
+      for (const row of fkRes.recordset || []) {
+        const key = `${row.schema_name}.${row.table_name}`;
+        if (!fksByTable.has(key)) fksByTable.set(key, []);
+        fksByTable.get(key).push({
+          columnName: row.column_name,
+          referencedTable: row.ref_table,
+          referencedColumn: row.ref_column
+        });
+      }
+      const idxRes = await this.pool.request().query(`
+        SELECT
+          s.name AS schema_name,
+          t.name AS table_name,
+          i.name AS index_name,
+          i.is_unique,
+          c.name AS column_name,
+          ic.key_ordinal
+        FROM sys.indexes i
+        JOIN sys.index_columns ic ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+        JOIN sys.columns c ON ic.object_id = c.object_id AND ic.column_id = c.column_id
+        JOIN sys.tables t ON i.object_id = t.object_id
+        JOIN sys.schemas s ON t.schema_id = s.schema_id
+        WHERE i.name IS NOT NULL AND i.is_primary_key = 0
+        ORDER BY s.name, t.name, i.name, ic.key_ordinal
+      `);
+      const idxByTable = /* @__PURE__ */ new Map();
+      for (const row of idxRes.recordset || []) {
+        const key = `${row.schema_name}.${row.table_name}`;
+        if (!idxByTable.has(key)) idxByTable.set(key, /* @__PURE__ */ new Map());
+        const tableIdxs = idxByTable.get(key);
+        if (!tableIdxs.has(row.index_name)) {
+          tableIdxs.set(row.index_name, { unique: row.is_unique, columns: [] });
+        }
+        tableIdxs.get(row.index_name).columns.push(row.column_name);
+      }
+      const colsByTable = /* @__PURE__ */ new Map();
+      for (const c of allCols) {
+        const key = `${c.TABLE_SCHEMA}.${c.TABLE_NAME}`;
+        if (!colsByTable.has(key)) colsByTable.set(key, []);
+        colsByTable.get(key).push(c);
+      }
+      return tables.map((t) => {
+        const schemaName = String(t.schema_name || "dbo");
+        const tableName = String(t.table_name || "");
+        const key = `${schemaName}.${tableName}`;
+        const displayName = schemaName === "dbo" ? tableName : `${schemaName}.${tableName}`;
+        const pks = pkMap.get(key) || /* @__PURE__ */ new Set();
+        const columns = (colsByTable.get(key) || []).map((c) => ({
+          name: String(c.COLUMN_NAME || ""),
+          type: String(c.DATA_TYPE || ""),
+          nullable: String(c.IS_NULLABLE || "") === "YES",
+          isPrimary: pks.has(String(c.COLUMN_NAME || "")),
+          defaultValue: c.COLUMN_DEFAULT ? String(c.COLUMN_DEFAULT) : void 0
+        }));
+        const foreignKeys = fksByTable.get(key) || [];
+        const tableIdxs = idxByTable.get(key) || /* @__PURE__ */ new Map();
+        const indexes = Array.from(tableIdxs.entries()).map(([name, info]) => ({
+          name,
+          columns: info.columns,
+          unique: info.unique
+        }));
+        return {
+          name: displayName,
+          rowCount: Number(t.row_count || 0),
+          columns,
+          indexes,
+          foreignKeys
+        };
+      });
+    } catch (error) {
+      throw chunkJZO5KRZN_js.mapDatabaseError(error, "mssql");
+    }
+  }
+  // ============================================================================
+  // Health & Monitoring
+  // ============================================================================
+  async getHealth() {
+    var _a, _b, _c;
+    this.ensureConnected();
+    try {
+      let activeConnections = 0;
+      let databaseSize = "N/A";
+      let cacheHitRatio = "N/A";
+      const slowQueries = [];
+      const activeSessions = [];
+      try {
+        const connRes = await this.pool.request().query(
+          `SELECT COUNT(*) AS cnt FROM sys.dm_exec_sessions WHERE is_user_process = 1`
+        );
+        activeConnections = ((_a = connRes.recordset[0]) == null ? void 0 : _a.cnt) || 0;
+      } catch (e) {
+      }
+      try {
+        const sizeRes = await this.pool.request().query(`
+          SELECT
+            CAST(SUM(size) * 8.0 / 1024 AS DECIMAL(10,2)) AS size_mb
+          FROM sys.database_files
+        `);
+        const mb = Number(((_b = sizeRes.recordset[0]) == null ? void 0 : _b.size_mb) || 0);
+        databaseSize = mb > 1024 ? `${(mb / 1024).toFixed(2)} GB` : `${mb} MB`;
+      } catch (e) {
+      }
+      try {
+        const cacheRes = await this.pool.request().query(`
+          SELECT
+            CAST(
+              (a.cntr_value * 1.0 / NULLIF(b.cntr_value, 0)) * 100
+              AS DECIMAL(5,2)
+            ) AS hit_ratio
+          FROM sys.dm_os_performance_counters a
+          CROSS JOIN sys.dm_os_performance_counters b
+          WHERE a.counter_name = 'Buffer cache hit ratio'
+            AND a.object_name LIKE '%Buffer Manager%'
+            AND b.counter_name = 'Buffer cache hit ratio base'
+            AND b.object_name LIKE '%Buffer Manager%'
+        `);
+        cacheHitRatio = `${((_c = cacheRes.recordset[0]) == null ? void 0 : _c.hit_ratio) || 0}%`;
+      } catch (e) {
+      }
+      try {
+        const slowRes = await this.pool.request().query(`
+          SELECT TOP 5
+            SUBSTRING(qt.text, 1, 100) AS query,
+            qs.execution_count AS calls,
+            CAST(qs.total_elapsed_time / NULLIF(qs.execution_count, 0) / 1000.0 AS DECIMAL(10,2)) AS avg_time_ms
+          FROM sys.dm_exec_query_stats qs
+          CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle) qt
+          WHERE qs.execution_count > 0
+          ORDER BY qs.total_elapsed_time DESC
+        `);
+        for (const row of slowRes.recordset || []) {
+          slowQueries.push({
+            query: String(row.query || ""),
+            calls: Number(row.calls || 0),
+            avgTime: `${row.avg_time_ms}ms`
+          });
+        }
+      } catch (e) {
+      }
+      try {
+        const sessRes = await this.pool.request().query(`
+          SELECT TOP 10
+            s.session_id AS pid,
+            s.login_name AS [user],
+            DB_NAME(s.database_id) AS [database],
+            s.status AS state,
+            ISNULL(SUBSTRING(t.text, 1, 100), '') AS query,
+            ISNULL(CAST(DATEDIFF(SECOND, s.last_request_start_time, GETDATE()) AS VARCHAR) + 's', 'N/A') AS duration
+          FROM sys.dm_exec_sessions s
+          LEFT JOIN sys.dm_exec_requests r ON s.session_id = r.session_id
+          OUTER APPLY sys.dm_exec_sql_text(r.sql_handle) t
+          WHERE s.is_user_process = 1
+          ORDER BY s.last_request_start_time DESC
+        `);
+        for (const row of sessRes.recordset || []) {
+          activeSessions.push({
+            pid: Number(row.pid || 0),
+            user: String(row.user || "unknown"),
+            database: String(row.database || ""),
+            state: String(row.state || "unknown"),
+            query: String(row.query || ""),
+            duration: String(row.duration || "N/A")
+          });
+        }
+      } catch (e) {
+      }
+      return { activeConnections, databaseSize, cacheHitRatio, slowQueries, activeSessions };
+    } catch (error) {
+      throw chunkJZO5KRZN_js.mapDatabaseError(error, "mssql");
+    }
+  }
+  // ============================================================================
+  // Maintenance Operations
+  // ============================================================================
+  async runMaintenance(type, target) {
+    this.ensureConnected();
+    const { result, executionTime } = await this.measureExecution(async () => {
+      try {
+        let sql = "";
+        switch (type) {
+          case "analyze":
+            if (target) {
+              sql = `UPDATE STATISTICS [${target.replace(/\]/g, "]]")}]`;
+            } else {
+              sql = `EXEC sp_updatestats`;
+            }
+            break;
+          case "check":
+            sql = `DBCC CHECKDB WITH NO_INFOMSGS`;
+            break;
+          case "optimize":
+            if (target) {
+              sql = `ALTER INDEX ALL ON [${target.replace(/\]/g, "]]")}] REBUILD`;
+            } else {
+              sql = `
+                DECLARE @sql NVARCHAR(MAX) = '';
+                SELECT @sql = @sql + 'ALTER INDEX ALL ON [' + s.name + '].[' + t.name + '] REBUILD;'
+                FROM sys.tables t
+                JOIN sys.schemas s ON t.schema_id = s.schema_id
+                WHERE t.type = 'U';
+                EXEC sp_executesql @sql;
+              `;
+            }
+            break;
+          case "kill":
+            if (!target) {
+              throw new chunkJZO5KRZN_js.QueryError("Target SPID is required for kill operation", "mssql");
+            }
+            const spid = parseInt(target, 10);
+            if (isNaN(spid)) {
+              throw new chunkJZO5KRZN_js.QueryError("Invalid SPID for kill operation", "mssql");
+            }
+            sql = `KILL ${spid}`;
+            break;
+          default:
+            throw new chunkJZO5KRZN_js.QueryError(`Unsupported maintenance type: ${type}`, "mssql");
+        }
+        await this.pool.request().query(sql);
+        return { success: true };
+      } catch (error) {
+        throw chunkJZO5KRZN_js.mapDatabaseError(error, "mssql");
+      }
+    });
+    return {
+      success: result.success,
+      executionTime,
+      message: `${type.toUpperCase()} completed successfully`
+    };
+  }
+  // ============================================================================
+  // Pool Statistics
+  // ============================================================================
+  getPoolStats() {
+    if (!this.pool) {
+      return { total: 0, idle: 0, active: 0, waiting: 0 };
+    }
+    return {
+      total: this.pool.size,
+      idle: this.pool.available,
+      active: this.pool.size - this.pool.available,
+      waiting: this.pool.pending
+    };
+  }
+  // ============================================================================
+  // Extended Monitoring Methods
+  // ============================================================================
+  async getOverview() {
+    var _a, _b, _c, _d, _e, _f;
+    this.ensureConnected();
+    try {
+      let version = "SQL Server";
+      let uptime = "N/A";
+      let startTime;
+      let activeConnections = 0;
+      let maxConnections = 0;
+      let databaseSize = "0 bytes";
+      let databaseSizeBytes = 0;
+      let tableCount = 0;
+      let indexCount = 0;
+      try {
+        const vRes = await this.pool.request().query(`SELECT @@VERSION AS version`);
+        version = String(((_a = vRes.recordset[0]) == null ? void 0 : _a.version) || "").split("\n")[0];
+      } catch (e) {
+      }
+      try {
+        const upRes = await this.pool.request().query(`
+          SELECT sqlserver_start_time,
+                 DATEDIFF(SECOND, sqlserver_start_time, GETDATE()) AS uptime_seconds
+          FROM sys.dm_os_sys_info
+        `);
+        if (upRes.recordset[0]) {
+          const secs = Number(upRes.recordset[0].uptime_seconds || 0);
+          const days = Math.floor(secs / 86400);
+          const hours = Math.floor(secs % 86400 / 3600);
+          const minutes = Math.floor(secs % 3600 / 60);
+          uptime = days > 0 ? `${days}d ${hours}h ${minutes}m` : hours > 0 ? `${hours}h ${minutes}m` : `${minutes}m`;
+          startTime = new Date(upRes.recordset[0].sqlserver_start_time);
+        }
+      } catch (e) {
+      }
+      try {
+        const connRes = await this.pool.request().query(`
+          SELECT
+            COUNT(*) AS active_connections,
+            (SELECT CAST(value_in_use AS INT) FROM sys.configurations WHERE name = 'user connections') AS max_connections
+          FROM sys.dm_exec_sessions
+          WHERE is_user_process = 1
+        `);
+        activeConnections = Number(((_b = connRes.recordset[0]) == null ? void 0 : _b.active_connections) || 0);
+        maxConnections = Number(((_c = connRes.recordset[0]) == null ? void 0 : _c.max_connections) || 32767);
+        if (maxConnections === 0) maxConnections = 32767;
+      } catch (e) {
+      }
+      try {
+        const sizeRes = await this.pool.request().query(`
+          SELECT SUM(CAST(size AS BIGINT)) * 8 * 1024 AS size_bytes FROM sys.database_files
+        `);
+        databaseSizeBytes = Number(((_d = sizeRes.recordset[0]) == null ? void 0 : _d.size_bytes) || 0);
+        databaseSize = chunkPTIRB2JO_js.formatBytes(databaseSizeBytes);
+      } catch (e) {
+      }
+      try {
+        const cntRes = await this.pool.request().query(`
+          SELECT
+            (SELECT COUNT(*) FROM sys.tables WHERE type = 'U') AS table_count,
+            (SELECT COUNT(*) FROM sys.indexes WHERE object_id IN (SELECT object_id FROM sys.tables WHERE type = 'U') AND name IS NOT NULL) AS index_count
+        `);
+        tableCount = Number(((_e = cntRes.recordset[0]) == null ? void 0 : _e.table_count) || 0);
+        indexCount = Number(((_f = cntRes.recordset[0]) == null ? void 0 : _f.index_count) || 0);
+      } catch (e) {
+      }
+      return {
+        version,
+        uptime,
+        startTime,
+        activeConnections,
+        maxConnections,
+        databaseSize,
+        databaseSizeBytes,
+        tableCount,
+        indexCount
+      };
+    } catch (error) {
+      throw chunkJZO5KRZN_js.mapDatabaseError(error, "mssql");
+    }
+  }
+  async getPerformanceMetrics() {
+    var _a;
+    this.ensureConnected();
+    try {
+      let cacheHitRatio = 100;
+      let bufferPoolUsage;
+      try {
+        const cacheRes = await this.pool.request().query(`
+          SELECT
+            CAST(
+              (a.cntr_value * 1.0 / NULLIF(b.cntr_value, 0)) * 100
+              AS DECIMAL(5,2)
+            ) AS hit_ratio
+          FROM sys.dm_os_performance_counters a
+          CROSS JOIN sys.dm_os_performance_counters b
+          WHERE a.counter_name = 'Buffer cache hit ratio'
+            AND a.object_name LIKE '%Buffer Manager%'
+            AND b.counter_name = 'Buffer cache hit ratio base'
+            AND b.object_name LIKE '%Buffer Manager%'
+        `);
+        cacheHitRatio = Number(((_a = cacheRes.recordset[0]) == null ? void 0 : _a.hit_ratio) || 100);
+        bufferPoolUsage = cacheHitRatio;
+      } catch (e) {
+      }
+      return {
+        cacheHitRatio,
+        bufferPoolUsage
+      };
+    } catch (error) {
+      throw chunkJZO5KRZN_js.mapDatabaseError(error, "mssql");
+    }
+  }
+  async getSlowQueries(options) {
+    var _a;
+    this.ensureConnected();
+    const limit = (_a = options == null ? void 0 : options.limit) != null ? _a : 10;
+    try {
+      const res = await this.pool.request().query(`
+        SELECT TOP ${limit}
+          CAST(qs.query_hash AS VARCHAR(50)) AS query_id,
+          SUBSTRING(qt.text, 1, 500) AS query,
+          qs.execution_count AS calls,
+          CAST(qs.total_elapsed_time / 1000.0 AS DECIMAL(18,2)) AS total_time,
+          CAST(qs.total_elapsed_time / NULLIF(qs.execution_count, 0) / 1000.0 AS DECIMAL(18,2)) AS avg_time,
+          CAST(qs.min_elapsed_time / 1000.0 AS DECIMAL(18,2)) AS min_time,
+          CAST(qs.max_elapsed_time / 1000.0 AS DECIMAL(18,2)) AS max_time,
+          qs.total_rows AS row_cnt,
+          qs.total_logical_reads AS logical_reads,
+          qs.total_physical_reads AS physical_reads
+        FROM sys.dm_exec_query_stats qs
+        CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle) qt
+        WHERE qs.execution_count > 0
+        ORDER BY qs.total_elapsed_time DESC
+      `);
+      return (res.recordset || []).map((r) => ({
+        queryId: String(r.query_id || ""),
+        query: String(r.query || ""),
+        calls: Number(r.calls || 0),
+        totalTime: Number(r.total_time || 0),
+        avgTime: Number(r.avg_time || 0),
+        minTime: Number(r.min_time || 0),
+        maxTime: Number(r.max_time || 0),
+        rows: Number(r.row_cnt || 0),
+        sharedBlksHit: Number(r.logical_reads || 0),
+        sharedBlksRead: Number(r.physical_reads || 0)
+      }));
+    } catch (e) {
+      return [];
+    }
+  }
+  async getActiveSessions(options) {
+    var _a;
+    this.ensureConnected();
+    const limit = (_a = options == null ? void 0 : options.limit) != null ? _a : 50;
+    try {
+      const res = await this.pool.request().query(`
+        SELECT TOP ${limit}
+          s.session_id AS pid,
+          s.login_name AS [user],
+          DB_NAME(s.database_id) AS [database],
+          s.program_name AS application_name,
+          s.host_name AS client_addr,
+          s.status AS state,
+          ISNULL(SUBSTRING(t.text, 1, 500), '') AS query,
+          s.last_request_start_time AS query_start,
+          ISNULL(CAST(DATEDIFF(SECOND, s.last_request_start_time, GETDATE()) AS VARCHAR) + 's', 'N/A') AS duration,
+          ISNULL(DATEDIFF(MILLISECOND, s.last_request_start_time, GETDATE()), 0) AS duration_ms,
+          r.wait_type,
+          r.last_wait_type,
+          CASE WHEN r.blocking_session_id > 0 THEN 1 ELSE 0 END AS is_blocked
+        FROM sys.dm_exec_sessions s
+        LEFT JOIN sys.dm_exec_requests r ON s.session_id = r.session_id
+        OUTER APPLY sys.dm_exec_sql_text(r.sql_handle) t
+        WHERE s.is_user_process = 1
+        ORDER BY
+          CASE s.status WHEN 'running' THEN 0 WHEN 'sleeping' THEN 1 ELSE 2 END,
+          s.last_request_start_time DESC
+      `);
+      return (res.recordset || []).map((r) => ({
+        pid: Number(r.pid || 0),
+        user: String(r.user || "unknown"),
+        database: String(r.database || ""),
+        applicationName: r.application_name ? String(r.application_name) : void 0,
+        clientAddr: r.client_addr ? String(r.client_addr) : void 0,
+        state: String(r.state || "unknown"),
+        query: String(r.query || ""),
+        queryStart: r.query_start ? new Date(String(r.query_start)) : void 0,
+        duration: String(r.duration || "N/A"),
+        durationMs: Number(r.duration_ms || 0),
+        waitEventType: r.wait_type ? String(r.wait_type) : void 0,
+        waitEvent: r.last_wait_type ? String(r.last_wait_type) : void 0,
+        blocked: Boolean(r.is_blocked)
+      }));
+    } catch (e) {
+      return [];
+    }
+  }
+  async getTableStats() {
+    this.ensureConnected();
+    try {
+      const res = await this.pool.request().query(`
+        SELECT
+          s.name AS schema_name,
+          t.name AS table_name,
+          SUM(p.rows) AS row_count,
+          SUM(a.total_pages) * 8 * 1024 AS total_size_bytes,
+          SUM(a.used_pages) * 8 * 1024 AS used_size_bytes,
+          SUM(CASE WHEN i.type IN (0, 1) THEN a.total_pages ELSE 0 END) * 8 * 1024 AS table_size_bytes,
+          SUM(CASE WHEN i.type > 1 THEN a.total_pages ELSE 0 END) * 8 * 1024 AS index_size_bytes,
+          STATS_DATE(t.object_id, 1) AS last_stats_update
+        FROM sys.tables t
+        JOIN sys.schemas s ON t.schema_id = s.schema_id
+        JOIN sys.indexes i ON t.object_id = i.object_id
+        JOIN sys.partitions p ON i.object_id = p.object_id AND i.index_id = p.index_id
+        JOIN sys.allocation_units a ON p.partition_id = a.container_id
+        WHERE t.type = 'U'
+        GROUP BY s.name, t.name, t.object_id
+        ORDER BY SUM(a.total_pages) DESC
+      `);
+      return (res.recordset || []).map((r) => {
+        const tableSizeBytes = Number(r.table_size_bytes || 0);
+        const indexSizeBytes = Number(r.index_size_bytes || 0);
+        const totalSizeBytes = Number(r.total_size_bytes || 0);
+        return {
+          schemaName: String(r.schema_name || "dbo"),
+          tableName: String(r.table_name || ""),
+          rowCount: Number(r.row_count || 0),
+          tableSize: chunkPTIRB2JO_js.formatBytes(tableSizeBytes),
+          tableSizeBytes,
+          indexSize: chunkPTIRB2JO_js.formatBytes(indexSizeBytes),
+          indexSizeBytes,
+          totalSize: chunkPTIRB2JO_js.formatBytes(totalSizeBytes),
+          totalSizeBytes,
+          lastAnalyze: r.last_stats_update ? new Date(String(r.last_stats_update)) : void 0
+        };
+      });
+    } catch (e) {
+      return [];
+    }
+  }
+  async getIndexStats() {
+    this.ensureConnected();
+    try {
+      const res = await this.pool.request().query(`
+        SELECT
+          s.name AS schema_name,
+          t.name AS table_name,
+          i.name AS index_name,
+          i.type_desc AS index_type,
+          i.is_unique,
+          i.is_primary_key,
+          SUM(a.total_pages) * 8 * 1024 AS index_size_bytes,
+          ISNULL(u.user_seeks + u.user_scans + u.user_lookups, 0) AS scans
+        FROM sys.indexes i
+        JOIN sys.tables t ON i.object_id = t.object_id
+        JOIN sys.schemas s ON t.schema_id = s.schema_id
+        LEFT JOIN sys.partitions p ON i.object_id = p.object_id AND i.index_id = p.index_id
+        LEFT JOIN sys.allocation_units a ON p.partition_id = a.container_id
+        LEFT JOIN sys.dm_db_index_usage_stats u ON i.object_id = u.object_id AND i.index_id = u.index_id AND u.database_id = DB_ID()
+        WHERE i.name IS NOT NULL AND t.type = 'U'
+        GROUP BY s.name, t.name, i.name, i.type_desc, i.is_unique, i.is_primary_key,
+                 i.object_id, i.index_id, u.user_seeks, u.user_scans, u.user_lookups
+        ORDER BY SUM(a.total_pages) DESC
+      `);
+      const colRes = await this.pool.request().query(`
+        SELECT
+          s.name AS schema_name,
+          t.name AS table_name,
+          i.name AS index_name,
+          c.name AS column_name,
+          ic.key_ordinal
+        FROM sys.index_columns ic
+        JOIN sys.indexes i ON ic.object_id = i.object_id AND ic.index_id = i.index_id
+        JOIN sys.columns c ON ic.object_id = c.object_id AND ic.column_id = c.column_id
+        JOIN sys.tables t ON i.object_id = t.object_id
+        JOIN sys.schemas s ON t.schema_id = s.schema_id
+        WHERE i.name IS NOT NULL AND t.type = 'U'
+        ORDER BY s.name, t.name, i.name, ic.key_ordinal
+      `);
+      const colMap = /* @__PURE__ */ new Map();
+      for (const c of colRes.recordset || []) {
+        const key = `${c.schema_name}.${c.table_name}.${c.index_name}`;
+        if (!colMap.has(key)) colMap.set(key, []);
+        colMap.get(key).push(String(c.column_name));
+      }
+      return (res.recordset || []).map((r) => {
+        const key = `${r.schema_name}.${r.table_name}.${r.index_name}`;
+        const idxSizeBytes = Number(r.index_size_bytes || 0);
+        return {
+          schemaName: String(r.schema_name || "dbo"),
+          tableName: String(r.table_name || ""),
+          indexName: String(r.index_name || ""),
+          indexType: String(r.index_type || ""),
+          columns: colMap.get(key) || [],
+          isUnique: Boolean(r.is_unique),
+          isPrimary: Boolean(r.is_primary_key),
+          indexSize: chunkPTIRB2JO_js.formatBytes(idxSizeBytes),
+          indexSizeBytes: idxSizeBytes,
+          scans: Number(r.scans || 0)
+        };
+      });
+    } catch (e) {
+      return [];
+    }
+  }
+  async getStorageStats() {
+    this.ensureConnected();
+    try {
+      const res = await this.pool.request().query(`
+        SELECT
+          name,
+          physical_name AS location,
+          CAST(size AS BIGINT) * 8 * 1024 AS size_bytes,
+          type_desc
+        FROM sys.database_files
+        ORDER BY size DESC
+      `);
+      return (res.recordset || []).map((r) => {
+        const sizeBytes = Number(r.size_bytes || 0);
+        return {
+          name: String(r.name || ""),
+          location: String(r.location || ""),
+          size: chunkPTIRB2JO_js.formatBytes(sizeBytes),
+          sizeBytes
+        };
+      });
+    } catch (e) {
+      return [];
+    }
+  }
+};
+
+exports.MSSQLProvider = MSSQLProvider;
+//# sourceMappingURL=mssql-PMOU4D36.js.map
+//# sourceMappingURL=mssql-PMOU4D36.js.map