strong_migrations 2.0.2 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98ed2c92ee055824eefbb8239b65a6ef1c847b1ffa87e8cafb7fce34f8878c3c
-  data.tar.gz: 4f20acd9b50d07dfbe8ff6745f2fda6aaf7ca6731be72c8275929e15b12bd212
+  metadata.gz: e155e036c26788c7c9fa7f513131422b784b895fe1cbfdfc8052ad1f5233cd6c
+  data.tar.gz: 5fe21cada2e29c433313c686332d96c67e2c55d057fd6c68839fe1993307c0f8
 SHA512:
-  metadata.gz: 492d1dec59fc74196c3670b8a49fcc080af36eb3297c1c9aabfea7f0ff1943c21a4fe43e66d0e406d4eae1b785223f3e137bf05ee377d5597e87573f7b7c7af4
-  data.tar.gz: 2a955f9eb53386c39678f48291603345be5d086877ce9a2fdd2f60dcc5eec84b671945fd9dba6a4f5d98d9d41da7cb32ab061daa333f461344ae7b9c7884c9d0
+  metadata.gz: 7f40abaf84f10ce6ce7255d083b3ec0940c2f7380705857767b0cde56b23802dcf844c27251c634006559dfb4489b799ab3758bf9928b6cb57b6bceb1bf051ec
+  data.tar.gz: c283b8b93715a4aabd2c0e8dc15b022e45ebfbe3bb52fccc037b9c95d3b2279d6002b78354cab8600cf2972f96a6966af0fd80aa9b58cde53343b5035d8bc59c

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## 2.2.0 (2025-02-01)
+
+- Fixed constraint name for long table and column names with `change_column_null`
+- Dropped support for Active Record < 7
+
+## 2.1.0 (2024-11-08)
+
+- Added `skip_database` method
+- Added experimental `remove_invalid_indexes` option
+- Added warning for unsupported adapters
+- Improved output for `db:forward`, `db:rollback`, `db:migrate:up`, and `db:migrate:down`
+- Made operations more retriable with `safe_by_default`
+
 ## 2.0.2 (2024-10-30)
 
 - Fixed migrations not running with Active Record 8 rc2

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2013 Bob Remeika and David Waller, 2015-2024 Andrew Kane
+Copyright (c) 2013 Bob Remeika and David Waller, 2015-2025 Andrew Kane
 
 MIT License
 

data/README.md

@@ -43,7 +43,7 @@ end
 
 Deploy the code, then wrap this step in a safety_assured { ... } block.
 
-class RemoveColumn < ActiveRecord::Migration[7.2]
+class RemoveColumn < ActiveRecord::Migration[8.0]
   def change
     safety_assured { remove_column :users, :name }
   end
@@ -98,7 +98,7 @@ You can also add [custom checks](#custom-checks) or [disable specific checks](#d
 Active Record caches database columns at runtime, so if you drop a column, it can cause exceptions until your app reboots.
 
 ```ruby
-class RemoveSomeColumnFromUsers < ActiveRecord::Migration[7.2]
+class RemoveSomeColumnFromUsers < ActiveRecord::Migration[8.0]
   def change
     remove_column :users, :some_column
   end
@@ -119,7 +119,7 @@ end
 3. Write a migration to remove the column (wrap in `safety_assured` block)
 
   ```ruby
-  class RemoveSomeColumnFromUsers < ActiveRecord::Migration[7.2]
+  class RemoveSomeColumnFromUsers < ActiveRecord::Migration[8.0]
     def change
       safety_assured { remove_column :users, :some_column }
     end
@@ -136,7 +136,7 @@ end
 Changing the type of a column causes the entire table to be rewritten. During this time, reads and writes are blocked in Postgres, and writes are blocked in MySQL and MariaDB.
 
 ```ruby
-class ChangeSomeColumnType < ActiveRecord::Migration[7.2]
+class ChangeSomeColumnType < ActiveRecord::Migration[8.0]
   def change
     change_column :users, :some_column, :new_type
   end
@@ -182,7 +182,7 @@ A safer approach is to:
 Renaming a column that’s in use will cause errors in your application.
 
 ```ruby
-class RenameSomeColumn < ActiveRecord::Migration[7.2]
+class RenameSomeColumn < ActiveRecord::Migration[8.0]
   def change
     rename_column :users, :some_column, :new_name
   end
@@ -207,7 +207,7 @@ A safer approach is to:
 Renaming a table that’s in use will cause errors in your application.
 
 ```ruby
-class RenameUsersToCustomers < ActiveRecord::Migration[7.2]
+class RenameUsersToCustomers < ActiveRecord::Migration[8.0]
   def change
     rename_table :users, :customers
   end
@@ -232,7 +232,7 @@ A safer approach is to:
 The `force` option can drop an existing table.
 
 ```ruby
-class CreateUsers < ActiveRecord::Migration[7.2]
+class CreateUsers < ActiveRecord::Migration[8.0]
   def change
     create_table :users, force: true do |t|
       # ...
@@ -246,7 +246,7 @@ end
 Create tables without the `force` option.
 
 ```ruby
-class CreateUsers < ActiveRecord::Migration[7.2]
+class CreateUsers < ActiveRecord::Migration[8.0]
   def change
     create_table :users do |t|
       # ...
@@ -264,7 +264,7 @@ If you intend to drop an existing table, run `drop_table` first.
 Adding an auto-incrementing column (`serial`/`bigserial` in Postgres and `AUTO_INCREMENT` in MySQL and MariaDB) causes the entire table to be rewritten. During this time, reads and writes are blocked in Postgres, and writes are blocked in MySQL and MariaDB.
 
 ```ruby
-class AddIdToCitiesUsers < ActiveRecord::Migration[7.2]
+class AddIdToCitiesUsers < ActiveRecord::Migration[8.0]
   def change
     add_column :cities_users, :id, :primary_key
   end
@@ -284,7 +284,7 @@ Create a new table and migrate the data with the same steps as [renaming a table
 Adding a stored generated column causes the entire table to be rewritten. During this time, reads and writes are blocked in Postgres, and writes are blocked in MySQL and MariaDB.
 
 ```ruby
-class AddSomeColumnToUsers < ActiveRecord::Migration[7.2]
+class AddSomeColumnToUsers < ActiveRecord::Migration[8.0]
   def change
     add_column :users, :some_column, :virtual, type: :string, as: "...", stored: true
   end
@@ -304,7 +304,7 @@ Add a non-generated column and use callbacks or triggers instead (or a virtual g
 Adding a check constraint blocks reads and writes in Postgres and blocks writes in MySQL and MariaDB while every row is checked.
 
 ```ruby
-class AddCheckConstraint < ActiveRecord::Migration[7.2]
+class AddCheckConstraint < ActiveRecord::Migration[8.0]
   def change
     add_check_constraint :users, "price > 0", name: "price_check"
   end
@@ -316,7 +316,7 @@ end
 Add the check constraint without validating existing rows:
 
 ```ruby
-class AddCheckConstraint < ActiveRecord::Migration[7.2]
+class AddCheckConstraint < ActiveRecord::Migration[8.0]
   def change
     add_check_constraint :users, "price > 0", name: "price_check", validate: false
   end
@@ -326,7 +326,7 @@ end
 Then validate them in a separate migration.
 
 ```ruby
-class ValidateCheckConstraint < ActiveRecord::Migration[7.2]
+class ValidateCheckConstraint < ActiveRecord::Migration[8.0]
   def change
     validate_check_constraint :users, name: "price_check"
   end
@@ -342,7 +342,7 @@ end
 Strong Migrations can’t ensure safety for raw SQL statements. Make really sure that what you’re doing is safe, then use:
 
 ```ruby
-class ExecuteSQL < ActiveRecord::Migration[7.2]
+class ExecuteSQL < ActiveRecord::Migration[8.0]
   def change
     safety_assured { execute "..." }
   end
@@ -351,12 +351,14 @@ end
 
 ### Backfilling data
 
+Note: Strong Migrations does not detect dangerous backfills.
+
 #### Bad
 
 Active Record creates a transaction around each migration, and backfilling in the same transaction that alters a table keeps the table locked for the [duration of the backfill](https://wework.github.io/data/2015/11/05/add-columns-with-default-values-to-large-tables-in-rails-postgres/).
 
 ```ruby
-class AddSomeColumnToUsers < ActiveRecord::Migration[7.2]
+class AddSomeColumnToUsers < ActiveRecord::Migration[8.0]
   def change
     add_column :users, :some_column, :text
     User.update_all some_column: "default_value"
@@ -371,7 +373,7 @@ Also, running a single query to update data can cause issues for large tables.
 There are three keys to backfilling safely: batching, throttling, and running it outside a transaction. Use the Rails console or a separate migration with `disable_ddl_transaction!`.
 
 ```ruby
-class BackfillSomeColumn < ActiveRecord::Migration[7.2]
+class BackfillSomeColumn < ActiveRecord::Migration[8.0]
   disable_ddl_transaction!
 
   def up
@@ -383,6 +385,8 @@ class BackfillSomeColumn < ActiveRecord::Migration[7.2]
 end
 ```
 
+Note: If backfilling with a method other than `update_all`, use `User.reset_column_information` to ensure the model has up-to-date column information.
+
 ### Adding an index non-concurrently
 
 :turtle: Safe by default available
@@ -392,7 +396,7 @@ end
 In Postgres, adding an index non-concurrently blocks writes.
 
 ```ruby
-class AddSomeIndexToUsers < ActiveRecord::Migration[7.2]
+class AddSomeIndexToUsers < ActiveRecord::Migration[8.0]
   def change
     add_index :users, :some_column
   end
@@ -404,7 +408,7 @@ end
 Add indexes concurrently.
 
 ```ruby
-class AddSomeIndexToUsers < ActiveRecord::Migration[7.2]
+class AddSomeIndexToUsers < ActiveRecord::Migration[8.0]
   disable_ddl_transaction!
 
   def change
@@ -430,7 +434,7 @@ rails g index table column
 Rails adds an index non-concurrently to references by default, which blocks writes in Postgres.
 
 ```ruby
-class AddReferenceToUsers < ActiveRecord::Migration[7.2]
+class AddReferenceToUsers < ActiveRecord::Migration[8.0]
   def change
     add_reference :users, :city
   end
@@ -442,7 +446,7 @@ end
 Make sure the index is added concurrently.
 
 ```ruby
-class AddReferenceToUsers < ActiveRecord::Migration[7.2]
+class AddReferenceToUsers < ActiveRecord::Migration[8.0]
   disable_ddl_transaction!
 
   def change
@@ -460,7 +464,7 @@ end
 In Postgres, adding a foreign key blocks writes on both tables.
 
 ```ruby
-class AddForeignKeyOnUsers < ActiveRecord::Migration[7.2]
+class AddForeignKeyOnUsers < ActiveRecord::Migration[8.0]
   def change
     add_foreign_key :users, :orders
   end
@@ -470,7 +474,7 @@ end
 or
 
 ```ruby
-class AddReferenceToUsers < ActiveRecord::Migration[7.2]
+class AddReferenceToUsers < ActiveRecord::Migration[8.0]
   def change
     add_reference :users, :order, foreign_key: true
   end
@@ -482,7 +486,7 @@ end
 Add the foreign key without validating existing rows:
 
 ```ruby
-class AddForeignKeyOnUsers < ActiveRecord::Migration[7.2]
+class AddForeignKeyOnUsers < ActiveRecord::Migration[8.0]
   def change
     add_foreign_key :users, :orders, validate: false
   end
@@ -492,7 +496,7 @@ end
 Then validate them in a separate migration.
 
 ```ruby
-class ValidateForeignKeyOnUsers < ActiveRecord::Migration[7.2]
+class ValidateForeignKeyOnUsers < ActiveRecord::Migration[8.0]
   def change
     validate_foreign_key :users, :orders
   end
@@ -506,7 +510,7 @@ end
 In Postgres, adding a unique constraint creates a unique index, which blocks reads and writes.
 
 ```ruby
-class AddUniqueConstraint < ActiveRecord::Migration[7.2]
+class AddUniqueConstraint < ActiveRecord::Migration[8.0]
   def change
     add_unique_constraint :users, :some_column
   end
@@ -518,7 +522,7 @@ end
 Create a unique index concurrently, then use it for the constraint.
 
 ```ruby
-class AddUniqueConstraint < ActiveRecord::Migration[7.2]
+class AddUniqueConstraint < ActiveRecord::Migration[8.0]
   disable_ddl_transaction!
 
   def up
@@ -539,7 +543,7 @@ end
 In Postgres, adding an exclusion constraint blocks reads and writes while every row is checked.
 
 ```ruby
-class AddExclusionConstraint < ActiveRecord::Migration[7.2]
+class AddExclusionConstraint < ActiveRecord::Migration[8.0]
   def change
     add_exclusion_constraint :users, "number WITH =", using: :gist
   end
@@ -557,7 +561,7 @@ end
 In Postgres, there’s no equality operator for the `json` column type, which can cause errors for existing `SELECT DISTINCT` queries in your application.
 
 ```ruby
-class AddPropertiesToUsers < ActiveRecord::Migration[7.2]
+class AddPropertiesToUsers < ActiveRecord::Migration[8.0]
   def change
     add_column :users, :properties, :json
   end
@@ -569,7 +573,7 @@ end
 Use `jsonb` instead.
 
 ```ruby
-class AddPropertiesToUsers < ActiveRecord::Migration[7.2]
+class AddPropertiesToUsers < ActiveRecord::Migration[8.0]
   def change
     add_column :users, :properties, :jsonb
   end
@@ -585,7 +589,7 @@ end
 In Postgres, setting `NOT NULL` on an existing column blocks reads and writes while every row is checked.
 
 ```ruby
-class SetSomeColumnNotNull < ActiveRecord::Migration[7.2]
+class SetSomeColumnNotNull < ActiveRecord::Migration[8.0]
   def change
     change_column_null :users, :some_column, false
   end
@@ -597,7 +601,7 @@ end
 Instead, add a check constraint.
 
 ```ruby
-class SetSomeColumnNotNull < ActiveRecord::Migration[7.2]
+class SetSomeColumnNotNull < ActiveRecord::Migration[8.0]
   def change
     add_check_constraint :users, "some_column IS NOT NULL", name: "users_some_column_null", validate: false
   end
@@ -607,12 +611,17 @@ end
 Then validate it in a separate migration. Once the check constraint is validated, you can safely set `NOT NULL` on the column and drop the check constraint.
 
 ```ruby
-class ValidateSomeColumnNotNull < ActiveRecord::Migration[7.2]
-  def change
+class ValidateSomeColumnNotNull < ActiveRecord::Migration[8.0]
+  def up
     validate_check_constraint :users, name: "users_some_column_null"
     change_column_null :users, :some_column, false
     remove_check_constraint :users, name: "users_some_column_null"
   end
+
+  def down
+    add_check_constraint :users, "some_column IS NOT NULL", name: "users_some_column_null", validate: false
+    change_column_null :users, :some_column, true
+  end
 end
 ```
 
@@ -623,7 +632,7 @@ end
 Adding a column with a volatile default value to an existing table causes the entire table to be rewritten. During this time, reads and writes are blocked.
 
 ```ruby
-class AddSomeColumnToUsers < ActiveRecord::Migration[7.2]
+class AddSomeColumnToUsers < ActiveRecord::Migration[8.0]
   def change
     add_column :users, :some_column, :uuid, default: "gen_random_uuid()"
   end
@@ -635,7 +644,7 @@ end
 Instead, add the column without a default value, then change the default.
 
 ```ruby
-class AddSomeColumnToUsers < ActiveRecord::Migration[7.2]
+class AddSomeColumnToUsers < ActiveRecord::Migration[8.0]
   def up
     add_column :users, :some_column, :uuid
     change_column_default :users, :some_column, from: nil, to: "gen_random_uuid()"
@@ -686,7 +695,7 @@ config.active_record.partial_inserts = false
 Adding a non-unique index with more than three columns rarely improves performance.
 
 ```ruby
-class AddSomeIndexToUsers < ActiveRecord::Migration[7.2]
+class AddSomeIndexToUsers < ActiveRecord::Migration[8.0]
   def change
     add_index :users, [:a, :b, :c, :d]
   end
@@ -698,7 +707,7 @@ end
 Instead, start an index with columns that narrow down the results the most.
 
 ```ruby
-class AddSomeIndexToUsers < ActiveRecord::Migration[7.2]
+class AddSomeIndexToUsers < ActiveRecord::Migration[8.0]
   def change
     add_index :users, [:d, :b]
   end
@@ -712,7 +721,7 @@ For Postgres, be sure to add them concurrently.
 To mark a step in the migration as safe, despite using a method that might otherwise be dangerous, wrap it in a `safety_assured` block.
 
 ```ruby
-class MySafeMigration < ActiveRecord::Migration[7.2]
+class MySafeMigration < ActiveRecord::Migration[8.0]
   def change
     safety_assured { remove_column :users, :some_column }
   end
@@ -723,7 +732,7 @@ Certain methods like `execute` and `change_table` cannot be inspected and are pr
 
 ## Safe by Default
 
-Make operations safe by default.
+Make certain operations safe by default. This allows you to write the code under the "Bad" section, but the migration will be performed as if you had written the "Good" version.
 
 - adding and removing an index
 - adding a foreign key
@@ -772,6 +781,16 @@ StrongMigrations.disable_check(:add_index)
 
 Check the [source code](https://github.com/ankane/strong_migrations/blob/master/lib/strong_migrations/error_messages.rb) for the list of keys.
 
+## Skip Databases
+
+Skip checks and other functionality for specific databases with:
+
+```ruby
+StrongMigrations.skip_database(:catalog)
+```
+
+Note: This does not affect `alphabetize_schema`.
+
 ## Down Migrations / Rollbacks
 
 By default, checks are disabled when migrating down. Enable them with:
@@ -853,7 +872,21 @@ production:
 
 For HTTP connections, Redis, and other services, check out [this guide](https://github.com/ankane/the-ultimate-guide-to-ruby-timeouts).
 
-## Lock Timeout Retries [experimental]
+## Invalid Indexes
+
+In Postgres, adding an index non-concurrently can leave behind an invalid index if the lock timeout is reached. Running the migration again can result in an error.
+
+To automatically remove the invalid index when the migration runs again, use:
+
+```ruby
+StrongMigrations.remove_invalid_indexes = true
+```
+
+Note: This feature is experimental.
+
+## Lock Timeout Retries
+
+Note: This feature is experimental.
 
 There’s the option to automatically retry statements for migrations when the lock timeout is reached. Here’s how it works:
 
@@ -877,7 +910,7 @@ StrongMigrations.lock_timeout_retry_delay = 10.seconds
 To mark migrations as safe that were created before installing this gem, create an initializer with:
 
 ```ruby
-StrongMigrations.start_after = 20230101000000
+StrongMigrations.start_after = 20250101000000
 ```
 
 Use the version from your latest migration.

data/lib/strong_migrations/adapters/abstract_adapter.rb

@@ -13,11 +13,11 @@ module StrongMigrations
       end
 
       def set_statement_timeout(timeout)
-        raise StrongMigrations::Error, "Statement timeout not supported for this database"
+        # do nothing
       end
 
       def set_lock_timeout(timeout)
-        raise StrongMigrations::Error, "Lock timeout not supported for this database"
+        # do nothing
       end
 
       def check_lock_timeout(limit)
@@ -40,6 +40,9 @@ module StrongMigrations
         ["primary_key"]
       end
 
+      def max_constraint_name_length
+      end
+
       private
 
       def connection

data/lib/strong_migrations/adapters/mysql_adapter.rb

@@ -92,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

@@ -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,10 @@ module StrongMigrations
         ["primary_key", "serial", "bigserial"]
       end
 
+      def max_constraint_name_length
+        63
+      end
+
       private
 
       def set_timeout(setting, timeout)
@@ -210,15 +214,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
@@ -216,11 +216,11 @@ module StrongMigrations
       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
 
@@ -228,32 +228,40 @@ module StrongMigrations
       table, column, null, default = args
       if !null
         if postgresql?
-          safe = adapter.constraints(table).any? { |c| c["def"] == "CHECK ((#{column} IS NOT NULL))" || c["def"] == "CHECK ((#{connection.quote_column_name(column)} IS NOT NULL))" }
+          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])
-
-            validate_constraint_code = String.new(command_str(:validate_check_constraint, [table, {name: constraint_name}]))
+              # 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]
-
-            validate_constraint_code << "\n    #{command_str(:change_column_null, change_args)}"
-            validate_constraint_code << "\n    #{command_str(:remove_check_constraint, [table, {name: constraint_name}])}"
+            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, default, constraints)
               throw :safe
             end
 
-            add_constraint_code = command_str(:add_check_constraint, [table, "#{quote_column_if_needed(column)} IS NOT NULL", {name: constraint_name, validate: false}])
+            add_constraint_code = command_str(:add_check_constraint, add_args)
 
+            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    #{validate_constraint_code}\n  end\n\n  def down\n    #{down_code}\n  end"
+            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,
@@ -302,29 +310,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" : ""
@@ -392,7 +399,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 {
@@ -433,7 +440,7 @@ 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}"
@@ -456,5 +463,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

@@ -147,7 +147,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,8 +1,26 @@
 module StrongMigrations
-  module DatabaseTasks
-    def migrate(...)
+  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

@@ -6,11 +6,13 @@ module StrongMigrations
       # 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, ...)
       end

data/lib/strong_migrations/safe_methods.rb

@@ -4,7 +4,6 @@ module StrongMigrations
       StrongMigrations.safe_by_default && [: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))
@@ -47,14 +46,16 @@ 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))
+          # validate option is unintentionally ignored for Active Record < 7.1
+          # https://github.com/rails/rails/pull/45896
+          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
-          validate_options = options.slice(:column, :name)
-          @migration.validate_foreign_key(from_table, to_table, **validate_options)
+          @migration.validate_foreign_key(from_table, to_table, **options.slice(:column, :name))
         end
         dir.down do
-          remove_options = options.slice(:column, :name)
-          @migration.remove_foreign_key(from_table, to_table, **remove_options)
+          @migration.remove_foreign_key(from_table, to_table, **options.slice(:column, :name))
         end
       end
     end
@@ -62,7 +63,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
@@ -72,35 +76,33 @@ 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, default, constraints)
       @migration.reversible do |dir|
         dir.up do
           unless default.nil?
             raise Error, "default value not supported yet with safe_by_default"
           end
 
-          @migration.safety_assured do
-            @migration.execute(add_code)
-            disable_transaction
-            @migration.execute(validate_code)
-          end
-          if change_args
-            @migration.change_column_null(*change_args)
-            @migration.safety_assured do
-              @migration.execute(remove_code)
-            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
@@ -109,13 +111,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/version.rb

@@ -1,3 +1,3 @@
 module StrongMigrations
-  VERSION = "2.0.2"
+  VERSION = "2.2.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
     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: 2.0.2
+  version: 2.2.0
 platform: ruby
 authors:
 - Andrew Kane
 - Bob Remeika
 - David Waller
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-30 00:00:00.000000000 Z
+date: 2025-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -18,15 +17,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.1'
-description:
+        version: '7'
 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
@@ -75,8 +72,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Catch unsafe migrations in development
 test_files: []