strong_migrations 1.8.0 → 2.3.0

data/lib/strong_migrations/adapters/mysql_adapter.rb

@@ -8,7 +8,7 @@ module StrongMigrations
       end
 
       def min_version
-        "5.7"
+        "8.0"
       end
 
       def server_version
@@ -65,9 +65,10 @@ module StrongMigrations
             sql = <<~SQL
               SELECT cs.MAXLEN
               FROM INFORMATION_SCHEMA.CHARACTER_SETS cs
-              INNER JOIN INFORMATION_SCHEMA.COLLATIONS c ON c.CHARACTER_SET_NAME = cs.CHARACTER_SET_NAME
-              INNER JOIN INFORMATION_SCHEMA.TABLES t ON t.TABLE_COLLATION = c.COLLATION_NAME
-              WHERE t.TABLE_SCHEMA = database() AND t.TABLE_NAME = #{connection.quote(table)}
+              INNER JOIN INFORMATION_SCHEMA.COLUMNS c ON c.CHARACTER_SET_NAME = cs.CHARACTER_SET_NAME
+              WHERE c.TABLE_SCHEMA = database() AND
+              c.TABLE_NAME = #{connection.quote(table)} AND
+              c.COLUMN_NAME = #{connection.quote(column)}
             SQL
             row = connection.select_all(sql).first
             if row
@@ -91,6 +92,10 @@ module StrongMigrations
         "writes"
       end
 
+      def max_constraint_name_length
+        64
+      end
+
       private
 
       # do not memoize

data/lib/strong_migrations/adapters/postgresql_adapter.rb

@@ -6,7 +6,7 @@ module StrongMigrations
       end
 
       def min_version
-        "10"
+        "12"
       end
 
       def server_version
@@ -42,7 +42,7 @@ module StrongMigrations
       end
 
       def add_column_default_safe?
-        server_version >= Gem::Version.new("11")
+        true
       end
 
       def change_type_safe?(table, column, type, options, existing_column, existing_type)
@@ -95,7 +95,7 @@ module StrongMigrations
             "timestamp" => "timestamp without time zone",
             "timestamptz" => "timestamp with time zone"
           }
-          maybe_safe = type_map.values.include?(existing_type) && precision >= existing_precision
+          maybe_safe = type_map.value?(existing_type) && precision >= existing_precision
 
           if maybe_safe
             new_type = type.to_s == "datetime" ? datetime_type : type.to_s
@@ -103,7 +103,7 @@ module StrongMigrations
             # resolve with fallback
             new_type = type_map[new_type] || new_type
 
-            safe = new_type == existing_type || (server_version >= Gem::Version.new("12") && time_zone == "UTC")
+            safe = new_type == existing_type || time_zone == "UTC"
           end
         when "time"
           precision = options[:precision] || options[:limit] || 6
@@ -127,19 +127,19 @@ module StrongMigrations
         safe
       end
 
-      def constraints(table_name)
+      # TODO remove when Active Record < 7.1 is no longer supported
+      def index_invalid?(table_name, index_name)
         query = <<~SQL
           SELECT
-            conname AS name,
-            pg_get_constraintdef(oid) AS def
+            indisvalid
           FROM
-            pg_constraint
+            pg_index
           WHERE
-            contype = 'c' AND
-            convalidated AND
-            conrelid = #{connection.quote(connection.quote_table_name(table_name))}::regclass
+            indrelid = to_regclass(#{connection.quote(connection.quote_table_name(table_name))}) AND
+            indexrelid = to_regclass(#{connection.quote(connection.quote_table_name(index_name))}) AND
+            indisvalid = false
         SQL
-        select_all(query.squish).to_a
+        select_all(query.squish).any?
       end
 
       def writes_blocked?
@@ -173,6 +173,15 @@ module StrongMigrations
         ["primary_key", "serial", "bigserial"]
       end
 
+      def max_constraint_name_length
+        63
+      end
+
+      def constraints(table, column)
+        # TODO improve column check
+        connection.check_constraints(table).select { |c| /\b#{Regexp.escape(column.to_s)}\b/.match?(c.expression) }
+      end
+
       private
 
       def set_timeout(setting, timeout)
@@ -210,15 +219,9 @@ module StrongMigrations
       end
 
       def datetime_type
-        key =
-          if ActiveRecord::VERSION::MAJOR >= 7
-            # https://github.com/rails/rails/pull/41084
-            # no need to support custom datetime_types
-            connection.class.datetime_type
-          else
-            # https://github.com/rails/rails/issues/21126#issuecomment-327895275
-            :datetime
-          end
+        # https://github.com/rails/rails/pull/41084
+        # no need to support custom datetime_types
+        key = connection.class.datetime_type
 
         # could be timestamp, timestamp without time zone, timestamp with time zone, etc
         connection.class.const_get(:NATIVE_DATABASE_TYPES).fetch(key).fetch(:name)

data/lib/strong_migrations/checker.rb

@@ -11,10 +11,16 @@ module StrongMigrations
 
     def initialize(migration)
       @migration = migration
+      reset
+    end
+
+    def reset
       @new_tables = []
       @new_columns = []
       @timeouts_set = false
       @committed = false
+      @transaction_disabled = false
+      @skip_retries = false
     end
 
     def self.safety_assured
@@ -27,7 +33,10 @@ module StrongMigrations
       end
     end
 
-    def perform(method, *args)
+    def perform(method, *args, &block)
+      return yield if skip?
+
+      check_adapter
       check_version_supported
       set_timeouts
       check_lock_timeout
@@ -96,9 +105,9 @@ module StrongMigrations
           # TODO figure out how to handle methods that generate multiple statements
           # like add_reference(table, ref, index: {algorithm: :concurrently})
           # lock timeout after first statement will cause retry to fail
-          retry_lock_timeouts { yield }
+          retry_lock_timeouts { perform_method(method, *args, &block) }
         else
-          yield
+          perform_method(method, *args, &block)
         end
 
       # outdated statistics + a new index can hurt performance of existing queries
@@ -109,6 +118,13 @@ module StrongMigrations
       result
     end
 
+    def perform_method(method, *args)
+      if StrongMigrations.remove_invalid_indexes && direction == :up && method == :add_index && postgresql?
+        remove_invalid_index_if_needed(*args)
+      end
+      yield
+    end
+
     def retry_lock_timeouts(check_committed: false)
       retries = 0
       begin
@@ -129,8 +145,22 @@ module StrongMigrations
       version && version <= StrongMigrations.start_after
     end
 
+    def skip?
+      StrongMigrations.skipped_databases.map(&:to_s).include?(db_config_name)
+    end
+
     private
 
+    def check_adapter
+      return if defined?(@adapter_checked)
+
+      if adapter.instance_of?(Adapters::AbstractAdapter)
+        warn "[strong_migrations] Unsupported adapter: #{connection.adapter_name}. Use StrongMigrations.skip_database(#{db_config_name.to_sym.inspect}) to silence this warning."
+      end
+
+      @adapter_checked = true
+    end
+
     def check_version_supported
       return if defined?(@version_checked)
 
@@ -200,12 +230,48 @@ module StrongMigrations
       @migration.connection
     end
 
+    def db_config_name
+      connection.pool.db_config.name
+    end
+
     def retry_lock_timeouts?(method)
       (
         StrongMigrations.lock_timeout_retries > 0 &&
         !in_transaction? &&
-        method != :transaction
+        method != :transaction &&
+        !@skip_retries
       )
     end
+
+    def without_retries
+      previous_value = @skip_retries
+      begin
+        @skip_retries = true
+        yield
+      ensure
+        @skip_retries = previous_value
+      end
+    end
+
+    # REINDEX INDEX CONCURRENTLY leaves a new invalid index if it fails, so use remove_index instead
+    def remove_invalid_index_if_needed(*args)
+      options = args.extract_options!
+
+      # ensures has same options as existing index
+      # check args to avoid errors with index_exists?
+      return unless args.size == 2 && connection.index_exists?(*args, **options.merge(valid: false))
+
+      table, columns = args
+      index_name = options.fetch(:name, connection.index_name(table, columns))
+
+      # valid option is ignored for Active Record < 7.1, so check name as well
+      return if ar_version < 7.1 && !adapter.index_invalid?(table, index_name)
+
+      @migration.say("Attempting to remove invalid index")
+      without_retries do
+        # TODO pass index schema for extra safety?
+        @migration.remove_index(table, **{name: index_name}.merge(options.slice(:algorithm)))
+      end
+    end
   end
 end

data/lib/strong_migrations/checks.rb

@@ -10,7 +10,7 @@ module StrongMigrations
       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]
+          name = options[:name] || connection.check_constraint_options(table, expression, options)[:name]
           validate_options = {name: name}
 
           if StrongMigrations.safe_by_default
@@ -39,27 +39,20 @@ module StrongMigrations
       #
       # Also, Active Record has special case for uuid columns that allows function default values
       # https://github.com/rails/rails/blob/v7.0.3.1/activerecord/lib/active_record/connection_adapters/postgresql/quoting.rb#L92-L93
-      if options.key?(:default) && (!adapter.add_column_default_safe? || (volatile = (postgresql? && type.to_s == "uuid" && default.to_s.include?("()") && adapter.default_volatile?(default))))
+      if !default.nil? && (!adapter.add_column_default_safe? || (volatile = (postgresql? && type.to_s == "uuid" && default.to_s.include?("()") && adapter.default_volatile?(default))))
         if options[:null] == false
           options = options.except(:null)
           append = "\n\nThen add the NOT NULL constraint in separate migrations."
         end
 
-        if default.nil?
-          raise_error :add_column_default_null,
-            command: command_str("add_column", [table, column, type, options.except(:default)]),
-            append: append,
-            rewrite_blocks: adapter.rewrite_blocks
-        else
-          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, volatile),
-            append: append,
-            rewrite_blocks: adapter.rewrite_blocks,
-            default_type: (volatile ? "volatile" : "non-null")
-        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, volatile),
+          append: append,
+          rewrite_blocks: adapter.rewrite_blocks,
+          default_type: (volatile ? "volatile" : "non-null")
       elsif default.is_a?(Proc) && postgresql?
         # adding a column with a VOLATILE default is not safe
         # https://www.postgresql.org/docs/current/sql-altertable.html#SQL-ALTERTABLE-NOTES
@@ -217,17 +210,43 @@ module StrongMigrations
       end
 
       raise_error :change_column, rewrite_blocks: adapter.rewrite_blocks unless safe
+
+      # constraints must be rechecked
+      # Postgres recommends dropping constraints before and adding them back
+      # https://www.postgresql.org/docs/current/ddl-alter.html#DDL-ALTER-COLUMN-TYPE
+      if postgresql?
+        constraints = adapter.constraints(table, column)
+        if constraints.any?
+          change_commands = []
+          constraints.each do |c|
+            change_commands << command_str(:remove_check_constraint, [table, c.expression, {name: c.name}])
+          end
+          change_commands << command_str(:change_column, args + [options])
+          constraints.each do |c|
+            change_commands << command_str(:add_check_constraint, [table, c.expression, {name: c.name, validate: false}])
+          end
+
+          validate_commands = []
+          constraints.each do |c|
+            validate_commands << command_str(:validate_check_constraint, [table, {name: c.name}])
+          end
+
+          raise_error :change_column_constraint,
+            change_column_code: change_commands.join("\n    "),
+            validate_constraint_code: validate_commands.join("\n    ")
+        end
+      end
     end
 
     def check_change_column_default(*args)
       table, column, _default_or_changes = args
 
       # just check ActiveRecord::Base, even though can override on model
-      partial_inserts = ar_version >= 7 ? ActiveRecord::Base.partial_inserts : ActiveRecord::Base.partial_writes
+      partial_inserts = ActiveRecord::Base.partial_inserts
 
       if partial_inserts && !new_column?(table, column)
         raise_error :change_column_default,
-          config: ar_version >= 7 ? "partial_inserts" : "partial_writes"
+          config: "partial_inserts"
       end
     end
 
@@ -235,60 +254,40 @@ module StrongMigrations
       table, column, null, default = args
       if !null
         if postgresql?
-          safe = false
-          safe_with_check_constraint = adapter.server_version >= Gem::Version.new("12")
-          if safe_with_check_constraint
-            safe = adapter.constraints(table).any? { |c| c["def"] == "CHECK ((#{column} IS NOT NULL))" || c["def"] == "CHECK ((#{connection.quote_column_name(column)} IS NOT NULL))" }
-          end
+          constraints = connection.check_constraints(table)
+          safe = constraints.any? { |c| c.options[:validate] && (c.expression == "#{column} IS NOT NULL" || c.expression == "#{connection.quote_column_name(column)} IS NOT NULL") }
 
           unless safe
+            expression = "#{quote_column_if_needed(column)} IS NOT NULL"
+
             # match https://github.com/nullobject/rein
             constraint_name = "#{table}_#{column}_null"
+            if adapter.max_constraint_name_length && constraint_name.bytesize > adapter.max_constraint_name_length
+              constraint_name = connection.check_constraint_options(table, expression, {})[:name]
 
-            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])
-
-            constraint_methods = ar_version >= 6.1
-
-            validate_constraint_code =
-              if constraint_methods
-                String.new(command_str(:validate_check_constraint, [table, {name: constraint_name}]))
-              else
-                String.new(safety_assured_str(validate_code))
-              end
-
-            if safe_with_check_constraint
-              change_args = [table, column, null]
-
-              validate_constraint_code << "\n    #{command_str(:change_column_null, change_args)}"
-
-              if constraint_methods
-                validate_constraint_code << "\n    #{command_str(:remove_check_constraint, [table, {name: constraint_name}])}"
-              else
-                validate_constraint_code << "\n    #{safety_assured_str(remove_code)}"
+              # avoid collision with Active Record naming for safe_by_default
+              if StrongMigrations.safe_by_default
+                constraint_name = constraint_name.sub("rails", "strong_migrations")
               end
             end
 
+            add_args = [table, expression, {name: constraint_name, validate: false}]
+            validate_args = [table, {name: constraint_name}]
+            change_args = [table, column, null]
+            remove_args = [table, {name: constraint_name}]
+
             if StrongMigrations.safe_by_default
-              safe_change_column_null(add_code, validate_code, change_args, remove_code, default)
+              safe_change_column_null(add_args, validate_args, change_args, remove_args, table, column, default, constraints)
               throw :safe
             end
 
-            add_constraint_code =
-              if constraint_methods
-                command_str(:add_check_constraint, [table, "#{quote_column_if_needed(column)} IS NOT NULL", {name: constraint_name, validate: false}])
-              else
-                safety_assured_str(add_code)
-              end
+            add_constraint_code = command_str(:add_check_constraint, add_args)
 
-            validate_constraint_code =
-              if safe_with_check_constraint
-                down_code = "#{add_constraint_code}\n    #{command_str(:change_column_null, [table, column, true])}"
-                "def up\n    #{validate_constraint_code}\n  end\n\n  def down\n    #{down_code}\n  end"
-              else
-                "def change\n    #{validate_constraint_code}\n  end"
-              end
+            up_code = String.new(command_str(:validate_check_constraint, validate_args))
+            up_code << "\n    #{command_str(:change_column_null, change_args)}"
+            up_code << "\n    #{command_str(:remove_check_constraint, remove_args)}"
+            down_code = "#{add_constraint_code}\n    #{command_str(:change_column_null, [table, column, true])}"
+            validate_constraint_code = "def up\n    #{up_code}\n  end\n\n  def down\n    #{down_code}\n  end"
 
             raise_error :change_column_null_postgresql,
               add_constraint_code: add_constraint_code,
@@ -337,29 +336,28 @@ module StrongMigrations
       columns =
         case method
         when :remove_timestamps
-          ["created_at", "updated_at"]
+          [:created_at, :updated_at]
         when :remove_column
-          [args[1].to_s]
+          [args[1]]
         when :remove_columns
-          # Active Record 6.1+ supports options
           if args.last.is_a?(Hash)
-            args[1..-2].map(&:to_s)
+            args[1..-2]
           else
-            args[1..-1].map(&:to_s)
+            args[1..-1]
           end
         else
           options = args[2] || {}
           reference = args[1]
           cols = []
-          cols << "#{reference}_type" if options[:polymorphic]
-          cols << "#{reference}_id"
+          cols << "#{reference}_type".to_sym if options[:polymorphic]
+          cols << "#{reference}_id".to_sym
           cols
         end
 
-      code = "self.ignored_columns += #{columns.inspect}"
+      code = "self.ignored_columns += #{columns.map(&:to_s).inspect}"
 
       raise_error :remove_column,
-        model: args[0].to_s.classify,
+        model: model_name(args[0]),
         code: code,
         command: command_str(method, args),
         column_suffix: columns.size > 1 ? "s" : ""
@@ -373,12 +371,6 @@ module StrongMigrations
         # avoid suggesting extra (invalid) args
         args = args[0..1] unless StrongMigrations.safe_by_default
 
-        # Active Record < 6.1 only supports two arguments (including options)
-        if args.size == 2 && ar_version < 6.1
-          # arg takes precedence over option
-          options[:column] = args.pop
-        end
-
         if StrongMigrations.safe_by_default
           safe_remove_index(*args, **options)
           throw :safe
@@ -433,7 +425,7 @@ module StrongMigrations
       message = message + append if append
 
       vars[:migration_name] = @migration.class.name
-      vars[:migration_suffix] = "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      vars[:migration_suffix] = migration_suffix
       vars[:base_model] = "ApplicationRecord"
 
       # escape % not followed by {
@@ -474,20 +466,20 @@ module StrongMigrations
     end
 
     def backfill_code(table, column, default, function = false)
-      model = table.to_s.classify
+      model = model_name(table)
       if function
         # update_all(column: Arel.sql(default)) also works in newer versions of Active Record
         update_expr = "#{quote_column_if_needed(column)} = #{default}"
-        "#{model}.unscoped.in_batches do |relation| \n      relation.where(#{column}: nil).update_all(#{update_expr.inspect})\n      sleep(0.01)\n    end"
+        "#{model}.unscoped.in_batches(of: 10000) do |relation| \n      relation.where(#{column}: nil).update_all(#{update_expr.inspect})\n      sleep(0.01)\n    end"
       else
-        "#{model}.unscoped.in_batches do |relation| \n      relation.update_all #{column}: #{default.inspect}\n      sleep(0.01)\n    end"
+        "#{model}.unscoped.in_batches(of: 10000) do |relation| \n      relation.where(#{column}: nil).update_all #{column}: #{default.inspect}\n      sleep(0.01)\n    end"
       end
     end
 
     # only quote when needed
     # important! only use for display purposes
     def quote_column_if_needed(column)
-      column.to_s =~ /\A[a-z0-9_]+\z/ ? column : connection.quote_column_name(column)
+      /\A[a-z0-9_]+\z/.match?(column.to_s) ? column : connection.quote_column_name(column)
     end
 
     def new_table?(table)
@@ -497,5 +489,13 @@ module StrongMigrations
     def new_column?(table, column)
       new_table?(table) || @new_columns.include?([table.to_s, column.to_s])
     end
+
+    def migration_suffix
+      "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+    end
+
+    def model_name(table)
+      table.to_s.classify
+    end
   end
 end

data/lib/strong_migrations/error_messages.rb

@@ -25,16 +25,6 @@ class Backfill%{migration_name} < ActiveRecord::Migration%{migration_suffix}
   end
 end",
 
-    add_column_default_null:
-"Adding a column with a null default blocks %{rewrite_blocks} while the entire table is rewritten.
-Instead, add the column without a default value.
-
-class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
-  def change
-    %{command}
-  end
-end",
-
     add_column_default_callable:
 "Strong Migrations does not support inspecting callable default values.
 Please make really sure you're not calling a VOLATILE function,
@@ -70,6 +60,22 @@ while the entire table is rewritten. A safer approach is to:
     change_column_with_not_null:
 "Changing the type is safe, but setting NOT NULL is not.",
 
+    change_column_constraint: "Changing the type of a column that has check constraints blocks reads and writes
+while every row is checked. Drop the check constraints on the column before
+changing the type and add them back afterwards.
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{change_column_code}
+  end
+end
+
+class Validate%{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{validate_constraint_code}
+  end
+end",
+
     remove_column: "Active Record caches attributes, which causes problems
 when removing columns. Be sure to ignore the column%{column_suffix}:
 
@@ -157,7 +163,7 @@ you're doing is safe before proceeding, then wrap it in a safety_assured { ... }
     create_table:
 "The force option will destroy existing tables.
 If this is intended, drop the existing table first.
-Otherwise, remove the force option.",
+In any case, remove the force option.",
 
     execute:
 "Strong Migrations does not support inspecting what happens inside an

data/lib/strong_migrations/migration.rb

@@ -18,7 +18,8 @@ module StrongMigrations
         end
       end
     end
-    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+    # same as ActiveRecord::Migration
+    ruby2_keywords(:method_missing)
 
     def revert(*)
       if strong_migrations_checker.version_safe?

data/lib/strong_migrations/{database_tasks.rb → migration_context.rb}

@@ -1,9 +1,26 @@
 module StrongMigrations
-  module DatabaseTasks
-    # Active Record 7 adds version argument
-    def migrate(*args)
+  module MigrationContext
+    def up(...)
       super
     rescue => e
+      strong_migrations_process_exception(e)
+    end
+
+    def down(...)
+      super
+    rescue => e
+      strong_migrations_process_exception(e)
+    end
+
+    def run(...)
+      super
+    rescue => e
+      strong_migrations_process_exception(e)
+    end
+
+    private
+
+    def strong_migrations_process_exception(e)
       if e.cause.is_a?(StrongMigrations::Error)
         # strip cause and clean backtrace
         def e.cause

data/lib/strong_migrations/migrator.rb

@@ -1,18 +1,20 @@
 module StrongMigrations
   module Migrator
-    def ddl_transaction(migration, *args)
+    def ddl_transaction(migration, ...)
       return super unless StrongMigrations.lock_timeout_retries > 0 && use_transaction?(migration)
 
       # handle MigrationProxy class
       migration = migration.send(:migration) if migration.respond_to?(:migration, true)
 
-      # retry migration since the entire transaction needs to be rerun
       checker = migration.send(:strong_migrations_checker)
+      return super if checker.skip?
+
+      # retry migration since the entire transaction needs to be rerun
       checker.retry_lock_timeouts(check_committed: true) do
         # failed transaction reverts timeout, so need to re-apply
-        checker.timeouts_set = false
+        checker.reset
 
-        super(migration, *args)
+        super(migration, ...)
       end
     end
   end