@libredb/studio 0.9.7 → 0.9.13

package/{src/lib/db/providers/sql/oracle.ts → dist/oracle-P2G7T4P4.mjs}

@@ -1,131 +1,73 @@
-/**
- * Oracle Database Provider
- * Full Oracle support with connection pooling (Thin mode - no Instant Client needed)
- */
-
+import { SQLBaseProvider, DEFAULT_QUERY_LIMIT, MAX_UNLIMITED_ROWS, analyzeQuery } from './chunk-R3POCJK6.mjs';
+import { formatBytes } from './chunk-QJP5FZRY.mjs';
+import { DatabaseConfigError, ConnectionError, mapDatabaseError, QueryError } from './chunk-CZVV3JJB.mjs';
+import { __spreadProps, __spreadValues } from './chunk-4LVB3K53.mjs';
 import oracledb from 'oracledb';
-import { SQLBaseProvider } from './sql-base';
-import {
-  type DatabaseConnection,
-  type TableSchema,
-  type QueryResult,
-  type HealthInfo,
-  type MaintenanceType,
-  type MaintenanceResult,
-  type ProviderOptions,
-  type ProviderCapabilities,
-  type ProviderLabels,
-  type SlowQuery,
-  type ActiveSession,
-  type DatabaseOverview,
-  type PerformanceMetrics,
-  type SlowQueryStats,
-  type ActiveSessionDetails,
-  type TableStats,
-  type IndexStats,
-  type StorageStats,
-  type PreparedQuery,
-  type QueryPrepareOptions,
-} from '../../types';
-import {
-  DatabaseConfigError,
-  ConnectionError,
-  QueryError,
-  mapDatabaseError,
-} from '../../errors';
-import { formatBytes } from '../../utils/pool-manager';
-import {
-  analyzeQuery,
-  DEFAULT_QUERY_LIMIT,
-  MAX_UNLIMITED_ROWS,
-} from '../../utils/query-limiter';
-
-// ============================================================================
-// Oracle Provider
-// ============================================================================
-
-export class OracleProvider extends SQLBaseProvider {
-  private pool: oracledb.Pool | null = null;
-
-  // Transaction support: dedicated connection held outside pool
-  private txConn: oracledb.Connection | null = null;
-  private txActive = false;
-
-  // Track running connections for cancellation
-  private runningConns = new Map<string, oracledb.Connection>();
 
-  constructor(config: DatabaseConnection, options: ProviderOptions = {}) {
+var OracleProvider = class extends SQLBaseProvider {
+  constructor(config, options = {}) {
     super(config, options);
-    // Use thin mode (pure JS, no Oracle Instant Client)
-    oracledb.initOracleClient = undefined as unknown as typeof oracledb.initOracleClient;
+    this.pool = null;
+    // Transaction support: dedicated connection held outside pool
+    this.txConn = null;
+    this.txActive = false;
+    // Track running connections for cancellation
+    this.runningConns = /* @__PURE__ */ new Map();
+    oracledb.initOracleClient = void 0;
     oracledb.outFormat = oracledb.OUT_FORMAT_OBJECT;
     oracledb.autoCommit = true;
     this.validate();
   }
-
   // ============================================================================
   // Provider Metadata
   // ============================================================================
-
-  public override getCapabilities(): ProviderCapabilities {
-    return {
-      ...super.getCapabilities(),
+  getCapabilities() {
+    return __spreadProps(__spreadValues({}, super.getCapabilities()), {
       defaultPort: 1521,
       supportsExplain: true,
       supportsConnectionString: true,
-      maintenanceOperations: ['analyze', 'optimize', 'kill'],
-    };
+      maintenanceOperations: ["analyze", "optimize", "kill"]
+    });
   }
-
-  public override getLabels(): ProviderLabels {
-    return {
-      ...super.getLabels(),
-      analyzeAction: 'Gather Statistics',
-      vacuumAction: 'Rebuild Indexes',
-      analyzeGlobalLabel: 'Gather Stats',
-      analyzeGlobalTitle: 'Gather Statistics',
-      analyzeGlobalDesc: 'Collects optimizer statistics for all tables to improve query performance.',
-      vacuumGlobalLabel: 'Rebuild Indexes',
-      vacuumGlobalTitle: 'Rebuild All Indexes',
-      vacuumGlobalDesc: 'Rebuilds all indexes to reclaim space and improve performance.',
-    };
+  getLabels() {
+    return __spreadProps(__spreadValues({}, super.getLabels()), {
+      analyzeAction: "Gather Statistics",
+      vacuumAction: "Rebuild Indexes",
+      analyzeGlobalLabel: "Gather Stats",
+      analyzeGlobalTitle: "Gather Statistics",
+      analyzeGlobalDesc: "Collects optimizer statistics for all tables to improve query performance.",
+      vacuumGlobalLabel: "Rebuild Indexes",
+      vacuumGlobalTitle: "Rebuild All Indexes",
+      vacuumGlobalDesc: "Rebuilds all indexes to reclaim space and improve performance."
+    });
   }
-
   // ============================================================================
   // Validation
   // ============================================================================
-
-  public validate(): void {
+  validate() {
     super.validate();
-
     if (!this.config.connectionString) {
       if (!this.config.host) {
-        throw new DatabaseConfigError('Host is required for Oracle', 'oracle');
+        throw new DatabaseConfigError("Host is required for Oracle", "oracle");
       }
     }
   }
-
   // ============================================================================
   // Connection Management
   // ============================================================================
-
-  private getConnectString(): string {
+  getConnectString() {
     if (this.config.connectionString) {
       return this.config.connectionString;
     }
-
-    const host = this.config.host || 'localhost';
+    const host = this.config.host || "localhost";
     const port = this.config.port || 1521;
-    const serviceName = this.config.serviceName || this.config.database || 'ORCL';
-
+    const serviceName = this.config.serviceName || this.config.database || "ORCL";
     return `${host}:${port}/${serviceName}`;
   }
-
-  public async connect(): Promise<void> {
+  async connect() {
     if (this.pool) {
       return;
     }
-
     try {
       this.pool = await oracledb.createPool({
         user: this.config.user,
@@ -133,143 +75,121 @@ export class OracleProvider extends SQLBaseProvider {
         connectString: this.getConnectString(),
         poolMin: this.poolConfig.min,
         poolMax: this.poolConfig.max,
-        poolTimeout: Math.floor(this.poolConfig.idleTimeout / 1000),
+        poolTimeout: Math.floor(this.poolConfig.idleTimeout / 1e3)
       });
-
-      // Test the connection
       const conn = await this.pool.getConnection();
       await conn.close();
-
       this.setConnected(true);
     } catch (error) {
       this.setError(error instanceof Error ? error : new Error(String(error)));
       throw new ConnectionError(
         `Failed to connect to Oracle: ${error instanceof Error ? error.message : error}`,
-        'oracle',
+        "oracle",
         this.config.host,
         this.config.port
       );
     }
   }
-
-  public async disconnect(): Promise<void> {
+  async disconnect() {
     if (this.pool) {
       try {
         await this.pool.close(0);
-      } catch {
-        // Force close on error
+      } catch (e) {
       }
       this.pool = null;
       this.setConnected(false);
     }
   }
-
   // ============================================================================
   // Query Execution
   // ============================================================================
-
-  public async query(sql: string, params?: unknown[], queryId?: string): Promise<QueryResult> {
+  async query(sql, params, queryId) {
     this.ensureConnected();
-
     return this.trackQuery(async () => {
+      var _a, _b;
       const { result, executionTime } = await this.measureExecution(async () => {
-        let conn: oracledb.Connection | undefined;
+        let conn;
         try {
-          conn = await this.pool!.getConnection();
-
+          conn = await this.pool.getConnection();
           if (queryId) {
             this.runningConns.set(queryId, conn);
           }
-
           const bindParams = params || [];
           const res = await conn.execute(sql, bindParams, {
             outFormat: oracledb.OUT_FORMAT_OBJECT,
-            autoCommit: true,
+            autoCommit: true
           });
-
           return res;
         } catch (error) {
-          throw mapDatabaseError(error, 'oracle', sql);
+          throw mapDatabaseError(error, "oracle", sql);
         } finally {
           if (queryId) this.runningConns.delete(queryId);
           if (conn) {
-            try { await conn.close(); } catch { /* ignore */ }
+            try {
+              await conn.close();
+            } catch (e) {
+            }
           }
         }
       });
-
-      const rows = (result.rows || []) as Record<string, unknown>[];
-      const fields = result.metaData?.map((m: { name: string }) => m.name) ?? [];
-
+      const rows = result.rows || [];
+      const fields = (_b = (_a = result.metaData) == null ? void 0 : _a.map((m) => m.name)) != null ? _b : [];
       return {
         rows,
         fields,
         rowCount: rows.length,
-        executionTime,
+        executionTime
       };
     });
   }
-
-  public async cancelQuery(queryId: string): Promise<boolean> {
+  async cancelQuery(queryId) {
     const conn = this.runningConns.get(queryId);
     if (!conn) return false;
-
     try {
       await conn.break();
       return true;
     } catch (error) {
-      console.error('[Oracle] Failed to cancel query:', error);
+      console.error("[Oracle] Failed to cancel query:", error);
       return false;
     }
   }
-
   // ============================================================================
   // Query Preparation (Oracle FETCH FIRST instead of LIMIT)
   // ============================================================================
-
-  public override prepareQuery(query: string, options: QueryPrepareOptions = {}): PreparedQuery {
+  prepareQuery(query, options = {}) {
     const { limit = DEFAULT_QUERY_LIMIT, offset = 0, unlimited = false } = options;
     const effectiveLimit = unlimited ? MAX_UNLIMITED_ROWS : limit;
     const queryInfo = analyzeQuery(query);
-
-    if (queryInfo.type === 'SELECT' && !queryInfo.hasLimit) {
+    if (queryInfo.type === "SELECT" && !queryInfo.hasLimit) {
       let modifiedSql = query.trim();
-      const hasSemicolon = modifiedSql.endsWith(';');
+      const hasSemicolon = modifiedSql.endsWith(";");
       if (hasSemicolon) modifiedSql = modifiedSql.slice(0, -1).trim();
-
       if (offset > 0) {
         modifiedSql = `${modifiedSql} OFFSET ${offset} ROWS FETCH NEXT ${effectiveLimit} ROWS ONLY`;
       } else {
         modifiedSql = `${modifiedSql} FETCH FIRST ${effectiveLimit} ROWS ONLY`;
       }
-
-      if (hasSemicolon) modifiedSql += ';';
-
+      if (hasSemicolon) modifiedSql += ";";
       return {
         query: modifiedSql,
         wasLimited: true,
         limit: effectiveLimit,
-        offset,
+        offset
       };
     }
-
     return { query, wasLimited: false, limit: effectiveLimit, offset };
   }
-
   // ============================================================================
   // Transaction Support
   // ============================================================================
-
-  public async beginTransaction(): Promise<void> {
+  async beginTransaction() {
     this.ensureConnected();
-    if (this.txActive) throw new QueryError('Transaction already active', 'oracle');
-    this.txConn = await this.pool!.getConnection();
-    // Oracle auto-starts a transaction; we just hold the connection
+    if (this.txActive) throw new QueryError("Transaction already active", "oracle");
+    this.txConn = await this.pool.getConnection();
     this.txActive = true;
   }
-
-  public async commitTransaction(): Promise<void> {
-    if (!this.txConn || !this.txActive) throw new QueryError('No active transaction', 'oracle');
+  async commitTransaction() {
+    if (!this.txConn || !this.txActive) throw new QueryError("No active transaction", "oracle");
     try {
       await this.txConn.commit();
     } finally {
@@ -278,9 +198,8 @@ export class OracleProvider extends SQLBaseProvider {
       this.txActive = false;
     }
   }
-
-  public async rollbackTransaction(): Promise<void> {
-    if (!this.txConn || !this.txActive) throw new QueryError('No active transaction', 'oracle');
+  async rollbackTransaction() {
+    if (!this.txConn || !this.txActive) throw new QueryError("No active transaction", "oracle");
     try {
       await this.txConn.rollback();
     } finally {
@@ -289,59 +208,49 @@ export class OracleProvider extends SQLBaseProvider {
       this.txActive = false;
     }
   }
-
-  public isInTransaction(): boolean {
+  isInTransaction() {
     return this.txActive;
   }
-
-  public async queryInTransaction(sql: string, params?: unknown[]): Promise<QueryResult> {
-    if (!this.txConn || !this.txActive) throw new QueryError('No active transaction', 'oracle');
-
+  async queryInTransaction(sql, params) {
+    if (!this.txConn || !this.txActive) throw new QueryError("No active transaction", "oracle");
     return this.trackQuery(async () => {
+      var _a, _b;
       const { result, executionTime } = await this.measureExecution(async () => {
         try {
-          return await this.txConn!.execute(sql, params || [], {
+          return await this.txConn.execute(sql, params || [], {
             outFormat: oracledb.OUT_FORMAT_OBJECT,
-            autoCommit: false,
+            autoCommit: false
           });
         } catch (error) {
-          throw mapDatabaseError(error, 'oracle', sql);
+          throw mapDatabaseError(error, "oracle", sql);
         }
       });
-
-      const rows = (result.rows || []) as Record<string, unknown>[];
-      const fields = result.metaData?.map((m: { name: string }) => m.name) ?? [];
-
+      const rows = result.rows || [];
+      const fields = (_b = (_a = result.metaData) == null ? void 0 : _a.map((m) => m.name)) != null ? _b : [];
       return {
         rows,
         fields,
         rowCount: rows.length,
-        executionTime,
+        executionTime
       };
     });
   }
-
   // ============================================================================
   // Schema Operations
   // ============================================================================
-
-  public async getSchema(): Promise<TableSchema[]> {
+  async getSchema() {
+    var _a;
     this.ensureConnected();
-
-    let conn: oracledb.Connection | undefined;
+    let conn;
     try {
-      conn = await this.pool!.getConnection();
-      const owner = this.config.user?.toUpperCase() || '';
-
-      // Get tables
+      conn = await this.pool.getConnection();
+      const owner = ((_a = this.config.user) == null ? void 0 : _a.toUpperCase()) || "";
       const tablesRes = await conn.execute(
         `SELECT TABLE_NAME, NUM_ROWS FROM ALL_TABLES WHERE OWNER = :1 ORDER BY TABLE_NAME`,
         [owner],
         { outFormat: oracledb.OUT_FORMAT_OBJECT }
       );
-      const tables = (tablesRes.rows || []) as Record<string, unknown>[];
-
-      // Get columns
+      const tables = tablesRes.rows || [];
       const colsRes = await conn.execute(
         `SELECT TABLE_NAME, COLUMN_NAME, DATA_TYPE, NULLABLE, DATA_DEFAULT, COLUMN_ID
          FROM ALL_TAB_COLUMNS WHERE OWNER = :1
@@ -349,9 +258,7 @@ export class OracleProvider extends SQLBaseProvider {
         [owner],
         { outFormat: oracledb.OUT_FORMAT_OBJECT }
       );
-      const allCols = (colsRes.rows || []) as Record<string, unknown>[];
-
-      // Get primary keys
+      const allCols = colsRes.rows || [];
       const pkRes = await conn.execute(
         `SELECT ac.TABLE_NAME, acc.COLUMN_NAME
          FROM ALL_CONSTRAINTS ac
@@ -360,16 +267,14 @@ export class OracleProvider extends SQLBaseProvider {
         [owner],
         { outFormat: oracledb.OUT_FORMAT_OBJECT }
       );
-      const pkRows = (pkRes.rows || []) as Record<string, unknown>[];
-      const pkMap = new Map<string, Set<string>>();
+      const pkRows = pkRes.rows || [];
+      const pkMap = /* @__PURE__ */ new Map();
       for (const row of pkRows) {
-        const tbl = String(row.TABLE_NAME || '');
-        const col = String(row.COLUMN_NAME || '');
-        if (!pkMap.has(tbl)) pkMap.set(tbl, new Set());
-        pkMap.get(tbl)!.add(col);
+        const tbl = String(row.TABLE_NAME || "");
+        const col = String(row.COLUMN_NAME || "");
+        if (!pkMap.has(tbl)) pkMap.set(tbl, /* @__PURE__ */ new Set());
+        pkMap.get(tbl).add(col);
       }
-
-      // Get foreign keys
       const fkRes = await conn.execute(
         `SELECT ac.TABLE_NAME,
                 acc.COLUMN_NAME,
@@ -383,9 +288,7 @@ export class OracleProvider extends SQLBaseProvider {
         [owner],
         { outFormat: oracledb.OUT_FORMAT_OBJECT }
       );
-      const fkRows = (fkRes.rows || []) as Record<string, unknown>[];
-
-      // Get indexes
+      const fkRows = fkRes.rows || [];
       const idxRes = await conn.execute(
         `SELECT ai.TABLE_NAME, ai.INDEX_NAME, ai.UNIQUENESS, aic.COLUMN_NAME, aic.COLUMN_POSITION
          FROM ALL_INDEXES ai
@@ -395,115 +298,101 @@ export class OracleProvider extends SQLBaseProvider {
         [owner],
         { outFormat: oracledb.OUT_FORMAT_OBJECT }
       );
-      const idxRows = (idxRes.rows || []) as Record<string, unknown>[];
-
-      // Group columns, indexes, foreign keys by table
-      const colsByTable = new Map<string, Record<string, unknown>[]>();
+      const idxRows = idxRes.rows || [];
+      const colsByTable = /* @__PURE__ */ new Map();
       for (const c of allCols) {
-        const tbl = String(c.TABLE_NAME || '');
+        const tbl = String(c.TABLE_NAME || "");
         if (!colsByTable.has(tbl)) colsByTable.set(tbl, []);
-        colsByTable.get(tbl)!.push(c);
+        colsByTable.get(tbl).push(c);
       }
-
-      const fksByTable = new Map<string, Record<string, unknown>[]>();
+      const fksByTable = /* @__PURE__ */ new Map();
       for (const fk of fkRows) {
-        const tbl = String(fk.TABLE_NAME || '');
+        const tbl = String(fk.TABLE_NAME || "");
         if (!fksByTable.has(tbl)) fksByTable.set(tbl, []);
-        fksByTable.get(tbl)!.push(fk);
+        fksByTable.get(tbl).push(fk);
       }
-
-      const idxByTable = new Map<string, Map<string, { unique: boolean; columns: string[] }>>();
+      const idxByTable = /* @__PURE__ */ new Map();
       for (const idx of idxRows) {
-        const tbl = String(idx.TABLE_NAME || '');
-        const idxName = String(idx.INDEX_NAME || '');
-        if (!idxByTable.has(tbl)) idxByTable.set(tbl, new Map());
-        const tableIdxs = idxByTable.get(tbl)!;
+        const tbl = String(idx.TABLE_NAME || "");
+        const idxName = String(idx.INDEX_NAME || "");
+        if (!idxByTable.has(tbl)) idxByTable.set(tbl, /* @__PURE__ */ new Map());
+        const tableIdxs = idxByTable.get(tbl);
         if (!tableIdxs.has(idxName)) {
           tableIdxs.set(idxName, {
-            unique: String(idx.UNIQUENESS || '') === 'UNIQUE',
-            columns: [],
+            unique: String(idx.UNIQUENESS || "") === "UNIQUE",
+            columns: []
           });
         }
-        tableIdxs.get(idxName)!.columns.push(String(idx.COLUMN_NAME || ''));
+        tableIdxs.get(idxName).columns.push(String(idx.COLUMN_NAME || ""));
       }
-
       return tables.map((t) => {
-        const tableName = String(t.TABLE_NAME || '');
-        const pks = pkMap.get(tableName) || new Set();
-
+        const tableName = String(t.TABLE_NAME || "");
+        const pks = pkMap.get(tableName) || /* @__PURE__ */ new Set();
         const columns = (colsByTable.get(tableName) || []).map((c) => ({
-          name: String(c.COLUMN_NAME || ''),
-          type: String(c.DATA_TYPE || ''),
-          nullable: String(c.NULLABLE || '') === 'Y',
-          isPrimary: pks.has(String(c.COLUMN_NAME || '')),
-          defaultValue: c.DATA_DEFAULT ? String(c.DATA_DEFAULT).trim() : undefined,
+          name: String(c.COLUMN_NAME || ""),
+          type: String(c.DATA_TYPE || ""),
+          nullable: String(c.NULLABLE || "") === "Y",
+          isPrimary: pks.has(String(c.COLUMN_NAME || "")),
+          defaultValue: c.DATA_DEFAULT ? String(c.DATA_DEFAULT).trim() : void 0
         }));
-
         const foreignKeys = (fksByTable.get(tableName) || []).map((fk) => ({
-          columnName: String(fk.COLUMN_NAME || ''),
-          referencedTable: String(fk.REF_TABLE || ''),
-          referencedColumn: String(fk.REF_COLUMN || ''),
+          columnName: String(fk.COLUMN_NAME || ""),
+          referencedTable: String(fk.REF_TABLE || ""),
+          referencedColumn: String(fk.REF_COLUMN || "")
         }));
-
-        const tableIdxs = idxByTable.get(tableName) || new Map();
+        const tableIdxs = idxByTable.get(tableName) || /* @__PURE__ */ new Map();
         const indexes = Array.from(tableIdxs.entries()).map(([name, info]) => ({
           name,
           columns: info.columns,
-          unique: info.unique,
+          unique: info.unique
         }));
-
         return {
           name: tableName,
           rowCount: Number(t.NUM_ROWS || 0),
           columns,
           indexes,
-          foreignKeys,
+          foreignKeys
         };
       });
     } finally {
       if (conn) await conn.close();
     }
   }
-
   // ============================================================================
   // Health & Monitoring
   // ============================================================================
-
-  public async getHealth(): Promise<HealthInfo> {
+  async getHealth() {
+    var _a, _b, _c;
     this.ensureConnected();
-
-    let conn: oracledb.Connection | undefined;
+    let conn;
     try {
-      conn = await this.pool!.getConnection();
-
+      conn = await this.pool.getConnection();
       let activeConnections = 0;
-      let databaseSize = 'N/A';
-      let cacheHitRatio = 'N/A';
-      const slowQueries: SlowQuery[] = [];
-      const activeSessions: ActiveSession[] = [];
-
-      // Active connections
+      let databaseSize = "N/A";
+      let cacheHitRatio = "N/A";
+      const slowQueries = [];
+      const activeSessions = [];
       try {
         const connRes = await conn.execute(
           `SELECT COUNT(*) AS CNT FROM V$SESSION WHERE STATUS = 'ACTIVE'`,
-          [], { outFormat: oracledb.OUT_FORMAT_OBJECT }
+          [],
+          { outFormat: oracledb.OUT_FORMAT_OBJECT }
         );
-        const rows = (connRes.rows || []) as Record<string, unknown>[];
-        activeConnections = Number(rows[0]?.CNT || 0);
-      } catch { /* V$ requires privileges */ }
-
-      // Database size
+        const rows = connRes.rows || [];
+        activeConnections = Number(((_a = rows[0]) == null ? void 0 : _a.CNT) || 0);
+      } catch (e) {
+      }
       try {
         const sizeRes = await conn.execute(
           `SELECT ROUND(SUM(BYTES) / 1024 / 1024, 2) AS SIZE_MB FROM USER_SEGMENTS`,
-          [], { outFormat: oracledb.OUT_FORMAT_OBJECT }
+          [],
+          { outFormat: oracledb.OUT_FORMAT_OBJECT }
         );
-        const sizeRows = (sizeRes.rows || []) as Record<string, unknown>[];
-        const mb = Number(sizeRows[0]?.SIZE_MB || 0);
+        const sizeRows = sizeRes.rows || [];
+        const mb = Number(((_b = sizeRows[0]) == null ? void 0 : _b.SIZE_MB) || 0);
         databaseSize = mb > 1024 ? `${(mb / 1024).toFixed(2)} GB` : `${mb} MB`;
-      } catch { /* ignore */ }
-
-      // Cache hit ratio
+      } catch (e) {
+      }
       try {
         const cacheRes = await conn.execute(
           `SELECT ROUND(
@@ -512,13 +401,13 @@ export class OracleProvider extends SQLBaseProvider {
             )) * 100, 2) AS HIT_RATIO
            FROM V$SYSSTAT
            WHERE NAME IN ('db block gets', 'consistent gets', 'physical reads')`,
-          [], { outFormat: oracledb.OUT_FORMAT_OBJECT }
+          [],
+          { outFormat: oracledb.OUT_FORMAT_OBJECT }
         );
-        const cacheRows = (cacheRes.rows || []) as Record<string, unknown>[];
-        cacheHitRatio = `${cacheRows[0]?.HIT_RATIO || 0}%`;
-      } catch { /* ignore */ }
-
-      // Slow queries
+        const cacheRows = cacheRes.rows || [];
+        cacheHitRatio = `${((_c = cacheRows[0]) == null ? void 0 : _c.HIT_RATIO) || 0}%`;
+      } catch (e) {
+      }
       try {
         const slowRes = await conn.execute(
           `SELECT * FROM (
@@ -529,18 +418,18 @@ export class OracleProvider extends SQLBaseProvider {
             WHERE EXECUTIONS > 0
             ORDER BY ELAPSED_TIME DESC
           ) WHERE ROWNUM <= 5`,
-          [], { outFormat: oracledb.OUT_FORMAT_OBJECT }
+          [],
+          { outFormat: oracledb.OUT_FORMAT_OBJECT }
         );
-        for (const row of (slowRes.rows || []) as Record<string, unknown>[]) {
+        for (const row of slowRes.rows || []) {
           slowQueries.push({
-            query: String(row.QUERY || ''),
+            query: String(row.QUERY || ""),
             calls: Number(row.CALLS || 0),
-            avgTime: String(row.AVGTIME || 'N/A'),
+            avgTime: String(row.AVGTIME || "N/A")
           });
         }
-      } catch { /* V$SQL requires privileges */ }
-
-      // Active sessions
+      } catch (e) {
+      }
       try {
         const sessRes = await conn.execute(
           `SELECT * FROM (
@@ -551,74 +440,71 @@ export class OracleProvider extends SQLBaseProvider {
             WHERE TYPE = 'USER' AND STATUS = 'ACTIVE'
             ORDER BY LOGON_TIME DESC
           ) WHERE ROWNUM <= 10`,
-          [], { outFormat: oracledb.OUT_FORMAT_OBJECT }
+          [],
+          { outFormat: oracledb.OUT_FORMAT_OBJECT }
         );
-        for (const row of (sessRes.rows || []) as Record<string, unknown>[]) {
+        for (const row of sessRes.rows || []) {
           activeSessions.push({
-            pid: String(row.SID || ''),
-            user: String(row.USERNAME || 'unknown'),
-            database: String(row.DATABASE || ''),
-            state: String(row.STATUS || 'unknown'),
-            query: String(row.QUERY || ''),
-            duration: String(row.DURATION || 'N/A'),
+            pid: String(row.SID || ""),
+            user: String(row.USERNAME || "unknown"),
+            database: String(row.DATABASE || ""),
+            state: String(row.STATUS || "unknown"),
+            query: String(row.QUERY || ""),
+            duration: String(row.DURATION || "N/A")
           });
         }
-      } catch { /* ignore */ }
-
+      } catch (e) {
+      }
       return { activeConnections, databaseSize, cacheHitRatio, slowQueries, activeSessions };
     } finally {
       if (conn) await conn.close();
     }
   }
-
   // ============================================================================
   // Maintenance Operations
   // ============================================================================
-
-  public async runMaintenance(type: MaintenanceType, target?: string): Promise<MaintenanceResult> {
+  async runMaintenance(type, target) {
     this.ensureConnected();
-
     const { result, executionTime } = await this.measureExecution(async () => {
-      let conn: oracledb.Connection | undefined;
+      let conn;
       try {
-        conn = await this.pool!.getConnection();
-        let sql = '';
-
+        conn = await this.pool.getConnection();
+        let sql = "";
         switch (type) {
-          case 'analyze':
+          case "analyze":
             if (target) {
               sql = `BEGIN DBMS_STATS.GATHER_TABLE_STATS(USER, '${target.replace(/'/g, "''")}'); END;`;
             } else {
               sql = `BEGIN DBMS_STATS.GATHER_SCHEMA_STATS(USER); END;`;
             }
             break;
-          case 'optimize':
+          case "optimize":
             if (target) {
               sql = `ALTER INDEX "${target.replace(/"/g, '""')}" REBUILD`;
             } else {
-              // Rebuild all indexes for user
               const idxRes = await conn.execute(
                 `SELECT INDEX_NAME FROM USER_INDEXES WHERE INDEX_TYPE = 'NORMAL'`,
-                [], { outFormat: oracledb.OUT_FORMAT_OBJECT }
+                [],
+                { outFormat: oracledb.OUT_FORMAT_OBJECT }
               );
-              for (const row of (idxRes.rows || []) as Record<string, unknown>[]) {
+              for (const row of idxRes.rows || []) {
                 try {
                   await conn.execute(`ALTER INDEX "${String(row.INDEX_NAME)}" REBUILD`);
-                } catch { /* individual index rebuild may fail */ }
+                } catch (e) {
+                }
               }
               return { success: true };
             }
             break;
-          case 'kill':
+          case "kill":
             if (!target) {
-              throw new QueryError('Target SID,SERIAL# is required for kill operation', 'oracle');
+              throw new QueryError("Target SID,SERIAL# is required for kill operation", "oracle");
             }
             sql = `ALTER SYSTEM KILL SESSION '${target.replace(/'/g, "''")}'`;
             break;
           default:
-            throw new QueryError(`Unsupported maintenance type: ${type}`, 'oracle');
+            throw new QueryError(`Unsupported maintenance type: ${type}`, "oracle");
         }
-
         if (sql) {
           await conn.execute(sql);
         }
@@ -627,136 +513,133 @@ export class OracleProvider extends SQLBaseProvider {
         if (conn) await conn.close();
       }
     });
-
     return {
       success: result.success,
       executionTime,
-      message: `${type.toUpperCase()} completed successfully`,
+      message: `${type.toUpperCase()} completed successfully`
     };
   }
-
   // ============================================================================
   // Pool Statistics
   // ============================================================================
-
-  public getPoolStats() {
+  getPoolStats() {
     if (!this.pool) {
       return { total: 0, idle: 0, active: 0, waiting: 0 };
     }
-
     return {
       total: this.pool.connectionsOpen,
       idle: this.pool.connectionsOpen - this.pool.connectionsInUse,
       active: this.pool.connectionsInUse,
-      waiting: 0,
+      waiting: 0
     };
   }
-
   // ============================================================================
   // Extended Monitoring Methods
   // ============================================================================
-
-  public async getOverview(): Promise<DatabaseOverview> {
+  async getOverview() {
+    var _a, _b, _c, _d, _e, _f;
     this.ensureConnected();
-
-    let conn: oracledb.Connection | undefined;
+    let conn;
     try {
-      conn = await this.pool!.getConnection();
-
-      let version = 'Oracle';
-      let uptime = 'N/A';
-      let startTime: Date | undefined;
+      conn = await this.pool.getConnection();
+      let version = "Oracle";
+      let uptime = "N/A";
+      let startTime;
       let activeConnections = 0;
       let maxConnections = 0;
-      let databaseSize = '0 bytes';
+      let databaseSize = "0 bytes";
       let databaseSizeBytes = 0;
       let tableCount = 0;
       let indexCount = 0;
-
-      // Version and uptime
       try {
         const vRes = await conn.execute(
           `SELECT BANNER FROM V$VERSION WHERE ROWNUM = 1`,
-          [], { outFormat: oracledb.OUT_FORMAT_OBJECT }
+          [],
+          { outFormat: oracledb.OUT_FORMAT_OBJECT }
         );
-        const vRows = (vRes.rows || []) as Record<string, unknown>[];
-        if (vRows[0]?.BANNER) version = String(vRows[0].BANNER);
-      } catch { /* ignore */ }
-
+        const vRows = vRes.rows || [];
+        if ((_a = vRows[0]) == null ? void 0 : _a.BANNER) version = String(vRows[0].BANNER);
+      } catch (e) {
+      }
       try {
         const upRes = await conn.execute(
           `SELECT STARTUP_TIME, (SYSDATE - STARTUP_TIME) * 86400 AS UPTIME_SECS FROM V$INSTANCE`,
-          [], { outFormat: oracledb.OUT_FORMAT_OBJECT }
+          [],
+          { outFormat: oracledb.OUT_FORMAT_OBJECT }
         );
-        const upRows = (upRes.rows || []) as Record<string, unknown>[];
+        const upRows = upRes.rows || [];
         if (upRows[0]) {
           const secs = Number(upRows[0].UPTIME_SECS || 0);
           const days = Math.floor(secs / 86400);
-          const hours = Math.floor((secs % 86400) / 3600);
-          const minutes = Math.floor((secs % 3600) / 60);
+          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`;
           if (upRows[0].STARTUP_TIME) startTime = new Date(String(upRows[0].STARTUP_TIME));
         }
-      } catch { /* ignore */ }
-
-      // Connections
+      } catch (e) {
+      }
       try {
         const sessRes = await conn.execute(
           `SELECT COUNT(*) AS CNT FROM V$SESSION WHERE TYPE = 'USER'`,
-          [], { outFormat: oracledb.OUT_FORMAT_OBJECT }
+          [],
+          { outFormat: oracledb.OUT_FORMAT_OBJECT }
         );
-        activeConnections = Number(((sessRes.rows || []) as Record<string, unknown>[])[0]?.CNT || 0);
-
+        activeConnections = Number(((_b = (sessRes.rows || [])[0]) == null ? void 0 : _b.CNT) || 0);
         const maxRes = await conn.execute(
           `SELECT VALUE FROM V$PARAMETER WHERE NAME = 'sessions'`,
-          [], { outFormat: oracledb.OUT_FORMAT_OBJECT }
+          [],
+          { outFormat: oracledb.OUT_FORMAT_OBJECT }
         );
-        maxConnections = Number(((maxRes.rows || []) as Record<string, unknown>[])[0]?.VALUE || 0);
-      } catch { /* ignore */ }
-
-      // Database size
+        maxConnections = Number(((_c = (maxRes.rows || [])[0]) == null ? void 0 : _c.VALUE) || 0);
+      } catch (e) {
+      }
       try {
         const sizeRes = await conn.execute(
           `SELECT SUM(BYTES) AS TOTAL FROM USER_SEGMENTS`,
-          [], { outFormat: oracledb.OUT_FORMAT_OBJECT }
+          [],
+          { outFormat: oracledb.OUT_FORMAT_OBJECT }
         );
-        databaseSizeBytes = Number(((sizeRes.rows || []) as Record<string, unknown>[])[0]?.TOTAL || 0);
+        databaseSizeBytes = Number(((_d = (sizeRes.rows || [])[0]) == null ? void 0 : _d.TOTAL) || 0);
         databaseSize = formatBytes(databaseSizeBytes);
-      } catch { /* ignore */ }
-
-      // Table and index counts
+      } catch (e) {
+      }
       try {
         const cntRes = await conn.execute(
           `SELECT
             (SELECT COUNT(*) FROM USER_TABLES) AS TABLE_COUNT,
             (SELECT COUNT(*) FROM USER_INDEXES) AS INDEX_COUNT
            FROM DUAL`,
-          [], { outFormat: oracledb.OUT_FORMAT_OBJECT }
+          [],
+          { outFormat: oracledb.OUT_FORMAT_OBJECT }
         );
-        const cntRows = (cntRes.rows || []) as Record<string, unknown>[];
-        tableCount = Number(cntRows[0]?.TABLE_COUNT || 0);
-        indexCount = Number(cntRows[0]?.INDEX_COUNT || 0);
-      } catch { /* ignore */ }
-
+        const cntRows = cntRes.rows || [];
+        tableCount = Number(((_e = cntRows[0]) == null ? void 0 : _e.TABLE_COUNT) || 0);
+        indexCount = Number(((_f = cntRows[0]) == null ? void 0 : _f.INDEX_COUNT) || 0);
+      } catch (e) {
+      }
       return {
-        version, uptime, startTime, activeConnections, maxConnections,
-        databaseSize, databaseSizeBytes, tableCount, indexCount,
+        version,
+        uptime,
+        startTime,
+        activeConnections,
+        maxConnections,
+        databaseSize,
+        databaseSizeBytes,
+        tableCount,
+        indexCount
       };
     } finally {
       if (conn) await conn.close();
     }
   }
-
-  public async getPerformanceMetrics(): Promise<PerformanceMetrics> {
+  async getPerformanceMetrics() {
+    var _a;
     this.ensureConnected();
-
-    let conn: oracledb.Connection | undefined;
+    let conn;
     try {
-      conn = await this.pool!.getConnection();
-
+      conn = await this.pool.getConnection();
       let cacheHitRatio = 100;
-      let bufferPoolUsage: number | undefined;
-
+      let bufferPoolUsage;
       try {
         const cacheRes = await conn.execute(
           `SELECT ROUND(
@@ -765,30 +648,29 @@ export class OracleProvider extends SQLBaseProvider {
             )) * 100, 2) AS HIT_RATIO
            FROM V$SYSSTAT
            WHERE NAME IN ('db block gets', 'consistent gets', 'physical reads')`,
-          [], { outFormat: oracledb.OUT_FORMAT_OBJECT }
+          [],
+          { outFormat: oracledb.OUT_FORMAT_OBJECT }
         );
-        const rows = (cacheRes.rows || []) as Record<string, unknown>[];
-        cacheHitRatio = Number(rows[0]?.HIT_RATIO || 100);
+        const rows = cacheRes.rows || [];
+        cacheHitRatio = Number(((_a = rows[0]) == null ? void 0 : _a.HIT_RATIO) || 100);
         bufferPoolUsage = cacheHitRatio;
-      } catch { /* ignore */ }
-
+      } catch (e) {
+      }
       return {
         cacheHitRatio,
-        bufferPoolUsage,
+        bufferPoolUsage
       };
     } finally {
       if (conn) await conn.close();
     }
   }
-
-  public async getSlowQueries(options?: { limit?: number }): Promise<SlowQueryStats[]> {
+  async getSlowQueries(options) {
+    var _a;
     this.ensureConnected();
-    const limit = options?.limit ?? 10;
-
-    let conn: oracledb.Connection | undefined;
+    const limit = (_a = options == null ? void 0 : options.limit) != null ? _a : 10;
+    let conn;
     try {
-      conn = await this.pool!.getConnection();
-
+      conn = await this.pool.getConnection();
       const res = await conn.execute(
         `SELECT * FROM (
           SELECT SQL_ID AS QUERY_ID,
@@ -803,34 +685,32 @@ export class OracleProvider extends SQLBaseProvider {
           WHERE EXECUTIONS > 0
           ORDER BY ELAPSED_TIME DESC
         ) WHERE ROWNUM <= ${limit}`,
-        [], { outFormat: oracledb.OUT_FORMAT_OBJECT }
+        [],
+        { outFormat: oracledb.OUT_FORMAT_OBJECT }
       );
-
-      return ((res.rows || []) as Record<string, unknown>[]).map((r) => ({
-        queryId: String(r.QUERY_ID || ''),
-        query: String(r.QUERY || ''),
+      return (res.rows || []).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),
         rows: Number(r.ROW_CNT || 0),
         sharedBlksHit: Number(r.BUF_GETS || 0),
-        sharedBlksRead: Number(r.DISK_READS || 0),
+        sharedBlksRead: Number(r.DISK_READS || 0)
       }));
-    } catch {
+    } catch (e) {
       return [];
     } finally {
       if (conn) await conn.close();
     }
   }
-
-  public async getActiveSessions(options?: { limit?: number }): Promise<ActiveSessionDetails[]> {
+  async getActiveSessions(options) {
+    var _a;
     this.ensureConnected();
-    const limit = options?.limit ?? 50;
-
-    let conn: oracledb.Connection | undefined;
+    const limit = (_a = options == null ? void 0 : options.limit) != null ? _a : 50;
+    let conn;
     try {
-      conn = await this.pool!.getConnection();
-
+      conn = await this.pool.getConnection();
       const res = await conn.execute(
         `SELECT * FROM (
           SELECT s.SID, s.SERIAL#, s.USERNAME, s.SCHEMANAME, s.PROGRAM,
@@ -844,46 +724,41 @@ export class OracleProvider extends SQLBaseProvider {
           WHERE s.TYPE = 'USER'
           ORDER BY CASE s.STATUS WHEN 'ACTIVE' THEN 0 ELSE 1 END, s.LOGON_TIME DESC
         ) WHERE ROWNUM <= ${limit}`,
-        [], { outFormat: oracledb.OUT_FORMAT_OBJECT }
+        [],
+        { outFormat: oracledb.OUT_FORMAT_OBJECT }
       );
-
-      return ((res.rows || []) as Record<string, unknown>[]).map((r) => {
+      return (res.rows || []).map((r) => {
         const secs = Number(r.DURATION_SECS || 0);
-        const durationStr = secs > 3600 ? `${Math.floor(secs / 3600)}h ${Math.floor((secs % 3600) / 60)}m`
-          : secs > 60 ? `${Math.floor(secs / 60)}m ${secs % 60}s`
-          : `${secs}s`;
-
+        const durationStr = secs > 3600 ? `${Math.floor(secs / 3600)}h ${Math.floor(secs % 3600 / 60)}m` : secs > 60 ? `${Math.floor(secs / 60)}m ${secs % 60}s` : `${secs}s`;
         return {
-          pid: `${r.SID},${r['SERIAL#']}`,
-          user: String(r.USERNAME || 'unknown'),
-          database: String(r.SCHEMANAME || ''),
-          applicationName: String(r.PROGRAM || ''),
-          clientAddr: String(r.MACHINE || ''),
-          state: String(r.STATUS || 'unknown'),
-          query: String(r.QUERY || r.SQL_ID || ''),
-          queryStart: r.LOGON_TIME ? new Date(String(r.LOGON_TIME)) : undefined,
+          pid: `${r.SID},${r["SERIAL#"]}`,
+          user: String(r.USERNAME || "unknown"),
+          database: String(r.SCHEMANAME || ""),
+          applicationName: String(r.PROGRAM || ""),
+          clientAddr: String(r.MACHINE || ""),
+          state: String(r.STATUS || "unknown"),
+          query: String(r.QUERY || r.SQL_ID || ""),
+          queryStart: r.LOGON_TIME ? new Date(String(r.LOGON_TIME)) : void 0,
           duration: durationStr,
-          durationMs: secs * 1000,
-          waitEventType: r.WAIT_CLASS ? String(r.WAIT_CLASS) : undefined,
-          waitEvent: r.EVENT ? String(r.EVENT) : undefined,
-          blocked: false,
+          durationMs: secs * 1e3,
+          waitEventType: r.WAIT_CLASS ? String(r.WAIT_CLASS) : void 0,
+          waitEvent: r.EVENT ? String(r.EVENT) : void 0,
+          blocked: false
         };
       });
-    } catch {
+    } catch (e) {
       return [];
     } finally {
       if (conn) await conn.close();
     }
   }
-
-  public async getTableStats(): Promise<TableStats[]> {
+  async getTableStats() {
+    var _a;
     this.ensureConnected();
-
-    let conn: oracledb.Connection | undefined;
+    let conn;
     try {
-      conn = await this.pool!.getConnection();
-      const owner = this.config.user?.toUpperCase() || '';
-
+      conn = await this.pool.getConnection();
+      const owner = ((_a = this.config.user) == null ? void 0 : _a.toUpperCase()) || "";
       const res = await conn.execute(
         `SELECT t.TABLE_NAME,
                 NVL(t.NUM_ROWS, 0) AS ROW_COUNT,
@@ -903,13 +778,12 @@ export class OracleProvider extends SQLBaseProvider {
         [owner],
         { outFormat: oracledb.OUT_FORMAT_OBJECT }
       );
-
-      return ((res.rows || []) as Record<string, unknown>[]).map((r) => {
+      return (res.rows || []).map((r) => {
         const tableSizeBytes = Number(r.TABLE_SIZE_BYTES || 0);
         const indexSizeBytes = Number(r.INDEX_SIZE_BYTES || 0);
         return {
           schemaName: owner,
-          tableName: String(r.TABLE_NAME || ''),
+          tableName: String(r.TABLE_NAME || ""),
           rowCount: Number(r.ROW_COUNT || 0),
           tableSize: formatBytes(tableSizeBytes),
           tableSizeBytes,
@@ -917,24 +791,22 @@ export class OracleProvider extends SQLBaseProvider {
           indexSizeBytes,
           totalSize: formatBytes(tableSizeBytes + indexSizeBytes),
           totalSizeBytes: tableSizeBytes + indexSizeBytes,
-          lastAnalyze: r.LAST_ANALYZED ? new Date(String(r.LAST_ANALYZED)) : undefined,
+          lastAnalyze: r.LAST_ANALYZED ? new Date(String(r.LAST_ANALYZED)) : void 0
         };
       });
-    } catch {
+    } catch (e) {
       return [];
     } finally {
       if (conn) await conn.close();
     }
   }
-
-  public async getIndexStats(): Promise<IndexStats[]> {
+  async getIndexStats() {
+    var _a;
     this.ensureConnected();
-
-    let conn: oracledb.Connection | undefined;
+    let conn;
     try {
-      conn = await this.pool!.getConnection();
-      const owner = this.config.user?.toUpperCase() || '';
-
+      conn = await this.pool.getConnection();
+      const owner = ((_a = this.config.user) == null ? void 0 : _a.toUpperCase()) || "";
       const res = await conn.execute(
         `SELECT ai.TABLE_NAME, ai.INDEX_NAME, ai.INDEX_TYPE, ai.UNIQUENESS,
                 NVL(us.BYTES, 0) AS INDEX_SIZE_BYTES,
@@ -946,8 +818,6 @@ export class OracleProvider extends SQLBaseProvider {
         [owner],
         { outFormat: oracledb.OUT_FORMAT_OBJECT }
       );
-
-      // Get columns for each index
       const colRes = await conn.execute(
         `SELECT INDEX_NAME, COLUMN_NAME, COLUMN_POSITION
          FROM ALL_IND_COLUMNS WHERE INDEX_OWNER = :1
@@ -955,46 +825,40 @@ export class OracleProvider extends SQLBaseProvider {
         [owner],
         { outFormat: oracledb.OUT_FORMAT_OBJECT }
       );
-
-      const colMap = new Map<string, string[]>();
-      for (const c of (colRes.rows || []) as Record<string, unknown>[]) {
-        const idxName = String(c.INDEX_NAME || '');
+      const colMap = /* @__PURE__ */ new Map();
+      for (const c of colRes.rows || []) {
+        const idxName = String(c.INDEX_NAME || "");
         if (!colMap.has(idxName)) colMap.set(idxName, []);
-        colMap.get(idxName)!.push(String(c.COLUMN_NAME || ''));
+        colMap.get(idxName).push(String(c.COLUMN_NAME || ""));
       }
-
-      return ((res.rows || []) as Record<string, unknown>[]).map((r) => {
-        const idxName = String(r.INDEX_NAME || '');
+      return (res.rows || []).map((r) => {
+        const idxName = String(r.INDEX_NAME || "");
         const idxSizeBytes = Number(r.INDEX_SIZE_BYTES || 0);
         return {
           schemaName: owner,
-          tableName: String(r.TABLE_NAME || ''),
+          tableName: String(r.TABLE_NAME || ""),
           indexName: idxName,
-          indexType: String(r.INDEX_TYPE || ''),
+          indexType: String(r.INDEX_TYPE || ""),
           columns: colMap.get(idxName) || [],
-          isUnique: String(r.UNIQUENESS || '') === 'UNIQUE',
+          isUnique: String(r.UNIQUENESS || "") === "UNIQUE",
           isPrimary: false,
           indexSize: formatBytes(idxSizeBytes),
           indexSizeBytes: idxSizeBytes,
-          scans: 0,
+          scans: 0
         };
       });
-    } catch {
+    } catch (e) {
       return [];
     } finally {
       if (conn) await conn.close();
     }
   }
-
-  public async getStorageStats(): Promise<StorageStats[]> {
+  async getStorageStats() {
     this.ensureConnected();
-
-    let conn: oracledb.Connection | undefined;
+    let conn;
     try {
-      conn = await this.pool!.getConnection();
-      const results: StorageStats[] = [];
-
-      // Try DBA tablespaces first, fallback to USER
+      conn = await this.pool.getConnection();
+      const results = [];
       try {
         const tsRes = await conn.execute(
           `SELECT TABLESPACE_NAME AS NAME,
@@ -1002,19 +866,18 @@ export class OracleProvider extends SQLBaseProvider {
            FROM DBA_DATA_FILES
            GROUP BY TABLESPACE_NAME
            ORDER BY SUM(BYTES) DESC`,
-          [], { outFormat: oracledb.OUT_FORMAT_OBJECT }
+          [],
+          { outFormat: oracledb.OUT_FORMAT_OBJECT }
         );
-
-        for (const row of (tsRes.rows || []) as Record<string, unknown>[]) {
+        for (const row of tsRes.rows || []) {
           const sizeBytes = Number(row.SIZE_BYTES || 0);
           results.push({
-            name: String(row.NAME || ''),
+            name: String(row.NAME || ""),
             size: formatBytes(sizeBytes),
-            sizeBytes,
+            sizeBytes
           });
         }
-      } catch {
-        // Fallback: user segments
+      } catch (e) {
         try {
           const segRes = await conn.execute(
             `SELECT TABLESPACE_NAME AS NAME,
@@ -1022,23 +885,27 @@ export class OracleProvider extends SQLBaseProvider {
              FROM USER_SEGMENTS
              GROUP BY TABLESPACE_NAME
              ORDER BY SUM(BYTES) DESC`,
-            [], { outFormat: oracledb.OUT_FORMAT_OBJECT }
+            [],
+            { outFormat: oracledb.OUT_FORMAT_OBJECT }
           );
-
-          for (const row of (segRes.rows || []) as Record<string, unknown>[]) {
+          for (const row of segRes.rows || []) {
             const sizeBytes = Number(row.SIZE_BYTES || 0);
             results.push({
-              name: String(row.NAME || ''),
+              name: String(row.NAME || ""),
               size: formatBytes(sizeBytes),
-              sizeBytes,
+              sizeBytes
             });
           }
-        } catch { /* ignore */ }
+        } catch (e2) {
+        }
       }
-
       return results;
     } finally {
       if (conn) await conn.close();
     }
   }
-}
+};
+
+export { OracleProvider };
+//# sourceMappingURL=oracle-P2G7T4P4.mjs.map
+//# sourceMappingURL=oracle-P2G7T4P4.mjs.map