ruby-pg-extras 5.6.17 → 6.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 743910d2bd970c03a9ca1d79d56de46d40c5742aae37d0e24021d58e5c2883c6
-  data.tar.gz: e6a50ce83c92f55f49119feaeddf6796c3035a9b1b1d30a2d2439af4231c744a
+  metadata.gz: 9f5f1e9f65cc072944a879f93e059630dcb225520cfb2573c2f6a44dbbf8d1ad
+  data.tar.gz: db8fbf676357996e0f53d82228811bde3906732b9299a0988961f65b77bc2037
 SHA512:
-  metadata.gz: 7c9f78aed2dfbbadbb41e9957b390b1dc4f0effd997515b7fd8679d677c210d0da9a664f14e16a0bb5f5d26016c98c40331acb9db8327073ec9ee3514a3519e8
-  data.tar.gz: 73f758201aac10e76af41a531b9e0bf0badec4eba00491174225ac46981d1c92e9cfedaaebba694472b036d7b603197d361948999d1a11a2d4af0d990271db7c
+  metadata.gz: 27108e41870ead71fe9e2c47cdbf5b544031b0dd7b1be0f537ca9be0737ed887b43fef9b1a329be57510458cfeffe4df8540af29369ba8b87fe482d4596279b3
+  data.tar.gz: 778f5af8cb8eaa9a47892590dde26a99c3a78a9c940b128e060b121e4881d608ddb190cbeabf01e7d1c4b3ba98890fc0bf2e423de8c6caef2e37b7334558d06a

data/.github/workflows/ci.yml

@@ -15,6 +15,13 @@ jobs:
         ruby-version: ['3.4', '3.3', '3.2', '3.1', '3.0', '2.7']
     steps:
       - uses: actions/checkout@v4
+      - name: Run PostgreSQL 12
+        run: |
+          docker run --env POSTGRES_USER=postgres \
+            --env POSTGRES_DB=ruby-pg-extras-test \
+            --env POSTGRES_PASSWORD=secret \
+            -d -p 5432:5432 postgres:12.20-alpine \
+            postgres -c shared_preload_libraries=pg_stat_statements
       - name: Run PostgreSQL 13
         run: |
           docker run --env POSTGRES_USER=postgres \
@@ -64,6 +71,11 @@ jobs:
           bundle config set --local path 'vendor/bundle'
           bundle install
           sleep 5
+      - name: Run tests for PG 12
+        env:
+          PG_VERSION: 12
+        run: |
+          bundle exec rspec spec/
       - name: Run tests for PG 13
         env:
           PG_VERSION: 13

data/README.md

@@ -118,7 +118,7 @@ Keep reading to learn about methods that `diagnose` uses under the hood.
 
 ### `missing_fk_indexes`
 
-This method lists **actual foreign key columns** (based on existing foreign key constraints) which don't have a supporting index. It's recommended to always index foreign key columns because they are commonly used for lookups and join conditions.
+This method lists columns likely to be foreign keys (i.e. column name ending in `_id` and related table exists) which don't have an index. It's recommended to always index foreign key columns because they are used for searching relation objects. 
 
 You can add indexes on the columns returned by this query and later check if they are receiving scans using the [unused_indexes method](#unused_indexes). Please remember that each index decreases write performance and autovacuuming overhead, so be careful when adding multiple indexes to often updated tables.
 
@@ -136,34 +136,14 @@ RubyPgExtras.missing_fk_indexes(args: { table_name: "users" })
 
 ```
 
-You can also exclude known/intentional cases using `ignore_list` (array or comma-separated string), with entries like:
-- `"posts.topic_id"` (ignore a specific table+column)
-- `"topic_id"` (ignore this column name for all tables)
-- `"posts.*"` (ignore all columns on a table)
-- `"*"` (ignore everything)
-
-```ruby
-RubyPgExtras.missing_fk_indexes(args: { ignore_list: ["users.company_id", "posts.*"] })
-```
-
 `table_name` argument is optional, if omitted, the method will display missing fk indexes for all the tables.
 
 ## `missing_fk_constraints`
 
-This method shows **columns that look like foreign keys** but don't have a corresponding foreign key constraint yet. Foreign key constraints improve data integrity in the database by preventing relations with nonexisting objects. You can read more about the benefits of using foreign keys [in this blog post](https://pawelurbanek.com/rails-postgresql-data-integrity).
-
-Heuristic notes:
-- A column is considered a candidate if it matches `<table_singular>_id` and the related table exists (underscored prefixes like `account_user_id` are supported).
-- Rails polymorphic associations (`<name>_id` + `<name>_type`) are ignored since they cannot be expressed as real FK constraints.
-
-You can also exclude known/intentional cases using `ignore_list` (array or comma-separated string), with entries like:
-- `"posts.category_id"` (ignore a specific table+column)
-- `"category_id"` (ignore this column name for all tables)
-- `"posts.*"` (ignore all columns on a table)
-- `"*"` (ignore everything)
+Similarly to the previous method, this one shows columns likely to be foreign keys that don't have a corresponding foreign key constraint. Foreign key constraints improve data integrity in the database by preventing relations with nonexisting objects. You can read more about the benefits of using foreign keys [in this blog post](https://pawelurbanek.com/rails-postgresql-data-integrity).
 
 ```ruby
-RubyPgExtras.missing_fk_constraints(args: { table_name: "users", ignore_list: ["users.customer_id", "posts.*"] })
+RubyPgExtras.missing_fk_constraints(args: { table_name: "users" })
 
 +---------------------------------+
 | Missing foreign key constraints |
@@ -384,19 +364,19 @@ This command displays all the current locks, regardless of their type.
 
 RubyPgExtras.outliers(args: { limit: 20 })
 
-                   query                 |    exec_time     | prop_exec_time |   ncalls    | avg_exec_ms | sync_io_time
------------------------------------------+------------------+----------------+-------------+-------------+--------------
- SELECT * FROM archivable_usage_events.. | 154:39:26.431466 | 72.2%          | 34,211,877  | 16          | 00:00:00
- COPY public.archivable_usage_events (.. | 50:38:33.198418  | 23.6%          | 13          | 14014481    | 13:34:21.00108
- COPY public.usage_events (id, reporte.. | 02:32:16.335233  | 1.2%           | 13          | 70332       | 00:34:19.784318
- INSERT INTO usage_events (id, retaine.. | 01:42:59.436532  | 0.8%           | 12,328,187  | 0           | 00:00:00
- SELECT * FROM usage_events WHERE (alp.. | 01:18:10.754354  | 0.6%           | 102,114,301 | 0           | 00:00:00
- UPDATE usage_events SET reporter_id =.. | 00:52:35.683254  | 0.4%           | 23,786,348  | 0           | 00:00:00
- INSERT INTO usage_events (id, retaine.. | 00:49:24.952561  | 0.4%           | 21,988,201  | 0           | 00:00:00
+                   query                 |    exec_time     | prop_exec_time |   ncalls    | sync_io_time
+-----------------------------------------+------------------+----------------+-------------+--------------
+ SELECT * FROM archivable_usage_events.. | 154:39:26.431466 | 72.2%          | 34,211,877  | 00:00:00
+ COPY public.archivable_usage_events (.. | 50:38:33.198418  | 23.6%          | 13          | 13:34:21.00108
+ COPY public.usage_events (id, reporte.. | 02:32:16.335233  | 1.2%           | 13          | 00:34:19.784318
+ INSERT INTO usage_events (id, retaine.. | 01:42:59.436532  | 0.8%           | 12,328,187  | 00:00:00
+ SELECT * FROM usage_events WHERE (alp.. | 01:18:10.754354  | 0.6%           | 102,114,301 | 00:00:00
+ UPDATE usage_events SET reporter_id =.. | 00:52:35.683254  | 0.4%           | 23,786,348  | 00:00:00
+ INSERT INTO usage_events (id, retaine.. | 00:49:24.952561  | 0.4%           | 21,988,201  | 00:00:00
 (truncated results for brevity)
 ```
 
-This command displays statements, obtained from `pg_stat_statements`, ordered by the amount of time to execute in aggregate. This includes the statement itself, the total execution time for that statement, the proportion of total execution time for all statements that statement has taken up, the number of times that statement has been called, the average execution time per call in milliseconds, and the amount of time that statement spent on synchronous I/O (reading/writing from the file system).
+This command displays statements, obtained from `pg_stat_statements`, ordered by the amount of time to execute in aggregate. This includes the statement itself, the total execution time for that statement, the proportion of total execution time for all statements that statement has taken up, the number of times that statement has been called, and the amount of time that statement spent on synchronous I/O (reading/writing from the file system).
 
 Typically, an efficient query will have an appropriate ratio of calls to total execution time, with as little time spent on I/O as possible. Queries that have a high total execution time but low call count should be investigated to improve their performance. Queries that have a high proportion of execution time being spent on synchronous I/O should also be investigated.
 
@@ -408,15 +388,15 @@ Typically, an efficient query will have an appropriate ratio of calls to total e
 
 RubyPgExtras.calls(args: { limit: 10 })
 
-                   qry                   |    exec_time     | prop_exec_time |   ncalls    | avg_exec_ms | sync_io_time
------------------------------------------+------------------+----------------+-------------+-------------+--------------
- SELECT * FROM usage_events WHERE (alp.. | 01:18:11.073333  | 0.6%           | 102,120,780 | 0           | 00:00:00
- BEGIN                                   | 00:00:51.285988  | 0.0%           | 47,288,662  | 0           | 00:00:00
- COMMIT                                  | 00:00:52.31724   | 0.0%           | 47,288,615  | 0           | 00:00:00
- SELECT * FROM  archivable_usage_event.. | 154:39:26.431466 | 72.2%          | 34,211,877  | 16          | 00:00:00
- UPDATE usage_events SET reporter_id =.. | 00:52:35.986167  | 0.4%           | 23,788,388  | 0           | 00:00:00
- INSERT INTO usage_events (id, retaine.. | 00:49:25.260245  | 0.4%           | 21,990,326  | 0           | 00:00:00
- INSERT INTO usage_events (id, retaine.. | 01:42:59.436532  | 0.8%           | 12,328,187  | 0           | 00:00:00
+                   qry                   |    exec_time     | prop_exec_time |   ncalls    | sync_io_time
+-----------------------------------------+------------------+----------------+-------------+--------------
+ SELECT * FROM usage_events WHERE (alp.. | 01:18:11.073333  | 0.6%           | 102,120,780 | 00:00:00
+ BEGIN                                   | 00:00:51.285988  | 0.0%           | 47,288,662  | 00:00:00
+ COMMIT                                  | 00:00:52.31724   | 0.0%           | 47,288,615  | 00:00:00
+ SELECT * FROM  archivable_usage_event.. | 154:39:26.431466 | 72.2%          | 34,211,877  | 00:00:00
+ UPDATE usage_events SET reporter_id =.. | 00:52:35.986167  | 0.4%           | 23,788,388  | 00:00:00
+ INSERT INTO usage_events (id, retaine.. | 00:49:25.260245  | 0.4%           | 21,990,326  | 00:00:00
+ INSERT INTO usage_events (id, retaine.. | 01:42:59.436532  | 0.8%           | 12,328,187  | 00:00:00
 (truncated results for brevity)
 ```
 
@@ -667,60 +647,17 @@ This command displays an estimation of table "bloat" – space allocated to a re
 
 RubyPgExtras.vacuum_stats
 
- schema |         table         | last_manual_vacuum | manual_vacuum_count | last_autovacuum  | autovacuum_count |    rowcount    | dead_rowcount  | dead_tup_autovacuum_threshold | n_ins_since_vacuum | insert_autovacuum_threshold | expect_autovacuum
---------+-----------------------+--------------------+---------------------+------------------+------------------+----------------+----------------+-------------------------------+--------------------+-----------------------------+-------------------
- public | log_table             |                    |                   0 | 2013-04-26 17:37 |                5 |         18,030 |              0 |                       3,656   |                  0 |                         3,606 | 
- public | data_table            |                    |                   0 | 2013-04-26 13:09 |                3 |             79 |             28 |                          66   |                 10 |                            16 | yes (dead_tuples)
- public | other_table           |                    |                   0 | 2013-04-26 11:41 |                4 |             41 |             47 |                          58   |              2,000 |                           1,008 | yes (dead_tuples & inserts)
- (truncated results for brevity)
-```
-
-This command displays statistics related to vacuum operations for each table, including last manual vacuum and autovacuum timestamps and counters, an estimation of dead rows, dead-tuple-based autovacuum threshold, number of rows inserted since the last VACUUM (`n_ins_since_vacuum`) and the insert-based autovacuum threshold introduced in PostgreSQL 13 ([PostgreSQL autovacuum configuration](https://www.postgresql.org/docs/current/runtime-config-vacuum.html#RUNTIME-CONFIG-AUTOVACUUM)). It helps determine if current autovacuum thresholds (both dead-tuple and insert-based) are appropriate, and whether an automatic vacuum is expected to be triggered soon.
-
-### `vacuum_progress`
-
-```ruby
-
-RubyPgExtras.vacuum_progress
-
- database | schema |  table   |  pid  |        phase        | heap_blks_total | heap_blks_scanned | heap_blks_vacuumed | index_vacuum_count
-----------+--------+----------+-------+---------------------+-----------------+-------------------+--------------------+--------------------
- app_db   | public | users    | 12345 | scanning heap       |          125000 |             32000 |                  0 |                  0
- app_db   | public | orders   | 12346 | vacuuming indexes   |           80000 |             80000 |              75000 |                  3
- (truncated results for brevity)
-```
-
-This command shows the current progress of `VACUUM` / autovacuum operations by reading `pg_stat_progress_vacuum` ([VACUUM progress reporting docs](https://www.postgresql.org/docs/current/progress-reporting.html#VACUUM-PROGRESS-REPORTING)). It can be used to see which tables are being vacuumed right now, how far each operation has progressed, and how many index vacuum cycles have been performed.
-
-### `analyze_progress`
-
-```ruby
-
-RubyPgExtras.analyze_progress
-
- database | schema |  table   |  pid  |        phase         | sample_blks_total | sample_blks_scanned | ext_stats_total | ext_stats_computed
-----------+--------+----------+-------+----------------------+-------------------+---------------------+-----------------+--------------------
- app_db   | public | users    | 22345 | acquiring sample rows|              5000 |                 1200 |               2 |                   0
- app_db   | public | orders   | 22346 | computing statistics |              8000 |                 8000 |               1 |                   1
- (truncated results for brevity)
-```
-
-This command displays the current progress of `ANALYZE` and auto-analyze operations using `pg_stat_progress_analyze` ([ANALYZE progress reporting docs](https://www.postgresql.org/docs/current/progress-reporting.html#ANALYZE-PROGRESS-REPORTING)). It helps understand how far statistics collection has progressed for each active analyze and whether extended statistics are being computed.
-
-### `vacuum_io_stats`
-
-```ruby
-
-RubyPgExtras.vacuum_io_stats
-
-    backend_type    | object   | context  |  reads  | writes  | writebacks | extends | evictions | reuses  | fsyncs |  stats_reset
---------------------+----------+----------+---------+---------+-----------+---------+-----------+---------+--------+-------------------------------
- autovacuum worker  | relation | vacuum   | 5824251 | 3028684 |         0 |       0 |      2588 | 5821460 |      0 | 2025-01-10 11:50:27.583875+00
- autovacuum launcher| relation | autovacuum|   16306 |    2494 |         0 |    2915 |     17785 |       0 |      0 | 2025-01-10 11:50:27.583875+00
+ schema |         table         | last_vacuum | last_autovacuum  |    rowcount    | dead_rowcount  | autovacuum_threshold | expect_autovacuum
+--------+-----------------------+-------------+------------------+----------------+----------------+----------------------+-------------------
+ public | log_table             |             | 2013-04-26 17:37 |         18,030 |              0 |          3,656       |
+ public | data_table            |             | 2013-04-26 13:09 |             79 |             28 |             66       |
+ public | other_table           |             | 2013-04-26 11:41 |             41 |             47 |             58       |
+ public | queue_table           |             | 2013-04-26 17:39 |             12 |          8,228 |             52       | yes
+ public | picnic_table          |             |                  |             13 |              0 |             53       |
  (truncated results for brevity)
 ```
 
-This command surfaces cumulative I/O statistics for autovacuum-related VACUUM activity, based on the `pg_stat_io` view introduced in PostgreSQL 16 ([pg_stat_io documentation](https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-IO-VIEW)). It shows how many blocks autovacuum workers have read and written, how many buffer evictions and ring-buffer reuses occurred, and when the statistics were last reset; this is useful for determining whether autovacuum is responsible for I/O spikes, as described in the pganalyze article on `pg_stat_io` ([Tracking cumulative I/O activity by autovacuum and manual VACUUMs](https://pganalyze.com/blog/pg-stat-io#tracking-cumulative-io-activity-by-autovacuum-and-manual-vacuums)). On PostgreSQL versions below 16 this method returns a single informational row indicating that the feature is unavailable.
+This command displays statistics related to vacuum operations for each table, including an estimation of dead rows, last autovacuum and the current autovacuum threshold. This command can be useful when determining if current vacuum thresholds require adjustments, and to determine when the table was last vacuumed.
 
 ### `kill_all`
 

data/Rakefile

@@ -5,5 +5,5 @@ RSpec::Core::RakeTask.new(:spec)
 
 desc "Test all PG versions"
 task :test_all do
-  system("PG_VERSION=13 bundle exec rspec spec/ && PG_VERSION=14 bundle exec rspec spec/ && PG_VERSION=15 bundle exec rspec spec/ && PG_VERSION=16 bundle exec rspec spec/ && PG_VERSION=17 bundle exec rspec spec/")
+  system("PG_VERSION=12 bundle exec rspec spec/ && PG_VERSION=13 bundle exec rspec spec/ && PG_VERSION=14 bundle exec rspec spec/ && PG_VERSION=15 bundle exec rspec spec/ && PG_VERSION=16 bundle exec rspec spec/ && PG_VERSION=17 bundle exec rspec spec/")
 end

data/docker-compose.yml.sample

@@ -1,4 +1,13 @@
 services:
+  postgres12:
+    image: postgres:12.20-alpine
+    command: postgres -c shared_preload_libraries=pg_stat_statements
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_DB: ruby-pg-extras-test
+      POSTGRES_PASSWORD: secret
+    ports:
+      - '5432:5432'
   postgres13:
     image: postgres:13.16-alpine
     command: postgres -c shared_preload_libraries=pg_stat_statements
@@ -36,7 +45,7 @@ services:
     ports:
       - '5436:5432'
   postgres17:
-    image: postgres:17.7-alpine
+    image: postgres:17.0-alpine
     command: postgres -c shared_preload_libraries=pg_stat_statements
     environment:
       POSTGRES_USER: postgres
@@ -44,13 +53,4 @@ services:
       POSTGRES_PASSWORD: secret
     ports:
       - '5437:5432'
-  postgres18:
-    image: postgres:18.1-alpine
-    command: postgres -c shared_preload_libraries=pg_stat_statements
-    environment:
-      POSTGRES_USER: postgres
-      POSTGRES_DB: ruby-pg-extras-test
-      POSTGRES_PASSWORD: secret
-    ports:
-      - '5438:5432'
 

data/lib/ruby-pg-extras.rb

@@ -7,7 +7,6 @@ require "ruby_pg_extras/size_parser"
 require "ruby_pg_extras/diagnose_data"
 require "ruby_pg_extras/diagnose_print"
 require "ruby_pg_extras/detect_fk_column"
-require "ruby_pg_extras/ignore_list"
 require "ruby_pg_extras/missing_fk_indexes"
 require "ruby_pg_extras/missing_fk_constraints"
 require "ruby_pg_extras/index_info"
@@ -27,13 +26,10 @@ module RubyPgExtras
     long_running_queries mandelbrot outliers
     records_rank seq_scans table_index_scans table_indexes_size
     table_size total_index_size total_table_size
-    unused_indexes duplicate_indexes vacuum_stats vacuum_progress vacuum_io_stats
-    analyze_progress
-    kill_all kill_pid
+    unused_indexes duplicate_indexes vacuum_stats kill_all kill_pid
     pg_stat_statements_reset buffercache_stats
     buffercache_usage ssl_used connections
-    table_schema table_schemas
-    table_foreign_keys foreign_keys
+    table_schema table_foreign_keys
   )
 
   DEFAULT_SCHEMA = ENV["PG_EXTRAS_SCHEMA"] || "public"
@@ -53,11 +49,6 @@ module RubyPgExtras
     outliers: { limit: 10 },
     outliers_legacy: { limit: 10 },
     outliers_17: { limit: 10 },
-    vacuum_progress: {},
-    vacuum_progress_17: {},
-    vacuum_io_stats: {},
-    vacuum_io_stats_legacy: {},
-    analyze_progress: {},
     buffercache_stats: { limit: 10 },
     buffercache_usage: { limit: 20 },
     unused_indexes: { max_scans: 50, schema: DEFAULT_SCHEMA },
@@ -66,14 +57,12 @@ module RubyPgExtras
     index_cache_hit: { schema: DEFAULT_SCHEMA },
     table_cache_hit: { schema: DEFAULT_SCHEMA },
     table_size: { schema: DEFAULT_SCHEMA },
-    table_schemas: { schema: DEFAULT_SCHEMA },
     index_scans: { schema: DEFAULT_SCHEMA },
     cache_hit: { schema: DEFAULT_SCHEMA },
     seq_scans: { schema: DEFAULT_SCHEMA },
     table_index_scans: { schema: DEFAULT_SCHEMA },
     records_rank: { schema: DEFAULT_SCHEMA },
     tables: { schema: DEFAULT_SCHEMA },
-    foreign_keys: { schema: DEFAULT_SCHEMA },
     kill_pid: { pid: 0 },
   })
 
@@ -100,25 +89,6 @@ module RubyPgExtras
       end
     end
 
-    # vacuum_progress uses pg_stat_progress_vacuum only and does not depend on pg_stat_statements,
-    # so we switch it based on the server_version_num instead of the pg_stat_statements version.
-    if query_name == :vacuum_progress
-      server_version_num = conn.send(exec_method, "SHOW server_version_num").to_a[0].values[0].to_i
-      if server_version_num >= 170000
-        query_name = :vacuum_progress_17
-      end
-    end
-
-    # vacuum_io_stats relies on pg_stat_io which is available starting from PostgreSQL 16.
-    # For older versions we fall back to vacuum_io_stats_legacy which just indicates
-    # that this feature is not available on the current server.
-    if query_name == :vacuum_io_stats
-      server_version_num = conn.send(exec_method, "SHOW server_version_num").to_a[0].values[0].to_i
-      if server_version_num < 160000
-        query_name = :vacuum_io_stats_legacy
-      end
-    end
-
     REQUIRED_ARGS.fetch(query_name) { [] }.each do |arg_name|
       if args[arg_name].nil?
         raise ArgumentError, "'#{arg_name}' is required"
@@ -192,11 +162,11 @@ module RubyPgExtras
   end
 
   def self.missing_fk_indexes(args: {}, in_format: :display_table)
-    RubyPgExtras::MissingFkIndexes.call(args[:table_name], ignore_list: args[:ignore_list])
+    RubyPgExtras::MissingFkIndexes.call(args[:table_name])
   end
 
   def self.missing_fk_constraints(args: {}, in_format: :display_table)
-    RubyPgExtras::MissingFkConstraints.call(args[:table_name], ignore_list: args[:ignore_list])
+    RubyPgExtras::MissingFkConstraints.call(args[:table_name])
   end
 
   def self.display_result(result, title:, in_format:)
@@ -247,8 +217,6 @@ module RubyPgExtras
   end
 
   def self.database_url=(value)
-    @_connection&.close
-    @_connection = nil
     @@database_url = value
   end
 

data/lib/ruby_pg_extras/detect_fk_column.rb

@@ -34,25 +34,16 @@ module RubyPgExtras
     end
 
     def call(column_name, tables)
-      # Heuristic: Rails-style foreign keys are usually named `<table_singular>_id`.
-      # We accept underscores in the prefix (e.g. `account_user_id` -> `account_users`).
-      match = /\A(?<table_singular>.+)_id\z/i.match(column_name.to_s)
-      return false unless match
-
-      table_singular = match[:table_singular]
-      return false if table_singular.empty?
-
-      tables.include?(pluralize(table_singular))
+      return false unless column_name =~ /_id$/
+      table_name = column_name.split("_").first
+      table_name = pluralize(table_name)
+      tables.include?(table_name)
     end
 
     def pluralize(word)
-      # Table names from Postgres are typically lowercase. Normalize before applying rules.
-      word = word.to_s.downcase
-
-      return word if UNCOUNTABLE.include?(word)
-      return IRREGULAR.fetch(word) if IRREGULAR.key?(word)
-      # If the word is already an irregular plural (e.g. "people"), keep it as-is.
-      return word if IRREGULAR.value?(word)
+      return word if UNCOUNTABLE.include?(word.downcase)
+      return IRREGULAR[word] if IRREGULAR.key?(word)
+      return IRREGULAR.invert[word] if IRREGULAR.value?(word)
 
       PLURAL_RULES.reverse.each do |(rule, replacement)|
         return word.gsub(rule, replacement) if word.match?(rule)

data/lib/ruby_pg_extras/missing_fk_constraints.rb

@@ -2,68 +2,39 @@
 
 module RubyPgExtras
   class MissingFkConstraints
-    # ignore_list: array (or comma-separated string) of entries like:
-    # - "posts.category_id" (ignore a specific table+column)
-    # - "category_id"       (ignore this column name for all tables)
-    # - "posts.*"           (ignore all columns on a table)
-    # - "*"                 (ignore everything)
-    def self.call(table_name, ignore_list: nil)
-      new.call(table_name, ignore_list: ignore_list)
+    def self.call(table_name)
+      new.call(table_name)
     end
 
-    def call(table_name, ignore_list: nil)
-      ignore_list_matcher = IgnoreList.new(ignore_list)
-
-      tables =
-        if table_name
+    def call(table_name)
+      tables = if table_name
           [table_name]
         else
           all_tables
         end
 
-      schemas_by_table = query_module
-        .table_schemas(in_format: :hash)
-        .group_by { |row| row.fetch("table_name") }
-
-      fk_columns_by_table = query_module
-        .foreign_keys(in_format: :hash)
-        .group_by { |row| row.fetch("table_name") }
-        .transform_values { |rows| rows.map { |row| row.fetch("column_name") } }
-
-      tables.each_with_object([]) do |table, agg|
-        schema = schemas_by_table.fetch(table, [])
-        fk_columns_for_table = fk_columns_by_table.fetch(table, [])
-        schema_column_names = schema.map { |row| row.fetch("column_name") }
-
-        candidate_fk_columns = schema.filter_map do |row|
-          column_name = row.fetch("column_name")
-
-          # Skip columns explicitly excluded via ignore list.
-          next if ignore_list_matcher.ignored?(table: table, column_name: column_name)
+      tables.reduce([]) do |agg, table|
+        foreign_keys_info = query_module.table_foreign_keys(args: { table_name: table }, in_format: :hash)
+        schema = query_module.table_schema(args: { table_name: table }, in_format: :hash)
 
-          # Skip columns that already have a foreign key constraint on this table.
-          next if fk_columns_for_table.include?(column_name)
-
-          # Skip columns that don't look like an FK candidate based on naming conventions.
-          next unless DetectFkColumn.call(column_name, all_tables)
-
-          # Rails polymorphic associations use <name>_id + <name>_type and can't have FK constraints.
-          candidate_prefix = column_name.delete_suffix("_id")
-          polymorphic_type_column = "#{candidate_prefix}_type"
-          # Skip polymorphic associations (cannot be expressed as a real FK constraint).
-          next if schema_column_names.include?(polymorphic_type_column)
-
-          column_name
+        fk_columns = schema.filter_map do |row|
+          if DetectFkColumn.call(row.fetch("column_name"), all_tables)
+            row.fetch("column_name")
+          end
         end
 
-        candidate_fk_columns.each do |column_name|
-          agg.push(
-            {
-              table: table,
-              column_name: column_name,
-            }
-          )
+        fk_columns.each do |column_name|
+          if foreign_keys_info.none? { |row| row.fetch("column_name") == column_name }
+            agg.push(
+              {
+                table: table,
+                column_name: column_name,
+              }
+            )
+          end
         end
+
+        agg
       end
     end
 

data/lib/ruby_pg_extras/missing_fk_indexes.rb

@@ -2,37 +2,30 @@
 
 module RubyPgExtras
   class MissingFkIndexes
-    # ignore_list: array (or comma-separated string) of entries like:
-    # - "posts.topic_id" (ignore a specific table+column)
-    # - "topic_id"       (ignore this column name for all tables)
-    # - "posts.*"        (ignore all columns on a table)
-    # - "*"              (ignore everything)
-    def self.call(table_name, ignore_list: nil)
-      new.call(table_name, ignore_list: ignore_list)
+    def self.call(table_name)
+      new.call(table_name)
     end
 
-    def call(table_name, ignore_list: nil)
-      ignore_list_matcher = IgnoreList.new(ignore_list)
-
-      indexes_info = query_module.indexes(in_format: :hash)
-      foreign_keys = query_module.foreign_keys(in_format: :hash)
-
+    def call(table_name)
       tables = if table_name
           [table_name]
         else
-          foreign_keys.map { |row| row.fetch("table_name") }.uniq
+          all_tables
         end
 
+      indexes_info = query_module.indexes(in_format: :hash)
+
       tables.reduce([]) do |agg, table|
         index_info = indexes_info.select { |row| row.fetch("tablename") == table }
-        table_fks = foreign_keys.select { |row| row.fetch("table_name") == table }
+        schema = query_module.table_schema(args: { table_name: table }, in_format: :hash)
 
-        table_fks.each do |fk|
-          column_name = fk.fetch("column_name")
-
-          # Skip columns explicitly excluded via ignore list.
-          next if ignore_list_matcher.ignored?(table: table, column_name: column_name)
+        fk_columns = schema.filter_map do |row|
+          if DetectFkColumn.call(row.fetch("column_name"), all_tables)
+            row.fetch("column_name")
+          end
+        end
 
+        fk_columns.each do |column_name|
           if index_info.none? { |row| row.fetch("columns").split(",").first == column_name }
             agg.push(
               {
@@ -49,6 +42,10 @@ module RubyPgExtras
 
     private
 
+    def all_tables
+      @_all_tables ||= query_module.table_size(in_format: :hash).map { |row| row.fetch("name") }
+    end
+
     def query_module
       RubyPgExtras
     end

data/lib/ruby_pg_extras/queries/calls.sql

@@ -4,7 +4,6 @@ SELECT query AS qry,
 interval '1 millisecond' * total_exec_time AS exec_time,
 to_char((total_exec_time/sum(total_exec_time) OVER()) * 100, 'FM90D0') || '%%'  AS prop_exec_time,
 to_char(calls, 'FM999G999G990') AS ncalls,
-ROUND(total_exec_time/calls) AS avg_exec_ms,
 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 %{limit};

data/lib/ruby_pg_extras/queries/calls_17.sql

@@ -4,7 +4,6 @@ SELECT query AS qry,
 interval '1 millisecond' * total_exec_time AS exec_time,
 to_char((total_exec_time/sum(total_exec_time) OVER()) * 100, 'FM90D0') || '%%'  AS prop_exec_time,
 to_char(calls, 'FM999G999G990') AS ncalls,
-ROUND(total_exec_time/calls) AS avg_exec_ms,
 interval '1 millisecond' * (shared_blk_read_time + shared_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 %{limit};

data/lib/ruby_pg_extras/queries/calls_legacy.sql

@@ -4,7 +4,6 @@ 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,
-ROUND(total_time/calls) AS avg_exec_ms,
 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 %{limit};

data/lib/ruby_pg_extras/queries/outliers.sql

@@ -3,7 +3,6 @@
 SELECT interval '1 millisecond' * total_exec_time AS total_exec_time,
 to_char((total_exec_time/sum(total_exec_time) OVER()) * 100, 'FM90D0') || '%%'  AS prop_exec_time,
 to_char(calls, 'FM999G999G999G990') AS ncalls,
-ROUND(total_exec_time/calls) AS avg_exec_ms,
 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)

data/lib/ruby_pg_extras/queries/outliers_17.sql

@@ -3,7 +3,6 @@
 SELECT interval '1 millisecond' * total_exec_time AS total_exec_time,
 to_char((total_exec_time/sum(total_exec_time) OVER()) * 100, 'FM90D0') || '%%'  AS prop_exec_time,
 to_char(calls, 'FM999G999G999G990') AS ncalls,
-ROUND(total_exec_time/calls) AS avg_exec_ms,
 interval '1 millisecond' * (shared_blk_read_time + shared_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)

data/lib/ruby_pg_extras/queries/outliers_legacy.sql

@@ -3,7 +3,6 @@
 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,
-ROUND(total_time/calls) AS avg_exec_ms,
 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)