strong_migrations 1.6.0 → 2.8.0

data/lib/strong_migrations/error_messages.rb

@@ -25,20 +25,25 @@ 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.
+    add_column_default_callable:
+"Strong Migrations does not support inspecting callable default values.
+
+If the default value is %{default_type}, add the column without a default value, then change the default.
 
 class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
-  def change
-    %{command}
+  def up
+    %{add_command}
+    %{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,
-then wrap it in a safety_assured { ... } block.",
+  def down
+    %{remove_command}
+  end
+end
+
+Then backfill the existing rows in the Rails console or a separate migration with disable_ddl_transaction!.
+
+Otherwise, wrap this step in a safety_assured { ... } block.",
 
     add_column_json:
 "There's no equality operator for the json column type, which can cause errors for
@@ -53,6 +58,9 @@ end",
     add_column_generated_stored:
 "Adding a stored generated column blocks %{rewrite_blocks} while the entire table is rewritten.",
 
+    add_column_auto_incrementing:
+"Adding an auto-incrementing column blocks %{rewrite_blocks} while the entire table is rewritten.",
+
     change_column:
 "Changing the type of an existing column blocks %{rewrite_blocks}
 while the entire table is rewritten. A safer approach is to:
@@ -67,6 +75,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}:
 
@@ -88,18 +112,43 @@ in your application. A safer approach is to:
 
 1. Create a new column
 2. Write to both columns
-3. Backfill data from the old column to new column
+3. Backfill data from the old column to the new column
 4. Move reads from the old column to the new column
 5. Stop writing to the old column
 6. Drop the old column",
 
+    rename_enum_value:
+"Renaming an enum value that's in use will cause errors
+in your application. A safer approach is to:
+
+1. Add a new enum value before or after the old value
+2. Update application code to handle both values and write the new value
+3. Backfill data from the old value to the new value
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def up
+    %{command}
+  end
+end",
+
+    rename_schema:
+"Renaming a schema that's in use will cause errors
+in your application. A safer approach is to:
+
+1. Create a new schema
+2. Write to both schemas
+3. Backfill data from the old schema to the new schema
+4. Move reads from the old schema to the new schema
+5. Stop writing to the old schema
+6. Drop the old schema",
+
     rename_table:
 "Renaming a table that's in use will cause errors
 in your application. A safer approach is to:
 
 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
+3. Backfill data from the old table to the new table
 4. Move reads from the old table to the new table
 5. Stop writing to the old table
 6. Drop the old table",
@@ -154,7 +203,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
@@ -215,6 +264,28 @@ class Validate%{migration_name} < ActiveRecord::Migration%{migration_suffix}
   end
 end",
 
+    add_foreign_key_mysql:
+"Adding a foreign key blocks writes on both tables. If you are 100% sure
+all rows are valid and migrations do not use a connection pooler,
+you can add the foreign key without validating existing rows.
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def up
+    safety_assured do
+      begin
+        execute \"SET SESSION foreign_key_checks = 0\"
+        %{add_foreign_key_code}
+      ensure
+        execute \"SET SESSION foreign_key_checks = 1\"
+      end
+    end
+  end
+
+  def down
+    %{remove_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.",
@@ -244,7 +315,42 @@ end",
 Use disable_ddl_transaction! or a separate migration.",
 
     add_exclusion_constraint:
-"Adding an exclusion constraint blocks reads and writes while every row is checked."
+"Adding an exclusion constraint blocks reads and writes while every row is checked.",
+
+    add_unique_constraint:
+"Adding a unique constraint creates a unique index, which blocks reads and writes.
+Instead, create a unique index concurrently, then use it for the constraint.
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  disable_ddl_transaction!
+
+  def up
+    %{index_command}
+    %{constraint_command}
+  end
+
+  def down
+    %{remove_command}
+  end
+end",
+
+    copy_algorithm:
+"Using the COPY algorithm blocks writes. Instead, use:
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{command}
+  end
+end",
+
+    lock_option:
+"Using %{lock_type} locking blocks %{lock_blocks}. Instead, use:
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{command}
+  end
+end"
   }
   self.enabled_checks = (error_messages.keys - [:remove_index]).map { |k| [k, {}] }.to_h
 end

data/lib/strong_migrations/migration.rb

@@ -7,10 +7,7 @@ module StrongMigrations
     end
 
     def method_missing(method, *args)
-      return super if is_a?(ActiveRecord::Schema)
-
-      # Active Record 7.0.2+ versioned schema
-      return super if defined?(ActiveRecord::Schema::Definition) && is_a?(ActiveRecord::Schema::Definition)
+      return super if is_a?(ActiveRecord::Schema) || is_a?(ActiveRecord::Schema::Definition)
 
       catch(:safe) do
         strong_migrations_checker.perform(method, *args) do
@@ -18,10 +15,19 @@ 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?
+        safety_assured { super }
+      else
+        super
+      end
+    end
 
     def safety_assured
-      strong_migrations_checker.safety_assured do
+      strong_migrations_checker.class.safety_assured do
         yield
       end
     end

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,24 @@
 module StrongMigrations
   module Migrator
-    def ddl_transaction(migration, *args)
-      return super unless StrongMigrations.lock_timeout_retries > 0 && use_transaction?(migration)
+    def ddl_transaction(migration, ...)
+      retries = StrongMigrations.lock_timeout_retries > 0 && use_transaction?(migration)
+      return super unless retries || StrongMigrations.transaction_timeout
 
       # handle MigrationProxy class
-      migration = migration.send(:migration) if migration.respond_to?(:migration, true)
+      migration = migration.send(:migration) if !migration.is_a?(ActiveRecord::Migration) && 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?
+
+      checker.set_transaction_timeout
+      return super unless retries
+
+      # 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

data/lib/strong_migrations/safe_methods.rb

@@ -1,10 +1,9 @@
 module StrongMigrations
   module SafeMethods
     def safe_by_default_method?(method)
-      StrongMigrations.safe_by_default && [:add_index, :add_belongs_to, :add_reference, :remove_index, :add_foreign_key, :add_check_constraint, :change_column_null].include?(method)
+      StrongMigrations.safe_by_default && !version_safe? && [:add_index, :add_belongs_to, :add_reference, :remove_index, :add_foreign_key, :add_check_constraint, :change_column_null].include?(method)
     end
 
-    # TODO check if invalid index with expected name exists and remove if needed
     def safe_add_index(*args, **options)
       disable_transaction
       @migration.add_index(*args, **options.merge(algorithm: :concurrently))
@@ -30,10 +29,11 @@ module StrongMigrations
                 (ActiveRecord::Base.pluralize_table_names ? reference.to_s.pluralize : reference).to_sym
               end
 
+            foreign_key_opts = foreign_key.is_a?(Hash) ? foreign_key.except(:to_table) : {}
             if reference
-              @migration.add_foreign_key(table, name, column: "#{reference}_id")
+              @migration.add_foreign_key(table, name, column: "#{reference}_id", **foreign_key_opts)
             else
-              @migration.add_foreign_key(table, name)
+              @migration.add_foreign_key(table, name, **foreign_key_opts)
             end
           end
         end
@@ -46,22 +46,14 @@ module StrongMigrations
     def safe_add_foreign_key(from_table, to_table, *args, **options)
       @migration.reversible do |dir|
         dir.up do
-          @migration.add_foreign_key(from_table, to_table, *args, **options.merge(validate: false))
-          disable_transaction
-          validate_options = options.slice(:column, :name)
-          if ActiveRecord::VERSION::MAJOR >= 6
-            @migration.validate_foreign_key(from_table, to_table, **validate_options)
-          else
-            @migration.validate_foreign_key(from_table, validate_options.any? ? validate_options : to_table)
+          if !connection.foreign_key_exists?(from_table, to_table, **options.merge(validate: false))
+            @migration.add_foreign_key(from_table, to_table, *args, **options.merge(validate: false))
           end
+          disable_transaction
+          @migration.validate_foreign_key(from_table, to_table, **options.slice(:column, :name))
         end
         dir.down do
-          remove_options = options.slice(:column, :name)
-          if ActiveRecord::VERSION::MAJOR >= 6
-            @migration.remove_foreign_key(from_table, to_table, **remove_options)
-          else
-            @migration.remove_foreign_key(from_table, remove_options.any? ? remove_options : to_table)
-          end
+          @migration.remove_foreign_key(from_table, to_table, **options.slice(:column, :name))
         end
       end
     end
@@ -69,7 +61,10 @@ module StrongMigrations
     def safe_add_check_constraint(table, expression, *args, add_options, validate_options)
       @migration.reversible do |dir|
         dir.up do
-          @migration.add_check_constraint(table, expression, *args, **add_options)
+          # only skip invalid constraints
+          unless connection.check_constraints(table).any? { |c| c.options[:name] == validate_options[:name] && !c.options[:validate] }
+            @migration.add_check_constraint(table, expression, *args, **add_options)
+          end
           disable_transaction
           @migration.validate_check_constraint(table, **validate_options)
         end
@@ -79,35 +74,60 @@ module StrongMigrations
       end
     end
 
-    def safe_change_column_null(add_code, validate_code, change_args, remove_code, default)
+    def safe_change_column_null(add_args, validate_args, change_args, remove_args, table, column, default, constraints)
       @migration.reversible do |dir|
         dir.up do
           unless default.nil?
-            raise Error, "default value not supported yet with safe_by_default"
-          end
+            # TODO search for parent model if needed
+            if connection.pool != ActiveRecord::Base.connection_pool
+              raise_error :change_column_null,
+                code: backfill_code(table, column, default)
+            end
+
+            model =
+              Class.new(ActiveRecord::Base) do
+                self.table_name = table
 
-          @migration.safety_assured do
-            @migration.execute(add_code)
+                def self.to_s
+                  "Backfill"
+                end
+              end
+
+            update_sql =
+              model.connection_pool.with_connection do |c|
+                quoted_column = c.quote_column_name(column)
+                quoted_default = c.quote_default_expression(default, c.send(:column_for, table, column))
+                "#{quoted_column} = #{quoted_default}"
+              end
+
+            @migration.say("Backfilling default")
             disable_transaction
-            @migration.execute(validate_code)
-          end
-          if change_args
-            @migration.change_column_null(*change_args)
-            @migration.safety_assured do
-              @migration.execute(remove_code)
+            model.unscoped.in_batches(of: 10000) do |relation|
+              relation.where(column => nil).update_all(update_sql)
+              sleep(0.01)
             end
           end
+
+          add_options = add_args.extract_options!
+          validate_options = validate_args.extract_options!
+          remove_options = remove_args.extract_options!
+
+          # only skip invalid constraints
+          unless constraints.any? { |c| c.options[:name] == validate_options[:name] && !c.options[:validate] }
+            @migration.add_check_constraint(*add_args, **add_options)
+          end
+          disable_transaction
+
+          connection.begin_db_transaction
+          @migration.validate_check_constraint(*validate_args, **validate_options)
+          @migration.change_column_null(*change_args)
+          @migration.remove_check_constraint(*remove_args, **remove_options)
+          connection.commit_db_transaction
         end
         dir.down do
-          if change_args
-            down_args = change_args.dup
-            down_args[2] = true
-            @migration.change_column_null(*down_args)
-          else
-            @migration.safety_assured do
-              @migration.execute(remove_code)
-            end
-          end
+          down_args = change_args.dup
+          down_args[2] = true
+          @migration.change_column_null(*down_args)
         end
       end
     end
@@ -116,13 +136,13 @@ module StrongMigrations
     # so just commit at start
     def disable_transaction
       if in_transaction? && !transaction_disabled
-        @migration.connection.commit_db_transaction
+        connection.commit_db_transaction
         self.transaction_disabled = true
       end
     end
 
     def in_transaction?
-      @migration.connection.open_transactions > 0
+      connection.open_transactions > 0
     end
   end
 end

data/lib/strong_migrations/schema_dumper.rb

@@ -1,9 +1,9 @@
 module StrongMigrations
   module SchemaDumper
-    def initialize(connection, *args, **options)
+    def initialize(connection, ...)
       return super unless StrongMigrations.alphabetize_schema
 
-      super(WrappedConnection.new(connection), *args, **options)
+      super(WrappedConnection.new(connection), ...)
     end
   end
 
@@ -14,8 +14,19 @@ module StrongMigrations
       @connection = connection
     end
 
-    def columns(*args, **options)
-      @connection.columns(*args, **options).sort_by(&:name)
+    def columns(...)
+      @connection.columns(...).sort_by(&:name)
+    end
+
+    # forward private methods with send
+    # method_missing cannot tell how method was called
+    # this is not ideal, but other solutions have drawbacks
+    def send(name, ...)
+      if respond_to?(name, true)
+        super
+      else
+        @connection.send(name, ...)
+      end
     end
   end
 end

data/lib/strong_migrations/version.rb

@@ -1,3 +1,3 @@
 module StrongMigrations
-  VERSION = "1.6.0"
+  VERSION = "2.8.0"
 end

data/lib/strong_migrations.rb

@@ -11,8 +11,8 @@ require_relative "strong_migrations/adapters/postgresql_adapter"
 require_relative "strong_migrations/checks"
 require_relative "strong_migrations/safe_methods"
 require_relative "strong_migrations/checker"
-require_relative "strong_migrations/database_tasks"
 require_relative "strong_migrations/migration"
+require_relative "strong_migrations/migration_context"
 require_relative "strong_migrations/migrator"
 require_relative "strong_migrations/version"
 
@@ -29,7 +29,7 @@ module StrongMigrations
       :target_postgresql_version, :target_mysql_version, :target_mariadb_version,
       :enabled_checks, :lock_timeout, :statement_timeout, :check_down, :target_version,
       :safe_by_default, :target_sql_mode, :lock_timeout_retries, :lock_timeout_retry_delay,
-      :alphabetize_schema
+      :alphabetize_schema, :skipped_databases, :remove_invalid_indexes, :transaction_timeout
     attr_writer :lock_timeout_limit
   end
   self.auto_analyze = false
@@ -40,6 +40,8 @@ module StrongMigrations
   self.safe_by_default = false
   self.check_down = false
   self.alphabetize_schema = false
+  self.skipped_databases = []
+  self.remove_invalid_indexes = false
 
   # private
   def self.developer_env?
@@ -83,6 +85,10 @@ module StrongMigrations
       false
     end
   end
+
+  def self.skip_database(database)
+    self.skipped_databases << database
+  end
 end
 
 # load error messages
@@ -90,12 +96,9 @@ require_relative "strong_migrations/error_messages"
 
 ActiveSupport.on_load(:active_record) do
   ActiveRecord::Migration.prepend(StrongMigrations::Migration)
+  ActiveRecord::MigrationContext.prepend(StrongMigrations::MigrationContext)
   ActiveRecord::Migrator.prepend(StrongMigrations::Migrator)
 
-  if defined?(ActiveRecord::Tasks::DatabaseTasks)
-    ActiveRecord::Tasks::DatabaseTasks.singleton_class.prepend(StrongMigrations::DatabaseTasks)
-  end
-
   require_relative "strong_migrations/schema_dumper"
   ActiveRecord::SchemaDumper.prepend(StrongMigrations::SchemaDumper)
 end

metadata

@@ -1,16 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: strong_migrations
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 2.8.0
 platform: ruby
 authors:
 - Andrew Kane
 - Bob Remeika
 - David Waller
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-07-22 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -18,15 +17,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '7.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
-description:
+        version: '7.2'
 email:
 - andrew@ankane.org
 - bob.remeika@gmail.com
@@ -47,9 +45,9 @@ files:
 - lib/strong_migrations/adapters/postgresql_adapter.rb
 - lib/strong_migrations/checker.rb
 - lib/strong_migrations/checks.rb
-- lib/strong_migrations/database_tasks.rb
 - lib/strong_migrations/error_messages.rb
 - lib/strong_migrations/migration.rb
+- lib/strong_migrations/migration_context.rb
 - lib/strong_migrations/migrator.rb
 - lib/strong_migrations/railtie.rb
 - lib/strong_migrations/safe_methods.rb
@@ -60,7 +58,6 @@ homepage: https://github.com/ankane/strong_migrations
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -68,15 +65,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.6'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Catch unsafe migrations in development
 test_files: []