safe-pg-migrations 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 878eca03499c2fa44ef8e046f5828b2b0978e692ade4440f9489a29889a99b49
-  data.tar.gz: 88a9aa0adf58a3a716565d8a3482839ffd546570ab7238f67daecb0c2396a152
+  metadata.gz: 2fafd98448f0ff697da386a337dc22753be2144feedba4793f87a351581a5607
+  data.tar.gz: 9653ae6395d4c9f27b69dba9dee9142a4535384c42e8d05fac9ca2e2ef1bdce6
 SHA512:
-  metadata.gz: 15cd514d22cf2b5f182faf16a50a4775fa528754357eeeaa0c81f2f93bf25d12375ae2c7742e8e762addd01ae3b5aeeedb09c758e9e6da063f4b0beca8544c45
-  data.tar.gz: d930ac0e741025ea05743a2ad8f6da979932f67cd9e93e13c64b22581bb073b164212144d152f9a0729a93e49098cb9279caba57a91b746502ccb259cb18bbcb
+  metadata.gz: 64297c9ba4f040e7afa21fefa2acb2a26e27fb0bfee3d9f9cbf902ee4bb0ac087f4e22591a7b5470cf73dc7bc73345e59904649c02d7540bd4693372e7069549
+  data.tar.gz: 7a2640fd2494480d560cfa6f19059550ecc316eaf729df6d8f97a434c189f4565c49d47acbb02f437d9b1285a466a5615a79a84d6ba1dfb3d94bb54f87b9e788

data/README.md

@@ -109,7 +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.
+
+---
+**NOTE**
+
+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
+
+1. First migration :
+
+    a. adds the column without default and without null constraint;
+
+    b. add the default value.
+
+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>
 
@@ -130,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)
@@ -201,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,13 +1,16 @@
 # frozen_string_literal: true
 
 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/polyfills/satisfied_helper'
 require 'safe-pg-migrations/polyfills/index_definition_polyfill'
 require 'safe-pg-migrations/polyfills/verbose_query_logs_polyfill'
 
@@ -23,15 +26,16 @@ module SafePgMigrations
   ].freeze
 
   class << self
-    attr_reader :current_migration
+    attr_reader :current_migration, :pg_version_num
 
     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, &block)
+      connection.with_setting :lock_timeout, SafePgMigrations.config.pg_lock_timeout, &block
     ensure
       close_alternate_connection
       @current_migration = nil
@@ -72,6 +76,10 @@ 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
@@ -102,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,22 +4,32 @@ require 'active_support/core_ext/numeric/time'
 
 module SafePgMigrations
   class Configuration
-    attr_accessor :safe_timeout, :blocking_activity_logger_margin, :blocking_activity_logger_verbose, :batch_size,
-                  :retry_delay, :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/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/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 : {}
 
@@ -80,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)
+
+      return super if constraint_definition.nil?
+
+      SafePgMigrations.say "/!\\ Constraint '#{constraint_definition.name}' already exists. Skipping statement.", true
+    end
+
+    def change_column_null(table_name, column_name, null, *)
+      column = column_for(table_name, column_name)
 
-    def index_definition(table_name, column_name, **options)
-      index_definition, = add_index_options(table_name, column_name, **options)
-      index_definition
+      return super if column.null != null
+
+      SafePgMigrations.say(
+        "/!\\ Column '#{table_name}.#{column.name}' is already set to 'null: #{null}'. Skipping statement.",
+        true
+      )
     end
 
-    private
+    def validate_check_constraint(table_name, **options)
+      constraint_definition = check_constraint_for!(table_name, **options)
+
+      return super unless constraint_definition.validated?
 
-    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 "/!\\ 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,18 +2,41 @@
 
 module SafePgMigrations
   module StatementInsurer
-    %i[change_column_null change_column].each do |method|
+    include AddColumn
+
+    %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
 
+    def validate_check_constraint(table_name, **options)
+      without_statement_timeout do
+        super
+      end
+    end
+
+    def add_check_constraint(table_name, expression, **options)
+      Helpers::SatisfiedHelper.satisfies_add_check_constraints!
+      return unless supports_check_constraints?
+
+      options = check_constraint_options(table_name, expression, options)
+
+      SafePgMigrations.say_method_call :add_check_constraint, table_name, expression, **options, validate: false
+      super table_name, expression, **options, validate: false
+
+      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
 
@@ -24,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|
@@ -57,6 +80,22 @@ module SafePgMigrations
       without_timeout { super(table_name, **options) }
     end
 
+    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
+
+      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)
       old_value = query_value("SHOW #{key}")
       execute("SET #{key} TO #{quote(value)}")

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/polyfills/index_definition_polyfill.rb

@@ -3,14 +3,14 @@
 module SafePgMigrations
   module Polyfills
     module IndexDefinitionPolyfill
-      include SatisfiedHelper
+      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 satisfied? '>=6.1.0'
+        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))

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

@@ -4,16 +4,14 @@ module SafePgMigrations
   module Polyfills
     module VerboseQueryLogsPolyfill
       class << self
-        include SatisfiedHelper
-
         def verbose_query_logs
-          return ActiveRecord.verbose_query_logs if satisfied? '>=7.0.0'
+          return ActiveRecord.verbose_query_logs if Helpers::SatisfiedHelper.satisfied? '>=7.0.0'
 
           ActiveRecord::Base.verbose_query_logs
         end
 
         def verbose_query_logs=(value)
-          if satisfied? '>=7.0.0'
+          if Helpers::SatisfiedHelper.satisfied? '>=7.0.0'
             ActiveRecord.verbose_query_logs = value
             return
           end

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

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: safe-pg-migrations
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Matthieu Prat
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-17 00:00:00.000000000 Z
+date: 2023-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -51,16 +51,19 @@ 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/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/satisfied_helper.rb
 - lib/safe-pg-migrations/polyfills/verbose_query_logs_polyfill.rb
 - lib/safe-pg-migrations/railtie.rb
 - lib/safe-pg-migrations/version.rb

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

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module SafePgMigrations
-  module Polyfills
-    module SatisfiedHelper
-      private
-
-      def satisfied?(version)
-        Gem::Requirement.new(version).satisfied_by? Gem::Version.new(::ActiveRecord::VERSION::STRING)
-      end
-    end
-  end
-end