safe-pg-migrations 2.0.0 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 878eca03499c2fa44ef8e046f5828b2b0978e692ade4440f9489a29889a99b49
-  data.tar.gz: 88a9aa0adf58a3a716565d8a3482839ffd546570ab7238f67daecb0c2396a152
+  metadata.gz: 624821b7134dee05186350edada6f27faaf8c820976837d32403dc5fffa4880a
+  data.tar.gz: bf41324b8d563de7bc893a302d45d8f175e890bb888a2f52e0b14be7676f942c
 SHA512:
-  metadata.gz: 15cd514d22cf2b5f182faf16a50a4775fa528754357eeeaa0c81f2f93bf25d12375ae2c7742e8e762addd01ae3b5aeeedb09c758e9e6da063f4b0beca8544c45
-  data.tar.gz: d930ac0e741025ea05743a2ad8f6da979932f67cd9e93e13c64b22581bb073b164212144d152f9a0729a93e49098cb9279caba57a91b746502ccb259cb18bbcb
+  metadata.gz: 76601dcf0b97013edc36de6ac351beb8e4f6c532a0e223cba95d1a29e4eb7f18b8a4e7b3e3f28e4e7bde02144a4de8c512c19e2725396578dcb322e040963168
+  data.tar.gz: 767876e75af3292f9c4d3fc82810ab37bb3d38dad7b8b87ee6ba7068ec5e4aa9967ac0e53170be77bda07dd3424f2d3b3b3a03d9b8dc6ebcda94cee21e61fcfc

data/README.md

@@ -109,7 +109,51 @@ 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
+safety_assured do
+  add_column :users, :created_at, default: 'clock_timestamp()', default_value_backfill: :update_in_batches
+end
+```
+
+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.
+
+### Preventing :update_in_batches when the table is too big
+
+`add_column` with `default_value_backfill: :update_in_batches` can be dangerous on big tables. To avoid unwanted long migrations, **Safe PG Migrations** does not automatically mark this usage as safe when used with `strong-migrations`, usage of `safety_assured` is required.
+
+It is also possible to set a threshold for the table size, above which the migration will fail. This can be done by setting the `default_value_backfill_threshold:` option in the configuration.
+
 
 </details>
 
@@ -130,13 +174,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)
@@ -145,6 +246,35 @@ When a statement fails with a lock timeout, **Safe PG Migrations** retries it (5
 <details><summary>Blocking activity logging</summary>
 
 If a statement fails with a lock timeout, **Safe PG Migrations** will try to tell you what was the blocking statement.
+
+---
+**NOTE**
+
+Data logged by the Blocking activity logger can be sensitive (it will contain raw SQL queries, which can be hashes of password, user information, ...)
+
+If you cannot afford to log this type of data, you can either
+* Set `SafePgMigrations.config.blocking_activity_logger_verbose = false`. In this case, the logger will only log the pid of the blocking statement, which should be enough to investigate;
+* Provide a different logger through `SafePgMigrations.config.sensitive_logger = YourLogger.new`. Instead of using the default IO stream, SafePgMigrations will send sensitive data to the given logger which can be managed as you wish.
+
+---
+
+</details>
+
+<details><summary>Dropping a table</summary>
+
+Dropping a table can be difficult to achieve in a small amount of time if it holds several foreign keys to busy tables.
+To remove the table, PostgreSQL will have to acquire an access exclusive lock on all the tables referenced by the foreign keys.
+
+To solve this issue, **Safe Pg Migrations** will drop the foreign keys before dropping the table.
+
+---
+**NOTE**
+
+Dropping a table is a dangerous operation by nature. **Safe Pg Migrations** will not prevent the deletion of a table which
+would still be in use.
+
+---
+
 </details>
 
 <details><summary>Verbose SQL logging</summary>
@@ -195,31 +325,32 @@ So you can actually check that the `CREATE INDEX` statement will be performed co
 **Safe PG Migrations** can be customized, here is an example of a Rails initializer (the values are the default ones):
 
 ```ruby
-SafePgMigrations.config.safe_timeout = 5.seconds # Lock and statement timeout used for all DDL operations except from CREATE / DROP INDEX
+SafePgMigrations.config.safe_timeout = 5.seconds # Statement timeout used for all DDL operations except from CREATE / DROP INDEX
+
+SafePgMigrations.config.lock_timeout = nil # Lock timeout used for all DDL operations except from CREATE / DROP INDEX. If not set, safe_timeout will be used with a deduction of 1% to ensure that the lock timeout is raised in priority
 
 SafePgMigrations.config.blocking_activity_logger_verbose = true # Outputs the raw blocking queries on timeout. When false, outputs information about the lock instead
 
+SafePgMigrations.config.sensitive_logger = nil # When given, sensitive data will be sent to this logger instead of the standard output. Must implement method `info`.
+
 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.retry_delay = 1.minute # Delay between retries for retryable statements
+SafePgMigrations.config.backfill_pause = 0.5.second # Delay between each batch during a backfill. This ensure replication can happen safely. 
 
-SafePgMigrations.config.max_tries = 5 # Number of retries before abortion of the migration
-```
+SafePgMigrations.config.default_value_backfill_threshold = nil # When set, batch backfill will only be available if the table is under the given threshold. If the number of rows is higher (according to stats), the migration will fail. 
 
-## Running tests
+SafePgMigrations.config.retry_delay = 1.minute # Delay between retries for retryable statements
 
-```bash
-bundle
-psql -h localhost -c 'CREATE DATABASE safe_pg_migrations_test'
-rake test
+SafePgMigrations.config.max_tries = 5 # Number of retries before abortion of the migration
 ```
 
 ## Authors
 
 - [Matthieu Prat](https://github.com/matthieuprat)
 - [Romain Choquet](https://github.com/rchoquet)
+- [Thomas Hareau](https://github.com/ThHareau)
 - [Paul-Etienne Coisne](https://github.com/coisnepe)
 
 ## License

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

@@ -1,13 +1,20 @@
 # frozen_string_literal: true
 
 require 'safe-pg-migrations/configuration'
+require 'safe-pg-migrations/helpers/logger'
+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/helpers/session_setting_management'
 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/change_column_null'
 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/plugins/strong_migrations_integration'
 require 'safe-pg-migrations/polyfills/index_definition_polyfill'
 require 'safe-pg-migrations/polyfills/verbose_query_logs_polyfill'
 
@@ -23,19 +30,34 @@ 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)
+      with_current_migration(migration) do
+        stdout_sql_logger = VerboseSqlLogger.new.setup if verbose?
+
+        VerboseSqlLogger.new.setup if verbose?
+        PLUGINS.each { |plugin| connection.extend(plugin) }
+
+        connection.with_setting :lock_timeout, SafePgMigrations.config.pg_lock_timeout do
+          connection.with_setting :statement_timeout, SafePgMigrations.config.pg_statement_timeout, &block
+        end
+      ensure
+        stdout_sql_logger&.teardown
+      end
     ensure
       close_alternate_connection
+    end
+
+    def with_current_migration(migration, &block)
+      @current_migration = migration
+
+      yield block
+    ensure
       @current_migration = nil
-      stdout_sql_logger&.teardown
     end
 
     def alternate_connection
@@ -49,16 +71,6 @@ module SafePgMigrations
       @alternate_connection = nil
     end
 
-    ruby2_keywords def say(*args)
-      return unless current_migration
-
-      current_migration.say(*args)
-    end
-
-    ruby2_keywords def say_method_call(method, *args)
-      say "#{method}(#{args.map(&:inspect) * ', '})", true
-    end
-
     def verbose?
       unless current_migration.class._safe_pg_migrations_verbose.nil?
         return current_migration.class._safe_pg_migrations_verbose
@@ -72,9 +84,15 @@ 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
+    include StrongMigrationsIntegration
+
     module ClassMethods
       attr_accessor :_safe_pg_migrations_verbose
 
@@ -90,27 +108,11 @@ module SafePgMigrations
     end
 
     def disable_ddl_transaction
-      UselessStatementsLogger.warn_useless '`disable_ddl_transaction`' if super
-      true
-    end
+      SafePgMigrations.with_current_migration(self) do
+        UselessStatementsLogger.warn_useless '`disable_ddl_transaction`' if super
 
-    SAFE_METHODS = %i[
-      execute
-      add_column
-      add_index
-      add_reference
-      add_belongs_to
-      change_column_null
-      add_foreign_key
-    ].freeze
-
-    SAFE_METHODS.each do |method|
-      define_method method do |*args|
-        return super(*args) unless respond_to?(:safety_assured)
-
-        safety_assured { super(*args) }
+        true
       end
-      ruby2_keywords method
     end
   end
 end

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

@@ -4,22 +4,66 @@ 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(*%i[
+                    blocking_activity_logger_margin
+                    blocking_activity_logger_verbose
+                    default_value_backfill_threshold
+                    backfill_batch_size
+                    backfill_pause
+                    retry_delay
+                    max_tries
+                    sensitive_logger
+                  ])
+    attr_reader :lock_timeout, :safe_timeout
 
     def initialize
+      self.default_value_backfill_threshold = nil
       self.safe_timeout = 5.seconds
+      self.lock_timeout = nil
       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
+      self.sensitive_logger = nil
     end
 
-    def pg_safe_timeout
-      pg_duration(safe_timeout)
+    def lock_timeout=(value)
+      raise 'Setting lock timeout to 0 disables the lock timeout and is dangerous' if value == 0.seconds
+
+      unless value.nil? || value < safe_timeout
+        raise ArgumentError, "Lock timeout (#{value}) cannot be greater than safe timeout (#{safe_timeout})"
+      end
+
+      @lock_timeout = value
+    end
+
+    def safe_timeout=(value)
+      raise 'Setting safe timeout to 0 disables the safe timeout and is dangerous' unless value
+
+      unless lock_timeout.nil? || value > lock_timeout
+        raise ArgumentError, "Safe timeout (#{value}) cannot be less than lock timeout (#{lock_timeout})"
+      end
+
+      @safe_timeout = value
     end
 
+    def pg_statement_timeout
+      pg_duration safe_timeout
+    end
+
+    def pg_lock_timeout
+      return pg_duration lock_timeout if 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

@@ -5,20 +5,20 @@ module SafePgMigrations
     module BlockingActivityFormatter
       def log_queries(queries)
         if queries.empty?
-          SafePgMigrations.say 'Could not find any blocking query.', true
+          Logger.say 'Could not find any blocking query.', sub_item: true
         else
-          SafePgMigrations.say(
-            "Statement was being blocked by the following #{'query'.pluralize(queries.size)}:",
-            true
-          )
-          SafePgMigrations.say '', true
+          Logger.say <<~MESSAGE.squish, sub_item: true
+            Statement was being blocked by the following #{'query'.pluralize(queries.size)}:
+          MESSAGE
+
+          Logger.say '', sub_item: 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
+          Logger.say <<~MESSAGE.squish, sub_item: true
+            Beware, some of those queries might run in a transaction. In this case the locking query might be located
+            elsewhere in the transaction
+          MESSAGE
+
+          Logger.say '', sub_item: true
         end
       end
 
@@ -27,8 +27,10 @@ module SafePgMigrations
       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
+            Logger.say(
+              "Query with pid #{pid || 'null'} started #{format_start_time start_time}: #{query}",
+              sub_item: true, sensitive: true
+            )
           end
         else
           output_confidentially_blocking_queries(queries)
@@ -37,14 +39,13 @@ module SafePgMigrations
 
       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
-          )
+          Logger.say <<~MESSAGE.squish, sub_item: true, sensitive: true
+            Query with pid #{pid || 'null'}
+            started #{format_start_time(start_time)}:
+            lock type: #{locktype || 'null'},
+            lock mode: #{mode || 'null'},
+            lock transactionid: #{transactionid || 'null'}",
+          MESSAGE
         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/logger.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module SafePgMigrations
+  module Helpers
+    module Logger
+      class << self
+        def say(message, sub_item: false, sensitive: false, warn_sensitive_logs: true)
+          return unless SafePgMigrations.current_migration
+
+          if sensitive
+            log_sensitive message, sub_item: sub_item
+            if warn_sensitive_logs && sensitive_logger?
+              log 'Sensitive data sent to sensitive logger', sub_item: sub_item
+            end
+          else
+            log message, sub_item: sub_item
+          end
+        end
+
+        def say_method_call(method, *args, sensitive: false, warn_sensitive_logs: true, **options)
+          args += [options] unless options.empty?
+
+          say "#{method}(#{args.map(&:inspect) * ', '})",
+              sub_item: true, sensitive: sensitive, warn_sensitive_logs: warn_sensitive_logs
+        end
+
+        private
+
+        def log(message, sub_item:)
+          SafePgMigrations.current_migration.say message, sub_item
+        end
+
+        def log_sensitive(message, sub_item:)
+          if sensitive_logger?
+            SafePgMigrations.config.sensitive_logger.info message
+          else
+            log message, sub_item: sub_item
+          end
+        end
+
+        def sensitive_logger?
+          SafePgMigrations.config.sensitive_logger
+        end
+      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