@zz1996/dbhub-dameng 0.1.7 → 1.2.5-dameng.621

package/dist/dameng-5KYI5JBK.js

@@ -1,898 +0,0 @@
-import {
-  ConnectorRegistry,
-  SafeURL,
-  obfuscateDSNPassword,
-  splitSQLStatements,
-  stripCommentsAndStrings
-} from "./chunk-SQA2ISDE.js";
-
-// src/connectors/dameng/index.ts
-import dmdb from "dmdb";
-var DEFAULT_OPERATION_TIMEOUT_MS = 11e4;
-var RESOURCE_CLEANUP_TIMEOUT_MS = 2e3;
-var CONNECT_RETRY_ATTEMPTS = 3;
-var CONNECT_RETRY_DELAY_MS = 500;
-var DamengOperationTimeoutError = class extends Error {
-  constructor(message, label) {
-    super(message);
-    this.label = label;
-    this.name = "DamengOperationTimeoutError";
-  }
-};
-var DamengDSNParser = class {
-  async parse(dsn, config) {
-    if (!this.isValidDSN(dsn)) {
-      const obfuscatedDSN = obfuscateDSNPassword(dsn);
-      const expectedFormat = this.getSampleDSN();
-      throw new Error(
-        `Invalid Dameng DSN format.
-Provided: ${obfuscatedDSN}
-Expected: ${expectedFormat}`
-      );
-    }
-    try {
-      const url = new SafeURL(dsn);
-      const schema = url.pathname ? decodeURIComponent(url.pathname.substring(1)) : void 0;
-      const port = url.port ? parseInt(url.port, 10) : 5236;
-      const queryParams = {};
-      const queryStringParts = [];
-      url.forEachSearchParam((value, key) => {
-        queryParams[key] = value;
-        queryStringParts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
-      });
-      const connectionConfig = {
-        connectString: `dm://${encodeURIComponent(url.username)}:${encodeURIComponent(url.password)}@${url.hostname}:${port}${queryStringParts.length > 0 ? `?${queryStringParts.join("&")}` : ""}`,
-        directConnectString: `${url.hostname}:${port}`,
-        user: url.username,
-        password: url.password,
-        schema: schema || void 0,
-        poolMin: 0,
-        poolMax: 4,
-        ...queryParams
-      };
-      if (config?.connectionTimeoutSeconds !== void 0) {
-        connectionConfig.connectTimeout = config.connectionTimeoutSeconds * 1e3;
-        connectionConfig.queueTimeout = config.connectionTimeoutSeconds * 1e3;
-      }
-      if (config?.queryTimeoutSeconds !== void 0) {
-        connectionConfig.sessionTimeout = config.queryTimeoutSeconds;
-        connectionConfig.socketTimeout = config.queryTimeoutSeconds * 1e3 + 1e3;
-      }
-      return connectionConfig;
-    } catch (error) {
-      throw new Error(
-        `Failed to parse Dameng DSN: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  getSampleDSN() {
-    return "dameng://SYSDBA:password@localhost:5236/SYSDBA";
-  }
-  isValidDSN(dsn) {
-    try {
-      return dsn.startsWith("dameng://") || dsn.startsWith("dm://");
-    } catch {
-      return false;
-    }
-  }
-};
-var DamengConnector = class _DamengConnector {
-  constructor() {
-    this.id = "dameng";
-    this.name = "Dameng";
-    this.dsnParser = new DamengDSNParser();
-    this.pool = null;
-    this.sourceId = "default";
-    this.defaultSchema = null;
-    this.poolAlias = null;
-    this.connectionConfig = null;
-    this.connectionTimeoutMs = 5e3;
-    this.operationTimeoutMs = DEFAULT_OPERATION_TIMEOUT_MS;
-    this.reconnectingPool = null;
-  }
-  getId() {
-    return this.sourceId;
-  }
-  clone() {
-    return new _DamengConnector();
-  }
-  async connect(dsn, initScript, config) {
-    for (let attempt = 1; attempt <= CONNECT_RETRY_ATTEMPTS; attempt += 1) {
-      let createdPool = null;
-      try {
-        const connectionConfig = await this.dsnParser.parse(dsn, config);
-        connectionConfig.poolAlias = this.buildPoolAlias();
-        this.defaultSchema = connectionConfig.schema ?? null;
-        this.poolAlias = connectionConfig.poolAlias;
-        this.connectionTimeoutMs = config?.connectionTimeoutSeconds !== void 0 ? config.connectionTimeoutSeconds * 1e3 : 5e3;
-        this.operationTimeoutMs = config?.queryTimeoutSeconds !== void 0 ? config.queryTimeoutSeconds * 1e3 : DEFAULT_OPERATION_TIMEOUT_MS;
-        connectionConfig.connectTimeout ?? (connectionConfig.connectTimeout = this.connectionTimeoutMs);
-        connectionConfig.queueTimeout ?? (connectionConfig.queueTimeout = this.connectionTimeoutMs);
-        await this.closeRegisteredPool(connectionConfig.poolAlias);
-        await this.validateDirectConnection(connectionConfig);
-        createdPool = await dmdb.createPool(connectionConfig);
-        this.pool = createdPool;
-        await this.withConnection((conn) => this.initializeSession(conn, initScript));
-        this.connectionConfig = connectionConfig;
-        this.initScript = initScript;
-        return;
-      } catch (error) {
-        if (createdPool) {
-          await this.closePoolQuietly(createdPool);
-        } else if (this.poolAlias) {
-          await this.closeRegisteredPool(this.poolAlias);
-        }
-        this.pool = null;
-        this.poolAlias = null;
-        this.connectionConfig = null;
-        this.initScript = void 0;
-        if (attempt < CONNECT_RETRY_ATTEMPTS && this.isRetryableConnectFailure(error)) {
-          console.error(
-            `Retrying Dameng source '${this.sourceId}' connection after transient failure (${attempt}/${CONNECT_RETRY_ATTEMPTS}): ${error instanceof Error ? error.message : String(error)}`
-          );
-          await this.delay(CONNECT_RETRY_DELAY_MS * attempt);
-          continue;
-        }
-        console.error("Failed to connect to Dameng database:", error);
-        throw error;
-      }
-    }
-    throw new Error("Failed to connect to Dameng database");
-  }
-  async initializeSession(conn, initScript) {
-    await this.executeWithTimeout(
-      conn,
-      "SELECT 1 AS OK",
-      [],
-      this.executeOptions()
-    );
-    if (!this.defaultSchema) {
-      const result = await this.executeWithTimeout(
-        conn,
-        "SELECT USER AS SCHEMA_NAME FROM DUAL",
-        [],
-        this.executeOptions()
-      );
-      this.defaultSchema = this.rowValue(result.rows?.[0], "SCHEMA_NAME") ?? null;
-    }
-    if (initScript) {
-      for (const statement of splitSQLStatements(initScript, "dameng")) {
-        await this.executeWithTimeout(
-          conn,
-          statement,
-          [],
-          this.executeOptions({ autoCommit: true })
-        );
-      }
-    }
-  }
-  async disconnect() {
-    if (this.pool) {
-      await this.closePoolQuietly(this.pool);
-      this.pool = null;
-    }
-    if (this.poolAlias) {
-      await this.closeRegisteredPool(this.poolAlias);
-      this.poolAlias = null;
-    }
-    this.connectionConfig = null;
-    this.initScript = void 0;
-    this.reconnectingPool = null;
-  }
-  async getSchemas() {
-    const rows = await this.queryRows(`
-      SELECT USERNAME AS SCHEMA_NAME
-      FROM ALL_USERS
-      WHERE USERNAME NOT IN ('SYS', 'SYSTEM', 'SYSAUDITOR', 'SYSSSO', 'CTISYS')
-      ORDER BY USERNAME
-    `);
-    return rows.map((row) => this.rowValue(row, "SCHEMA_NAME")).filter(this.isPresent);
-  }
-  async schemaExists(schema) {
-    const rows = await this.queryRows(
-      `
-      SELECT COUNT(*) AS CNT
-      FROM ALL_USERS
-      WHERE USERNAME = :1
-      `,
-      [this.normalizeIdentifier(schema)]
-    );
-    return Number(this.rowValue(rows[0], "CNT") ?? 0) > 0;
-  }
-  async getDefaultSchema() {
-    return this.defaultSchema;
-  }
-  async getTables(schema) {
-    const owner = await this.resolveSchema(schema);
-    const rows = await this.queryRows(
-      `
-      SELECT TABLE_NAME
-      FROM ALL_TABLES
-      WHERE OWNER = :1
-      ORDER BY TABLE_NAME
-      `,
-      [owner]
-    );
-    return rows.map((row) => this.rowValue(row, "TABLE_NAME")).filter(this.isPresent);
-  }
-  async searchTables(pattern, schema, limit = 100) {
-    const owner = await this.resolveSchema(schema);
-    const rowLimit = this.normalizeLimit(limit);
-    const rows = await this.queryRows(
-      `
-      SELECT TABLE_NAME
-      FROM (
-        SELECT TABLE_NAME
-        FROM ALL_TABLES
-        WHERE OWNER = :1
-          AND TABLE_NAME LIKE :2
-        ORDER BY TABLE_NAME
-      )
-      WHERE ROWNUM <= ${rowLimit}
-      `,
-      [owner, this.normalizeLikePattern(pattern)]
-    );
-    return rows.map((row) => this.rowValue(row, "TABLE_NAME")).filter(this.isPresent).map((name) => ({ name, schema: owner }));
-  }
-  async searchColumns(pattern, schema, table, limit = 100) {
-    const owner = await this.resolveSchema(schema);
-    const rowLimit = this.normalizeLimit(limit);
-    const bindValues = [
-      owner,
-      this.normalizeLikePattern(pattern),
-      ...table ? [this.normalizeIdentifier(table)] : []
-    ];
-    const tablePredicate = table ? "AND c.TABLE_NAME = :3" : "";
-    const rows = await this.queryRows(
-      `
-      SELECT COLUMN_NAME,
-             TABLE_NAME,
-             DATA_TYPE,
-             DATA_LENGTH,
-             DATA_PRECISION,
-             DATA_SCALE,
-             NULLABLE,
-             DATA_DEFAULT,
-             COMMENTS
-      FROM (
-        SELECT c.COLUMN_NAME,
-               c.TABLE_NAME,
-               c.DATA_TYPE,
-               c.DATA_LENGTH,
-               c.DATA_PRECISION,
-               c.DATA_SCALE,
-               c.NULLABLE,
-               c.DATA_DEFAULT,
-               cc.COMMENTS,
-               c.COLUMN_ID
-        FROM ALL_TAB_COLUMNS c
-        LEFT JOIN ALL_COL_COMMENTS cc
-          ON cc.OWNER = c.OWNER
-         AND cc.TABLE_NAME = c.TABLE_NAME
-         AND cc.COLUMN_NAME = c.COLUMN_NAME
-        WHERE c.OWNER = :1
-          AND c.COLUMN_NAME LIKE :2
-          ${tablePredicate}
-        ORDER BY c.TABLE_NAME, c.COLUMN_ID
-      )
-      WHERE ROWNUM <= ${rowLimit}
-      `,
-      bindValues
-    );
-    return rows.map((row) => {
-      const description = this.rowValue(row, "COMMENTS");
-      return {
-        name: this.rowValue(row, "COLUMN_NAME") ?? "",
-        table: this.rowValue(row, "TABLE_NAME") ?? "",
-        schema: owner,
-        type: this.formatDataType(row),
-        nullable: this.rowValue(row, "NULLABLE") === "Y",
-        default: this.rowValue(row, "DATA_DEFAULT") ?? null,
-        ...description ? { description } : {}
-      };
-    });
-  }
-  async getViews(schema) {
-    const owner = await this.resolveSchema(schema);
-    const rows = await this.queryRows(
-      `
-      SELECT VIEW_NAME
-      FROM ALL_VIEWS
-      WHERE OWNER = :1
-      ORDER BY VIEW_NAME
-      `,
-      [owner]
-    );
-    return rows.map((row) => this.rowValue(row, "VIEW_NAME")).filter(this.isPresent);
-  }
-  async tableExists(tableName, schema) {
-    const owner = await this.resolveSchema(schema);
-    const rows = await this.queryRows(
-      `
-      SELECT COUNT(*) AS CNT
-      FROM ALL_OBJECTS
-      WHERE OWNER = :1
-        AND OBJECT_NAME = :2
-        AND OBJECT_TYPE IN ('TABLE', 'VIEW')
-      `,
-      [owner, this.normalizeIdentifier(tableName)]
-    );
-    return Number(this.rowValue(rows[0], "CNT") ?? 0) > 0;
-  }
-  async getTableSchema(tableName, schema) {
-    const owner = await this.resolveSchema(schema);
-    const rows = await this.queryRows(
-      `
-      SELECT c.COLUMN_NAME,
-             c.DATA_TYPE,
-             c.DATA_LENGTH,
-             c.DATA_PRECISION,
-             c.DATA_SCALE,
-             c.NULLABLE,
-             c.DATA_DEFAULT,
-             cc.COMMENTS
-      FROM ALL_TAB_COLUMNS c
-      LEFT JOIN ALL_COL_COMMENTS cc
-        ON cc.OWNER = c.OWNER
-       AND cc.TABLE_NAME = c.TABLE_NAME
-       AND cc.COLUMN_NAME = c.COLUMN_NAME
-      WHERE c.OWNER = :1
-        AND c.TABLE_NAME = :2
-      ORDER BY c.COLUMN_ID
-      `,
-      [owner, this.normalizeIdentifier(tableName)]
-    );
-    return rows.map((row) => {
-      const dataType = this.formatDataType(row);
-      return {
-        column_name: this.rowValue(row, "COLUMN_NAME") ?? "",
-        data_type: dataType,
-        is_nullable: this.rowValue(row, "NULLABLE") === "Y" ? "YES" : "NO",
-        column_default: this.rowValue(row, "DATA_DEFAULT") ?? null,
-        description: this.rowValue(row, "COMMENTS") ?? null
-      };
-    });
-  }
-  async getTableIndexes(tableName, schema) {
-    const owner = await this.resolveSchema(schema);
-    const rows = await this.queryRows(
-      `
-      SELECT i.INDEX_NAME,
-             i.UNIQUENESS,
-             ic.COLUMN_NAME,
-             ic.COLUMN_POSITION,
-             CASE WHEN c.CONSTRAINT_TYPE = 'P' THEN 1 ELSE 0 END AS IS_PRIMARY
-      FROM ALL_INDEXES i
-      JOIN ALL_IND_COLUMNS ic
-        ON i.OWNER = ic.INDEX_OWNER
-       AND i.INDEX_NAME = ic.INDEX_NAME
-      LEFT JOIN ALL_CONSTRAINTS c
-        ON c.OWNER = i.TABLE_OWNER
-       AND c.TABLE_NAME = i.TABLE_NAME
-       AND c.INDEX_NAME = i.INDEX_NAME
-       AND c.CONSTRAINT_TYPE = 'P'
-      WHERE i.TABLE_OWNER = :1
-        AND i.TABLE_NAME = :2
-      ORDER BY i.INDEX_NAME, ic.COLUMN_POSITION
-      `,
-      [owner, this.normalizeIdentifier(tableName)]
-    );
-    const indexMap = /* @__PURE__ */ new Map();
-    for (const row of rows) {
-      const indexName = this.rowValue(row, "INDEX_NAME") ?? "";
-      if (!indexMap.has(indexName)) {
-        indexMap.set(indexName, {
-          index_name: indexName,
-          column_names: [],
-          is_unique: this.rowValue(row, "UNIQUENESS") === "UNIQUE",
-          is_primary: Number(this.rowValue(row, "IS_PRIMARY") ?? 0) === 1
-        });
-      }
-      const columnName = this.rowValue(row, "COLUMN_NAME");
-      if (columnName) {
-        indexMap.get(indexName).column_names.push(columnName);
-      }
-    }
-    return Array.from(indexMap.values());
-  }
-  async getStoredProcedures(schema, routineType) {
-    const owner = await this.resolveSchema(schema);
-    const types = routineType ? [routineType === "procedure" ? "PROCEDURE" : "FUNCTION"] : ["PROCEDURE", "FUNCTION"];
-    const rows = await this.queryRows(
-      `
-      SELECT OBJECT_NAME
-      FROM ALL_OBJECTS
-      WHERE OWNER = :1
-        AND OBJECT_TYPE IN (${types.map((_, i) => `:${i + 2}`).join(", ")})
-      ORDER BY OBJECT_NAME
-      `,
-      [owner, ...types]
-    );
-    return rows.map((row) => this.rowValue(row, "OBJECT_NAME")).filter(this.isPresent);
-  }
-  async getStoredProcedureDetail(procedureName, schema) {
-    const owner = await this.resolveSchema(schema);
-    const name = this.normalizeIdentifier(procedureName);
-    const rows = await this.queryRows(
-      `
-      SELECT OBJECT_NAME, OBJECT_TYPE
-      FROM ALL_OBJECTS
-      WHERE OWNER = :1
-        AND OBJECT_NAME = :2
-        AND OBJECT_TYPE IN ('PROCEDURE', 'FUNCTION')
-      `,
-      [owner, name]
-    );
-    if (rows.length === 0) {
-      throw new Error(`Stored procedure '${procedureName}' not found in ${owner}`);
-    }
-    const sourceRows = await this.queryRows(
-      `
-      SELECT TEXT
-      FROM ALL_SOURCE
-      WHERE OWNER = :1
-        AND NAME = :2
-      ORDER BY LINE
-      `,
-      [owner, name]
-    );
-    const objectType = this.rowValue(rows[0], "OBJECT_TYPE") ?? "PROCEDURE";
-    return {
-      procedure_name: this.rowValue(rows[0], "OBJECT_NAME") ?? procedureName,
-      procedure_type: objectType === "FUNCTION" ? "function" : "procedure",
-      language: "sql",
-      parameter_list: "",
-      definition: sourceRows.map((row) => this.rowValue(row, "TEXT") ?? "").join("")
-    };
-  }
-  async getTableRowCount(tableName, schema) {
-    const owner = await this.resolveSchema(schema);
-    const rows = await this.queryRows(
-      `
-      SELECT NUM_ROWS
-      FROM ALL_TABLES
-      WHERE OWNER = :1
-        AND TABLE_NAME = :2
-      `,
-      [owner, this.normalizeIdentifier(tableName)]
-    );
-    const value = this.rowValue(rows[0], "NUM_ROWS");
-    return value === null || value === void 0 ? null : Number(value);
-  }
-  async getTableComment(tableName, schema) {
-    const owner = await this.resolveSchema(schema);
-    const rows = await this.queryRows(
-      `
-      SELECT COMMENTS
-      FROM ALL_TAB_COMMENTS
-      WHERE OWNER = :1
-        AND TABLE_NAME = :2
-      `,
-      [owner, this.normalizeIdentifier(tableName)]
-    );
-    return this.rowValue(rows[0], "COMMENTS") ?? null;
-  }
-  async executeSQL(sql, options, parameters) {
-    if (!this.pool) {
-      throw new Error("Not connected to Dameng database");
-    }
-    return this.withConnection(async (conn) => {
-      const statements = splitSQLStatements(sql, "dameng");
-      const allRows = [];
-      let rowCount = 0;
-      for (const [index, statement] of statements.entries()) {
-        const processedSQL = this.applyMaxRows(statement, options.maxRows);
-        const { sql: boundSQL, bindValues } = this.replacePositionalParameters(
-          processedSQL,
-          index === 0 ? parameters ?? [] : []
-        );
-        const result = await this.executeWithTimeout(
-          conn,
-          boundSQL,
-          this.toBindParams(bindValues),
-          this.executeOptions({ autoCommit: true, maxRows: options.maxRows })
-        );
-        const rows = this.normalizeRows(result.rows ?? []);
-        allRows.push(...rows);
-        rowCount += Number(result.rowsAffected ?? rows.length ?? 0);
-      }
-      return { rows: allRows, rowCount };
-    });
-  }
-  async queryRows(sql, bindValues = []) {
-    return this.withConnection(async (conn) => {
-      const result = await this.executeWithTimeout(
-        conn,
-        sql,
-        this.toBindParams(bindValues),
-        this.executeOptions()
-      );
-      return this.normalizeRows(result.rows ?? []);
-    });
-  }
-  async withConnection(fn) {
-    try {
-      return await this.withConnectionAttempt(fn);
-    } catch (error) {
-      if (!this.isConnectionAcquisitionFailure(error)) {
-        throw error;
-      }
-      console.error(
-        `Retrying Dameng source '${this.sourceId}' after connection acquisition failure: ${error instanceof Error ? error.message : String(error)}`
-      );
-      await this.ensurePool();
-      return this.withConnectionAttempt(fn);
-    }
-  }
-  async withConnectionAttempt(fn) {
-    await this.ensurePool();
-    const pool = this.pool;
-    if (!pool) {
-      throw new Error("Not connected to Dameng database");
-    }
-    let conn = null;
-    let shouldRelease = true;
-    try {
-      conn = await this.acquireConnectionWithTimeout(pool);
-      return await fn(conn);
-    } catch (error) {
-      if (error instanceof DamengOperationTimeoutError) {
-        shouldRelease = false;
-        this.markPoolUnhealthy(error.message);
-      } else if (!conn && this.isConnectionAcquisitionFailure(error)) {
-        shouldRelease = false;
-        this.markPoolUnhealthy(error instanceof Error ? error.message : String(error));
-      }
-      throw error;
-    } finally {
-      if (conn && shouldRelease) {
-        await this.releaseConnectionQuietly(conn);
-      }
-    }
-  }
-  async acquireConnectionWithTimeout(pool) {
-    const acquisition = pool.getConnection();
-    try {
-      return await this.withTimeout(
-        acquisition,
-        this.connectionTimeoutMs,
-        "Dameng connection acquisition"
-      );
-    } catch (error) {
-      if (error instanceof DamengOperationTimeoutError) {
-        void acquisition.then((conn) => this.releaseConnectionQuietly(conn)).catch(() => void 0);
-      }
-      throw error;
-    }
-  }
-  async ensurePool() {
-    if (this.pool) {
-      return;
-    }
-    if (!this.connectionConfig) {
-      throw new Error("Not connected to Dameng database");
-    }
-    if (!this.reconnectingPool) {
-      this.reconnectingPool = this.reconnectPool();
-    }
-    try {
-      await this.reconnectingPool;
-    } finally {
-      this.reconnectingPool = null;
-    }
-  }
-  async reconnectPool() {
-    const config = this.connectionConfig;
-    if (!config) {
-      throw new Error("Not connected to Dameng database");
-    }
-    console.error(`Reconnecting Dameng source '${this.sourceId}' after pool reset...`);
-    await this.closeRegisteredPool(config.poolAlias ?? this.buildPoolAlias());
-    await this.validateDirectConnection(config);
-    const createdPool = await dmdb.createPool(config);
-    this.pool = createdPool;
-    this.poolAlias = config.poolAlias ?? null;
-    try {
-      await this.withConnection(async (conn) => {
-        await this.executeWithTimeout(conn, "SELECT 1 AS OK", [], this.executeOptions());
-        if (this.initScript) {
-          for (const statement of splitSQLStatements(this.initScript, "dameng")) {
-            await this.executeWithTimeout(
-              conn,
-              statement,
-              [],
-              this.executeOptions({ autoCommit: true })
-            );
-          }
-        }
-      });
-    } catch (error) {
-      await this.closePoolQuietly(createdPool);
-      this.pool = null;
-      throw error;
-    }
-  }
-  executeWithTimeout(conn, sql, bindParams, options) {
-    return this.withTimeout(
-      conn.execute(sql, bindParams, options),
-      this.operationTimeoutMs,
-      "Dameng SQL execution"
-    );
-  }
-  async withTimeout(promise, timeoutMs, label) {
-    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-      return promise;
-    }
-    let timer;
-    const timeout = new Promise((_, reject) => {
-      timer = setTimeout(() => {
-        reject(new DamengOperationTimeoutError(`${label} timed out after ${timeoutMs}ms`, label));
-      }, timeoutMs);
-    });
-    try {
-      return await Promise.race([promise, timeout]);
-    } finally {
-      if (timer) {
-        clearTimeout(timer);
-      }
-    }
-  }
-  markPoolUnhealthy(reason) {
-    const pool = this.pool;
-    this.pool = null;
-    console.error(`Resetting Dameng source '${this.sourceId}' pool: ${reason}`);
-    if (pool) {
-      void this.closePoolQuietly(pool);
-    }
-  }
-  async releaseConnectionQuietly(conn) {
-    try {
-      const release = conn.release ? conn.release() : conn.close();
-      await this.withTimeout(
-        release,
-        RESOURCE_CLEANUP_TIMEOUT_MS,
-        "Dameng connection release"
-      );
-    } catch (error) {
-      this.markPoolUnhealthy(
-        `failed to release connection: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  isConnectionAcquisitionFailure(error) {
-    if (error instanceof DamengOperationTimeoutError) {
-      return error.label === "Dameng connection acquisition";
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    return [
-      "Connection request timeout in queue",
-      "Pool cannot open more connections",
-      "\u83B7\u53D6\u8FDE\u63A5\u8BF7\u6C42\u7B49\u5F85\u8D85\u65F6",
-      "\u8FDE\u63A5\u6C60\u5DF2\u8FBE\u5230\u6700\u5927\u8FDE\u63A5\u6570"
-    ].some((item) => message.includes(item));
-  }
-  isRetryableConnectFailure(error) {
-    if (error instanceof DamengOperationTimeoutError) {
-      return [
-        "Dameng direct connection",
-        "Dameng connection acquisition",
-        "Dameng SQL execution"
-      ].includes(error.label);
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    return [
-      "ECONNRESET",
-      "ETIMEDOUT",
-      "ECONNREFUSED",
-      "socket hang up",
-      "Socket timeout",
-      "connect timeout",
-      "Connection request timeout in queue",
-      "Pool cannot open more connections",
-      "\u7F51\u7EDC\u901A\u8BAF\u8D85\u65F6",
-      "\u7F51\u7EDC\u901A\u4FE1\u5F02\u5E38",
-      "\u8FDE\u63A5\u8D85\u65F6",
-      "\u83B7\u53D6\u8FDE\u63A5\u8BF7\u6C42\u7B49\u5F85\u8D85\u65F6",
-      "\u8FDE\u63A5\u6C60\u5DF2\u8FBE\u5230\u6700\u5927\u8FDE\u63A5\u6570"
-    ].some((item) => message.includes(item));
-  }
-  delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-  executeOptions(extra = {}) {
-    return {
-      outFormat: dmdb.OUT_FORMAT_OBJECT,
-      ...extra
-    };
-  }
-  async validateDirectConnection(config) {
-    let conn = null;
-    try {
-      const {
-        directConnectString,
-        poolAlias,
-        poolMin,
-        poolMax,
-        queueRequests,
-        queueTimeout,
-        ...directConfig
-      } = config;
-      const directConn = await this.withTimeout(
-        dmdb.getConnection({
-          ...directConfig,
-          connectString: directConnectString ?? config.connectString
-        }),
-        this.connectionTimeoutMs,
-        "Dameng direct connection"
-      );
-      conn = directConn;
-      await this.executeWithTimeout(conn, "SELECT 1 AS OK", [], this.executeOptions());
-    } finally {
-      if (conn) {
-        await this.releaseConnectionQuietly(conn);
-      }
-    }
-  }
-  buildPoolAlias() {
-    const safeSourceId = this.sourceId.replace(/[^a-zA-Z0-9_-]/g, "_") || "default";
-    return `dbhub_dameng_${safeSourceId}`;
-  }
-  async closeRegisteredPool(poolAlias) {
-    if (!dmdb.pools?.has?.(poolAlias)) {
-      return;
-    }
-    const pool = dmdb.pools.get(poolAlias);
-    await this.closePoolQuietly(pool);
-    dmdb.pools?.delete?.(poolAlias);
-  }
-  async closePoolQuietly(pool) {
-    try {
-      await this.withTimeout(pool.close(0), RESOURCE_CLEANUP_TIMEOUT_MS, "Dameng pool close");
-    } catch {
-      if (pool.poolAlias) {
-        dmdb.pools?.delete?.(pool.poolAlias);
-      }
-    }
-  }
-  async resolveSchema(schema) {
-    const resolved = schema || this.defaultSchema || await this.getDefaultSchema();
-    if (!resolved) {
-      throw new Error("No Dameng schema specified and current schema could not be resolved");
-    }
-    return this.normalizeIdentifier(resolved);
-  }
-  normalizeIdentifier(identifier) {
-    return /[a-z]/.test(identifier) ? identifier.toUpperCase() : identifier;
-  }
-  normalizeLikePattern(pattern) {
-    return /[a-z]/.test(pattern) ? pattern.toUpperCase() : pattern;
-  }
-  normalizeLimit(limit) {
-    return Math.max(1, Math.min(1e3, Math.floor(limit)));
-  }
-  normalizeRows(rows) {
-    return rows.map((row) => {
-      if (!Array.isArray(row)) {
-        return row;
-      }
-      return row;
-    });
-  }
-  rowValue(row, key) {
-    if (!row) {
-      return null;
-    }
-    return row[key] ?? row[key.toLowerCase()] ?? row[key.toUpperCase()] ?? null;
-  }
-  isPresent(value) {
-    return value !== null && value !== "";
-  }
-  formatDataType(row) {
-    const dataType = this.rowValue(row, "DATA_TYPE") ?? "";
-    const precision = this.rowValue(row, "DATA_PRECISION");
-    const scale = this.rowValue(row, "DATA_SCALE");
-    const length = this.rowValue(row, "DATA_LENGTH");
-    if (precision !== null && precision !== void 0) {
-      return scale !== null && scale !== void 0 ? `${dataType}(${precision},${scale})` : `${dataType}(${precision})`;
-    }
-    if (length !== null && length !== void 0 && /CHAR|VARCHAR|BINARY/i.test(dataType)) {
-      return `${dataType}(${length})`;
-    }
-    return dataType;
-  }
-  toBindParams(values) {
-    return values.map((value) => ({ val: value }));
-  }
-  applyMaxRows(sql, maxRows) {
-    if (!maxRows) {
-      return sql;
-    }
-    const cleaned = stripCommentsAndStrings(sql, "dameng").trim().toLowerCase();
-    if (!cleaned.startsWith("select")) {
-      return sql;
-    }
-    const trimmed = sql.trim();
-    const withoutSemicolon = trimmed.endsWith(";") ? trimmed.slice(0, -1) : trimmed;
-    return `SELECT * FROM (${withoutSemicolon}) WHERE ROWNUM <= ${maxRows}`;
-  }
-  replacePositionalParameters(sql, parameters) {
-    if (!parameters.length) {
-      return { sql, bindValues: [] };
-    }
-    let index = 0;
-    let result = "";
-    let i = 0;
-    while (i < sql.length) {
-      const char = sql[i];
-      const next = sql[i + 1];
-      if (char === "'") {
-        const start = i++;
-        while (i < sql.length) {
-          if (sql[i] === "'" && sql[i + 1] === "'") {
-            i += 2;
-          } else if (sql[i] === "'") {
-            i++;
-            break;
-          } else {
-            i++;
-          }
-        }
-        result += sql.slice(start, i);
-        continue;
-      }
-      if (char === '"') {
-        const start = i++;
-        while (i < sql.length) {
-          if (sql[i] === '"' && sql[i + 1] === '"') {
-            i += 2;
-          } else if (sql[i] === '"') {
-            i++;
-            break;
-          } else {
-            i++;
-          }
-        }
-        result += sql.slice(start, i);
-        continue;
-      }
-      if (char === "-" && next === "-") {
-        const start = i;
-        i += 2;
-        while (i < sql.length && sql[i] !== "\n") {
-          i++;
-        }
-        result += sql.slice(start, i);
-        continue;
-      }
-      if (char === "/" && next === "*") {
-        const start = i;
-        i += 2;
-        while (i < sql.length && !(sql[i] === "*" && sql[i + 1] === "/")) {
-          i++;
-        }
-        i = i < sql.length ? i + 2 : i;
-        result += sql.slice(start, i);
-        continue;
-      }
-      if (char === "?") {
-        index += 1;
-        result += `:${index}`;
-        i++;
-        continue;
-      }
-      result += char;
-      i++;
-    }
-    if (index !== parameters.length) {
-      throw new Error(
-        `Parameter count mismatch: SQL statement has ${index} parameter(s), but ${parameters.length} value(s) were provided.`
-      );
-    }
-    return { sql: result, bindValues: parameters };
-  }
-};
-var damengConnector = new DamengConnector();
-ConnectorRegistry.register(damengConnector);
-export {
-  DamengConnector
-};