pg_peek 0.1.0

data/app/queries/pg_peek/pg15/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/pg16/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/pg16/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/pg16/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/pg16/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/pg16/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/pg16/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/pg16/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/pg16/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/pg16/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/pg16/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/pg16/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/pg16/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/pg17/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/pg17/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/pg17/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/pg17/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/pg17/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/pg17/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/pg17/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/pg17/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' * (shared_blk_read_time + shared_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/pg17/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' * (shared_blk_read_time + shared_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/pg17/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/pg17/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/pg17/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/pg18/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/pg18/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/pg18/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/pg18/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/pg18/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/pg18/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/pg18/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/pg18/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' * (shared_blk_read_time + shared_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/pg18/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' * (shared_blk_read_time + shared_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}}