safe-pg-migrations 1.4.2 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5137a033537f088b0a0c3f41dc8b632d5c37ef81cf5ac25bc62d6b01e62c56c
-  data.tar.gz: 5f0029750d93bcb04ffcb65e8a8bf0b6a8420ee1f6d7c12a85efac967e3b5c93
+  metadata.gz: 2fafd98448f0ff697da386a337dc22753be2144feedba4793f87a351581a5607
+  data.tar.gz: 9653ae6395d4c9f27b69dba9dee9142a4535384c42e8d05fac9ca2e2ef1bdce6
 SHA512:
-  metadata.gz: afbb64bcc3de2680200ec2cc735b6fa7fc7bb02a71b056be7dcafd3a02a9a11895398632e128ad727e6b089e149ccf75617c5f82674bd1472b16af79c15c0f77
-  data.tar.gz: '0946ab447b6c503ff9965f71edba84e973ddc6e5bc658fe9785672d23c3dc6b0ace071e9081727defd8585dba3d6faedb22145bd9fe8c84e0cd735e4ce44457f'
+  metadata.gz: 64297c9ba4f040e7afa21fefa2acb2a26e27fb0bfee3d9f9cbf902ee4bb0ac087f4e22591a7b5470cf73dc7bc73345e59904649c02d7540bd4693372e7069549
+  data.tar.gz: 7a2640fd2494480d560cfa6f19059550ecc316eaf729df6d8f97a434c189f4565c49d47acbb02f437d9b1285a466a5615a79a84d6ba1dfb3d94bb54f87b9e788

data/README.md

@@ -6,9 +6,9 @@ ActiveRecord migrations for Postgres made safe.
 
 ## Requirements
 
-- Ruby 2.5+
-- Rails 5.2+
-- PostgreSQL 9.3+
+- Ruby 2.7+
+- Rails 6.0+
+- PostgreSQL 11.7+
 
 ## Usage
 
@@ -25,43 +25,46 @@ gem 'safe-pg-migrations'
 Consider the following migration:
 
 ```rb
-class AddAdminToUsers < ActiveRecord::Migration[5.2]
+class AddPatientRefToAppointments < ActiveRecord::Migration[6.0]
   def change
-    add_column :users, :admin, :boolean, default: false, null: false
+    add_reference :appointments, :patient
   end
 end
 ```
 
-If the `users` table is large, running this migration on a live Postgres 9 database will likely cause downtime. **Safe PG Migrations** hooks into Active Record so that the following gets executed instead:
+If the `users` table is large, running this migration will likely cause downtime. **Safe PG Migrations** hooks into Active Record so that the following gets executed instead:
 
 ```rb
-class AddAdminToUsers < ActiveRecord::Migration[5.2]
+class AddPatientRefToAppointments < ActiveRecord::Migration[6.0]
   # Do not wrap the migration in a transaction so that locks are held for a shorter time.
   disable_ddl_transaction!
 
   def change
     # Lower Postgres' lock timeout to avoid statement queueing. Acts like a seatbelt.
-    execute "SET lock_timeout TO '5s'" # The lock_timeout duration is customizable.
+    execute("SET lock_timeout TO '5s'")
 
-    # Add the column without the default value and the not-null constraint.
-    add_column :users, :admin, :boolean
+    # Lower Postgres' statement timeout to avoid too long transactions. Acts like a seatbelt.
+    execute("SET statement_timeout TO '5s'")
+    add_column :appointments, :patient_id, :bigint
 
-    # Set the column's default value.
-    change_column_default :users, :admin, false
+    # add_index using the concurrent algorithm, to avoid locking the tables
+    add_index :appointments, :patient_id, algorithm: :concurrently
 
-    # Backfill the column in batches.
-    User.in_batches.update_all(admin: false)
+    # add_foreign_key without validation, to avoid locking the table for too long
+    execute("SET statement_timeout TO '5s'")
+    add_foreign_key :appointments, :patients, validate: false
 
-    # Add the not-null constraint. Beforehand, set a short statement timeout so that
-    # Postgres does not spend too much time performing the full table scan to verify
-    # the column contains no nulls.
-    execute "SET statement_timeout TO '5s'"
-    change_column_null :users, :admin, false
+    execute("SET statement_timeout TO '0'")
+
+    # validate the foreign key separately, it avoids taking a lock on the entire tables
+    validate_foreign_key :appointments, :patients
+    
+    # we also need to set timeouts to their initial values if needed
   end
 end
 ```
 
-Under the hood, **Safe PG Migrations** patches `ActiveRecord::Migration` and extends `ActiveRecord::Base.connection` to make potentially dangerous methods—like `add_column`—safe.
+Under the hood, **Safe PG Migrations** patches `ActiveRecord::Migration` and extends `ActiveRecord::Base.connection` to make potentially dangerous methods—like `add_reference`—safe.
 
 ## Motivation
 
@@ -106,23 +109,43 @@ Beware though, when adding a volatile default value:
 ```ruby
 add_column :users, :created_at, default: 'clock_timestamp()'
 ```
-PG will still needs to update every row of the table, and will most likely statement timeout for big table. In this case, your best bet is to add the column without default, set the default, and backfill existing rows.
+PG will still needs to update every row of the table, and will most likely statement timeout for big table. In this case, **Safe PG Migrations** can automatically backfill data when the option `default_value_backfill:` is set to `:update_in_batches`. 
+
+</details>
+
+<details>
+<summary>Safe add_column - adding a volatile default value</summary>
+
+**Safe PG Migrations** provides the extra option parameter `default_value_backfill:`. When your migration is adding a volatile default value, the option `:update_in_batches` can be set. It will automatically backfill the value in a safe manner.
+
+```ruby
+add_column :users, :created_at, default: 'clock_timestamp()', default_value_backfill: :update_in_batches
+```
+
+More specifically, it will: 
+
+1. create the column without default value and without null constraint. This ensure the `ACCESS EXCLUSIVE` lock is acquired for the least amount of time;
+2. add the default value, without data backfill. An `ACCESS EXCLUSIVE` lock is acquired and released immediately;
+3. backfill data, in batch of `SafePgMigrations.config.backfill_batch_size` and with a pause of `SafePgMigrations.config.backfill_pause` between each batch;
+4. change the column to `null: false`, if defined in the parameters, following the algorithm we have defined below.
 
-<blockquote>
+---
+**NOTE**
 
-**Note: Pre-postgres 11**
-Adding a column with a default value and a not-null constraint is [dangerous](https://wework.github.io/data/2015/11/05/add-columns-with-default-values-to-large-tables-in-rails-postgres/).
+Data backfill take time. If your table is big, your migrations will (safely) hangs for a while. You might want to backfill data manually instead, to do so you will need two migrations
 
-**Safe PG Migrations** makes it safe by:
+1. First migration :
 
-1.  Adding the column without the default value and the not null constraint,
-2.  Then set the default value on the column,
-3.  Then backfilling the column,
-4.  And then adding the not null constraint with a short statement timeout.
+    a. adds the column without default and without null constraint;
 
-Note: the addition of the not null constraint may timeout. In that case, you may want to add the not-null constraint as initially not valid and validate it in a separate statement. See [Adding a not-null constraint on Postgres with minimal locking](https://medium.com/doctolib-engineering/adding-a-not-null-constraint-on-pg-faster-with-minimal-locking-38b2c00c4d1c).
+    b. add the default value.
 
-</blockquote>
+2. manual data backfill (rake task, manual operation, ...)
+3. Second migration which change the column to null false (with **Safe PG Migrations**, `change_column_null` is safe and can be used; see section below)
+
+---
+
+`default_value_backfill:` also accept the value `:auto` which is set by default. In this case, **Safe PG Migrations** will not backfill data and will let PostgreSQL handle it itself.
 
 </details>
 
@@ -143,13 +166,70 @@ If you still get lock timeout while adding / removing indexes, it might be for o
 
 Adding a foreign key requires a `SHARE ROW EXCLUSIVE` lock, which **prevent writing in the tables** while the migration is running.
 
-Adding the constraint itself is rather fast, the major part of the time is spent on validating this constraint. Thus safe-pg-migrations ensures that adding a foreign key holds blocking locks for the least amount of time by splitting the foreign key creation in two steps: 
+Adding the constraint itself is rather fast, the major part of the time is spent on validating this constraint. Thus **Safe PG Migrations** ensures that adding a foreign key holds blocking locks for the least amount of time by splitting the foreign key creation in two steps: 
 
 1. adding the constraint *without validation*, will not validate existing rows;
 2. validating the constraint, will validate existing rows in the table, without blocking read or write on the table
 
 </details>
 
+
+<details><summary id="safe_add_check_constraint">Safe <code>add_check_constraint</code> (ActiveRecord > 6.1)</summary>
+
+Adding a check constraint requires an `ACCESS EXCLUSIVE` lock, which **prevent writing and reading in the tables** [as soon as the lock is requested](https://medium.com/doctolib/stop-worrying-about-postgresql-locks-in-your-rails-migrations-3426027e9cc9).
+
+Adding the constraint itself is rather fast, the major part of the time is spent on validating this constraint.
+Thus **Safe PG Migrations** ensures that adding a constraints holds blocking locks for the least amount of time by
+splitting the constraint addition in two steps: 
+
+1. adding the constraint *without validation*, will not validate existing rows;
+2. validating the constraint, will validate existing rows in the table, without blocking read or write on the table
+
+</details>
+
+<details><summary id="safe_change_column_null">Safe <code>change_column_null</code> (ActiveRecord and PG version dependant)</summary>
+
+Changing the nullability of a column requires an `ACCESS EXCLUSIVE` lock, which **prevent writing and reading in the tables** [as soon as the lock is requested](https://medium.com/doctolib/stop-worrying-about-postgresql-locks-in-your-rails-migrations-3426027e9cc9).
+
+Adding the constraint itself is rather fast, the major part of the time is spent on validating this constraint.
+
+**Safe PG Migrations** acts differently depending on the version you are on. 
+
+### Recent versions of PG and Active Record (> 12 and > 6.1)
+
+Starting on PostgreSQL versions 12, adding the column NOT NULL constraint is safe if a check constraint validates the
+nullability of the same column. **Safe PG Migrations** also relies on add_check_constraint, which was introduced in
+ActiveRecord 6.1.  
+
+If these requirements are met, **Safe PG Migrations** ensures that adding a constraints holds blocking locks for the least
+amount of time by splitting the constraint addition in several steps: 
+
+1. adding a `IS NOT NULL` constraint *without validation*, will not validate existing rows but block read or write;
+2. validating the constraint, will validate existing rows in the table, without blocking read or write on the table;
+3. changing the not null status of the column, thanks to the NOT NULL constraint without having to scan the table sequentially;
+4. dropping the `IS NOT NULL` constraint.
+
+### Older versions of PG or ActiveRecord
+
+If the version of PostgreSQL is below 12, or if the version of ActiveRecord is below 6.1, **Safe PG Migrations** will only
+wrap ActiveRecord method into a statement timeout and lock timeout.
+
+### Call with a default parameter
+
+Calling change_column_null with a default parameter [is dangerous](https://github.com/rails/rails/blob/716baea69f989b64f5bfeaff880c2512377bebab/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb#L446)
+and is likely not to finish in the statement timeout defined by **Safe PG Migrations**. For this reason, when the default
+parameter is given, **Safe PG Migrations** will simply forward it to activerecord methods without trying to improve it
+
+### Dropping a NULL constraint
+
+Dropping a null constraint still requires an `ACCESS EXCLUSIVE` lock, but does not require extra operation to reduce the
+amount of time during which the lock is held. **Safe PG Migrations** only wrap methods of activerecord in lock and statement
+timeouts
+
+</details>
+
+
+
 <details><summary>Retry after lock timeout</summary>
 
 When a statement fails with a lock timeout, **Safe PG Migrations** retries it (5 times max) [list of retriable statements](https://github.com/doctolib/safe-pg-migrations/blob/66933256252b6bbf12e404b829a361dbba30e684/lib/safe-pg-migrations/plugins/statement_retrier.rb#L5)
@@ -214,7 +294,9 @@ SafePgMigrations.config.blocking_activity_logger_verbose = true # Outputs the ra
 
 SafePgMigrations.config.blocking_activity_logger_margin = 1.second # Delay to output blocking queries before timeout. Must be shorter than safe_timeout
 
-SafePgMigrations.config.batch_size = 1000 # Size of the batches used for backfilling when adding a column with a default value pre-PG11
+SafePgMigrations.config.backfill_batch_size = 100_000 # Size of the batches used for backfilling when adding a column with a default value
+
+SafePgMigrations.config.backfill_pause = 0.5.second # Delay between each batch during a backfill. This ensure replication can happen safely. 
 
 SafePgMigrations.config.retry_delay = 1.minute # Delay between retries for retryable statements
 

data/lib/safe-pg-migrations/base.rb

@@ -1,14 +1,18 @@
 # frozen_string_literal: true
 
-require 'ruby2_keywords'
 require 'safe-pg-migrations/configuration'
+require 'safe-pg-migrations/helpers/satisfied_helper'
+require 'safe-pg-migrations/helpers/index_helper'
+require 'safe-pg-migrations/helpers/batch_over'
 require 'safe-pg-migrations/plugins/verbose_sql_logger'
 require 'safe-pg-migrations/plugins/blocking_activity_logger'
+require 'safe-pg-migrations/plugins/statement_insurer/add_column'
 require 'safe-pg-migrations/plugins/statement_insurer'
 require 'safe-pg-migrations/plugins/statement_retrier'
 require 'safe-pg-migrations/plugins/idempotent_statements'
 require 'safe-pg-migrations/plugins/useless_statements_logger'
-require 'safe-pg-migrations/plugins/legacy_active_record_support'
+require 'safe-pg-migrations/polyfills/index_definition_polyfill'
+require 'safe-pg-migrations/polyfills/verbose_query_logs_polyfill'
 
 module SafePgMigrations
   # Order matters: the bottom-most plugin will have precedence
@@ -18,30 +22,26 @@ module SafePgMigrations
     StatementRetrier,
     StatementInsurer,
     UselessStatementsLogger,
-    LegacyActiveRecordSupport,
+    Polyfills::IndexDefinitionPolyfill,
   ].freeze
 
   class << self
     attr_reader :current_migration, :pg_version_num
 
-    def setup_and_teardown(migration, connection)
+    def setup_and_teardown(migration, connection, &block)
       @pg_version_num = get_pg_version_num(connection)
       @alternate_connection = nil
       @current_migration = migration
       stdout_sql_logger = VerboseSqlLogger.new.setup if verbose?
       PLUGINS.each { |plugin| connection.extend(plugin) }
 
-      connection.with_setting(:lock_timeout, SafePgMigrations.config.pg_safe_timeout) { yield }
+      connection.with_setting :lock_timeout, SafePgMigrations.config.pg_lock_timeout, &block
     ensure
       close_alternate_connection
       @current_migration = nil
       stdout_sql_logger&.teardown
     end
 
-    def get_pg_version_num(connection)
-      connection.query_value('SHOW server_version_num').to_i
-    end
-
     def alternate_connection
       @alternate_connection ||= ActiveRecord::Base.connection_pool.send(:new_connection)
     end
@@ -64,6 +64,9 @@ module SafePgMigrations
     end
 
     def verbose?
+      unless current_migration.class._safe_pg_migrations_verbose.nil?
+        return current_migration.class._safe_pg_migrations_verbose
+      end
       return ENV['SAFE_PG_MIGRATIONS_VERBOSE'] == '1' if ENV['SAFE_PG_MIGRATIONS_VERBOSE']
       return Rails.env.production? if defined?(Rails)
 
@@ -73,9 +76,21 @@ module SafePgMigrations
     def config
       @config ||= Configuration.new
     end
+
+    def get_pg_version_num(connection)
+      connection.query_value('SHOW server_version_num').to_i
+    end
   end
 
   module Migration
+    module ClassMethods
+      attr_accessor :_safe_pg_migrations_verbose
+
+      def safe_pg_migrations_verbose(verbose)
+        @_safe_pg_migrations_verbose = verbose
+      end
+    end
+
     def exec_migration(connection, direction)
       SafePgMigrations.setup_and_teardown(self, connection) do
         super(connection, direction)
@@ -95,6 +110,7 @@ module SafePgMigrations
       add_belongs_to
       change_column_null
       add_foreign_key
+      add_check_constraint
     ].freeze
 
     SAFE_METHODS.each do |method|

data/lib/safe-pg-migrations/configuration.rb

@@ -4,26 +4,32 @@ require 'active_support/core_ext/numeric/time'
 
 module SafePgMigrations
   class Configuration
-    attr_accessor :safe_timeout
-    attr_accessor :blocking_activity_logger_margin
-    attr_accessor :blocking_activity_logger_verbose
-    attr_accessor :batch_size
-    attr_accessor :retry_delay
-    attr_accessor :max_tries
+    attr_accessor :safe_timeout, :blocking_activity_logger_margin, :blocking_activity_logger_verbose,
+                  :backfill_batch_size, :backfill_pause, :retry_delay, :max_tries
 
     def initialize
       self.safe_timeout = 5.seconds
       self.blocking_activity_logger_margin = 1.second
       self.blocking_activity_logger_verbose = true
-      self.batch_size = 1000
+      self.backfill_batch_size = 100_000
+      self.backfill_pause = 0.5.second
       self.retry_delay = 1.minute
       self.max_tries = 5
     end
 
-    def pg_safe_timeout
-      pg_duration(safe_timeout)
+    def pg_statement_timeout
+      pg_duration safe_timeout
     end
 
+    def pg_lock_timeout
+      # if statement timeout and lock timeout have the same value, statement timeout will raise in priority. We actually
+      # need the opposite for BlockingActivityLogger to detect lock timeouts correctly.
+      # By reducing the lock timeout by a very small margin, we ensure that the lock timeout is raised in priority
+      pg_duration safe_timeout * 0.99
+    end
+
+    private
+
     def pg_duration(duration)
       value, unit = duration.integer? ? [duration, 's'] : [(duration * 1000).to_i, 'ms']
       "#{value}#{unit}"

data/lib/safe-pg-migrations/helpers/batch_over.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module SafePgMigrations
+  module Helpers
+    class BatchOver
+      def initialize(model, of: SafePgMigrations.config.backfill_batch_size)
+        @model = model
+        @of = of
+
+        @current_range = nil
+      end
+
+      def each_batch
+        yield scope.where(primary_key => @current_range) while next_batch
+      end
+
+      private
+
+      def next_batch
+        return if endless?
+
+        first = next_scope.take
+
+        return unless first
+
+        last = next_scope.offset(@of).take
+
+        first_key = first[primary_key]
+        last_key = last.nil? ? nil : last[primary_key]
+
+        @current_range = first_key...last_key
+      end
+
+      def next_scope
+        return scope if @current_range.nil?
+        return scope.none if endless?
+
+        scope.where(primary_key => @current_range.end..)
+      end
+
+      def scope
+        @model.order(primary_key => :asc)
+      end
+
+      def endless?
+        return false if @current_range.nil?
+
+        @current_range.end.nil?
+      end
+
+      def primary_key
+        @model.primary_key
+      end
+    end
+  end
+end

data/lib/safe-pg-migrations/helpers/blocking_activity_formatter.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module SafePgMigrations
+  module Helpers
+    module BlockingActivityFormatter
+      def log_queries(queries)
+        if queries.empty?
+          SafePgMigrations.say 'Could not find any blocking query.', true
+        else
+          SafePgMigrations.say(
+            "Statement was being blocked by the following #{'query'.pluralize(queries.size)}:",
+            true
+          )
+          SafePgMigrations.say '', true
+          output_blocking_queries(queries)
+          SafePgMigrations.say(
+            'Beware, some of those queries might run in a transaction. In this case the locking query might be ' \
+            'located elsewhere in the transaction',
+            true
+          )
+          SafePgMigrations.say '', true
+        end
+      end
+
+      private
+
+      def output_blocking_queries(queries)
+        if SafePgMigrations.config.blocking_activity_logger_verbose
+          queries.each do |pid, query, start_time|
+            SafePgMigrations.say "Query with pid #{pid || 'null'} started #{format_start_time start_time}:  #{query}",
+                                 true
+          end
+        else
+          output_confidentially_blocking_queries(queries)
+        end
+      end
+
+      def output_confidentially_blocking_queries(queries)
+        queries.each do |start_time, locktype, mode, pid, transactionid|
+          SafePgMigrations.say(
+            "Query with pid #{pid || 'null'} " \
+            "started #{format_start_time(start_time)}: " \
+            "lock type: #{locktype || 'null'}, " \
+            "lock mode: #{mode || 'null'}, " \
+            "lock transactionid: #{transactionid || 'null'}",
+            true
+          )
+        end
+      end
+
+      def format_start_time(start_time, reference_time = Time.now)
+        start_time = Time.parse(start_time) unless start_time.is_a? Time
+
+        duration = (reference_time - start_time).round
+        "#{duration} #{'second'.pluralize(duration)} ago"
+      end
+    end
+  end
+end

data/lib/safe-pg-migrations/helpers/blocking_activity_selector.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module SafePgMigrations
+  module Helpers
+    module BlockingActivitySelector
+      FILTERED_COLUMNS = %w[
+        blocked_activity.xact_start
+        blocked_locks.locktype
+        blocked_locks.mode
+        blocking_activity.pid
+        blocked_locks.transactionid
+      ].freeze
+
+      VERBOSE_COLUMNS = %w[
+        blocking_activity.pid
+        blocking_activity.query
+        blocked_activity.xact_start
+      ].freeze
+
+      def select_blocking_queries_sql
+        columns =
+          (
+            if SafePgMigrations.config.blocking_activity_logger_verbose
+              VERBOSE_COLUMNS
+            else
+              FILTERED_COLUMNS
+            end
+          )
+
+        <<~SQL.squish
+          SELECT #{columns.join(', ')}
+          FROM pg_catalog.pg_locks           blocked_locks
+          JOIN pg_catalog.pg_stat_activity   blocked_activity
+            ON blocked_activity.pid = blocked_locks.pid
+          JOIN pg_catalog.pg_locks           blocking_locks
+            ON blocking_locks.locktype = blocked_locks.locktype
+            AND blocking_locks.DATABASE      IS NOT DISTINCT FROM blocked_locks.DATABASE
+            AND blocking_locks.relation      IS NOT DISTINCT FROM blocked_locks.relation
+            AND blocking_locks.page          IS NOT DISTINCT FROM blocked_locks.page
+            AND blocking_locks.tuple         IS NOT DISTINCT FROM blocked_locks.tuple
+            AND blocking_locks.virtualxid    IS NOT DISTINCT FROM blocked_locks.virtualxid
+            AND blocking_locks.transactionid IS NOT DISTINCT FROM blocked_locks.transactionid
+            AND blocking_locks.classid       IS NOT DISTINCT FROM blocked_locks.classid
+            AND blocking_locks.objid         IS NOT DISTINCT FROM blocked_locks.objid
+            AND blocking_locks.objsubid      IS NOT DISTINCT FROM blocked_locks.objsubid
+            AND blocking_locks.pid != blocked_locks.pid
+          JOIN pg_catalog.pg_stat_activity   blocking_activity
+            ON blocking_activity.pid = blocking_locks.pid
+          WHERE blocked_locks.pid = %d
+        SQL
+      end
+    end
+  end
+end

data/lib/safe-pg-migrations/helpers/index_helper.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SafePgMigrations
+  module Helpers
+    module IndexHelper
+      def index_definition(table_name, column_name, **options)
+        index_definition, = add_index_options(table_name, column_name, **options)
+        index_definition
+      end
+
+      private
+
+      def index_valid?(index_name)
+        query_value <<~SQL.squish
+          SELECT indisvalid
+          FROM pg_index i
+          JOIN pg_class c
+            ON i.indexrelid = c.oid
+          WHERE c.relname = '#{index_name}';
+        SQL
+      end
+    end
+  end
+end

data/lib/safe-pg-migrations/helpers/satisfied_helper.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SafePgMigrations
+  module Helpers
+    module SatisfiedHelper
+      class << self
+        def satisfies_change_column_null_requirements?
+          satisfies_add_check_constraints? && SafePgMigrations.pg_version_num >= 120_000
+        end
+
+        def satisfies_add_check_constraints!
+          return if satisfies_add_check_constraints?
+
+          raise NotImplementedError, 'add_check_constraint is not supported in your ActiveRecord version'
+        end
+
+        def satisfies_add_check_constraints?
+          satisfied? '>=6.1.0'
+        end
+
+        def satisfies_add_column_update_rows_backfill?
+          satisfies_change_column_null_requirements?
+        end
+
+        def satisfied?(version)
+          Gem::Requirement.new(version).satisfied_by? Gem::Version.new(::ActiveRecord::VERSION::STRING)
+        end
+      end
+    end
+  end
+end

data/lib/safe-pg-migrations/plugins/blocking_activity_logger.rb

@@ -1,65 +1,62 @@
 # frozen_string_literal: true
 
+require_relative '../helpers/blocking_activity_formatter'
+require_relative '../helpers/blocking_activity_selector'
+
 module SafePgMigrations
-  module BlockingActivityLogger # rubocop:disable Metrics/ModuleLength
-    FILTERED_COLUMNS = %w[
-      blocked_activity.xact_start
-      blocked_locks.locktype
-      blocked_locks.mode
-      blocking_activity.pid
-      blocked_locks.transactionid
-    ].freeze
-
-    VERBOSE_COLUMNS = %w[
-      blocking_activity.query
-      blocked_activity.xact_start
-    ].freeze
+  module BlockingActivityLogger
+    include ::SafePgMigrations::Helpers::BlockingActivityFormatter
+    include ::SafePgMigrations::Helpers::BlockingActivitySelector
 
     %i[
-      add_column remove_column add_foreign_key remove_foreign_key change_column_default change_column_null create_table
+      add_column
+      remove_column
+      add_foreign_key
+      remove_foreign_key
+      change_column_default
+      change_column_null
+      create_table
     ].each do |method|
       define_method method do |*args, &block|
-        log_blocking_queries { super(*args, &block) }
+        log_blocking_queries_after_lock { super(*args, &block) }
       end
       ruby2_keywords method
     end
 
-    private
+    %i[add_index remove_index].each do |method|
+      define_method method do |*args, **options, &block|
+        return super(*args, **options, &block) if options[:algorithm] != :concurrently
 
-    def select_blocking_queries_sql
-      columns = SafePgMigrations.config.blocking_activity_logger_verbose ? VERBOSE_COLUMNS : FILTERED_COLUMNS
-
-      <<~SQL.squish
-        SELECT #{columns.join(', ')}
-        FROM pg_catalog.pg_locks           blocked_locks
-        JOIN pg_catalog.pg_stat_activity   blocked_activity
-          ON blocked_activity.pid = blocked_locks.pid
-        JOIN pg_catalog.pg_locks           blocking_locks
-          ON blocking_locks.locktype = blocked_locks.locktype
-          AND blocking_locks.DATABASE      IS NOT DISTINCT FROM blocked_locks.DATABASE
-          AND blocking_locks.relation      IS NOT DISTINCT FROM blocked_locks.relation
-          AND blocking_locks.page          IS NOT DISTINCT FROM blocked_locks.page
-          AND blocking_locks.tuple         IS NOT DISTINCT FROM blocked_locks.tuple
-          AND blocking_locks.virtualxid    IS NOT DISTINCT FROM blocked_locks.virtualxid
-          AND blocking_locks.transactionid IS NOT DISTINCT FROM blocked_locks.transactionid
-          AND blocking_locks.classid       IS NOT DISTINCT FROM blocked_locks.classid
-          AND blocking_locks.objid         IS NOT DISTINCT FROM blocked_locks.objid
-          AND blocking_locks.objsubid      IS NOT DISTINCT FROM blocked_locks.objsubid
-          AND blocking_locks.pid != blocked_locks.pid
-        JOIN pg_catalog.pg_stat_activity   blocking_activity
-          ON blocking_activity.pid = blocking_locks.pid
-        WHERE blocked_locks.pid = %d
-      SQL
+        log_blocking_queries_loop { super(*args, **options, &block) }
+      end
     end
 
-    def log_blocking_queries
-      delay_before_logging =
-        SafePgMigrations.config.safe_timeout - SafePgMigrations.config.blocking_activity_logger_margin
+    private
+
+    def log_blocking_queries_loop
+      blocking_queries_retriever_thread =
+        Thread.new do
+          loop do
+            sleep SafePgMigrations.config.retry_delay
+
+            log_queries SafePgMigrations.alternate_connection.query(
+              select_blocking_queries_sql % raw_connection.backend_pid
+            )
+          end
+        end
+
+      yield
+
+      blocking_queries_retriever_thread.kill
+    end
 
+    def log_blocking_queries_after_lock
       blocking_queries_retriever_thread =
         Thread.new do
           sleep delay_before_logging
-          SafePgMigrations.alternate_connection.query(select_blocking_queries_sql % raw_connection.backend_pid)
+          SafePgMigrations.alternate_connection.query(
+            select_blocking_queries_sql % raw_connection.backend_pid
+          )
         end
 
       yield
@@ -71,51 +68,25 @@ module SafePgMigrations
         begin
           blocking_queries_retriever_thread.value
         rescue StandardError => e
-          SafePgMigrations.say("Error while retrieving blocking queries: #{e}", true)
+          SafePgMigrations.say(
+            "Error while retrieving blocking queries: #{e}",
+            true
+          )
           nil
         end
 
-      raise if queries.nil?
-
-      if queries.empty?
-        SafePgMigrations.say 'Could not find any blocking query.', true
-      else
-        SafePgMigrations.say(
-          "Statement was being blocked by the following #{'query'.pluralize(queries.size)}:", true
-        )
-        SafePgMigrations.say '', true
-        output_blocking_queries(queries)
-        SafePgMigrations.say(
-          'Beware, some of those queries might run in a transaction. In this case the locking query might be '\
-          'located elsewhere in the transaction',
-          true
-        )
-        SafePgMigrations.say '', true
-      end
+      log_queries queries unless queries.nil?
 
       raise
     end
 
-    def output_blocking_queries(queries)
-      if SafePgMigrations.config.blocking_activity_logger_verbose
-        queries.each { |query, start_time| SafePgMigrations.say "#{format_start_time start_time}:  #{query}", true }
-      else
-        queries.each do |start_time, locktype, mode, pid, transactionid|
-          SafePgMigrations.say(
-            "#{format_start_time(start_time)}: lock type: #{locktype || 'null'}, " \
-              "lock mode: #{mode || 'null'}, " \
-              "lock pid: #{pid || 'null'}, " \
-              "lock transactionid: #{transactionid || 'null'}",
-            true
-          )
-        end
-      end
+    def delay_before_logging
+      SafePgMigrations.config.safe_timeout -
+        SafePgMigrations.config.blocking_activity_logger_margin
     end
 
-    def format_start_time(start_time, reference_time = Time.now)
-      start_time = Time.parse(start_time) unless start_time.is_a? Time
-      duration = (reference_time - start_time).round
-      "transaction started #{duration} #{'second'.pluralize(duration)} ago"
+    def delay_before_retry
+      SafePgMigrations.config.blocking_activity_logger_margin + SafePgMigrations.config.retry_delay
     end
   end
 end

data/lib/safe-pg-migrations/plugins/idempotent_statements.rb

@@ -2,6 +2,8 @@
 
 module SafePgMigrations
   module IdempotentStatements
+    include SafePgMigrations::Helpers::IndexHelper
+
     ruby2_keywords def add_index(table_name, column_name, *args)
       options = args.last.is_a?(Hash) ? args.last : {}
 
@@ -53,6 +55,16 @@ module SafePgMigrations
       )
     end
 
+    def remove_foreign_key(from_table, to_table = nil, **options)
+      return super if foreign_key_exists?(from_table, to_table, **options)
+
+      reference_name = to_table || options[:to_table] || options[:column] || options[:name]
+      SafePgMigrations.say(
+        "/!\\ Foreign key '#{from_table}' -> '#{reference_name}' does not exist. Skipping statement.",
+        true
+      )
+    end
+
     ruby2_keywords def create_table(table_name, *args)
       options = args.last.is_a?(Hash) ? args.last : {}
       return super if options[:force] || !table_exists?(table_name)
@@ -70,23 +82,51 @@ module SafePgMigrations
       end
     end
 
-    protected
+    def add_check_constraint(table_name, expression, **options)
+      constraint_definition = check_constraint_for table_name,
+                                                   **check_constraint_options(table_name, expression, options)
 
-    def index_definition(table_name, column_name, **options)
-      index_definition, = add_index_options(table_name, column_name, **options)
-      index_definition
+      return super if constraint_definition.nil?
+
+      SafePgMigrations.say "/!\\ Constraint '#{constraint_definition.name}' already exists. Skipping statement.", true
     end
 
-    private
+    def change_column_null(table_name, column_name, null, *)
+      column = column_for(table_name, column_name)
+
+      return super if column.null != null
 
-    def index_valid?(index_name)
-      query_value <<~SQL.squish
-        SELECT indisvalid
-        FROM pg_index i
-        JOIN pg_class c
-          ON i.indexrelid = c.oid
-        WHERE c.relname = '#{index_name}';
-      SQL
+      SafePgMigrations.say(
+        "/!\\ Column '#{table_name}.#{column.name}' is already set to 'null: #{null}'. Skipping statement.",
+        true
+      )
+    end
+
+    def validate_check_constraint(table_name, **options)
+      constraint_definition = check_constraint_for!(table_name, **options)
+
+      return super unless constraint_definition.validated?
+
+      SafePgMigrations.say "/!\\ Constraint '#{constraint_definition.name}' already validated. Skipping statement.",
+                           true
+    end
+
+    def change_column_default(table_name, column_name, default_or_changes)
+      column = column_for(table_name, column_name)
+
+      previous_alter_statement = change_column_default_for_alter(table_name, column_name, column.default)
+      new_alter_statement = change_column_default_for_alter(table_name, column_name, default_or_changes)
+
+      # NOTE: PG change_column_default is already idempotent.
+      # We try to detect it because it still takes an ACCESS EXCLUSIVE lock
+
+      return super if new_alter_statement != previous_alter_statement
+
+      SafePgMigrations.say(
+        "/!\\ Column '#{table_name}.#{column.name}' is already set to 'default: #{column.default}'. " \
+        'Skipping statement.',
+        true
+      )
     end
   end
 end

data/lib/safe-pg-migrations/plugins/statement_insurer/add_column.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module SafePgMigrations
+  module StatementInsurer
+    module AddColumn
+      ruby2_keywords def add_column(table_name, column_name, type, *args)
+        options = args.last.is_a?(Hash) && args.last
+        options ||= {}
+
+        if should_keep_default_implementation?(**options)
+          with_setting(:statement_timeout, SafePgMigrations.config.pg_statement_timeout) { return super }
+        end
+
+        default = options.delete(:default)
+        null = options.delete(:null)
+
+        with_setting(:statement_timeout, SafePgMigrations.config.pg_statement_timeout) do
+          SafePgMigrations.say_method_call(:add_column, table_name, column_name, type, options)
+          super table_name, column_name, type, **options
+        end
+
+        SafePgMigrations.say_method_call(:change_column_default, table_name, column_name, default)
+        change_column_default(table_name, column_name, default)
+
+        SafePgMigrations.say_method_call(:backfill_column_default, table_name, column_name)
+        without_statement_timeout do
+          backfill_column_default(table_name, column_name)
+        end
+
+        change_column_null(table_name, column_name, null) if null == false
+      end
+
+      private
+
+      def should_keep_default_implementation?(default: nil, default_value_backfill: :auto, **)
+        default_value_backfill != :update_in_batches || !default ||
+          !SafePgMigrations::Helpers::SatisfiedHelper.satisfies_add_column_update_rows_backfill?
+      end
+
+      def backfill_column_default(table_name, column_name)
+        model = Class.new(ActiveRecord::Base) { self.table_name = table_name }
+        quoted_column_name = quote_column_name(column_name)
+
+        SafePgMigrations::Helpers::BatchOver.new(model).each_batch do |batch|
+          batch
+            .update_all("#{quoted_column_name} = DEFAULT")
+          sleep SafePgMigrations.config.backfill_pause
+        end
+      end
+    end
+  end
+end

data/lib/safe-pg-migrations/plugins/statement_insurer.rb

@@ -2,47 +2,41 @@
 
 module SafePgMigrations
   module StatementInsurer
-    PG_11_VERSION_NUM = 110_000
+    include AddColumn
 
-    %i[change_column_null change_column].each do |method|
+    %i[change_column].each do |method|
       define_method method do |*args, &block|
-        with_setting(:statement_timeout, SafePgMigrations.config.pg_safe_timeout) { super(*args, &block) }
+        with_setting(:statement_timeout, SafePgMigrations.config.pg_statement_timeout) { super(*args, &block) }
       end
       ruby2_keywords method
     end
 
-    ruby2_keywords def add_column(table_name, column_name, type, *args) # rubocop:disable Metrics/CyclomaticComplexity
-      options = args.last.is_a?(Hash) ? args.last : {}
-      return super if SafePgMigrations.pg_version_num >= PG_11_VERSION_NUM
-
-      default = options.delete(:default)
-      null = options.delete(:null)
-
-      if !default.nil? || null == false
-        SafePgMigrations.say_method_call(:add_column, table_name, column_name, type, options)
+    def validate_check_constraint(table_name, **options)
+      without_statement_timeout do
+        super
       end
+    end
 
-      super
+    def add_check_constraint(table_name, expression, **options)
+      Helpers::SatisfiedHelper.satisfies_add_check_constraints!
+      return unless supports_check_constraints?
 
-      unless default.nil?
-        SafePgMigrations.say_method_call(:change_column_default, table_name, column_name, default)
-        change_column_default(table_name, column_name, default)
+      options = check_constraint_options(table_name, expression, options)
 
-        SafePgMigrations.say_method_call(:backfill_column_default, table_name, column_name)
-        backfill_column_default(table_name, column_name)
-      end
+      SafePgMigrations.say_method_call :add_check_constraint, table_name, expression, **options, validate: false
+      super table_name, expression, **options, validate: false
 
-      if null == false # rubocop:disable Style/GuardClause
-        SafePgMigrations.say_method_call(:change_column_null, table_name, column_name, null)
-        change_column_null(table_name, column_name, null)
-      end
+      return unless options.fetch(:validate, true)
+
+      SafePgMigrations.say_method_call :validate_check_constraint, table_name, name: options[:name]
+      validate_check_constraint table_name, name: options[:name]
     end
 
     ruby2_keywords def add_foreign_key(from_table, to_table, *args)
       options = args.last.is_a?(Hash) ? args.last : {}
-      validate_present = options.key? :validate
+      validate_present = options.key?(:validate)
       options[:validate] = false unless validate_present
-      with_setting(:statement_timeout, SafePgMigrations.config.pg_safe_timeout) do
+      with_setting(:statement_timeout, SafePgMigrations.config.pg_statement_timeout) do
         super(from_table, to_table, **options)
       end
 
@@ -53,7 +47,7 @@ module SafePgMigrations
     end
 
     ruby2_keywords def create_table(*)
-      with_setting(:statement_timeout, SafePgMigrations.config.pg_safe_timeout) do
+      with_setting(:statement_timeout, SafePgMigrations.config.pg_statement_timeout) do
         super do |td|
           yield td if block_given?
           td.indexes.map! do |key, index_options|
@@ -64,7 +58,9 @@ module SafePgMigrations
       end
     end
 
-    def add_index(table_name, column_name, **options)
+    ruby2_keywords def add_index(table_name, column_name, *args_options)
+      options = args_options.last.is_a?(Hash) ? args_options.last : {}
+
       if options[:algorithm] == :default
         options.delete :algorithm
       else
@@ -84,13 +80,20 @@ module SafePgMigrations
       without_timeout { super(table_name, **options) }
     end
 
-    def backfill_column_default(table_name, column_name)
-      model = Class.new(ActiveRecord::Base) { self.table_name = table_name }
-      quoted_column_name = quote_column_name(column_name)
+    def change_column_null(table_name, column_name, null, default = nil)
+      if default || null || !Helpers::SatisfiedHelper.satisfies_change_column_null_requirements?
+        with_setting(:statement_timeout, SafePgMigrations.config.pg_statement_timeout) { return super }
+      end
 
-      model.in_batches(of: SafePgMigrations.config.batch_size).each do |relation|
-        relation.update_all("#{quoted_column_name} = DEFAULT")
+      add_check_constraint table_name, "#{column_name} IS NOT NULL"
+
+      SafePgMigrations.say_method_call :change_column_null, table_name, column_name, false
+      with_setting(:statement_timeout, SafePgMigrations.config.pg_statement_timeout) do
+        super table_name, column_name, false
       end
+
+      SafePgMigrations.say_method_call :remove_check_constraint, table_name, "#{column_name} IS NOT NULL"
+      remove_check_constraint table_name, "#{column_name} IS NOT NULL"
     end
 
     def with_setting(key, value)
@@ -109,16 +112,16 @@ module SafePgMigrations
       end
     end
 
-    def without_statement_timeout
-      with_setting(:statement_timeout, 0) { yield }
+    def without_statement_timeout(&block)
+      with_setting(:statement_timeout, 0, &block)
     end
 
-    def without_lock_timeout
-      with_setting(:lock_timeout, 0) { yield }
+    def without_lock_timeout(&block)
+      with_setting(:lock_timeout, 0, &block)
     end
 
-    def without_timeout
-      without_statement_timeout { without_lock_timeout { yield } }
+    def without_timeout(&block)
+      without_statement_timeout { without_lock_timeout(&block) }
     end
   end
 end

data/lib/safe-pg-migrations/plugins/statement_retrier.rb

@@ -3,7 +3,7 @@
 module SafePgMigrations
   module StatementRetrier
     RETRIABLE_SCHEMA_STATEMENTS = %i[
-      add_column add_foreign_key remove_foreign_key change_column_default change_column_null remove_column
+      add_column add_foreign_key remove_foreign_key change_column_default change_column_null remove_column drop_table
     ].freeze
 
     RETRIABLE_SCHEMA_STATEMENTS.each do |method|

data/lib/safe-pg-migrations/plugins/useless_statements_logger.rb

@@ -29,6 +29,14 @@ module SafePgMigrations
       super
     end
 
+    ruby2_keywords def add_check_constraint(*args)
+      options = args.last.is_a?(Hash) ? args.last : {}
+      if options[:validate] == false
+        UselessStatementsLogger.warn_useless '`validate: :false`', 'https://github.com/doctolib/safe-pg-migrations#safe_add_check_constraint'
+      end
+      super
+    end
+
     def warn_for_index(**options)
       return unless options[:algorithm] == :concurrently
 

data/lib/safe-pg-migrations/plugins/verbose_sql_logger.rb

@@ -4,7 +4,7 @@ module SafePgMigrations
   class VerboseSqlLogger
     def setup
       @activerecord_logger_was = ActiveRecord::Base.logger
-      @verbose_query_logs_was = ActiveRecord::Base.verbose_query_logs
+      @verbose_query_logs_was = Polyfills::VerboseQueryLogsPolyfill.verbose_query_logs
       @colorize_logging_was = ActiveRecord::LogSubscriber.colorize_logging
 
       disable_marginalia if defined?(Marginalia)
@@ -13,12 +13,12 @@ module SafePgMigrations
       ActiveRecord::Base.logger = stdout_logger
       ActiveRecord::LogSubscriber.colorize_logging = colorize_logging?
       # Do not output caller method, we know it is coming from the migration
-      ActiveRecord::Base.verbose_query_logs = false
+      Polyfills::VerboseQueryLogsPolyfill.verbose_query_logs = false
       self
     end
 
     def teardown
-      ActiveRecord::Base.verbose_query_logs = @verbose_query_logs_was
+      Polyfills::VerboseQueryLogsPolyfill.verbose_query_logs = @verbose_query_logs_was
       ActiveRecord::LogSubscriber.colorize_logging = @colorize_logging_was
       ActiveRecord::Base.logger = @activerecord_logger_was
       enable_marginalia if defined?(Marginalia)

data/lib/safe-pg-migrations/polyfills/index_definition_polyfill.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SafePgMigrations
+  module Polyfills
+    module IndexDefinitionPolyfill
+      include Helpers::SatisfiedHelper
+
+      protected
+
+      IndexDefinition = Struct.new(:table, :name)
+
+      def index_definition(table_name, column_name, **options)
+        return super(table_name, column_name, **options) if Helpers::SatisfiedHelper.satisfied? '>=6.1.0'
+
+        index_name = options.key?(:name) ? options[:name].to_s : index_name(table_name, index_column_names(column_name))
+        validate_index_length!(table_name, index_name, options.fetch(:internal, false))
+
+        IndexDefinition.new(table_name, index_name)
+      end
+    end
+  end
+end

data/lib/safe-pg-migrations/polyfills/verbose_query_logs_polyfill.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SafePgMigrations
+  module Polyfills
+    module VerboseQueryLogsPolyfill
+      class << self
+        def verbose_query_logs
+          return ActiveRecord.verbose_query_logs if Helpers::SatisfiedHelper.satisfied? '>=7.0.0'
+
+          ActiveRecord::Base.verbose_query_logs
+        end
+
+        def verbose_query_logs=(value)
+          if Helpers::SatisfiedHelper.satisfied? '>=7.0.0'
+            ActiveRecord.verbose_query_logs = value
+            return
+          end
+
+          ActiveRecord::Base.verbose_query_logs = value
+        end
+      end
+    end
+  end
+end

data/lib/safe-pg-migrations/railtie.rb

@@ -7,6 +7,7 @@ module SafePgMigrations
     initializer 'safe_pg_migrations.insert_into_active_record' do
       ActiveSupport.on_load :active_record do
         ActiveRecord::Migration.prepend(SafePgMigrations::Migration)
+        ActiveRecord::Migration.singleton_class.prepend(SafePgMigrations::Migration::ClassMethods)
       end
     end
   end

data/lib/safe-pg-migrations/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SafePgMigrations
-  VERSION = '1.4.2'
+  VERSION = '2.1.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: safe-pg-migrations
 version: !ruby/object:Gem::Version
-  version: 1.4.2
+  version: 2.1.0
 platform: ruby
 authors:
 - Matthieu Prat
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-10 00:00:00.000000000 Z
+date: 2023-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -18,42 +18,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
-- !ruby/object:Gem::Dependency
-  name: ruby2_keywords
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.0.4
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.0.4
+        version: '6.0'
 description: Make your PG migrations safe.
 email:
 executables: []
@@ -65,13 +51,20 @@ files:
 - lib/safe-pg-migrations.rb
 - lib/safe-pg-migrations/base.rb
 - lib/safe-pg-migrations/configuration.rb
+- lib/safe-pg-migrations/helpers/batch_over.rb
+- lib/safe-pg-migrations/helpers/blocking_activity_formatter.rb
+- lib/safe-pg-migrations/helpers/blocking_activity_selector.rb
+- lib/safe-pg-migrations/helpers/index_helper.rb
+- lib/safe-pg-migrations/helpers/satisfied_helper.rb
 - lib/safe-pg-migrations/plugins/blocking_activity_logger.rb
 - lib/safe-pg-migrations/plugins/idempotent_statements.rb
-- lib/safe-pg-migrations/plugins/legacy_active_record_support.rb
 - lib/safe-pg-migrations/plugins/statement_insurer.rb
+- lib/safe-pg-migrations/plugins/statement_insurer/add_column.rb
 - lib/safe-pg-migrations/plugins/statement_retrier.rb
 - lib/safe-pg-migrations/plugins/useless_statements_logger.rb
 - lib/safe-pg-migrations/plugins/verbose_sql_logger.rb
+- lib/safe-pg-migrations/polyfills/index_definition_polyfill.rb
+- lib/safe-pg-migrations/polyfills/verbose_query_logs_polyfill.rb
 - lib/safe-pg-migrations/railtie.rb
 - lib/safe-pg-migrations/version.rb
 homepage: https://github.com/doctolib/safe-pg-migrations
@@ -83,6 +76,7 @@ metadata:
   mailing_list_uri: https://doctolib.engineering/engineering-news-ruby-rails-react
   source_code_uri: https://github.com/doctolib/safe-pg-migrations
   contributors_uri: https://github.com/doctolib/safe-pg-migrations/graphs/contributors
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -91,18 +85,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
-  - - "<"
-    - !ruby/object:Gem::Version
-      version: '4'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.7.3
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Make your PG migrations safe.

data/lib/safe-pg-migrations/plugins/legacy_active_record_support.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module SafePgMigrations
-  module LegacyActiveRecordSupport
-    ruby2_keywords def validate_foreign_key(*args)
-      return super(*args) if satisfied? '>=6.0.0'
-
-      from_table, to_table, options = args
-      super(from_table, to_table || options)
-    end
-
-    ruby2_keywords def foreign_key_exists?(*args)
-      return super(*args) if satisfied? '>=6.0.0'
-
-      from_table, to_table, options = args
-      super(from_table, to_table || options)
-    end
-
-    protected
-
-    IndexDefinition = Struct.new(:table, :name)
-
-    def index_definition(table_name, column_name, **options)
-      return super(table_name, column_name, **options) if satisfied? '>=6.1.0'
-
-      index_name = options.key?(:name) ? options[:name].to_s : index_name(table_name, index_column_names(column_name))
-      validate_index_length!(table_name, index_name, options.fetch(:internal, false))
-
-      IndexDefinition.new(table_name, index_name)
-    end
-
-    private
-
-    def satisfied?(version)
-      Gem::Requirement.new(version).satisfied_by? Gem::Version.new(::ActiveRecord::VERSION::STRING)
-    end
-  end
-end