pg-stats 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f0b03f1555456bb9186044dd2e591d03905c61a3861dec3852a7aeb2778625d
-  data.tar.gz: 11bc08a05d97bc1c75e2486d4e5768f6e5a50022e927c9102e889d7dbeaeccd9
+  metadata.gz: 9e621fc8e0c48634775ea2900f893961830848e582a027713de9fb50dbc109da
+  data.tar.gz: 9c10943edee1b52e1ea39e51be577e51c8114e41495b3ad09024426f0500134c
 SHA512:
-  metadata.gz: b1d30f8938922f6a7a31cb3c703bbd0348b3b7b0a38f591ab1c3483901c7a1fb194464b467d32806468012ba0625fbe72416225022be034af9e22908033a25da
-  data.tar.gz: db963d167755e828781bf57cffa49a6a13943899000ff4c2ea9bd671c079f92d9424f017d3e2c4935324ec5f676a7cafc4770fd97f08212a5366880e4a08c1d4
+  metadata.gz: 8586306450c8f4efdc01bd19bdd9ca4d057310e4f20928c7da66e35c721e656e9284ee5b958b902d94d2fff05cc6c866ddb2756b57bc42d806a592579fc9885d
+  data.tar.gz: 9675a5a7d7332a7a43d06ac35d8f1f347b5e22362609c995203a89a404ada143b449bb2e7e346de82f4346c377645badacff6896f6d7c2230a3f05e0aeaf5238

data/queries/bloat.sql

@@ -1,63 +1,122 @@
 /* Table and index bloat in your database ordered by most wasteful */
 
-WITH constants AS (
-  SELECT current_setting('block_size')::numeric AS bs, 23 AS hdr, 4 AS ma
-), bloat_info AS (
-  SELECT
-    ma,bs,schemaname,tablename,
-    (datawidth+(hdr+ma-(case when hdr%ma=0 THEN ma ELSE hdr%ma END)))::numeric AS datahdr,
-    (maxfracsum*(nullhdr+ma-(case when nullhdr%ma=0 THEN ma ELSE nullhdr%ma END))) AS nullhdr2
-  FROM (
+WITH
+  constants AS (
     SELECT
-      schemaname, tablename, hdr, ma, bs,
-      SUM((1-null_frac)*avg_width) AS datawidth,
-      MAX(null_frac) AS maxfracsum,
-      hdr+(
-        SELECT 1+count(*)/8
-        FROM pg_stats s2
-        WHERE null_frac<>0 AND s2.schemaname = s.schemaname AND s2.tablename = s.tablename
-      ) AS nullhdr
-    FROM pg_stats s, constants
-    GROUP BY 1,2,3,4,5
-  ) AS foo
-), table_bloat AS (
-  SELECT
-    schemaname, tablename, cc.relpages, bs,
-    CEIL((cc.reltuples*((datahdr+ma-
-      (CASE WHEN datahdr%ma=0 THEN ma ELSE datahdr%ma END))+nullhdr2+4))/(bs-20::float)) AS otta
-  FROM bloat_info
-  JOIN pg_class cc ON cc.relname = bloat_info.tablename
-  JOIN pg_namespace nn ON cc.relnamespace = nn.oid AND nn.nspname = bloat_info.schemaname AND nn.nspname <> 'information_schema'
-), index_bloat AS (
+      current_setting('block_size')::numeric AS bs,
+      23 AS hdr,
+      4 AS ma
+  ),
+  bloat_info AS (
+    SELECT
+      ma,
+      bs,
+      schemaname,
+      tablename,
+      (datawidth+(hdr+ma-(case when hdr%ma=0 THEN ma ELSE hdr%ma END)))::numeric AS datahdr,
+      (maxfracsum*(nullhdr+ma-(case when nullhdr%ma=0 THEN ma ELSE nullhdr%ma END))) AS nullhdr2
+    FROM (
+      SELECT
+        schemaname,
+        tablename,
+        hdr,
+        ma,
+        bs,
+        SUM((1-null_frac)*avg_width) AS datawidth,
+        MAX(null_frac) AS maxfracsum,
+        hdr+(
+          SELECT
+            1+count(*)/8
+          FROM
+            pg_stats s2
+          WHERE
+            null_frac<>0 AND
+              s2.schemaname = s.schemaname AND
+              s2.tablename = s.tablename
+        ) AS nullhdr
+      FROM
+        pg_stats s,
+        constants
+      GROUP BY
+        1,
+        2,
+        3,
+        4,
+        5
+    ) AS foo
+  ),
+  table_bloat AS (
+    SELECT
+      schemaname,
+      tablename,
+      cc.relpages,
+      bs,
+      CEIL((cc.reltuples*((datahdr+ma-
+        (CASE WHEN datahdr%ma=0 THEN ma ELSE datahdr%ma END))+nullhdr2+4))/(bs-20::float)) AS otta
+    FROM
+      bloat_info
+    JOIN
+      pg_class cc ON
+        cc.relname = bloat_info.tablename
+    JOIN
+      pg_namespace nn ON
+        cc.relnamespace = nn.oid AND
+        nn.nspname = bloat_info.schemaname AND
+        nn.nspname <> 'information_schema'
+  ),
+  index_bloat AS (
+    SELECT
+      schemaname,
+      tablename,
+      bs,
+      COALESCE(c2.relname,'?') AS iname,
+      COALESCE(c2.reltuples,0) AS ituples,
+      COALESCE(c2.relpages,0) AS ipages,
+      COALESCE(CEIL((c2.reltuples*(datahdr-12))/(bs-20::float)),0) AS iotta -- very rough approximation, assumes all cols
+    FROM
+      bloat_info
+    JOIN
+      pg_class cc
+        ON cc.relname = bloat_info.tablename
+    JOIN
+      pg_namespace nn ON
+        cc.relnamespace = nn.oid AND
+        nn.nspname = bloat_info.schemaname AND
+        nn.nspname <> 'information_schema'
+    JOIN
+      pg_index i ON
+        indrelid = cc.oid
+    JOIN
+      pg_class c2 ON
+        c2.oid = i.indexrelid
+  )
+
   SELECT
-    schemaname, tablename, bs,
-    COALESCE(c2.relname,'?') AS iname, COALESCE(c2.reltuples,0) AS ituples, COALESCE(c2.relpages,0) AS ipages,
-    COALESCE(CEIL((c2.reltuples*(datahdr-12))/(bs-20::float)),0) AS iotta -- very rough approximation, assumes all cols
-  FROM bloat_info
-  JOIN pg_class cc ON cc.relname = bloat_info.tablename
-  JOIN pg_namespace nn ON cc.relnamespace = nn.oid AND nn.nspname = bloat_info.schemaname AND nn.nspname <> 'information_schema'
-  JOIN pg_index i ON indrelid = cc.oid
-  JOIN pg_class c2 ON c2.oid = i.indexrelid
-)
-SELECT
-  type, schemaname, object_name, bloat, pg_size_pretty(raw_waste) as waste
-FROM
-(SELECT
-  'table' as type,
-  schemaname,
-  tablename as object_name,
-  ROUND(CASE WHEN otta=0 THEN 0.0 ELSE table_bloat.relpages/otta::numeric END,1) AS bloat,
-  CASE WHEN relpages < otta THEN '0' ELSE (bs*(table_bloat.relpages-otta)::bigint)::bigint END AS raw_waste
-FROM
-  table_bloat
-    UNION
-SELECT
-  'index' as type,
-  schemaname,
-  tablename || '::' || iname as object_name,
-  ROUND(CASE WHEN iotta=0 OR ipages=0 THEN 0.0 ELSE ipages/iotta::numeric END,1) AS bloat,
-  CASE WHEN ipages < iotta THEN '0' ELSE (bs*(ipages-iotta))::bigint END AS raw_waste
-FROM
-  index_bloat) bloat_summary
-ORDER BY raw_waste DESC, bloat DESC;
+    type,
+    schemaname,
+    object_name,
+    bloat,
+    pg_size_pretty(raw_waste) as waste
+  FROM
+    (
+      SELECT
+        'table' as type,
+        schemaname,
+        tablename as object_name,
+        ROUND(CASE WHEN otta=0 THEN 0.0 ELSE table_bloat.relpages/otta::numeric END,1) AS bloat,
+        CASE WHEN relpages < otta THEN '0' ELSE (bs*(table_bloat.relpages-otta)::bigint)::bigint END AS raw_waste
+      FROM
+        table_bloat
+      UNION SELECT
+        'index' as type,
+        schemaname,
+        tablename || '::' || iname as object_name,
+        ROUND(CASE WHEN iotta=0 OR ipages=0 THEN 0.0 ELSE ipages/iotta::numeric END,1) AS bloat,
+        CASE WHEN ipages < iotta THEN '0' ELSE (bs*(ipages-iotta))::bigint END AS raw_waste
+      FROM
+        index_bloat
+    ) bloat_summary
+  ORDER BY
+    raw_waste DESC,
+    bloat DESC;
 

data/queries/blocking-queries.sql

@@ -1,16 +1,23 @@
 /* Queries holding locks which other queries are waiting to be released */
 
-SELECT bl.pid AS blocked_pid,
+SELECT
+  bl.pid AS blocked_pid,
   ka.query AS blocking_statement,
   now() - ka.query_start AS blocking_duration,
   kl.pid AS blocking_pid,
   a.query AS blocked_statement,
   now() - a.query_start AS blocked_duration
-FROM pg_catalog.pg_locks bl
-JOIN pg_catalog.pg_stat_activity a
-  ON bl.pid = a.pid
-JOIN pg_catalog.pg_locks kl
-  JOIN pg_catalog.pg_stat_activity ka
-    ON kl.pid = ka.pid
-ON bl.transactionid = kl.transactionid AND bl.pid != kl.pid
-WHERE NOT bl.granted;
+FROM
+  pg_catalog.pg_locks bl
+JOIN
+  pg_catalog.pg_stat_activity a ON
+    bl.pid = a.pid
+JOIN
+  pg_catalog.pg_locks kl
+JOIN
+  pg_catalog.pg_stat_activity ka ON
+    kl.pid = ka.pid ON
+      bl.transactionid = kl.transactionid AND
+      bl.pid != kl.pid
+WHERE
+  NOT bl.granted;

data/queries/cache-hit-rate.sql

@@ -3,9 +3,10 @@
 SELECT
   'index hit rate' AS name,
   (sum(idx_blks_hit)) / nullif(sum(idx_blks_hit + idx_blks_read),0) AS ratio
-FROM pg_statio_user_indexes
-UNION ALL
-SELECT
+FROM
+  pg_statio_user_indexes
+UNION ALL SELECT
  'table hit rate' AS name,
   sum(heap_blks_hit) / nullif(sum(heap_blks_hit) + sum(heap_blks_read),0) AS ratio
-FROM pg_statio_user_tables;
+FROM
+  pg_statio_user_tables;

data/queries/extensions.sql

@@ -1,4 +1,10 @@
 /* Available and installed extensions */
 
-SELECT * FROM pg_available_extensions ORDER BY name, installed_version;
+SELECT
+  *
+FROM
+  pg_available_extensions
+ORDER BY
+  name,
+  installed_version;
 

data/queries/index-size.sql

@@ -1,11 +1,18 @@
 /* The size of indexes, descending by size */
 
-SELECT c.relname AS name,
+SELECT
+  c.relname AS name,
   pg_size_pretty(sum(c.relpages::bigint*8192)::bigint) AS size
-FROM pg_class c
-LEFT JOIN pg_namespace n ON (n.oid = c.relnamespace)
-WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
-AND n.nspname !~ '^pg_toast'
-AND c.relkind='i'
-GROUP BY c.relname
-ORDER BY sum(c.relpages) DESC;
+FROM
+  pg_class c
+LEFT JOIN
+  pg_namespace n ON
+    (n.oid = c.relnamespace)
+WHERE
+  n.nspname NOT IN ('pg_catalog', 'information_schema') AND
+    n.nspname !~ '^pg_toast' AND
+    c.relkind='i'
+GROUP BY
+  c.relname
+ORDER BY
+  sum(c.relpages) DESC;

data/queries/index-usage.sql

@@ -1,11 +1,12 @@
 /* Index hit rate (effective databases are at 99% and up) */
 
-SELECT relname,
-   CASE idx_scan
-     WHEN 0 THEN 'Insufficient data'
-     ELSE (100 * idx_scan / (seq_scan + idx_scan))::text
-   END percent_of_times_index_used,
-   n_live_tup rows_in_table
+SELECT
+  relname,
+  CASE idx_scan
+    WHEN 0 THEN 'Insufficient data'
+    ELSE (100 * idx_scan / (seq_scan + idx_scan))::text
+  END percent_of_times_index_used,
+  n_live_tup rows_in_table
  FROM
    pg_stat_user_tables
  ORDER BY

data/queries/locks.sql

@@ -8,9 +8,13 @@ SELECT
   pg_locks.mode,
   pg_stat_activity.query AS query_snippet,
   age(now(),pg_stat_activity.query_start) AS "age"
-FROM pg_stat_activity,pg_locks left
-OUTER JOIN pg_class
-  ON (pg_locks.relation = pg_class.oid)
-WHERE pg_stat_activity.query <> '<insufficient privilege>'
-  AND pg_locks.pid = pg_stat_activity.pid
-  AND pg_stat_activity.pid <> pg_backend_pid() order by query_start;
+FROM
+  pg_stat_activity,
+  pg_locks
+LEFT OUTER JOIN
+  pg_class ON
+    (pg_locks.relation = pg_class.oid)
+WHERE
+  pg_stat_activity.query <> '<insufficient privilege>' AND
+    pg_locks.pid = pg_stat_activity.pid AND
+    pg_stat_activity.pid <> pg_backend_pid() order by query_start;

data/queries/long-running-queries.sql

@@ -7,8 +7,8 @@ SELECT
 FROM
   pg_stat_activity
 WHERE
-  pg_stat_activity.query <> ''::text
-  AND state <> 'idle'
-  AND now() - pg_stat_activity.query_start > interval '1 minute'
+  pg_stat_activity.query <> ''::text AND
+    state <> 'idle' AND
+    now() - pg_stat_activity.query_start > interval '1 minute'
 ORDER BY
   now() - pg_stat_activity.query_start DESC;

data/queries/outliers.sql

@@ -1,10 +1,25 @@
 /* 10 queries that have longest execution time in aggregate */
 
-SELECT interval '1 millisecond' * total_time AS total_exec_time,
-to_char((total_time/sum(total_time) OVER()) * 100, 'FM90D0') || '%'  AS prop_exec_time,
-to_char(calls, 'FM999G999G999G990') AS ncalls,
-interval '1 millisecond' * (blk_read_time + blk_write_time) AS sync_io_time,
-query AS query
-FROM pg_stat_statements WHERE userid = (SELECT usesysid FROM pg_user WHERE usename = current_user LIMIT 1)
-ORDER BY total_time DESC
-LIMIT 10;
+SELECT
+  interval '1 millisecond' * total_time AS total_exec_time,
+  to_char((total_time/sum(total_time) OVER()) * 100, 'FM90D0') || '%'  AS prop_exec_time,
+  to_char(calls, 'FM999G999G999G990') AS ncalls,
+  interval '1 millisecond' * (blk_read_time + blk_write_time) AS sync_io_time,
+  query AS query
+FROM
+  pg_stat_statements
+WHERE
+  userid = (
+    SELECT
+      usesysid
+    FROM
+      pg_user
+    WHERE
+      usename = current_user
+    LIMIT
+      1
+  )
+ORDER BY
+  total_time DESC
+LIMIT
+  10;

data/queries/seq-scans.sql

@@ -1,7 +1,9 @@
 /* Count of sequential scans by table descending by order */
 
-SELECT relname AS name,
-       seq_scan as count
+SELECT
+  relname AS name,
+  seq_scan as count
 FROM
   pg_stat_user_tables
-ORDER BY seq_scan DESC;
+ORDER BY
+  seq_scan DESC;

data/queries/slow-statements.sql

@@ -1,9 +1,25 @@
 /* 10 queries that have longest execution time in aggregate */
 
-SELECT query AS qry,
-interval '1 millisecond' * total_time AS exec_time,
-to_char((total_time/sum(total_time) OVER()) * 100, 'FM90D0') || '%'  AS prop_exec_time,
-to_char(calls, 'FM999G999G990') AS ncalls,
-interval '1 millisecond' * (blk_read_time + blk_write_time) AS sync_io_time
-FROM pg_stat_statements WHERE userid = (SELECT usesysid FROM pg_user WHERE usename = current_user LIMIT 1)
-ORDER BY calls DESC LIMIT 10;
+SELECT
+  query AS qry,
+  interval '1 millisecond' * total_time AS exec_time,
+  to_char((total_time/sum(total_time) OVER()) * 100, 'FM90D0') || '%'  AS prop_exec_time,
+  to_char(calls, 'FM999G999G990') AS ncalls,
+  interval '1 millisecond' * (blk_read_time + blk_write_time) AS sync_io_time
+FROM
+  pg_stat_statements
+WHERE
+  userid = (
+    SELECT
+      usesysid
+    FROM
+      pg_user
+    WHERE
+      usename = current_user
+    LIMIT
+      1
+  )
+ORDER BY
+  calls DESC
+LIMIT
+  10;

data/queries/table-indexes-size.sql

@@ -1,10 +1,16 @@
 /* Total size of all the indexes on each table, descending by size */
 
-SELECT c.relname AS table,
+SELECT
+  c.relname AS table,
   pg_size_pretty(pg_indexes_size(c.oid)) AS index_size
-FROM pg_class c
-LEFT JOIN pg_namespace n ON (n.oid = c.relnamespace)
-WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
-AND n.nspname !~ '^pg_toast'
-AND c.relkind='r'
-ORDER BY pg_indexes_size(c.oid) DESC;
+FROM
+  pg_class c
+LEFT JOIN
+  pg_namespace n ON
+    (n.oid = c.relnamespace)
+WHERE
+  n.nspname NOT IN ('pg_catalog', 'information_schema') AND
+    n.nspname !~ '^pg_toast' AND
+    c.relkind='r'
+ORDER BY
+  pg_indexes_size(c.oid) DESC;

data/queries/table-size.sql

@@ -1,10 +1,15 @@
 /* Size of the tables (excluding indexes), descending by size */
 
-SELECT c.relname AS name,
+SELECT
+  c.relname AS name,
   pg_size_pretty(pg_table_size(c.oid)) AS size
-FROM pg_class c
-LEFT JOIN pg_namespace n ON (n.oid = c.relnamespace)
-WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
-AND n.nspname !~ '^pg_toast'
-AND c.relkind='r'
-ORDER BY pg_table_size(c.oid) DESC;
+FROM
+  pg_class c
+LEFT JOIN
+  pg_namespace n ON
+    (n.oid = c.relnamespace)
+WHERE
+  n.nspname NOT IN ('pg_catalog', 'information_schema') AND
+    n.nspname !~ '^pg_toast' AND c.relkind='r'
+ORDER BY
+  pg_table_size(c.oid) DESC;

data/queries/total-index-size.sql

@@ -1,8 +1,13 @@
 /* Total size of all indexes in MB */
 
-SELECT pg_size_pretty(sum(c.relpages::bigint*8192)::bigint) AS size
-FROM pg_class c
-LEFT JOIN pg_namespace n ON (n.oid = c.relnamespace)
-WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
-AND n.nspname !~ '^pg_toast'
-AND c.relkind='i';
+SELECT
+  pg_size_pretty(sum(c.relpages::bigint*8192)::bigint) AS size
+FROM
+  pg_class c
+LEFT JOIN
+  pg_namespace n ON
+    (n.oid = c.relnamespace)
+WHERE
+  n.nspname NOT IN ('pg_catalog', 'information_schema') AND
+  n.nspname !~ '^pg_toast' AND
+  c.relkind='i';

data/queries/total-table-size.sql

@@ -1,10 +1,15 @@
 /* Size of the tables (including indexes), descending by size */
 
-SELECT c.relname AS name,
+SELECT
+  c.relname AS name,
   pg_size_pretty(pg_total_relation_size(c.oid)) AS size
-FROM pg_class c
-LEFT JOIN pg_namespace n ON (n.oid = c.relnamespace)
-WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
-AND n.nspname !~ '^pg_toast'
-AND c.relkind='r'
-ORDER BY pg_total_relation_size(c.oid) DESC;
+FROM
+  pg_class c
+LEFT JOIN
+  pg_namespace n ON
+    (n.oid = c.relnamespace)
+WHERE
+  n.nspname NOT IN ('pg_catalog', 'information_schema') AND
+    n.nspname !~ '^pg_toast' AND c.relkind='r'
+ORDER BY
+  pg_total_relation_size(c.oid) DESC;

data/queries/unused-indexes.sql

@@ -9,8 +9,15 @@ SELECT
   indexrelname AS index,
   pg_size_pretty(pg_relation_size(i.indexrelid)) AS index_size,
   idx_scan as index_scans
-FROM pg_stat_user_indexes ui
-JOIN pg_index i ON ui.indexrelid = i.indexrelid
-WHERE NOT indisunique AND idx_scan < 50 AND pg_relation_size(relid) > 5 * 8192
-ORDER BY pg_relation_size(i.indexrelid) / nullif(idx_scan, 0) DESC NULLS FIRST,
-pg_relation_size(i.indexrelid) DESC;
+FROM
+  pg_stat_user_indexes ui
+JOIN
+  pg_index i ON
+    ui.indexrelid = i.indexrelid
+WHERE
+  NOT indisunique AND
+    idx_scan < 50 AND
+    pg_relation_size(relid) > 5 * 8192
+ORDER BY
+  pg_relation_size(i.indexrelid) / nullif(idx_scan, 0) DESC NULLS FIRST,
+  pg_relation_size(i.indexrelid) DESC;

data/queries/vacuum.sql

@@ -35,6 +35,10 @@ SELECT
     THEN 'yes'
   END AS expect_autovacuum
 FROM
-  pg_stat_user_tables psut INNER JOIN pg_class ON psut.relid = pg_class.oid
-    INNER JOIN vacuum_settings ON pg_class.oid = vacuum_settings.oid
+  pg_stat_user_tables psut INNER JOIN
+    pg_class ON
+      psut.relid = pg_class.oid
+    INNER JOIN
+      vacuum_settings ON
+        pg_class.oid = vacuum_settings.oid
 ORDER BY 1;

data/scripts/cache-hit-rate.sh

@@ -10,4 +10,4 @@ echo "= = ="
 echo "Index and table hit rate"
 echo
 
-run cache-hit.sql
+run cache-hit-rate.sql

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg-stats
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - The Eventide Project