pg_peek 0.1.0

data/app/models/pg_peek/table.rb

@@ -0,0 +1,266 @@
+class PgPeek::Table
+  attr_reader :database, :name
+
+  STATS_RESET_QUERY = PgPeek::QueryLoader.mark("SELECT stats_reset FROM pg_stat_bgwriter").freeze
+
+  def self.inline_stats_for(database, table_names)
+    return {} if table_names.empty?
+
+    query = PgPeek::QueryLoader.load("tables/inline_stats",
+                                      pg_version: database.major_version,
+                                      count: table_names.size)
+
+    result = database.connection.exec_query(query, "PgPeek::Table InlineStats", table_names)
+    result.rows.each_with_object({}) do |row, hash|
+      table_name = row[0]
+      heap_blks_read = row[1].to_i
+      heap_blks_hit = row[2].to_i
+      idx_blks_read = row[3].to_i
+      idx_blks_hit = row[4].to_i
+
+      hash[table_name] = {
+        heap_hit_ratio: cache_hit_ratio(heap_blks_hit, heap_blks_read),
+        index_hit_ratio: cache_hit_ratio(idx_blks_hit, idx_blks_read)
+      }
+    end
+  end
+
+  def self.cache_hit_ratio(hits, reads)
+    total = hits + reads
+    return nil if total.zero?
+    (hits.to_f / total * 100).round(1)
+  end
+
+  def self.excluded?(table_name)
+    PgPeek.config.excluded_tables.any? do |pattern|
+      case pattern
+      when Regexp
+        pattern.match?(table_name)
+      when String
+        pattern == table_name
+      else
+        false
+      end
+    end
+  end
+
+  def initialize(database, name)
+    @database = database
+    @name = name
+  end
+
+  def stats
+    @stats ||= fetch_stats
+  end
+
+  def stats_reset_at
+    @stats_reset_at ||= begin
+      result = database.connection.execute(STATS_RESET_QUERY)
+      result.first&.dig("stats_reset")
+    end
+  end
+
+  def seconds_since_reset
+    return nil unless stats_reset_at
+    Time.current - stats_reset_at
+  end
+
+  # Cache metrics
+  def heap_cache_hit_ratio
+    self.class.cache_hit_ratio(heap_blks_hit, heap_blks_read)
+  end
+
+  def index_cache_hit_ratio
+    self.class.cache_hit_ratio(idx_blks_hit, idx_blks_read)
+  end
+
+  def toast_cache_hit_ratio
+    self.class.cache_hit_ratio(toast_blks_hit, toast_blks_read)
+  end
+
+  def toast_index_cache_hit_ratio
+    self.class.cache_hit_ratio(tidx_blks_hit, tidx_blks_read)
+  end
+
+  # Row stats
+  def seq_scan
+    stats["seq_scan"].to_i
+  end
+
+  def idx_scan
+    stats["idx_scan"].to_i
+  end
+
+  def total_scans
+    seq_scan + idx_scan
+  end
+
+  def seq_scan_percentage
+    return nil if total_scans.zero?
+    (seq_scan.to_f / total_scans * 100).round(1)
+  end
+
+  def idx_scan_percentage
+    return nil if total_scans.zero?
+    (idx_scan.to_f / total_scans * 100).round(1)
+  end
+
+  def index_usage_percentage
+    idx_scan_percentage
+  end
+
+  def seq_tup_read
+    stats["seq_tup_read"].to_i
+  end
+
+  def idx_tup_fetch
+    stats["idx_tup_fetch"].to_i
+  end
+
+  def rows_fetched
+    seq_tup_read + idx_tup_fetch
+  end
+
+  def rows_inserted
+    stats["n_tup_ins"].to_i
+  end
+
+  def rows_updated
+    stats["n_tup_upd"].to_i
+  end
+
+  def rows_deleted
+    stats["n_tup_del"].to_i
+  end
+
+  def live_tuples
+    stats["n_live_tup"].to_i
+  end
+
+  def dead_tuples
+    stats["n_dead_tup"].to_i
+  end
+
+  def dead_tuple_ratio
+    total = live_tuples + dead_tuples
+    return nil if total.zero?
+    (dead_tuples.to_f / total * 100).round(1)
+  end
+
+  def dead_tuple_warning?
+    ratio = dead_tuple_ratio
+    return false if ratio.nil?
+    ratio >= PgPeek.config.dead_tuple_warning_threshold
+  end
+
+  def row_estimate
+    estimate = stats["row_estimate"]
+    estimate.nil? ? 0 : estimate.to_i
+  end
+
+  # Vacuum/maintenance stats
+  def last_vacuum
+    stats["last_vacuum"]
+  end
+
+  def last_autovacuum
+    stats["last_autovacuum"]
+  end
+
+  def last_analyze
+    stats["last_analyze"]
+  end
+
+  def last_autoanalyze
+    stats["last_autoanalyze"]
+  end
+
+  def vacuum_count
+    stats["vacuum_count"].to_i
+  end
+
+  def autovacuum_count
+    stats["autovacuum_count"].to_i
+  end
+
+  def analyze_count
+    stats["analyze_count"].to_i
+  end
+
+  def autoanalyze_count
+    stats["autoanalyze_count"].to_i
+  end
+
+  # Cache block stats (raw)
+  def heap_blks_read
+    stats["heap_blks_read"].to_i
+  end
+
+  def heap_blks_hit
+    stats["heap_blks_hit"].to_i
+  end
+
+  def idx_blks_read
+    stats["idx_blks_read"].to_i
+  end
+
+  def idx_blks_hit
+    stats["idx_blks_hit"].to_i
+  end
+
+  def toast_blks_read
+    stats["toast_blks_read"].to_i
+  end
+
+  def toast_blks_hit
+    stats["toast_blks_hit"].to_i
+  end
+
+  def tidx_blks_read
+    stats["tidx_blks_read"].to_i
+  end
+
+  def tidx_blks_hit
+    stats["tidx_blks_hit"].to_i
+  end
+
+  private
+
+  def fetch_stats
+    query = PgPeek::QueryLoader.load("tables/stats", pg_version: database.major_version)
+    result = database.connection.exec_query(query, "PgPeek::Table Stats", [ name ])
+    result.first || empty_stats
+  end
+
+  def empty_stats
+    {
+      "table_name" => name,
+      "seq_scan" => 0,
+      "seq_tup_read" => 0,
+      "idx_scan" => 0,
+      "idx_tup_fetch" => 0,
+      "n_tup_ins" => 0,
+      "n_tup_upd" => 0,
+      "n_tup_del" => 0,
+      "n_live_tup" => 0,
+      "n_dead_tup" => 0,
+      "last_vacuum" => nil,
+      "last_autovacuum" => nil,
+      "last_analyze" => nil,
+      "last_autoanalyze" => nil,
+      "vacuum_count" => 0,
+      "autovacuum_count" => 0,
+      "analyze_count" => 0,
+      "autoanalyze_count" => 0,
+      "heap_blks_read" => 0,
+      "heap_blks_hit" => 0,
+      "idx_blks_read" => 0,
+      "idx_blks_hit" => 0,
+      "toast_blks_read" => 0,
+      "toast_blks_hit" => 0,
+      "tidx_blks_read" => 0,
+      "tidx_blks_hit" => 0,
+      "row_estimate" => 0
+    }
+  end
+end

data/app/queries/pg_peek/pg14/activity/sessions.sql

@@ -0,0 +1,26 @@
+-- Client sessions on the current database, except the one asking. Every
+-- duration is taken from one clock reading, so they agree with each other;
+-- clock_timestamp() rather than now() because the reader may be inside a
+-- long transaction of its own.
+SELECT
+  pid,
+  usename,
+  application_name,
+  client_addr::text AS client_addr,
+  state,
+  wait_event_type,
+  wait_event,
+  backend_start,
+  xact_start,
+  query_start,
+  state_change,
+  round(1000 * EXTRACT(EPOCH FROM (clock_timestamp() - query_start)))::bigint AS query_ms,
+  round(1000 * EXTRACT(EPOCH FROM (clock_timestamp() - xact_start)))::bigint AS xact_ms,
+  round(1000 * EXTRACT(EPOCH FROM (clock_timestamp() - state_change)))::bigint AS state_ms,
+  array_to_string(pg_blocking_pids(pid), ',') AS blocked_by,
+  query
+FROM pg_stat_activity
+WHERE datname = current_database()
+  AND backend_type = 'client backend'
+  AND pid <> pg_backend_pid()
+ORDER BY pid

data/app/queries/pg_peek/pg14/activity/summary.sql

@@ -0,0 +1,8 @@
+-- Server-wide connection use. max_connections is a cluster setting, so the
+-- count spans every database. current_user is who pg_peek connects as, for
+-- the hint about hidden query text.
+SELECT
+  current_setting('max_connections')::int AS max_connections,
+  count(*) FILTER (WHERE backend_type = 'client backend') AS client_connections,
+  current_user AS username
+FROM pg_stat_activity

data/app/queries/pg_peek/pg14/activity/waiting_locks.sql

@@ -0,0 +1,11 @@
+-- What each waiting session is waiting for. A backend waits for at most one
+-- lock at a time, so pid identifies the row. Relations from other databases
+-- render as a bare oid, which the caller filters out by pid anyway.
+SELECT
+  pid,
+  locktype,
+  mode,
+  CASE WHEN relation IS NOT NULL THEN relation::regclass::text END AS relation
+FROM pg_locks
+WHERE NOT granted
+  AND pid <> pg_backend_pid()

data/app/queries/pg_peek/pg14/database/vitals.sql

@@ -0,0 +1,11 @@
+-- One row of health figures for the current database.
+SELECT
+  round(100.0 * blks_hit / NULLIF(blks_hit + blks_read, 0), 1) AS cache_hit_ratio,
+  numbackends AS connections,
+  xact_commit,
+  xact_rollback,
+  deadlocks,
+  temp_files,
+  stats_reset
+FROM pg_stat_database
+WHERE datname = current_database()

data/app/queries/pg_peek/pg14/indexes/all.sql

@@ -0,0 +1,17 @@
+-- Every index on a user table, with how often it has been scanned since the
+-- statistics were last reset. Constraint indexes are marked so a zero scan
+-- count is not mistaken for waste: they earn their keep on writes.
+SELECT
+  s.relname AS table_name,
+  s.indexrelname AS index_name,
+  s.idx_scan AS scans,
+  s.idx_tup_read AS tuples_read,
+  pg_relation_size(s.indexrelid) AS size_bytes,
+  pg_size_pretty(pg_relation_size(s.indexrelid)) AS size,
+  i.indisprimary AS primary_key,
+  i.indisunique AS unique_index,
+  pg_get_indexdef(s.indexrelid) AS definition
+FROM pg_stat_user_indexes s
+JOIN pg_index i ON i.indexrelid = s.indexrelid
+WHERE s.schemaname = ANY (current_schemas(false))
+ORDER BY pg_relation_size(s.indexrelid) DESC, s.relname, s.indexrelname

data/app/queries/pg_peek/pg14/pg_stat_statements/endpoints.sql

@@ -0,0 +1,43 @@
+-- Database cost per controller#action, from SQLcommenter tags.
+--
+-- Catalog queries are excluded throughout: Rails' schema introspection runs
+-- once when a model loads and is tagged with whichever endpoint happened to
+-- trigger it, so it both inflates that endpoint's cost and, sitting at calls=1
+-- forever, destroys the min(calls) request-count estimate below.
+WITH application_queries AS (
+  SELECT
+    COALESCE(
+      substring(query from 'namespaced_controller=''([^'']+)'''),
+      substring(query from 'controller=''([^'']+)''')
+    ) AS controller,
+    substring(query from 'action=''([^'']+)''') AS action,
+    calls, total_exec_time, rows
+  FROM pg_stat_statements
+  WHERE userid = (SELECT usesysid FROM pg_user WHERE usename = current_user LIMIT 1)
+    AND dbid = (SELECT oid FROM pg_database WHERE datname = current_database())
+  AND query NOT LIKE '%/* pg_peek */%'
+    AND query ~ 'controller=''[^'']+'''
+    AND query ~ 'action=''[^'']+'''
+    AND query !~* 'pg_catalog|information_schema|pg_index|pg_class|pg_attribute'
+    AND query !~* '^\s*SHOW '
+),
+requests AS (
+  -- Some query runs exactly once per request, so the smallest call count for an
+  -- endpoint approximates how many times it was served.
+  SELECT controller, action, min(calls) AS request_count
+  FROM application_queries
+  GROUP BY controller, action
+)
+SELECT
+  q.controller || '#' || q.action AS endpoint,
+  SUM(q.total_exec_time) AS total_exec_time_ms,
+  SUM(q.calls) AS total_calls,
+  COUNT(*) AS query_count,
+  SUM(q.rows) AS total_rows,
+  r.request_count,
+  ROUND((MAX(q.calls)::numeric / NULLIF(r.request_count, 0)), 1) AS max_queries_per_request
+FROM application_queries q
+JOIN requests r ON r.controller = q.controller AND r.action = q.action
+GROUP BY q.controller, q.action, r.request_count
+ORDER BY total_exec_time_ms DESC
+LIMIT {{limit}}

data/app/queries/pg_peek/pg14/pg_stat_statements/jobs.sql

@@ -0,0 +1,12 @@
+SELECT
+  substring(query from 'job=''([^'']+)''') AS job_class,
+  SUM(calls) AS total_calls,
+  SUM(total_exec_time) AS total_exec_time_ms,
+  COUNT(*) AS query_count
+FROM pg_stat_statements
+WHERE userid = (SELECT usesysid FROM pg_user WHERE usename = current_user LIMIT 1)
+  AND dbid = (SELECT oid FROM pg_database WHERE datname = current_database())
+  AND query NOT LIKE '%/* pg_peek */%'
+  AND query ~ 'job=''[^'']+'''
+GROUP BY job_class
+ORDER BY total_exec_time_ms DESC

data/app/queries/pg_peek/pg14/pg_stat_statements/outliers.sql

@@ -0,0 +1,13 @@
+SELECT
+  interval '1 millisecond' * total_exec_time AS total_exec_time,
+  COALESCE(to_char((total_exec_time/NULLIF(sum(total_exec_time) OVER(), 0)) * 100, 'FM990D0'), '0') || '%' AS prop_exec_time,
+  to_char(calls, 'FM999G999G999G990') AS ncalls,
+  ROUND(total_exec_time/NULLIF(calls, 0)) AS avg_exec_ms,
+  interval '1 millisecond' * (blk_read_time + blk_write_time) AS sync_io_time,
+  query
+FROM pg_stat_statements
+WHERE userid = (SELECT usesysid FROM pg_user WHERE usename = current_user LIMIT 1)
+  AND dbid = (SELECT oid FROM pg_database WHERE datname = current_database())
+  AND query NOT LIKE '%/* pg_peek */%'
+ORDER BY total_exec_time DESC
+LIMIT {{limit}}

data/app/queries/pg_peek/pg14/pg_stat_statements/outliers_by_job.sql

@@ -0,0 +1,14 @@
+SELECT
+  interval '1 millisecond' * total_exec_time AS total_exec_time,
+  COALESCE(to_char((total_exec_time/NULLIF(sum(total_exec_time) OVER(), 0)) * 100, 'FM990D0'), '0') || '%' AS prop_exec_time,
+  to_char(calls, 'FM999G999G999G990') AS ncalls,
+  ROUND(total_exec_time/NULLIF(calls, 0)) AS avg_exec_ms,
+  interval '1 millisecond' * (blk_read_time + blk_write_time) AS sync_io_time,
+  query
+FROM pg_stat_statements
+WHERE userid = (SELECT usesysid FROM pg_user WHERE usename = current_user LIMIT 1)
+  AND dbid = (SELECT oid FROM pg_database WHERE datname = current_database())
+  AND query NOT LIKE '%/* pg_peek */%'
+  AND query LIKE {{job_pattern}}
+ORDER BY total_exec_time DESC
+LIMIT {{limit}}

data/app/queries/pg_peek/pg14/tables/dead_tuples.sql

@@ -0,0 +1,11 @@
+-- Tables whose dead-tuple share is at or above the warning threshold.
+SELECT
+  relname,
+  n_live_tup,
+  n_dead_tup,
+  round(100.0 * n_dead_tup / NULLIF(n_live_tup + n_dead_tup, 0), 1) AS dead_ratio,
+  last_autovacuum
+FROM pg_stat_user_tables
+WHERE n_live_tup + n_dead_tup > 0
+  AND 100.0 * n_dead_tup / (n_live_tup + n_dead_tup) >= {{threshold}}
+ORDER BY dead_ratio DESC

data/app/queries/pg_peek/pg14/tables/inline_stats.sql

@@ -0,0 +1,9 @@
+SELECT
+  t.relname AS table_name,
+  s.heap_blks_read,
+  s.heap_blks_hit,
+  s.idx_blks_read,
+  s.idx_blks_hit
+FROM pg_stat_user_tables t
+LEFT JOIN pg_statio_user_tables s ON t.relid = s.relid
+WHERE t.relname IN ({{placeholders:count}})

data/app/queries/pg_peek/pg14/tables/stats.sql

@@ -0,0 +1,32 @@
+SELECT
+  t.relname AS table_name,
+  t.seq_scan,
+  t.seq_tup_read,
+  t.idx_scan,
+  t.idx_tup_fetch,
+  t.n_tup_ins,
+  t.n_tup_upd,
+  t.n_tup_del,
+  t.n_live_tup,
+  t.n_dead_tup,
+  t.last_vacuum,
+  t.last_autovacuum,
+  t.last_analyze,
+  t.last_autoanalyze,
+  t.vacuum_count,
+  t.autovacuum_count,
+  t.analyze_count,
+  t.autoanalyze_count,
+  s.heap_blks_read,
+  s.heap_blks_hit,
+  s.idx_blks_read,
+  s.idx_blks_hit,
+  s.toast_blks_read,
+  s.toast_blks_hit,
+  s.tidx_blks_read,
+  s.tidx_blks_hit,
+  c.reltuples AS row_estimate
+FROM pg_stat_user_tables t
+LEFT JOIN pg_statio_user_tables s ON t.relid = s.relid
+LEFT JOIN pg_class c ON t.relid = c.oid
+WHERE t.relname = $1

data/app/queries/pg_peek/pg15/activity/sessions.sql

@@ -0,0 +1,26 @@
+-- Client sessions on the current database, except the one asking. Every
+-- duration is taken from one clock reading, so they agree with each other;
+-- clock_timestamp() rather than now() because the reader may be inside a
+-- long transaction of its own.
+SELECT
+  pid,
+  usename,
+  application_name,
+  client_addr::text AS client_addr,
+  state,
+  wait_event_type,
+  wait_event,
+  backend_start,
+  xact_start,
+  query_start,
+  state_change,
+  round(1000 * EXTRACT(EPOCH FROM (clock_timestamp() - query_start)))::bigint AS query_ms,
+  round(1000 * EXTRACT(EPOCH FROM (clock_timestamp() - xact_start)))::bigint AS xact_ms,
+  round(1000 * EXTRACT(EPOCH FROM (clock_timestamp() - state_change)))::bigint AS state_ms,
+  array_to_string(pg_blocking_pids(pid), ',') AS blocked_by,
+  query
+FROM pg_stat_activity
+WHERE datname = current_database()
+  AND backend_type = 'client backend'
+  AND pid <> pg_backend_pid()
+ORDER BY pid

data/app/queries/pg_peek/pg15/activity/summary.sql

@@ -0,0 +1,8 @@
+-- Server-wide connection use. max_connections is a cluster setting, so the
+-- count spans every database. current_user is who pg_peek connects as, for
+-- the hint about hidden query text.
+SELECT
+  current_setting('max_connections')::int AS max_connections,
+  count(*) FILTER (WHERE backend_type = 'client backend') AS client_connections,
+  current_user AS username
+FROM pg_stat_activity

data/app/queries/pg_peek/pg15/activity/waiting_locks.sql

@@ -0,0 +1,11 @@
+-- What each waiting session is waiting for. A backend waits for at most one
+-- lock at a time, so pid identifies the row. Relations from other databases
+-- render as a bare oid, which the caller filters out by pid anyway.
+SELECT
+  pid,
+  locktype,
+  mode,
+  CASE WHEN relation IS NOT NULL THEN relation::regclass::text END AS relation
+FROM pg_locks
+WHERE NOT granted
+  AND pid <> pg_backend_pid()

data/app/queries/pg_peek/pg15/database/vitals.sql

@@ -0,0 +1,11 @@
+-- One row of health figures for the current database.
+SELECT
+  round(100.0 * blks_hit / NULLIF(blks_hit + blks_read, 0), 1) AS cache_hit_ratio,
+  numbackends AS connections,
+  xact_commit,
+  xact_rollback,
+  deadlocks,
+  temp_files,
+  stats_reset
+FROM pg_stat_database
+WHERE datname = current_database()

data/app/queries/pg_peek/pg15/indexes/all.sql

@@ -0,0 +1,17 @@
+-- Every index on a user table, with how often it has been scanned since the
+-- statistics were last reset. Constraint indexes are marked so a zero scan
+-- count is not mistaken for waste: they earn their keep on writes.
+SELECT
+  s.relname AS table_name,
+  s.indexrelname AS index_name,
+  s.idx_scan AS scans,
+  s.idx_tup_read AS tuples_read,
+  pg_relation_size(s.indexrelid) AS size_bytes,
+  pg_size_pretty(pg_relation_size(s.indexrelid)) AS size,
+  i.indisprimary AS primary_key,
+  i.indisunique AS unique_index,
+  pg_get_indexdef(s.indexrelid) AS definition
+FROM pg_stat_user_indexes s
+JOIN pg_index i ON i.indexrelid = s.indexrelid
+WHERE s.schemaname = ANY (current_schemas(false))
+ORDER BY pg_relation_size(s.indexrelid) DESC, s.relname, s.indexrelname

data/app/queries/pg_peek/pg15/pg_stat_statements/endpoints.sql

@@ -0,0 +1,43 @@
+-- Database cost per controller#action, from SQLcommenter tags.
+--
+-- Catalog queries are excluded throughout: Rails' schema introspection runs
+-- once when a model loads and is tagged with whichever endpoint happened to
+-- trigger it, so it both inflates that endpoint's cost and, sitting at calls=1
+-- forever, destroys the min(calls) request-count estimate below.
+WITH application_queries AS (
+  SELECT
+    COALESCE(
+      substring(query from 'namespaced_controller=''([^'']+)'''),
+      substring(query from 'controller=''([^'']+)''')
+    ) AS controller,
+    substring(query from 'action=''([^'']+)''') AS action,
+    calls, total_exec_time, rows
+  FROM pg_stat_statements
+  WHERE userid = (SELECT usesysid FROM pg_user WHERE usename = current_user LIMIT 1)
+    AND dbid = (SELECT oid FROM pg_database WHERE datname = current_database())
+  AND query NOT LIKE '%/* pg_peek */%'
+    AND query ~ 'controller=''[^'']+'''
+    AND query ~ 'action=''[^'']+'''
+    AND query !~* 'pg_catalog|information_schema|pg_index|pg_class|pg_attribute'
+    AND query !~* '^\s*SHOW '
+),
+requests AS (
+  -- Some query runs exactly once per request, so the smallest call count for an
+  -- endpoint approximates how many times it was served.
+  SELECT controller, action, min(calls) AS request_count
+  FROM application_queries
+  GROUP BY controller, action
+)
+SELECT
+  q.controller || '#' || q.action AS endpoint,
+  SUM(q.total_exec_time) AS total_exec_time_ms,
+  SUM(q.calls) AS total_calls,
+  COUNT(*) AS query_count,
+  SUM(q.rows) AS total_rows,
+  r.request_count,
+  ROUND((MAX(q.calls)::numeric / NULLIF(r.request_count, 0)), 1) AS max_queries_per_request
+FROM application_queries q
+JOIN requests r ON r.controller = q.controller AND r.action = q.action
+GROUP BY q.controller, q.action, r.request_count
+ORDER BY total_exec_time_ms DESC
+LIMIT {{limit}}

data/app/queries/pg_peek/pg15/pg_stat_statements/jobs.sql

@@ -0,0 +1,12 @@
+SELECT
+  substring(query from 'job=''([^'']+)''') AS job_class,
+  SUM(calls) AS total_calls,
+  SUM(total_exec_time) AS total_exec_time_ms,
+  COUNT(*) AS query_count
+FROM pg_stat_statements
+WHERE userid = (SELECT usesysid FROM pg_user WHERE usename = current_user LIMIT 1)
+  AND dbid = (SELECT oid FROM pg_database WHERE datname = current_database())
+  AND query NOT LIKE '%/* pg_peek */%'
+  AND query ~ 'job=''[^'']+'''
+GROUP BY job_class
+ORDER BY total_exec_time_ms DESC

data/app/queries/pg_peek/pg15/pg_stat_statements/outliers.sql

@@ -0,0 +1,13 @@
+SELECT
+  interval '1 millisecond' * total_exec_time AS total_exec_time,
+  COALESCE(to_char((total_exec_time/NULLIF(sum(total_exec_time) OVER(), 0)) * 100, 'FM990D0'), '0') || '%' AS prop_exec_time,
+  to_char(calls, 'FM999G999G999G990') AS ncalls,
+  ROUND(total_exec_time/NULLIF(calls, 0)) AS avg_exec_ms,
+  interval '1 millisecond' * (blk_read_time + blk_write_time) AS sync_io_time,
+  query
+FROM pg_stat_statements
+WHERE userid = (SELECT usesysid FROM pg_user WHERE usename = current_user LIMIT 1)
+  AND dbid = (SELECT oid FROM pg_database WHERE datname = current_database())
+  AND query NOT LIKE '%/* pg_peek */%'
+ORDER BY total_exec_time DESC
+LIMIT {{limit}}

data/app/queries/pg_peek/pg15/pg_stat_statements/outliers_by_job.sql

@@ -0,0 +1,14 @@
+SELECT
+  interval '1 millisecond' * total_exec_time AS total_exec_time,
+  COALESCE(to_char((total_exec_time/NULLIF(sum(total_exec_time) OVER(), 0)) * 100, 'FM990D0'), '0') || '%' AS prop_exec_time,
+  to_char(calls, 'FM999G999G999G990') AS ncalls,
+  ROUND(total_exec_time/NULLIF(calls, 0)) AS avg_exec_ms,
+  interval '1 millisecond' * (blk_read_time + blk_write_time) AS sync_io_time,
+  query
+FROM pg_stat_statements
+WHERE userid = (SELECT usesysid FROM pg_user WHERE usename = current_user LIMIT 1)
+  AND dbid = (SELECT oid FROM pg_database WHERE datname = current_database())
+  AND query NOT LIKE '%/* pg_peek */%'
+  AND query LIKE {{job_pattern}}
+ORDER BY total_exec_time DESC
+LIMIT {{limit}}

data/app/queries/pg_peek/pg15/tables/dead_tuples.sql

@@ -0,0 +1,11 @@
+-- Tables whose dead-tuple share is at or above the warning threshold.
+SELECT
+  relname,
+  n_live_tup,
+  n_dead_tup,
+  round(100.0 * n_dead_tup / NULLIF(n_live_tup + n_dead_tup, 0), 1) AS dead_ratio,
+  last_autovacuum
+FROM pg_stat_user_tables
+WHERE n_live_tup + n_dead_tup > 0
+  AND 100.0 * n_dead_tup / (n_live_tup + n_dead_tup) >= {{threshold}}
+ORDER BY dead_ratio DESC

data/app/queries/pg_peek/pg15/tables/inline_stats.sql

@@ -0,0 +1,9 @@
+SELECT
+  t.relname AS table_name,
+  s.heap_blks_read,
+  s.heap_blks_hit,
+  s.idx_blks_read,
+  s.idx_blks_hit
+FROM pg_stat_user_tables t
+LEFT JOIN pg_statio_user_tables s ON t.relid = s.relid
+WHERE t.relname IN ({{placeholders:count}})