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

package/dist/{postgres-VFNLBWMF.js → postgres-C24SBQ4I.js}

@@ -1,21 +1,28 @@
+import {
+  toNullableNumber
+} from "./chunk-FU2ZJE4E.js";
 import {
   quoteIdentifier
-} from "./chunk-IPK7BYBL.js";
+} from "./chunk-JFWX35TB.js";
+import {
+  obfuscateDSNPassword
+} from "./chunk-3RJRH3CN.js";
 import {
-  SQLRowLimiter
-} from "./chunk-ZNQTMARG.js";
+  SQLRowLimiter,
+  closeQuietly
+} from "./chunk-O3PEWKBB.js";
+import "./chunk-HDPZAIDL.js";
 import {
   ConnectorRegistry,
   SafeURL,
-  obfuscateDSNPassword,
   splitSQLStatements
-} from "./chunk-SQA2ISDE.js";
+} from "./chunk-2JL4KCP5.js";
 
 // src/connectors/postgres/index.ts
 import fs from "fs";
 import os from "os";
 import path from "path";
-import pg from "pg";
+import pg2 from "pg";
 
 // src/connectors/postgres/failed-to-read-certificate.ts
 var FailedToReadCertificate = class extends Error {
@@ -25,12 +32,40 @@ var FailedToReadCertificate = class extends Error {
   }
 };
 
+// src/connectors/postgres/type-parsers.ts
+import pg from "pg";
+var VERBATIM_DATE_TIME_OIDS = /* @__PURE__ */ new Set([
+  1082,
+  // date
+  1114,
+  // timestamp without time zone
+  1184,
+  // timestamp with time zone
+  1182,
+  // date[]
+  1115,
+  // timestamp[]
+  1185
+  // timestamptz[]
+]);
+var passthrough = (value) => value;
+var postgresTypeParsers = {
+  getTypeParser(oid, format) {
+    if (VERBATIM_DATE_TIME_OIDS.has(oid) && (format === void 0 || format === "text")) {
+      return passthrough;
+    }
+    return pg.types.getTypeParser(oid, format);
+  }
+};
+
 // src/connectors/postgres/index.ts
-var { Pool } = pg;
+var { Pool } = pg2;
+var POSTGRES_CLIENT_QUERY_TIMEOUT_GRACE_MS = 5e3;
 var PostgresDSNParser = class {
   async parse(dsn, config) {
     const connectionTimeoutSeconds = config?.connectionTimeoutSeconds;
     const queryTimeoutSeconds = config?.queryTimeoutSeconds;
+    const poolMaxConnections = config?.poolMaxConnections;
     if (!this.isValidDSN(dsn)) {
       const obfuscatedDSN = obfuscateDSNPassword(dsn);
       const expectedFormat = this.getSampleDSN();
@@ -86,7 +121,12 @@ Expected: ${expectedFormat}`
         poolConfig.connectionTimeoutMillis = connectionTimeoutSeconds * 1e3;
       }
       if (queryTimeoutSeconds !== void 0) {
-        poolConfig.query_timeout = queryTimeoutSeconds * 1e3;
+        const queryTimeoutMs = queryTimeoutSeconds * 1e3;
+        poolConfig.statement_timeout = queryTimeoutMs;
+        poolConfig.query_timeout = queryTimeoutMs + POSTGRES_CLIENT_QUERY_TIMEOUT_GRACE_MS;
+      }
+      if (poolMaxConnections !== void 0) {
+        poolConfig.max = poolMaxConnections;
       }
       return poolConfig;
     } catch (error) {
@@ -132,6 +172,7 @@ var PostgresConnector = class _PostgresConnector {
     this.defaultSchema = "public";
     try {
       const poolConfig = await this.dsnParser.parse(dsn, config);
+      poolConfig.types = postgresTypeParsers;
       if (config?.readonly) {
         poolConfig.options = (poolConfig.options || "") + " -c default_transaction_read_only=on";
       }
@@ -145,9 +186,20 @@ var PostgresConnector = class _PostgresConnector {
         }
       }
       this.pool = new Pool(poolConfig);
+      this.pool.on("error", (err) => {
+        console.error(
+          `PostgreSQL pool (source "${this.sourceId}"): idle connection dropped, will reconnect on next query:`,
+          err.message
+        );
+      });
       const client = await this.pool.connect();
       client.release();
     } catch (err) {
+      if (this.pool) {
+        const pool = this.pool;
+        this.pool = null;
+        await closeQuietly(() => pool.end());
+      }
       console.error("Failed to connect to PostgreSQL database:", err);
       throw err;
     }
@@ -187,7 +239,7 @@ var PostgresConnector = class _PostgresConnector {
         SELECT table_name
         FROM information_schema.tables
         WHERE table_schema = $1
-        AND table_type = 'BASE TABLE'
+        AND table_type IN ('BASE TABLE', 'FOREIGN')
         ORDER BY table_name
       `,
         [schemaToUse]
@@ -266,7 +318,7 @@ var PostgresConnector = class _PostgresConnector {
           AND i.oid = ix.indexrelid
           AND a.attrelid = t.oid
           AND a.attnum = ANY(ix.indkey)
-          AND t.relkind = 'r'
+          AND t.relkind IN ('r','p')
           AND t.relname = $1
           AND ns.oid = t.relnamespace
           AND ns.nspname = $2
@@ -377,6 +429,64 @@ var PostgresConnector = class _PostgresConnector {
       client.release();
     }
   }
+  async getHealthCheck() {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const [connectionsResult, maxConnectionsResult, bufferCacheResult] = await Promise.all([
+        client.query(`
+          SELECT
+            count(*) AS total,
+            count(*) FILTER (WHERE state = 'active') AS active,
+            count(*) FILTER (WHERE state = 'idle') AS idle,
+            count(*) FILTER (WHERE state = 'idle in transaction') AS idle_in_transaction,
+            count(*) FILTER (WHERE state = 'idle in transaction (aborted)') AS idle_in_transaction_aborted,
+            max(EXTRACT(EPOCH FROM (now() - state_change)))
+              FILTER (WHERE state = 'idle in transaction') AS longest_idle_in_transaction_seconds,
+            max(EXTRACT(EPOCH FROM (now() - query_start)))
+              FILTER (WHERE state = 'active') AS longest_active_query_seconds
+          FROM pg_stat_activity
+          WHERE pid <> pg_backend_pid()
+        `),
+        client.query(`SHOW max_connections`),
+        client.query(
+          `
+          SELECT
+            blks_hit,
+            blks_read,
+            CASE WHEN (blks_hit + blks_read) = 0 THEN NULL
+                 ELSE round(100.0 * blks_hit / (blks_hit + blks_read), 2)
+            END AS hit_ratio_pct
+          FROM pg_stat_database
+          WHERE datname = current_database()
+        `
+        )
+      ]);
+      const conn = connectionsResult.rows[0];
+      const cache = bufferCacheResult.rows[0];
+      return {
+        connections: {
+          total: Number(conn.total),
+          active: Number(conn.active),
+          idle: Number(conn.idle),
+          idleInTransaction: Number(conn.idle_in_transaction),
+          idleInTransactionAborted: Number(conn.idle_in_transaction_aborted),
+          maxConnections: Number(maxConnectionsResult.rows[0].max_connections),
+          longestIdleInTransactionSeconds: toNullableNumber(conn.longest_idle_in_transaction_seconds),
+          longestActiveQuerySeconds: toNullableNumber(conn.longest_active_query_seconds)
+        },
+        bufferCache: {
+          hitRatioPct: toNullableNumber(cache.hit_ratio_pct),
+          blocksHit: Number(cache.blks_hit),
+          blocksRead: Number(cache.blks_read)
+        }
+      };
+    } finally {
+      client.release();
+    }
+  }
   async getStoredProcedures(schema, routineType) {
     if (!this.pool) {
       throw new Error("Not connected to database");
@@ -490,57 +600,65 @@ var PostgresConnector = class _PostgresConnector {
     try {
       const statements = splitSQLStatements(sql, "postgres");
       if (statements.length === 1) {
-        const processedStatement = SQLRowLimiter.applyMaxRows(statements[0], options.maxRows);
+        const { sql: processedStatement, probeApplied } = SQLRowLimiter.applyMaxRowsWithTruncationProbe(
+          statements[0],
+          options.maxRows,
+          "postgres"
+        );
         if (options.readonly) {
           await client.query("BEGIN READ ONLY");
           try {
             const result2 = parameters && parameters.length > 0 ? await client.query(processedStatement, parameters) : await client.query(processedStatement);
             await client.query("COMMIT");
-            return { rows: result2.rows, rowCount: result2.rowCount ?? result2.rows.length };
+            const resultSet2 = {
+              sql: statements[0],
+              rows: result2.rows,
+              rowCount: result2.rowCount ?? result2.rows.length
+            };
+            SQLRowLimiter.flagTruncation(resultSet2, options.maxRows, probeApplied);
+            return { resultSets: [resultSet2] };
           } catch (error) {
             try {
               await client.query("ROLLBACK");
             } catch {
             }
-            console.error(`[PostgreSQL executeSQL] ERROR: ${error.message}`);
-            console.error(`[PostgreSQL executeSQL] SQL: ${processedStatement}`);
-            if (parameters && parameters.length > 0) {
-              console.error(`[PostgreSQL executeSQL] Parameters: ${JSON.stringify(parameters)}`);
-            }
             throw error;
           }
         }
         let result;
         if (parameters && parameters.length > 0) {
-          try {
-            result = await client.query(processedStatement, parameters);
-          } catch (error) {
-            console.error(`[PostgreSQL executeSQL] ERROR: ${error.message}`);
-            console.error(`[PostgreSQL executeSQL] SQL: ${processedStatement}`);
-            console.error(`[PostgreSQL executeSQL] Parameters: ${JSON.stringify(parameters)}`);
-            throw error;
-          }
+          result = await client.query(processedStatement, parameters);
         } else {
           result = await client.query(processedStatement);
         }
-        return { rows: result.rows, rowCount: result.rowCount ?? result.rows.length };
+        const resultSet = {
+          sql: statements[0],
+          rows: result.rows,
+          rowCount: result.rowCount ?? result.rows.length
+        };
+        SQLRowLimiter.flagTruncation(resultSet, options.maxRows, probeApplied);
+        return { resultSets: [resultSet] };
       } else {
         if (parameters && parameters.length > 0) {
           throw new Error("Parameters are not supported for multi-statement queries in PostgreSQL");
         }
-        let allRows = [];
-        let totalRowCount = 0;
+        const resultSets = [];
         await client.query(options.readonly ? "BEGIN READ ONLY" : "BEGIN");
         try {
           for (let statement of statements) {
-            const processedStatement = SQLRowLimiter.applyMaxRows(statement, options.maxRows);
+            const { sql: processedStatement, probeApplied } = SQLRowLimiter.applyMaxRowsWithTruncationProbe(
+              statement,
+              options.maxRows,
+              "postgres"
+            );
             const result = await client.query(processedStatement);
-            if (result.rows && result.rows.length > 0) {
-              allRows.push(...result.rows);
-            }
-            if (result.rowCount) {
-              totalRowCount += result.rowCount;
-            }
+            const resultSet = {
+              sql: statement,
+              rows: result.rows ?? [],
+              rowCount: result.rowCount ?? result.rows?.length ?? 0
+            };
+            SQLRowLimiter.flagTruncation(resultSet, options.maxRows, probeApplied);
+            resultSets.push(resultSet);
           }
           await client.query("COMMIT");
         } catch (error) {
@@ -550,7 +668,7 @@ var PostgresConnector = class _PostgresConnector {
           }
           throw error;
         }
-        return { rows: allRows, rowCount: totalRowCount };
+        return { resultSets };
       }
     } finally {
       client.release();