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

package/dist/chunk-O3PEWKBB.js

@@ -0,0 +1,302 @@
+import {
+  hasMutatingKeyword
+} from "./chunk-HDPZAIDL.js";
+import {
+  blankCommentsAndStrings
+} from "./chunk-2JL4KCP5.js";
+
+// src/utils/sql-row-limiter.ts
+var SQLRowLimiter = class {
+  /**
+   * Check if a SQL statement is a row-returning query that can benefit from row limiting.
+   *
+   * Classification runs on the comment-blanked text, so a query introduced by a
+   * `--` or `/* ... *\/` comment (a query tag, say) is classified by its real
+   * leading keyword. The SQL sent to the server is never rewritten by this
+   * check, so an attribution comment survives verbatim.
+   *
+   * `WITH` leads a CTE whose final statement is normally a SELECT, so it is
+   * limitable too, except for a data-modifying CTE
+   * (`WITH x AS (DELETE ... RETURNING *) SELECT ...`), where a LIMIT would cap
+   * the rows handed back while the write still runs in full. Detection there is
+   * the same keyword heuristic the read-only classifier uses, so a false
+   * positive only means the statement keeps the old behaviour of not being limited.
+   *
+   * `dialect` selects the connector's scanner so dialect-specific quoting
+   * (PostgreSQL dollar quotes, MySQL backticks, SQL Server brackets) is
+   * blanked the same way the read-only classifier blanks it; without it only
+   * ANSI syntax is recognized.
+   */
+  static isSelectQuery(sql, dialect) {
+    const blankedSQL = blankCommentsAndStrings(sql, dialect).trim().toLowerCase();
+    const firstKeyword = /^[(;\s]*([a-z_]+)/.exec(blankedSQL)?.[1] ?? "";
+    if (firstKeyword === "select") {
+      return true;
+    }
+    return firstKeyword === "with" && !hasMutatingKeyword(blankedSQL, dialect);
+  }
+  /**
+   * Check if a SQL statement has a LIMIT clause of its own (not one nested in
+   * a CTE body or subquery).
+   */
+  static hasLimitClause(sql, dialect) {
+    return this.findTopLevelLimit(sql, dialect) !== null;
+  }
+  /**
+   * Check if a SQL statement has a TOP clause of its own (SQL Server).
+   */
+  static hasTopClause(sql) {
+    return this.findTopLevelTop(sql) !== null;
+  }
+  /**
+   * Extract the statement's own LIMIT value. Null when it has no LIMIT of its
+   * own, or when that LIMIT is a parameter placeholder rather than a literal
+   * (see hasParameterizedLimit).
+   */
+  static extractLimitValue(sql, dialect) {
+    return this.findTopLevelLimit(sql, dialect)?.value ?? null;
+  }
+  /**
+   * Extract the statement's own TOP value (SQL Server), or null when it has none.
+   */
+  static extractTopValue(sql) {
+    return this.findTopLevelTop(sql)?.value ?? null;
+  }
+  /**
+   * Check if the statement's own LIMIT clause uses a parameter placeholder
+   * ($1, ?, @p1) instead of a literal number.
+   */
+  static hasParameterizedLimit(sql, dialect) {
+    const limit = this.findTopLevelLimit(sql, dialect);
+    return limit !== null && limit.value === null;
+  }
+  /**
+   * Add or tighten the LIMIT clause of a SQL statement
+   */
+  static applyLimitToQuery(sql, maxRows, dialect) {
+    const limit = this.findTopLevelLimit(sql, dialect);
+    if (limit !== null && limit.value !== null) {
+      const effectiveLimit = Math.min(limit.value, maxRows);
+      return `${sql.slice(0, limit.index)}LIMIT ${effectiveLimit}${sql.slice(limit.index + limit.length)}`;
+    }
+    const { sql: sqlWithoutSemicolon, semicolon } = trimSemicolon(sql);
+    return `${sqlWithoutSemicolon}
+LIMIT ${maxRows}${semicolon}`;
+  }
+  /**
+   * Scan blanked (comment/string-free, length-preserving) SQL for parenthesis
+   * depth, invoking onMatch for every regex hit at depth 0 (i.e. not nested
+   * inside a subquery, function call, or window OVER clause).
+   */
+  static scanTopLevel(blankedSQL, regex, onMatch) {
+    let depth = 0;
+    let m;
+    while ((m = regex.exec(blankedSQL)) !== null) {
+      const token = m[0];
+      if (token === "(") {
+        depth++;
+      } else if (token === ")") {
+        depth--;
+      } else if (depth === 0) {
+        onMatch(m);
+      }
+    }
+  }
+  /**
+   * The first or last regex match at parenthesis depth 0, i.e. one belonging
+   * to the statement itself rather than to a nested query. Match indices refer
+   * to positions in the original `sql`, since blankCommentsAndStrings
+   * preserves length. The regex must offer `\(` and `\)` alternatives so depth
+   * can be tracked, and must carry the `g` flag.
+   */
+  static findTopLevelMatch(sql, regex, pick, dialect) {
+    let found = null;
+    this.scanTopLevel(blankCommentsAndStrings(sql, dialect), regex, (m) => {
+      if (pick === "last" || found === null) {
+        found = m;
+      }
+    });
+    return found;
+  }
+  /** The statement's own LIMIT clause, literal or parameterized ($1, ?, @p1). */
+  static findTopLevelLimit(sql, dialect) {
+    const match = this.findTopLevelMatch(
+      sql,
+      /\(|\)|\blimit\s+(?:(\d+)|\$\d+|\?|@p\d+)/gi,
+      "last",
+      dialect
+    );
+    if (match === null) {
+      return null;
+    }
+    return {
+      index: match.index,
+      length: match[0].length,
+      value: match[1] !== void 0 ? parseInt(match[1], 10) : null
+    };
+  }
+  /** The statement's own `SELECT TOP n` clause (SQL Server). */
+  static findTopLevelTop(sql) {
+    const match = this.findTopLevelMatch(sql, /\(|\)|\bselect\s+top\s+(\d+)/gi, "first", "sqlserver");
+    if (match === null) {
+      return null;
+    }
+    return { index: match.index, length: match[0].length, value: parseInt(match[1], 10) };
+  }
+  /**
+   * The statement's own SELECT keyword (SQL Server). For a CTE this is the
+   * final SELECT, not the one inside a CTE body.
+   */
+  static findTopLevelSelect(sql) {
+    return this.findTopLevelMatch(sql, /\(|\)|\bselect\b/gi, "first", "sqlserver");
+  }
+  /**
+   * Check if a SQL statement combines multiple SELECTs with a set operator
+   * (UNION [ALL], INTERSECT, EXCEPT) at the top level — i.e. not nested
+   * inside a subquery already wrapped in parentheses.
+   */
+  static hasSetOperator(sql) {
+    return this.findTopLevelMatch(sql, /\(|\)|\bunion\b|\bintersect\b|\bexcept\b/gi, "first", "sqlserver") !== null;
+  }
+  /**
+   * Find the start index of a top-level trailing ORDER BY clause (not one
+   * nested inside a subquery or a window function's OVER (...) clause).
+   * Returns -1 if none exists.
+   */
+  static findTopLevelOrderByIndex(sql) {
+    return this.findTopLevelMatch(sql, /\(|\)|\border\s+by\b/gi, "last", "sqlserver")?.index ?? -1;
+  }
+  /**
+   * Add or modify TOP clause in a SQL statement (SQL Server)
+   */
+  static applyTopToQuery(sql, maxRows) {
+    if (this.hasSetOperator(sql)) {
+      const { sql: sqlWithoutSemicolon, semicolon } = trimSemicolon(sql);
+      const cteIndex = this.findTopLevelSelect(sqlWithoutSemicolon)?.index ?? 0;
+      const ctePrefix = sqlWithoutSemicolon.slice(0, cteIndex);
+      const body = sqlWithoutSemicolon.slice(cteIndex);
+      const orderByIndex = this.findTopLevelOrderByIndex(body);
+      if (orderByIndex !== -1) {
+        const innerSql = body.slice(0, orderByIndex).trimEnd();
+        const orderByClause = body.slice(orderByIndex).trim();
+        return `${ctePrefix}SELECT TOP ${maxRows} * FROM (${innerSql}
+) AS subq ${orderByClause}${semicolon}`;
+      }
+      return `${ctePrefix}SELECT TOP ${maxRows} * FROM (${body}
+) AS subq${semicolon}`;
+    }
+    const existingTop = this.findTopLevelTop(sql);
+    if (existingTop !== null) {
+      const effectiveTop = Math.min(existingTop.value, maxRows);
+      return `${sql.slice(0, existingTop.index)}SELECT TOP ${effectiveTop}${sql.slice(existingTop.index + existingTop.length)}`;
+    }
+    const selectMatch = this.findTopLevelSelect(sql);
+    if (selectMatch === null) {
+      return sql;
+    }
+    return `${sql.slice(0, selectMatch.index)}SELECT TOP ${maxRows}${sql.slice(selectMatch.index + selectMatch[0].length)}`;
+  }
+  /**
+   * Apply maxRows limit to a row-returning 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.
+   *
+   * `dialect` selects the connector's comment/string scanner (see isSelectQuery).
+   */
+  static applyMaxRows(sql, maxRows, dialect) {
+    if (!maxRows || !this.isSelectQuery(sql, dialect)) {
+      return sql;
+    }
+    if (this.hasParameterizedLimit(sql, dialect)) {
+      const { sql: sqlWithoutSemicolon, semicolon } = trimSemicolon(sql);
+      return `SELECT * FROM (${sqlWithoutSemicolon}
+) AS subq LIMIT ${maxRows}${semicolon}`;
+    }
+    return this.applyLimitToQuery(sql, maxRows, dialect);
+  }
+  /**
+   * Apply maxRows limit to a row-returning query using SQL Server TOP syntax
+   */
+  static applyMaxRowsForSQLServer(sql, maxRows) {
+    if (!maxRows || !this.isSelectQuery(sql, "sqlserver")) {
+      return sql;
+    }
+    return this.applyTopToQuery(sql, maxRows);
+  }
+  /**
+   * Like applyMaxRows, but requests one probe row (maxRows + 1) whenever the
+   * cap is the binding constraint, so callers can detect truncation exactly
+   * instead of guessing from `rowCount === maxRows` (which a table with
+   * exactly maxRows rows also produces).
+   *
+   * `probeApplied` is false when the cap cannot fire: no maxRows, not a
+   * SELECT, or the query's own literal LIMIT is already within the cap (the
+   * user asked for fewer rows than the cap — that is their limit, not
+   * truncation).
+   */
+  static applyMaxRowsWithTruncationProbe(sql, maxRows, dialect) {
+    if (!maxRows || !this.isSelectQuery(sql, dialect)) {
+      return { sql, probeApplied: false };
+    }
+    if (!this.hasParameterizedLimit(sql, dialect)) {
+      const existingLimit = this.extractLimitValue(sql, dialect);
+      if (existingLimit !== null && existingLimit <= maxRows) {
+        return { sql, probeApplied: false };
+      }
+    }
+    return { sql: this.applyMaxRows(sql, maxRows + 1, dialect), probeApplied: true };
+  }
+  /**
+   * SQL Server variant of applyMaxRowsWithTruncationProbe, using TOP syntax.
+   * A set-operator statement is always wrapped (any TOP on an individual
+   * branch caps only that branch, not the combined output), so the probe
+   * applies there regardless of branch-level TOPs.
+   */
+  static applyMaxRowsForSQLServerWithTruncationProbe(sql, maxRows) {
+    if (!maxRows || !this.isSelectQuery(sql, "sqlserver")) {
+      return { sql, probeApplied: false };
+    }
+    if (!this.hasSetOperator(sql)) {
+      const existingTop = this.extractTopValue(sql);
+      if (existingTop !== null && existingTop <= maxRows) {
+        return { sql, probeApplied: false };
+      }
+    }
+    return { sql: this.applyMaxRowsForSQLServer(sql, maxRows + 1), probeApplied: true };
+  }
+  /**
+   * Post-process a result set produced by a truncation-probe rewrite: when
+   * the probe row came back (more than maxRows rows), drop it, clamp the
+   * count to maxRows, and mark the set truncated so consumers can tell a
+   * capped result from a complete one.
+   */
+  static flagTruncation(resultSet, maxRows, probeApplied) {
+    if (!probeApplied || !maxRows || resultSet.rows.length <= maxRows) {
+      return;
+    }
+    resultSet.rows = resultSet.rows.slice(0, maxRows);
+    resultSet.rowCount = maxRows;
+    resultSet.truncated = true;
+  }
+};
+function trimSemicolon(sql) {
+  const trimmed = sql.trim();
+  return trimmed.endsWith(";") ? { sql: trimmed.slice(0, -1), semicolon: ";" } : { sql: trimmed, semicolon: "" };
+}
+
+// src/utils/resource-cleanup.ts
+async function closeQuietly(close) {
+  try {
+    await close();
+  } catch {
+  }
+}
+
+export {
+  SQLRowLimiter,
+  closeQuietly
+};

package/dist/dameng-NKF7NZKE.js

@@ -0,0 +1,250 @@
+import {
+  SQLRowLimiter,
+  closeQuietly
+} from "./chunk-O3PEWKBB.js";
+import "./chunk-HDPZAIDL.js";
+import {
+  ConnectorRegistry,
+  SafeURL,
+  splitSQLStatements
+} from "./chunk-2JL4KCP5.js";
+
+// src/connectors/dameng/index.ts
+import { randomUUID } from "node:crypto";
+import dmdb from "dmdb";
+var DamengDSNParser = class {
+  isValidDSN(dsn) {
+    return dsn.startsWith("dameng://");
+  }
+  getSampleDSN() {
+    return "dameng://user:password@localhost:5236/APP";
+  }
+  async parse(dsn, config) {
+    if (!this.isValidDSN(dsn)) throw new Error("Expected a dameng:// DSN");
+    const url = new SafeURL(dsn);
+    if (!url.hostname || !url.username) throw new Error("Dameng DSN requires host and user");
+    const params = new URLSearchParams();
+    url.forEachSearchParam((value, key) => params.set(key, value));
+    if (url.pathname.length > 1) params.set("schema", decodeURIComponent(url.pathname.slice(1)));
+    if (config?.connectionTimeoutSeconds !== void 0) {
+      params.set("connectTimeout", String(config.connectionTimeoutSeconds * 1e3));
+    }
+    if (config?.queryTimeoutSeconds !== void 0) {
+      params.set("sessionTimeout", String(config.queryTimeoutSeconds));
+    }
+    return {
+      connectString: `dm://${encodeURIComponent(url.username)}:${encodeURIComponent(url.password)}@${url.hostname}:${url.port || 5236}?${params}`
+    };
+  }
+};
+var DamengConnector = class _DamengConnector {
+  constructor() {
+    this.id = "dameng";
+    this.name = "Dameng";
+    this.dsnParser = new DamengDSNParser();
+    this.sourceId = "default";
+    this.pool = null;
+    this.defaultSchema = null;
+  }
+  getId() {
+    return this.sourceId;
+  }
+  clone() {
+    return new _DamengConnector();
+  }
+  async connect(dsn, initScript, config) {
+    const attributes = await this.dsnParser.parse(dsn, config);
+    this.pool = await dmdb.createPool({ ...attributes, poolAlias: randomUUID() });
+    try {
+      await this.withConnection(async (conn) => {
+        const result = await conn.execute(
+          "SELECT SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA') AS SCHEMA_NAME FROM DUAL",
+          [],
+          { outFormat: dmdb.OUT_FORMAT_OBJECT }
+        );
+        this.defaultSchema = result.rows[0].SCHEMA_NAME;
+        if (initScript) {
+          for (const sql of splitSQLStatements(initScript, "dameng")) {
+            await conn.execute(sql, [], { autoCommit: true });
+          }
+        }
+      });
+    } catch (error) {
+      await closeQuietly(() => this.disconnect());
+      throw error;
+    }
+  }
+  async disconnect() {
+    const pool = this.pool;
+    this.pool = null;
+    this.defaultSchema = null;
+    if (pool) await pool.close(0);
+  }
+  async getDefaultSchema() {
+    return this.defaultSchema;
+  }
+  async withConnection(run) {
+    if (!this.pool) throw new Error("Not connected to Dameng");
+    const conn = await this.pool.getConnection();
+    try {
+      return await run(conn);
+    } finally {
+      await conn.close();
+    }
+  }
+  async query(sql, parameters = []) {
+    return this.withConnection(async (conn) => {
+      const result = await conn.execute(sql, parameters, {
+        outFormat: dmdb.OUT_FORMAT_OBJECT
+      });
+      return result.rows ?? [];
+    });
+  }
+  owner(schema) {
+    const owner = schema ?? this.defaultSchema;
+    if (!owner) throw new Error("No Dameng schema selected");
+    return owner;
+  }
+  async getSchemas() {
+    const rows = await this.query("SELECT USERNAME FROM ALL_USERS ORDER BY USERNAME");
+    return rows.map((row) => row.USERNAME);
+  }
+  async getTables(schema) {
+    const rows = await this.query(
+      "SELECT TABLE_NAME FROM ALL_TABLES WHERE OWNER = ? ORDER BY TABLE_NAME",
+      [this.owner(schema)]
+    );
+    return rows.map((row) => row.TABLE_NAME);
+  }
+  async getViews(schema) {
+    const rows = await this.query(
+      "SELECT VIEW_NAME FROM ALL_VIEWS WHERE OWNER = ? ORDER BY VIEW_NAME",
+      [this.owner(schema)]
+    );
+    return rows.map((row) => row.VIEW_NAME);
+  }
+  async tableExists(tableName, schema) {
+    const rows = await this.query(
+      `SELECT COUNT(*) AS CNT FROM ALL_OBJECTS
+       WHERE OWNER = ? AND OBJECT_NAME = ? AND OBJECT_TYPE IN ('TABLE', 'VIEW')`,
+      [this.owner(schema), tableName]
+    );
+    return Number(rows[0].CNT) > 0;
+  }
+  async getTableSchema(tableName, schema) {
+    const rows = await this.query(
+      `SELECT c.COLUMN_NAME, c.DATA_TYPE, 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 = ? AND c.TABLE_NAME = ? ORDER BY c.COLUMN_ID`,
+      [this.owner(schema), tableName]
+    );
+    return rows.map((row) => ({
+      column_name: row.COLUMN_NAME,
+      data_type: row.DATA_TYPE,
+      is_nullable: row.NULLABLE === "Y" ? "YES" : "NO",
+      column_default: row.DATA_DEFAULT ?? null,
+      description: row.COMMENTS ?? null
+    }));
+  }
+  async getTableIndexes(tableName, schema) {
+    const rows = await this.query(
+      `SELECT i.INDEX_NAME, i.UNIQUENESS, ic.COLUMN_NAME,
+              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 = ? AND i.TABLE_NAME = ? ORDER BY i.INDEX_NAME, ic.COLUMN_POSITION`,
+      [this.owner(schema), tableName]
+    );
+    const indexes = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      let index = indexes.get(row.INDEX_NAME);
+      if (!index) {
+        index = {
+          index_name: row.INDEX_NAME,
+          column_names: [],
+          is_unique: row.UNIQUENESS === "UNIQUE",
+          is_primary: Number(row.IS_PRIMARY) === 1
+        };
+        indexes.set(row.INDEX_NAME, index);
+      }
+      index.column_names.push(row.COLUMN_NAME);
+    }
+    return [...indexes.values()];
+  }
+  async getStoredProcedures(schema, routineType) {
+    const rows = await this.query(
+      `SELECT OBJECT_NAME FROM ALL_OBJECTS WHERE OWNER = ?
+       AND OBJECT_TYPE IN ('PROCEDURE', 'FUNCTION') ${routineType ? "AND OBJECT_TYPE = ?" : ""}
+       ORDER BY OBJECT_NAME`,
+      routineType ? [this.owner(schema), routineType.toUpperCase()] : [this.owner(schema)]
+    );
+    return rows.map((row) => row.OBJECT_NAME);
+  }
+  async getStoredProcedureDetail(procedureName, schema) {
+    const owner = this.owner(schema);
+    const rows = await this.query(
+      `SELECT OBJECT_NAME, OBJECT_TYPE FROM ALL_OBJECTS WHERE OWNER = ? AND OBJECT_NAME = ?
+       AND OBJECT_TYPE IN ('PROCEDURE', 'FUNCTION')`,
+      [owner, procedureName]
+    );
+    if (!rows.length) throw new Error(`Stored procedure '${procedureName}' not found`);
+    const source = await this.query(
+      "SELECT TEXT FROM ALL_SOURCE WHERE OWNER = ? AND NAME = ? ORDER BY LINE",
+      [owner, procedureName]
+    );
+    return {
+      procedure_name: rows[0].OBJECT_NAME,
+      procedure_type: rows[0].OBJECT_TYPE === "FUNCTION" ? "function" : "procedure",
+      language: "sql",
+      parameter_list: "",
+      definition: source.map((row) => row.TEXT).join("")
+    };
+  }
+  async getTableRowCount(tableName, schema) {
+    const rows = await this.query(
+      "SELECT NUM_ROWS FROM ALL_TABLES WHERE OWNER = ? AND TABLE_NAME = ?",
+      [this.owner(schema), tableName]
+    );
+    return rows[0]?.NUM_ROWS == null ? null : Number(rows[0].NUM_ROWS);
+  }
+  async getTableComment(tableName, schema) {
+    const rows = await this.query(
+      "SELECT COMMENTS FROM ALL_TAB_COMMENTS WHERE OWNER = ? AND TABLE_NAME = ?",
+      [this.owner(schema), tableName]
+    );
+    return rows[0]?.COMMENTS ?? null;
+  }
+  async executeSQL(sql, options, parameters) {
+    const statements = splitSQLStatements(sql, "dameng");
+    if (parameters?.length && statements.length !== 1) {
+      throw new Error("Parameters require a single Dameng statement");
+    }
+    return this.withConnection(async (conn) => {
+      const resultSets = [];
+      for (const statement of statements) {
+        const result = await conn.execute(statement, parameters ?? [], {
+          outFormat: dmdb.OUT_FORMAT_OBJECT,
+          autoCommit: true,
+          maxRows: options.maxRows ? options.maxRows + 1 : 0
+        });
+        const rows = result.rows ?? [];
+        const resultSet = {
+          sql: statement,
+          rows,
+          rowCount: result.rowsAffected ?? rows.length
+        };
+        SQLRowLimiter.flagTruncation(resultSet, options.maxRows, !!options.maxRows);
+        resultSets.push(resultSet);
+      }
+      return { resultSets };
+    });
+  }
+};
+ConnectorRegistry.register(new DamengConnector());
+export {
+  DamengConnector
+};