@zz1996/dbhub-dameng 0.1.0

package/dist/chunk-ZNQTMARG.js

@@ -0,0 +1,127 @@
+import {
+  stripCommentsAndStrings
+} from "./chunk-SQA2ISDE.js";
+
+// src/utils/sql-row-limiter.ts
+var SQLRowLimiter = class {
+  /**
+   * Check if a SQL statement is a SELECT query that can benefit from row limiting
+   * Only handles SELECT queries
+   */
+  static isSelectQuery(sql) {
+    const trimmed = sql.trim().toLowerCase();
+    return trimmed.startsWith("select");
+  }
+  /**
+   * Check if a SQL statement already has a LIMIT clause.
+   * Strips comments and string literals first to avoid false positives.
+   */
+  static hasLimitClause(sql) {
+    const cleanedSQL = stripCommentsAndStrings(sql);
+    const limitRegex = /\blimit\s+(?:\d+|\$\d+|\?|@p\d+)/i;
+    return limitRegex.test(cleanedSQL);
+  }
+  /**
+   * Check if a SQL statement already has a TOP clause (SQL Server).
+   * Strips comments and string literals first to avoid false positives.
+   */
+  static hasTopClause(sql) {
+    const cleanedSQL = stripCommentsAndStrings(sql);
+    const topRegex = /\bselect\s+top\s+\d+/i;
+    return topRegex.test(cleanedSQL);
+  }
+  /**
+   * Extract existing LIMIT value from SQL if present.
+   * Strips comments and string literals first to avoid false positives.
+   */
+  static extractLimitValue(sql) {
+    const cleanedSQL = stripCommentsAndStrings(sql);
+    const limitMatch = cleanedSQL.match(/\blimit\s+(\d+)/i);
+    if (limitMatch) {
+      return parseInt(limitMatch[1], 10);
+    }
+    return null;
+  }
+  /**
+   * Extract existing TOP value from SQL if present (SQL Server).
+   * Strips comments and string literals first to avoid false positives.
+   */
+  static extractTopValue(sql) {
+    const cleanedSQL = stripCommentsAndStrings(sql);
+    const topMatch = cleanedSQL.match(/\bselect\s+top\s+(\d+)/i);
+    if (topMatch) {
+      return parseInt(topMatch[1], 10);
+    }
+    return null;
+  }
+  /**
+   * Add or modify LIMIT clause in a SQL statement
+   */
+  static applyLimitToQuery(sql, maxRows) {
+    const existingLimit = this.extractLimitValue(sql);
+    if (existingLimit !== null) {
+      const effectiveLimit = Math.min(existingLimit, maxRows);
+      return sql.replace(/\blimit\s+\d+/i, `LIMIT ${effectiveLimit}`);
+    } else {
+      const trimmed = sql.trim();
+      const hasSemicolon = trimmed.endsWith(";");
+      const sqlWithoutSemicolon = hasSemicolon ? trimmed.slice(0, -1) : trimmed;
+      return `${sqlWithoutSemicolon} LIMIT ${maxRows}${hasSemicolon ? ";" : ""}`;
+    }
+  }
+  /**
+   * Add or modify TOP clause in a SQL statement (SQL Server)
+   */
+  static applyTopToQuery(sql, maxRows) {
+    const existingTop = this.extractTopValue(sql);
+    if (existingTop !== null) {
+      const effectiveTop = Math.min(existingTop, maxRows);
+      return sql.replace(/\bselect\s+top\s+\d+/i, `SELECT TOP ${effectiveTop}`);
+    } else {
+      return sql.replace(/\bselect\s+/i, `SELECT TOP ${maxRows} `);
+    }
+  }
+  /**
+   * Check if a LIMIT clause uses a parameter placeholder (not a literal number).
+   * Strips comments and string literals first to avoid false positives.
+   */
+  static hasParameterizedLimit(sql) {
+    const cleanedSQL = stripCommentsAndStrings(sql);
+    const parameterizedLimitRegex = /\blimit\s+(?:\$\d+|\?|@p\d+)/i;
+    return parameterizedLimitRegex.test(cleanedSQL);
+  }
+  /**
+   * Apply maxRows limit to a SELECT query only
+   *
+   * This method is used by PostgreSQL, MySQL, MariaDB, and SQLite connectors which all support
+   * the LIMIT clause syntax. SQL Server uses applyMaxRowsForSQLServer() instead with TOP syntax.
+   *
+   * For parameterized LIMIT clauses (e.g., LIMIT $1 or LIMIT ?), we wrap the query in a subquery
+   * to enforce max_rows as a hard cap, since the parameter value is not known until runtime.
+   */
+  static applyMaxRows(sql, maxRows) {
+    if (!maxRows || !this.isSelectQuery(sql)) {
+      return sql;
+    }
+    if (this.hasParameterizedLimit(sql)) {
+      const trimmed = sql.trim();
+      const hasSemicolon = trimmed.endsWith(";");
+      const sqlWithoutSemicolon = hasSemicolon ? trimmed.slice(0, -1) : trimmed;
+      return `SELECT * FROM (${sqlWithoutSemicolon}) AS subq LIMIT ${maxRows}${hasSemicolon ? ";" : ""}`;
+    }
+    return this.applyLimitToQuery(sql, maxRows);
+  }
+  /**
+   * Apply maxRows limit to a SELECT query using SQL Server TOP syntax
+   */
+  static applyMaxRowsForSQLServer(sql, maxRows) {
+    if (!maxRows || !this.isSelectQuery(sql)) {
+      return sql;
+    }
+    return this.applyTopToQuery(sql, maxRows);
+  }
+};
+
+export {
+  SQLRowLimiter
+};

package/dist/dameng-DC7OP4VV.js

@@ -0,0 +1,504 @@
+import {
+  ConnectorRegistry,
+  SafeURL,
+  obfuscateDSNPassword,
+  splitSQLStatements,
+  stripCommentsAndStrings
+} from "./chunk-SQA2ISDE.js";
+
+// src/connectors/dameng/index.ts
+import dmdb from "dmdb";
+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 = [];
+      url.forEachSearchParam((value, key) => {
+        queryParams.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+      });
+      const connectString = `dm://${encodeURIComponent(url.username)}:${encodeURIComponent(url.password)}@${url.hostname}:${port}${queryParams.length > 0 ? `?${queryParams.join("&")}` : ""}`;
+      const connectionConfig = {
+        connectString,
+        user: url.username,
+        password: url.password,
+        schema: schema || void 0,
+        poolMin: 0,
+        poolMax: 4
+      };
+      if (config?.connectionTimeoutSeconds !== void 0) {
+        connectionConfig.queueTimeout = config.connectionTimeoutSeconds * 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;
+  }
+  getId() {
+    return this.sourceId;
+  }
+  clone() {
+    return new _DamengConnector();
+  }
+  async connect(dsn, initScript, config) {
+    try {
+      const connectionConfig = await this.dsnParser.parse(dsn, config);
+      this.defaultSchema = connectionConfig.schema ?? null;
+      if (config?.queryTimeoutSeconds !== void 0) {
+        this.queryTimeoutMs = config.queryTimeoutSeconds * 1e3;
+      }
+      this.pool = await dmdb.createPool(connectionConfig);
+      await this.withConnection(async (conn) => {
+        await conn.execute("SELECT 1 AS OK", [], this.executeOptions());
+        if (!this.defaultSchema) {
+          const result = await conn.execute(
+            "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 conn.execute(statement, [], this.executeOptions({ autoCommit: true }));
+          }
+        }
+      });
+    } catch (error) {
+      console.error("Failed to connect to Dameng database:", error);
+      throw error;
+    }
+  }
+  async disconnect() {
+    if (this.pool) {
+      await this.pool.close(0);
+      this.pool = 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 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 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 conn.execute(
+          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 conn.execute(sql, this.toBindParams(bindValues), this.executeOptions());
+      return this.normalizeRows(result.rows ?? []);
+    });
+  }
+  async withConnection(fn) {
+    if (!this.pool) {
+      throw new Error("Not connected to Dameng database");
+    }
+    const conn = await this.pool.getConnection();
+    try {
+      return await fn(conn);
+    } finally {
+      if (conn.release) {
+        await conn.release();
+      } else {
+        await conn.close();
+      }
+    }
+  }
+  executeOptions(extra = {}) {
+    return {
+      outFormat: dmdb.OUT_FORMAT_OBJECT,
+      ...this.queryTimeoutMs !== void 0 && { queryTimeout: this.queryTimeoutMs },
+      ...extra
+    };
+  }
+  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;
+  }
+  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
+};