@indiekitai/pg-dash 0.5.2 → 0.6.0

package/README.md

@@ -147,6 +147,23 @@ Real-time lock wait monitor — refreshes every 3 seconds. Shows:
 - Long-running queries (configurable threshold via `--long-query-threshold`)
 - Table and lock type for each wait
 
+### 📊 query-stats (PG 18+)
+
+```bash
+# Export query statistics from production
+pg-dash query-stats export postgres://prod-server/db --file prod-stats.json
+
+# Import to development environment
+pg-dash query-stats import prod-stats.json postgres://localhost/db
+```
+
+Export/import PostgreSQL query statistics (requires PG 18+). Enables "production query plans without production data" workflow:
+1. Export stats from production: `pg-dash query-stats export prod`
+2. Import to dev: `pg-dash query-stats import prod-stats.json dev`
+3. Run `EXPLAIN` locally — now uses production statistics for accurate query plans
+
+The exported JSON is typically <1MB regardless of database size.
+
 ### 🛡️ Migration Safety Check
 - Analyze a migration SQL file for risks before running it
 - Detects: `CREATE INDEX` without `CONCURRENTLY` (lock risk), `ADD COLUMN NOT NULL` without `DEFAULT`, `ALTER COLUMN TYPE` (full table rewrite), `DROP COLUMN` (app breakage risk), `ADD CONSTRAINT` without `NOT VALID` (full table scan), `CREATE INDEX CONCURRENTLY` inside a transaction (runtime failure), `DROP TABLE`, `TRUNCATE`, `DELETE`/`UPDATE` without `WHERE`

package/README.zh-CN.md

@@ -183,6 +183,8 @@ pg-dash explain "<query>" <connection>           终端里 EXPLAIN ANALYZE 查
 pg-dash watch-locks <connection>                 实时锁和长查询监控
 pg-dash diff-env --source <url> --target <url>   对比两个环境
 pg-dash schema-diff <connection-string>          显示 Schema 变更
+pg-dash query-stats export <connection>          导出查询统计（PG 18+）
+pg-dash query-stats import <file> <connection>   导入查询统计（PG 18+）
 
 Options:
   -p, --port <port>      面板端口（默认：3480）

package/dist/cli.js

@@ -4195,6 +4195,8 @@ Usage:
   pg-dash watch-locks <connection>                      Real-time lock + long-query monitor
   pg-dash diff-env --source <url> --target <url>        Compare two environments
   pg-dash schema-diff <connection-string>               Show latest schema changes
+  pg-dash query-stats export <connection>               Export query statistics (PG 18+)
+  pg-dash query-stats import <file> <connection>       Import query statistics (PG 18+)
   pg-dash --host localhost --user postgres --db mydb
 
 Options:
@@ -4234,7 +4236,7 @@ Environment variables:
 `);
   process.exit(0);
 }
-var KNOWN_SUBCOMMANDS = ["check", "health", "check-migration", "schema-diff", "diff-env", "explain", "watch-locks"];
+var KNOWN_SUBCOMMANDS = ["check", "health", "check-migration", "schema-diff", "diff-env", "explain", "watch-locks", "query-stats"];
 var subcommand = positionals[0];
 function isValidConnectionString(s) {
   return s.startsWith("postgresql://") || s.startsWith("postgres://") || s.includes("@") || // user@host shorthand
@@ -4751,6 +4753,118 @@ ${bold}${yellow}  Long-running Queries (${report.longRunningQueries.length})${re
   await tick();
   const timer = setInterval(tick, intervalSec * 1e3);
   void timer;
+} else if (subcommand === "query-stats") {
+  const action = positionals[1];
+  const { Pool: Pool3 } = await import("pg");
+  const fs6 = await import("fs");
+  if (action === "export") {
+    const connStr = positionals[2] || resolveConnectionString(2);
+    if (!connStr) {
+      console.error("Error: provide a connection string.\n\nUsage: pg-dash query-stats export <connection> [--file output.json]");
+      process.exit(1);
+    }
+    const outputFile = values["snapshot-path"] || "query-stats.json";
+    const pool = new Pool3({ connectionString: connStr, max: 1, connectionTimeoutMillis: 1e4 });
+    try {
+      const versionRes = await pool.query("SHOW server_version_num");
+      const versionNum = parseInt(versionRes.rows[0].server_version_num, 10);
+      if (versionNum < 18e4) {
+        console.error("Error: query-stats export requires PostgreSQL 18+. Current:", versionRes.rows[0].server_version_num);
+        process.exit(1);
+      }
+      const stats = await pool.query("SELECT pg_stat_statements_reset()");
+      const res = await pool.query(`
+        SELECT 
+          s.datname,
+          s.relkind,
+          s.relname,
+          s.seq_scan,
+          s.seq_tup_read,
+          s.idx_scan,
+          s.idx_tup_fetch,
+          s.n_tup_ins,
+          s.n_tup_upd,
+          s.n_tup_del,
+          s.n_live_tup,
+          s.n_dead_tup,
+          s.vacuum_count,
+          s.autovacuum_count,
+          s.last_vacuum,
+          s.last_autovacuum,
+          s.last_autovacuum_age,
+          s.last_data_change_age,
+          s.changes_since_analyze,
+          s.changes_since_autovacuum,
+          s.tuple_count,
+          s.tuple_per_read,
+          s.tuple_written_per_sec
+        FROM pg_stat_user_tables s
+        ORDER BY seq_scan DESC
+        LIMIT 100
+      `);
+      const exportData = {
+        exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        pgVersion: versionRes.rows[0].server_version_num,
+        tables: res.rows
+      };
+      fs6.writeFileSync(outputFile, JSON.stringify(exportData, null, 2));
+      console.log(`Exported query statistics to ${outputFile}`);
+      console.log(`Tables: ${res.rows.length}, Size: ${JSON.stringify(exportData).length} bytes`);
+      await pool.end();
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      await pool.end();
+      process.exit(1);
+    }
+  } else if (action === "import") {
+    const inputFile = positionals[2];
+    const connStr = positionals[3] || resolveConnectionString(3);
+    if (!inputFile) {
+      console.error("Error: provide an input file.\n\nUsage: pg-dash query-stats import <file> <connection>");
+      process.exit(1);
+    }
+    if (!connStr) {
+      console.error("Error: provide a connection string.\n\nUsage: pg-dash query-stats import <file> <connection>");
+      process.exit(1);
+    }
+    if (!fs6.existsSync(inputFile)) {
+      console.error(`Error: file not found: ${inputFile}`);
+      process.exit(1);
+    }
+    const pool = new Pool3({ connectionString: connStr, max: 1, connectionTimeoutMillis: 1e4 });
+    try {
+      const versionRes = await pool.query("SHOW server_version_num");
+      const versionNum = parseInt(versionRes.rows[0].server_version_num, 10);
+      if (versionNum < 18e4) {
+        console.error("Error: query-stats import requires PostgreSQL 18+. Current:", versionRes.rows[0].server_version_num);
+        process.exit(1);
+      }
+      const importData = JSON.parse(fs6.readFileSync(inputFile, "utf-8"));
+      console.log(`Importing query statistics from ${inputFile}`);
+      console.log(`PG version: ${importData.pgVersion} -> current: ${versionRes.rows[0].server_version_num}`);
+      await pool.query(`
+        CREATE TEMP TABLE _imported_stats (LIKE pg_stat_user_tables INCLUDING ALL)
+      `);
+      for (const row of importData.tables) {
+        const cols = Object.keys(row).join(", ");
+        const vals = Object.values(row).map((v) => v === null ? "NULL" : typeof v === "string" ? `'${v.replace(/'/g, "''")}'` : v).join(", ");
+        try {
+          await pool.query(`INSERT INTO _imported_stats (${cols}) VALUES (${vals})`);
+        } catch (e) {
+        }
+      }
+      await pool.query("SELECT pg_restore_relation_stats('_imported_stats'::regclass)");
+      console.log(`Imported statistics for ${importData.tables.length} tables`);
+      await pool.end();
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      await pool.end();
+      process.exit(1);
+    }
+  } else {
+    console.error("Error: specify 'export' or 'import'.\n\nUsage:\n  pg-dash query-stats export <connection> [--file output.json]\n  pg-dash query-stats import <file> <connection>");
+    process.exit(1);
+  }
 } else {
   if (subcommand && !isValidConnectionString(subcommand) && KNOWN_SUBCOMMANDS.indexOf(subcommand) === -1) {
     console.error(