strong_migrations 0.3.1 → 0.7.6

data/lib/generators/strong_migrations/install_generator.rb

@@ -0,0 +1,46 @@
+require "rails/generators"
+
+module StrongMigrations
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.join(__dir__, "templates")
+
+      def create_initializer
+        template "initializer.rb", "config/initializers/strong_migrations.rb"
+      end
+
+      def start_after
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      end
+
+      def pgbouncer_message
+        if postgresql?
+          "\n# If you use PgBouncer in transaction mode, delete these lines and set timeouts on the database user"
+        end
+      end
+
+      def target_version
+        case adapter
+        when /mysql/
+          # could try to connect to database and check for MariaDB
+          # but this should be fine
+          '"8.0.12"'
+        else
+          "10"
+        end
+      end
+
+      def adapter
+        if ActiveRecord::VERSION::STRING.to_f >= 6.1
+          ActiveRecord::Base.connection_db_config.adapter.to_s
+        else
+          ActiveRecord::Base.connection_config[:adapter].to_s
+        end
+      end
+
+      def postgresql?
+        adapter =~ /postg/
+      end
+    end
+  end
+end

data/lib/generators/strong_migrations/templates/initializer.rb.tt

@@ -0,0 +1,25 @@
+# Mark existing migrations as safe
+StrongMigrations.start_after = <%= start_after %>
+
+# Set timeouts for migrations<%= pgbouncer_message %>
+StrongMigrations.lock_timeout = 10.seconds
+StrongMigrations.statement_timeout = 1.hour
+
+# Analyze tables after indexes are added
+# Outdated statistics can sometimes hurt performance
+StrongMigrations.auto_analyze = true
+
+# Set the version of the production database
+# so the right checks are run in development
+# StrongMigrations.target_version = <%= target_version %>
+
+# Add custom checks
+# StrongMigrations.add_check do |method, args|
+#   if method == :add_index && args[0].to_s == "users"
+#     stop! "No more indexes on the users table"
+#   end
+# end<% if postgresql? %>
+
+# Make some operations safe by default
+# See https://github.com/ankane/strong_migrations#safe-by-default
+# StrongMigrations.safe_by_default = true<% end %>

data/lib/strong_migrations.rb

@@ -1,21 +1,34 @@
+# dependencies
 require "active_support"
 
+# modules
+require "strong_migrations/safe_methods"
+require "strong_migrations/checker"
 require "strong_migrations/database_tasks"
 require "strong_migrations/migration"
-require "strong_migrations/railtie" if defined?(Rails)
-require "strong_migrations/unsafe_migration"
 require "strong_migrations/version"
 
+# integrations
+require "strong_migrations/railtie" if defined?(Rails)
+
 module StrongMigrations
+  class Error < StandardError; end
+  class UnsafeMigration < Error; end
+
   class << self
-    attr_accessor :auto_analyze, :start_after, :checks, :error_messages
+    attr_accessor :auto_analyze, :start_after, :checks, :error_messages,
+      :target_postgresql_version, :target_mysql_version, :target_mariadb_version,
+      :enabled_checks, :lock_timeout, :statement_timeout, :check_down, :target_version,
+      :safe_by_default
+    attr_writer :lock_timeout_limit
   end
   self.auto_analyze = false
   self.start_after = 0
   self.checks = []
+  self.safe_by_default = false
   self.error_messages = {
     add_column_default:
-"Adding a column with a non-null default causes the entire table to be rewritten.
+"Adding a column with a non-null default blocks %{rewrite_blocks} while the entire table is rewritten.
 Instead, add the column without a default value, then change the default.
 
 class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
@@ -34,29 +47,24 @@ Then backfill the existing rows in the Rails console or a separate migration wit
 class Backfill%{migration_name} < ActiveRecord::Migration%{migration_suffix}
   disable_ddl_transaction!
 
-  def change
+  def up
     %{code}
   end
 end",
 
     add_column_json:
-"There's no equality operator for the json column type, which
-causes issues for SELECT DISTINCT queries. Use jsonb instead.",
-
-    add_column_json_legacy:
-"There's no equality operator for the json column type, which.
-causes issues for SELECT DISTINCT queries.
-Replace all calls to uniq with a custom scope.
-
-class %{model} < %{base_model}
-  scope :uniq_on_id, -> { select('DISTINCT ON (%{table}.id) %{table}.*') }
-end
+"There's no equality operator for the json column type, which can cause errors for
+existing SELECT DISTINCT queries in your application. Use jsonb instead.
 
-Once it's deployed, wrap this step in a safety_assured { ... } block.",
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{command}
+  end
+end",
 
     change_column:
-"Changing the type of an existing column requires the entire
-table and indexes to be rewritten. A safer approach is to:
+"Changing the type of an existing column blocks %{rewrite_blocks}
+while the entire table is rewritten. A safer approach is to:
 
 1. Create a new column
 2. Write to both columns
@@ -65,7 +73,10 @@ table and indexes to be rewritten. A safer approach is to:
 5. Stop writing to the old column
 6. Drop the old column",
 
-    remove_column: "ActiveRecord caches attributes which causes problems
+    change_column_with_not_null:
+"Changing the type is safe, but setting NOT NULL is not.",
+
+    remove_column: "Active Record caches attributes, which causes problems
 when removing columns. Be sure to ignore the column%{column_suffix}:
 
 class %{model} < %{base_model}
@@ -81,7 +92,8 @@ class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
 end",
 
     rename_column:
-"Renaming a column is dangerous. A safer approach is to:
+"Renaming a column that's in use will cause errors
+in your application. A safer approach is to:
 
 1. Create a new column
 2. Write to both columns
@@ -91,9 +103,10 @@ end",
 6. Drop the old column",
 
     rename_table:
-"Renaming a table is dangerous. A safer approach is to:
+"Renaming a table that's in use will cause errors
+in your application. A safer approach is to:
 
-1. Create a new table
+1. Create a new table. Don't forget to recreate indexes from the old table
 2. Write to both tables
 3. Backfill data from the old table to new table
 4. Move reads from the old table to the new table
@@ -101,19 +114,18 @@ end",
 6. Drop the old table",
 
     add_reference:
-"Adding a non-concurrent index locks the table. Instead, use:
+"%{headline} Instead, use:
 
 class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
   disable_ddl_transaction!
 
   def change
-    %{reference_command}
-    %{index_command}
+    %{command}
   end
 end",
 
     add_index:
-"Adding a non-concurrent index locks the table. Instead, use:
+"Adding an index non-concurrently blocks writes. Instead, use:
 
 class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
   disable_ddl_transaction!
@@ -123,10 +135,20 @@ class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
   end
 end",
 
-    add_index_columns:
-"Adding an index with more than three columns only helps on extremely large tables.
+    remove_index:
+"Removing an index non-concurrently blocks writes. Instead, use:
 
-If you're sure this is what you want, wrap it in a safety_assured { ... } block.",
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  disable_ddl_transaction!
+
+  def change
+    %{command}
+  end
+end",
+
+    add_index_columns:
+"Adding a non-unique index with more than three columns rarely improves performance.
+Instead, start an index with columns that narrow down the results the most.",
 
     change_table:
 "Strong Migrations does not support inspecting what happens inside a
@@ -143,7 +165,7 @@ Otherwise, remove the force option.",
 execute call, so cannot help you here. Please make really sure that what
 you're doing is safe before proceeding, then wrap it in a safety_assured { ... } block.",
 
-   change_column_null:
+    change_column_null:
 "Passing a default value to change_column_null runs a single UPDATE query,
 which can cause downtime. Instead, backfill the existing rows in the
 Rails console or a separate migration with disable_ddl_transaction!.
@@ -151,15 +173,110 @@ Rails console or a separate migration with disable_ddl_transaction!.
 class Backfill%{migration_name} < ActiveRecord::Migration%{migration_suffix}
   disable_ddl_transaction!
 
-  def change
+  def up
     %{code}
   end
-end"
+end",
+
+    change_column_null_postgresql:
+"Setting NOT NULL on an existing column blocks reads and writes while every row is checked.
+Instead, add a check constraint and validate it in a separate migration.
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{add_constraint_code}
+  end
+end
+
+class Validate%{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{validate_constraint_code}
+  end
+end",
+
+    change_column_null_mysql:
+"Setting NOT NULL on an existing column is not safe with your database engine.",
+
+    add_foreign_key:
+"Adding a foreign key blocks writes on both tables. Instead,
+add the foreign key without validating existing rows,
+then validate them in a separate migration.
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{add_foreign_key_code}
+  end
+end
+
+class Validate%{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{validate_foreign_key_code}
+  end
+end",
+
+    validate_foreign_key:
+"Validating a foreign key while writes are blocked is dangerous.
+Use disable_ddl_transaction! or a separate migration.",
+
+    add_check_constraint:
+"Adding a check constraint key blocks reads and writes while every row is checked.
+Instead, add the check constraint without validating existing rows,
+then validate them in a separate migration.
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{add_check_constraint_code}
+  end
+end
+
+class Validate%{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{validate_check_constraint_code}
+  end
+end",
+
+    add_check_constraint_mysql:
+"Adding a check constraint to an existing table is not safe with your database engine.",
+
+    validate_check_constraint:
+"Validating a check constraint while writes are blocked is dangerous.
+Use disable_ddl_transaction! or a separate migration."
   }
+  self.enabled_checks = (error_messages.keys - [:remove_index]).map { |k| [k, {}] }.to_h
+  self.check_down = false
+
+  # private
+  def self.developer_env?
+    defined?(Rails) && (Rails.env.development? || Rails.env.test?)
+  end
+
+  def self.lock_timeout_limit
+    unless defined?(@lock_timeout_limit)
+      @lock_timeout_limit = developer_env? ? false : 10
+    end
+    @lock_timeout_limit
+  end
 
   def self.add_check(&block)
     checks << block
   end
+
+  def self.enable_check(check, start_after: nil)
+    enabled_checks[check] = {start_after: start_after}
+  end
+
+  def self.disable_check(check)
+    enabled_checks.delete(check)
+  end
+
+  def self.check_enabled?(check, version: nil)
+    if enabled_checks[check]
+      start_after = enabled_checks[check][:start_after] || StrongMigrations.start_after
+      !version || version > start_after
+    else
+      false
+    end
+  end
 end
 
 ActiveSupport.on_load(:active_record) do

data/lib/strong_migrations/checker.rb

@@ -0,0 +1,599 @@
+module StrongMigrations
+  class Checker
+    include SafeMethods
+
+    attr_accessor :direction, :transaction_disabled
+
+    def initialize(migration)
+      @migration = migration
+      @new_tables = []
+      @safe = false
+      @timeouts_set = false
+      @lock_timeout_checked = false
+    end
+
+    def safety_assured
+      previous_value = @safe
+      begin
+        @safe = true
+        yield
+      ensure
+        @safe = previous_value
+      end
+    end
+
+    def perform(method, *args)
+      set_timeouts
+      check_lock_timeout
+
+      if !safe? || safe_by_default_method?(method)
+        case method
+        when :remove_column, :remove_columns, :remove_timestamps, :remove_reference, :remove_belongs_to
+          columns =
+            case method
+            when :remove_timestamps
+              ["created_at", "updated_at"]
+            when :remove_column
+              [args[1].to_s]
+            when :remove_columns
+              args[1..-1].map(&:to_s)
+            else
+              options = args[2] || {}
+              reference = args[1]
+              cols = []
+              cols << "#{reference}_type" if options[:polymorphic]
+              cols << "#{reference}_id"
+              cols
+            end
+
+          code = "self.ignored_columns = #{columns.inspect}"
+
+          raise_error :remove_column,
+            model: args[0].to_s.classify,
+            code: code,
+            command: command_str(method, args),
+            column_suffix: columns.size > 1 ? "s" : ""
+        when :change_table
+          raise_error :change_table, header: "Possibly dangerous operation"
+        when :rename_table
+          raise_error :rename_table
+        when :rename_column
+          raise_error :rename_column
+        when :add_index
+          table, columns, options = args
+          options ||= {}
+
+          if columns.is_a?(Array) && columns.size > 3 && !options[:unique]
+            raise_error :add_index_columns, header: "Best practice"
+          end
+          if postgresql? && options[:algorithm] != :concurrently && !new_table?(table)
+            return safe_add_index(table, columns, options) if StrongMigrations.safe_by_default
+            raise_error :add_index, command: command_str("add_index", [table, columns, options.merge(algorithm: :concurrently)])
+          end
+        when :remove_index
+          table, options = args
+          unless options.is_a?(Hash)
+            options = {column: options}
+          end
+          options ||= {}
+
+          if postgresql? && options[:algorithm] != :concurrently && !new_table?(table)
+            return safe_remove_index(table, options) if StrongMigrations.safe_by_default
+            raise_error :remove_index, command: command_str("remove_index", [table, options.merge(algorithm: :concurrently)])
+          end
+        when :add_column
+          table, column, type, options = args
+          options ||= {}
+          default = options[:default]
+
+          if !default.nil? && !((postgresql? && postgresql_version >= Gem::Version.new("11")) || (mysql? && mysql_version >= Gem::Version.new("8.0.12")) || (mariadb? && mariadb_version >= Gem::Version.new("10.3.2")))
+
+            if options[:null] == false
+              options = options.except(:null)
+              append = "
+
+Then add the NOT NULL constraint in separate migrations."
+            end
+
+            raise_error :add_column_default,
+              add_command: command_str("add_column", [table, column, type, options.except(:default)]),
+              change_command: command_str("change_column_default", [table, column, default]),
+              remove_command: command_str("remove_column", [table, column]),
+              code: backfill_code(table, column, default),
+              append: append,
+              rewrite_blocks: rewrite_blocks
+          end
+
+          if type.to_s == "json" && postgresql?
+            raise_error :add_column_json,
+              command: command_str("add_column", [table, column, :jsonb, options])
+          end
+        when :change_column
+          table, column, type, options = args
+          options ||= {}
+
+          safe = false
+          existing_column = connection.columns(table).find { |c| c.name.to_s == column.to_s }
+          if existing_column
+            existing_type = existing_column.sql_type.split("(").first
+            if postgresql?
+              case type.to_s
+              when "string"
+                # safe to increase limit or remove it
+                # not safe to decrease limit or add a limit
+                case existing_type
+                when "character varying"
+                  safe = !options[:limit] || (existing_column.limit && options[:limit] >= existing_column.limit)
+                when "text"
+                  safe = !options[:limit]
+                end
+              when "text"
+                # safe to change varchar to text (and text to text)
+                safe = ["character varying", "text"].include?(existing_type)
+              when "numeric", "decimal"
+                # numeric and decimal are equivalent and can be used interchangably
+                safe = ["numeric", "decimal"].include?(existing_type) &&
+                  (
+                    (
+                      # unconstrained
+                      !options[:precision] && !options[:scale]
+                    ) || (
+                      # increased precision, same scale
+                      options[:precision] && existing_column.precision &&
+                      options[:precision] >= existing_column.precision &&
+                      options[:scale] == existing_column.scale
+                    )
+                  )
+              when "datetime", "timestamp", "timestamptz"
+                safe = ["timestamp without time zone", "timestamp with time zone"].include?(existing_type) &&
+                  postgresql_version >= Gem::Version.new("12") &&
+                  connection.select_all("SHOW timezone").first["TimeZone"] == "UTC"
+              end
+            elsif mysql? || mariadb?
+              case type.to_s
+              when "string"
+                # https://dev.mysql.com/doc/refman/5.7/en/innodb-online-ddl-operations.html
+                # https://mariadb.com/kb/en/innodb-online-ddl-operations-with-the-instant-alter-algorithm/#changing-the-data-type-of-a-column
+                # increased limit, but doesn't change number of length bytes
+                # 1-255 = 1 byte, 256-65532 = 2 bytes, 65533+ = too big for varchar
+                limit = options[:limit] || 255
+                safe = ["varchar"].include?(existing_type) &&
+                  limit >= existing_column.limit &&
+                  (limit <= 255 || existing_column.limit > 255)
+              end
+            end
+          end
+
+          # unsafe to set NOT NULL for safe types
+          if safe && existing_column.null && options[:null] == false
+            raise_error :change_column_with_not_null
+          end
+
+          raise_error :change_column, rewrite_blocks: rewrite_blocks unless safe
+        when :create_table
+          table, options = args
+          options ||= {}
+
+          raise_error :create_table if options[:force]
+
+          # keep track of new tables of add_index check
+          @new_tables << table.to_s
+        when :add_reference, :add_belongs_to
+          table, reference, options = args
+          options ||= {}
+
+          if postgresql?
+            index_value = options.fetch(:index, true)
+            concurrently_set = index_value.is_a?(Hash) && index_value[:algorithm] == :concurrently
+            bad_index = index_value && !concurrently_set
+
+            if bad_index || options[:foreign_key]
+              if index_value.is_a?(Hash)
+                options[:index] = options[:index].merge(algorithm: :concurrently)
+              else
+                options = options.merge(index: {algorithm: :concurrently})
+              end
+
+              return safe_add_reference(table, reference, options) if StrongMigrations.safe_by_default
+
+              if options.delete(:foreign_key)
+                headline = "Adding a foreign key blocks writes on both tables."
+                append = "
+
+Then add the foreign key in separate migrations."
+              else
+                headline = "Adding an index non-concurrently locks the table."
+              end
+
+              raise_error :add_reference,
+                headline: headline,
+                command: command_str(method, [table, reference, options]),
+                append: append
+            end
+          end
+        when :execute
+          raise_error :execute, header: "Possibly dangerous operation"
+        when :change_column_null
+          table, column, null, default = args
+          if !null
+            if postgresql?
+              safe = false
+              if postgresql_version >= Gem::Version.new("12")
+                safe = constraints(table).any? { |c| c["def"] == "CHECK ((#{column} IS NOT NULL))" || c["def"] == "CHECK ((#{connection.quote_column_name(column)} IS NOT NULL))" }
+              end
+
+              unless safe
+                # match https://github.com/nullobject/rein
+                constraint_name = "#{table}_#{column}_null"
+
+                add_code = constraint_str("ALTER TABLE %s ADD CONSTRAINT %s CHECK (%s IS NOT NULL) NOT VALID", [table, constraint_name, column])
+                validate_code = constraint_str("ALTER TABLE %s VALIDATE CONSTRAINT %s", [table, constraint_name])
+                remove_code = constraint_str("ALTER TABLE %s DROP CONSTRAINT %s", [table, constraint_name])
+
+                validate_constraint_code =
+                  if ar_version >= 6.1
+                    String.new(command_str(:validate_check_constraint, [table, {name: constraint_name}]))
+                  else
+                    String.new(safety_assured_str(validate_code))
+                  end
+
+                if postgresql_version >= Gem::Version.new("12")
+                  change_args = [table, column, null]
+
+                  validate_constraint_code << "\n    #{command_str(:change_column_null, change_args)}"
+
+                  if ar_version >= 6.1
+                    validate_constraint_code << "\n    #{command_str(:remove_check_constraint, [table, {name: constraint_name}])}"
+                  else
+                    validate_constraint_code << "\n    #{safety_assured_str(remove_code)}"
+                  end
+                end
+
+                return safe_change_column_null(add_code, validate_code, change_args, remove_code) if StrongMigrations.safe_by_default
+
+                add_constraint_code =
+                  if ar_version >= 6.1
+                    # only quote when needed
+                    expr_column = column.to_s =~ /\A[a-z0-9_]+\z/ ? column : connection.quote_column_name(column)
+                    command_str(:add_check_constraint, [table, "#{expr_column} IS NOT NULL", {name: constraint_name, validate: false}])
+                  else
+                    safety_assured_str(add_code)
+                  end
+
+                raise_error :change_column_null_postgresql,
+                  add_constraint_code: add_constraint_code,
+                  validate_constraint_code: validate_constraint_code
+              end
+            elsif mysql? || mariadb?
+              raise_error :change_column_null_mysql
+            elsif !default.nil?
+              raise_error :change_column_null,
+                code: backfill_code(table, column, default)
+            end
+          end
+        when :add_foreign_key
+          from_table, to_table, options = args
+          options ||= {}
+
+          # always validated before 5.2
+          validate = options.fetch(:validate, true) || ar_version < 5.2
+
+          if postgresql? && validate
+            if ar_version < 5.2
+              # fk name logic from rails
+              primary_key = options[:primary_key] || "id"
+              column = options[:column] || "#{to_table.to_s.singularize}_id"
+              hashed_identifier = Digest::SHA256.hexdigest("#{from_table}_#{column}_fk").first(10)
+              fk_name = options[:name] || "fk_rails_#{hashed_identifier}"
+
+              add_code = constraint_str("ALTER TABLE %s ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s (%s) NOT VALID", [from_table, fk_name, column, to_table, primary_key])
+              validate_code = constraint_str("ALTER TABLE %s VALIDATE CONSTRAINT %s", [from_table, fk_name])
+
+              return safe_add_foreign_key_code(from_table, to_table, add_code, validate_code) if StrongMigrations.safe_by_default
+
+              raise_error :add_foreign_key,
+                add_foreign_key_code: safety_assured_str(add_code),
+                validate_foreign_key_code: safety_assured_str(validate_code)
+            else
+              return safe_add_foreign_key(from_table, to_table, options) if StrongMigrations.safe_by_default
+
+              raise_error :add_foreign_key,
+                add_foreign_key_code: command_str("add_foreign_key", [from_table, to_table, options.merge(validate: false)]),
+                validate_foreign_key_code: command_str("validate_foreign_key", [from_table, to_table])
+            end
+          end
+        when :validate_foreign_key
+          if postgresql? && writes_blocked?
+            raise_error :validate_foreign_key
+          end
+        when :add_check_constraint
+          table, expression, options = args
+          options ||= {}
+
+          if !new_table?(table)
+            if postgresql? && options[:validate] != false
+              add_options = options.merge(validate: false)
+              name = options[:name] || @migration.check_constraint_options(table, expression, options)[:name]
+              validate_options = {name: name}
+
+              return safe_add_check_constraint(table, expression, add_options, validate_options) if StrongMigrations.safe_by_default
+
+              raise_error :add_check_constraint,
+                add_check_constraint_code: command_str("add_check_constraint", [table, expression, add_options]),
+                validate_check_constraint_code: command_str("validate_check_constraint", [table, validate_options])
+            elsif mysql? || mariadb?
+              raise_error :add_check_constraint_mysql
+            end
+          end
+        when :validate_check_constraint
+          if postgresql? && writes_blocked?
+            raise_error :validate_check_constraint
+          end
+        end
+
+        StrongMigrations.checks.each do |check|
+          @migration.instance_exec(method, args, &check)
+        end
+      end
+
+      result = yield
+
+      # outdated statistics + a new index can hurt performance of existing queries
+      if StrongMigrations.auto_analyze && direction == :up && method == :add_index
+        if postgresql?
+          connection.execute "ANALYZE #{connection.quote_table_name(args[0].to_s)}"
+        elsif mariadb? || mysql?
+          connection.execute "ANALYZE TABLE #{connection.quote_table_name(args[0].to_s)}"
+        end
+      end
+
+      result
+    end
+
+    private
+
+    def set_timeouts
+      if !@timeouts_set
+        if StrongMigrations.statement_timeout
+          statement =
+            if postgresql?
+              "SET statement_timeout TO #{connection.quote(postgresql_timeout(StrongMigrations.statement_timeout))}"
+            elsif mysql?
+              # use ceil to prevent no timeout for values under 1 ms
+              "SET max_execution_time = #{connection.quote((StrongMigrations.statement_timeout.to_f * 1000).ceil)}"
+            elsif mariadb?
+              "SET max_statement_time = #{connection.quote(StrongMigrations.statement_timeout)}"
+            else
+              raise StrongMigrations::Error, "Statement timeout not supported for this database"
+            end
+
+          connection.select_all(statement)
+        end
+
+        if StrongMigrations.lock_timeout
+          statement =
+            if postgresql?
+              "SET lock_timeout TO #{connection.quote(postgresql_timeout(StrongMigrations.lock_timeout))}"
+            elsif mysql? || mariadb?
+              "SET lock_wait_timeout = #{connection.quote(StrongMigrations.lock_timeout)}"
+            else
+              raise StrongMigrations::Error, "Lock timeout not supported for this database"
+            end
+
+          connection.select_all(statement)
+        end
+
+        @timeouts_set = true
+      end
+    end
+
+    def connection
+      @migration.connection
+    end
+
+    def version
+      @migration.version
+    end
+
+    def safe?
+      @safe || ENV["SAFETY_ASSURED"] || @migration.is_a?(ActiveRecord::Schema) ||
+        (direction == :down && !StrongMigrations.check_down) || version_safe?
+    end
+
+    def version_safe?
+      version && version <= StrongMigrations.start_after
+    end
+
+    def postgresql?
+      connection.adapter_name =~ /postg/i # PostgreSQL, PostGIS
+    end
+
+    def postgresql_version
+      @postgresql_version ||= begin
+        target_version(StrongMigrations.target_postgresql_version) do
+          # only works with major versions
+          connection.select_all("SHOW server_version_num").first["server_version_num"].to_i / 10000
+        end
+      end
+    end
+
+    def mysql?
+      connection.adapter_name =~ /mysql/i && !connection.try(:mariadb?)
+    end
+
+    def mysql_version
+      @mysql_version ||= begin
+        target_version(StrongMigrations.target_mysql_version) do
+          connection.select_all("SELECT VERSION()").first["VERSION()"].split("-").first
+        end
+      end
+    end
+
+    def mariadb?
+      connection.adapter_name =~ /mysql/i && connection.try(:mariadb?)
+    end
+
+    def mariadb_version
+      @mariadb_version ||= begin
+        target_version(StrongMigrations.target_mariadb_version) do
+          connection.select_all("SELECT VERSION()").first["VERSION()"].split("-").first
+        end
+      end
+    end
+
+    def target_version(target_version)
+      target_version ||= StrongMigrations.target_version
+      version =
+        if target_version && StrongMigrations.developer_env?
+          target_version.to_s
+        else
+          yield
+        end
+      Gem::Version.new(version)
+    end
+
+    def ar_version
+      ActiveRecord::VERSION::STRING.to_f
+    end
+
+    def check_lock_timeout
+      limit = StrongMigrations.lock_timeout_limit
+
+      if limit && !@lock_timeout_checked
+        if postgresql?
+          lock_timeout = connection.select_all("SHOW lock_timeout").first["lock_timeout"]
+          lock_timeout_sec = timeout_to_sec(lock_timeout)
+          if lock_timeout_sec == 0
+            warn "[strong_migrations] DANGER: No lock timeout set"
+          elsif lock_timeout_sec > limit
+            warn "[strong_migrations] DANGER: Lock timeout is longer than #{limit} seconds: #{lock_timeout}"
+          end
+        elsif mysql? || mariadb?
+          lock_timeout = connection.select_all("SHOW VARIABLES LIKE 'lock_wait_timeout'").first["Value"]
+          # lock timeout is an integer
+          if lock_timeout.to_i > limit
+            warn "[strong_migrations] DANGER: Lock timeout is longer than #{limit} seconds: #{lock_timeout}"
+          end
+        end
+        @lock_timeout_checked = true
+      end
+    end
+
+    # units: https://www.postgresql.org/docs/current/config-setting.html
+    def timeout_to_sec(timeout)
+      units = {
+        "us" => 0.001,
+        "ms" => 1,
+        "s" => 1000,
+        "min" => 1000 * 60,
+        "h" => 1000 * 60 * 60,
+        "d" => 1000 * 60 * 60 * 24
+      }
+      timeout_ms = timeout.to_i
+      units.each do |k, v|
+        if timeout.end_with?(k)
+          timeout_ms *= v
+          break
+        end
+      end
+      timeout_ms / 1000.0
+    end
+
+    def postgresql_timeout(timeout)
+      if timeout.is_a?(String)
+        timeout
+      else
+        # use ceil to prevent no timeout for values under 1 ms
+        (timeout.to_f * 1000).ceil
+      end
+    end
+
+    def constraints(table_name)
+      query = <<~SQL
+        SELECT
+          conname AS name,
+          pg_get_constraintdef(oid) AS def
+        FROM
+          pg_constraint
+        WHERE
+          contype = 'c' AND
+          convalidated AND
+          conrelid = #{connection.quote(connection.quote_table_name(table_name))}::regclass
+      SQL
+      connection.select_all(query.squish).to_a
+    end
+
+    def raise_error(message_key, header: nil, append: nil, **vars)
+      return unless StrongMigrations.check_enabled?(message_key, version: version)
+
+      message = StrongMigrations.error_messages[message_key] || "Missing message"
+      message = message + append if append
+
+      vars[:migration_name] = @migration.class.name
+      vars[:migration_suffix] = "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      vars[:base_model] = "ApplicationRecord"
+
+      # escape % not followed by {
+      message = message.gsub(/%(?!{)/, "%%") % vars if message.include?("%")
+      @migration.stop!(message, header: header || "Dangerous operation detected")
+    end
+
+    def constraint_str(statement, identifiers)
+      # not all identifiers are tables, but this method of quoting should be fine
+      statement % identifiers.map { |v| connection.quote_table_name(v) }
+    end
+
+    def safety_assured_str(code)
+      "safety_assured do\n      execute '#{code}' \n    end"
+    end
+
+    def command_str(command, args)
+      str_args = args[0..-2].map { |a| a.inspect }
+
+      # prettier last arg
+      last_arg = args[-1]
+      if last_arg.is_a?(Hash)
+        if last_arg.any?
+          str_args << last_arg.map do |k, v|
+            if v.is_a?(Hash)
+              # pretty index: {algorithm: :concurrently}
+              "#{k}: {#{v.map { |k2, v2| "#{k2}: #{v2.inspect}" }.join(", ")}}"
+            else
+              "#{k}: #{v.inspect}"
+            end
+          end.join(", ")
+        end
+      else
+        str_args << last_arg.inspect
+      end
+
+      "#{command} #{str_args.join(", ")}"
+    end
+
+    def writes_blocked?
+      query = <<~SQL
+        SELECT
+          relation::regclass::text
+        FROM
+          pg_locks
+        WHERE
+          mode IN ('ShareRowExclusiveLock', 'AccessExclusiveLock') AND
+          pid = pg_backend_pid()
+      SQL
+      connection.select_all(query.squish).any?
+    end
+
+    def rewrite_blocks
+      mysql? || mariadb? ? "writes" : "reads and writes"
+    end
+
+    def backfill_code(table, column, default)
+      model = table.to_s.classify
+      "#{model}.unscoped.in_batches do |relation| \n      relation.update_all #{column}: #{default.inspect}\n      sleep(0.01)\n    end"
+    end
+
+    def new_table?(table)
+      @new_tables.include?(table.to_s)
+    end
+  end
+end