strong_migrations 2.5.1 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9fa65b489492df55a19b402db34b26e6a8e4369ad0bd1078622e130d07813a85
-  data.tar.gz: 5ce0a9af74812f962a277ac87fefed4322448b3da5bf7bfbe778e83b5bbd1c88
+  metadata.gz: 33d90fe56d07dcdf864739aeae07dac0c63b6504460299724bc293a43c5aeb7e
+  data.tar.gz: 9e7ea3be4a0d3b8b03bcb2e4e6b5f6b4425057388a4b8ae52a7263d5497d5de8
 SHA512:
-  metadata.gz: bec4fce43c3f0dd2a8c8e0f74c7aa09d0a4fadf05132285ad91496266476faef87323076fab6067499d9688100b81a78f274e7769af730bc9502f706e6ea5ebb
-  data.tar.gz: 9cebe149959161a5bf1abd62ff69e553187f867da3f49837c95f4843077e9880654eafe41786ff913e1fdba02cc2dd4c8eaf7d35996ce190779d62003a8314fc
+  metadata.gz: fe975030ddbdd8bce5f8bc1a18498e67e505627618a47d201e916d6c0ca21f846852ef08dc923e3a8626c2634fdcfa4d38fe9b674bc13b58d7a0c5064a012f0a
+  data.tar.gz: 4e0fe03e8ac9cb3872a7d9179f5902a8044587ffab5b22c02c7bbf63303a9bee48e195c6b77f30491f382ff7435a22cfe9e92c0a6dc53f145cf67d1f21cfb109

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 2.6.0 (2026-04-07)
+
+- Added check for `algorithm: :copy` with MySQL and MariaDB
+- Added check for `lock: :shared` and `lock: :exclusive` with MySQL and MariaDB
+- Dropped support for Ruby < 3.3 and Active Record < 7.2
+
+## 2.5.2 (2025-12-20)
+
+- Fixed false positive for `add_reference` with `foreign_key: {validate: false}`
+
 ## 2.5.1 (2025-10-13)
 
 - Fixed `transaction_timeout` option with DDL transaction

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2013 Bob Remeika and David Waller, 2015-2025 Andrew Kane
+Copyright (c) 2013 Bob Remeika and David Waller, 2015-2026 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[8.0]
+class RemoveColumn < ActiveRecord::Migration[8.1]
   def change
     safety_assured { remove_column :users, :name }
   end
@@ -82,9 +82,10 @@ Postgres-specific checks:
 - [adding a column with a volatile default value](#adding-a-column-with-a-volatile-default-value)
 - [renaming a schema](#renaming-a-schema)
 
-Config-specific checks:
+MySQL and MariaDB-specific checks:
 
-- [changing the default value of a column](#changing-the-default-value-of-a-column)
+- [using the COPY algorithm](#using-the-copy-algorithm)
+- [using shared or exclusive locking](#using-shared-or-exclusive-locking)
 
 Best practices:
 
@@ -99,7 +100,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[8.0]
+class RemoveSomeColumnFromUsers < ActiveRecord::Migration[8.1]
   def change
     remove_column :users, :some_column
   end
@@ -120,7 +121,7 @@ end
 3. Write a migration to remove the column (wrap in `safety_assured` block)
 
   ```ruby
-  class RemoveSomeColumnFromUsers < ActiveRecord::Migration[8.0]
+  class RemoveSomeColumnFromUsers < ActiveRecord::Migration[8.1]
     def change
       safety_assured { remove_column :users, :some_column }
     end
@@ -137,7 +138,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[8.0]
+class ChangeSomeColumnType < ActiveRecord::Migration[8.1]
   def change
     change_column :users, :some_column, :new_type
   end
@@ -150,14 +151,14 @@ Type | Safe Changes
 --- | ---
 `cidr` | Changing to `inet`
 `citext` | Changing to `text` if not indexed, changing to `string` with no `:limit` if not indexed
-`datetime` | Increasing or removing `:precision`, changing to `timestamptz` when session time zone is UTC in Postgres 12+
+`datetime` | Increasing or removing `:precision`, changing to `timestamptz` when session time zone is UTC
 `decimal` | Increasing `:precision` at same `:scale`, removing `:precision` and `:scale`
 `interval` | Increasing or removing `:precision`
 `numeric` | Increasing `:precision` at same `:scale`, removing `:precision` and `:scale`
 `string` | Increasing or removing `:limit`, changing to `text`, changing `citext` if not indexed
 `text` | Changing to `string` with no `:limit`, changing to `citext` if not indexed
 `time` | Increasing or removing `:precision`
-`timestamptz` | Increasing or removing `:limit`, changing to `datetime` when session time zone is UTC in Postgres 12+
+`timestamptz` | Increasing or removing `:limit`, changing to `datetime` when session time zone is UTC
 
 And some in MySQL and MariaDB:
 
@@ -183,7 +184,7 @@ A safer approach is to:
 Renaming a column that’s in use will cause errors in your application.
 
 ```ruby
-class RenameSomeColumn < ActiveRecord::Migration[8.0]
+class RenameSomeColumn < ActiveRecord::Migration[8.1]
   def change
     rename_column :users, :some_column, :new_name
   end
@@ -208,7 +209,7 @@ A safer approach is to:
 Renaming a table that’s in use will cause errors in your application.
 
 ```ruby
-class RenameUsersToCustomers < ActiveRecord::Migration[8.0]
+class RenameUsersToCustomers < ActiveRecord::Migration[8.1]
   def change
     rename_table :users, :customers
   end
@@ -233,7 +234,7 @@ A safer approach is to:
 The `force` option can drop an existing table.
 
 ```ruby
-class CreateUsers < ActiveRecord::Migration[8.0]
+class CreateUsers < ActiveRecord::Migration[8.1]
   def change
     create_table :users, force: true do |t|
       # ...
@@ -247,7 +248,7 @@ end
 Create tables without the `force` option.
 
 ```ruby
-class CreateUsers < ActiveRecord::Migration[8.0]
+class CreateUsers < ActiveRecord::Migration[8.1]
   def change
     create_table :users do |t|
       # ...
@@ -265,7 +266,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[8.0]
+class AddIdToCitiesUsers < ActiveRecord::Migration[8.1]
   def change
     add_column :cities_users, :id, :primary_key
   end
@@ -285,7 +286,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[8.0]
+class AddSomeColumnToUsers < ActiveRecord::Migration[8.1]
   def change
     add_column :users, :some_column, :virtual, type: :string, as: "...", stored: true
   end
@@ -305,7 +306,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[8.0]
+class AddCheckConstraint < ActiveRecord::Migration[8.1]
   def change
     add_check_constraint :users, "price > 0", name: "price_check"
   end
@@ -317,7 +318,7 @@ end
 Add the check constraint without validating existing rows:
 
 ```ruby
-class AddCheckConstraint < ActiveRecord::Migration[8.0]
+class AddCheckConstraint < ActiveRecord::Migration[8.1]
   def change
     add_check_constraint :users, "price > 0", name: "price_check", validate: false
   end
@@ -327,7 +328,7 @@ end
 Then validate them in a separate migration.
 
 ```ruby
-class ValidateCheckConstraint < ActiveRecord::Migration[8.0]
+class ValidateCheckConstraint < ActiveRecord::Migration[8.1]
   def change
     validate_check_constraint :users, name: "price_check"
   end
@@ -343,7 +344,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[8.0]
+class ExecuteSQL < ActiveRecord::Migration[8.1]
   def change
     safety_assured { execute "..." }
   end
@@ -359,7 +360,7 @@ Note: Strong Migrations does not detect dangerous backfills.
 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[8.0]
+class AddSomeColumnToUsers < ActiveRecord::Migration[8.1]
   def change
     add_column :users, :some_column, :text
     User.update_all some_column: "default_value"
@@ -374,7 +375,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[8.0]
+class BackfillSomeColumn < ActiveRecord::Migration[8.1]
   disable_ddl_transaction!
 
   def up
@@ -397,7 +398,7 @@ Note: If backfilling with a method other than `update_all`, use `User.reset_colu
 In Postgres, adding an index non-concurrently blocks writes.
 
 ```ruby
-class AddSomeIndexToUsers < ActiveRecord::Migration[8.0]
+class AddSomeIndexToUsers < ActiveRecord::Migration[8.1]
   def change
     add_index :users, :some_column
   end
@@ -409,7 +410,7 @@ end
 Add indexes concurrently.
 
 ```ruby
-class AddSomeIndexToUsers < ActiveRecord::Migration[8.0]
+class AddSomeIndexToUsers < ActiveRecord::Migration[8.1]
   disable_ddl_transaction!
 
   def change
@@ -435,7 +436,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[8.0]
+class AddReferenceToUsers < ActiveRecord::Migration[8.1]
   def change
     add_reference :users, :city
   end
@@ -447,7 +448,7 @@ end
 Make sure the index is added concurrently.
 
 ```ruby
-class AddReferenceToUsers < ActiveRecord::Migration[8.0]
+class AddReferenceToUsers < ActiveRecord::Migration[8.1]
   disable_ddl_transaction!
 
   def change
@@ -465,7 +466,7 @@ end
 In Postgres, adding a foreign key blocks writes on both tables.
 
 ```ruby
-class AddForeignKeyOnUsers < ActiveRecord::Migration[8.0]
+class AddForeignKeyOnUsers < ActiveRecord::Migration[8.1]
   def change
     add_foreign_key :users, :orders
   end
@@ -475,7 +476,7 @@ end
 or
 
 ```ruby
-class AddReferenceToUsers < ActiveRecord::Migration[8.0]
+class AddReferenceToUsers < ActiveRecord::Migration[8.1]
   def change
     add_reference :users, :order, foreign_key: true
   end
@@ -487,7 +488,7 @@ end
 Add the foreign key without validating existing rows:
 
 ```ruby
-class AddForeignKeyOnUsers < ActiveRecord::Migration[8.0]
+class AddForeignKeyOnUsers < ActiveRecord::Migration[8.1]
   def change
     add_foreign_key :users, :orders, validate: false
   end
@@ -497,7 +498,7 @@ end
 Then validate them in a separate migration.
 
 ```ruby
-class ValidateForeignKeyOnUsers < ActiveRecord::Migration[8.0]
+class ValidateForeignKeyOnUsers < ActiveRecord::Migration[8.1]
   def change
     validate_foreign_key :users, :orders
   end
@@ -511,7 +512,7 @@ end
 In Postgres, adding a unique constraint creates a unique index, which blocks reads and writes.
 
 ```ruby
-class AddUniqueConstraint < ActiveRecord::Migration[8.0]
+class AddUniqueConstraint < ActiveRecord::Migration[8.1]
   def change
     add_unique_constraint :users, :some_column
   end
@@ -523,7 +524,7 @@ end
 Create a unique index concurrently, then use it for the constraint.
 
 ```ruby
-class AddUniqueConstraint < ActiveRecord::Migration[8.0]
+class AddUniqueConstraint < ActiveRecord::Migration[8.1]
   disable_ddl_transaction!
 
   def up
@@ -544,7 +545,7 @@ end
 In Postgres, adding an exclusion constraint blocks reads and writes while every row is checked.
 
 ```ruby
-class AddExclusionConstraint < ActiveRecord::Migration[8.0]
+class AddExclusionConstraint < ActiveRecord::Migration[8.1]
   def change
     add_exclusion_constraint :users, "number WITH =", using: :gist
   end
@@ -562,7 +563,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[8.0]
+class AddPropertiesToUsers < ActiveRecord::Migration[8.1]
   def change
     add_column :users, :properties, :json
   end
@@ -574,7 +575,7 @@ end
 Use `jsonb` instead.
 
 ```ruby
-class AddPropertiesToUsers < ActiveRecord::Migration[8.0]
+class AddPropertiesToUsers < ActiveRecord::Migration[8.1]
   def change
     add_column :users, :properties, :jsonb
   end
@@ -590,7 +591,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[8.0]
+class SetSomeColumnNotNull < ActiveRecord::Migration[8.1]
   def change
     change_column_null :users, :some_column, false
   end
@@ -602,7 +603,7 @@ end
 Instead, add a check constraint.
 
 ```ruby
-class SetSomeColumnNotNull < ActiveRecord::Migration[8.0]
+class SetSomeColumnNotNull < ActiveRecord::Migration[8.1]
   def change
     add_check_constraint :users, "some_column IS NOT NULL", name: "users_some_column_null", validate: false
   end
@@ -612,7 +613,7 @@ 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[8.0]
+class ValidateSomeColumnNotNull < ActiveRecord::Migration[8.1]
   def up
     validate_check_constraint :users, name: "users_some_column_null"
     change_column_null :users, :some_column, false
@@ -633,7 +634,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[8.0]
+class AddSomeColumnToUsers < ActiveRecord::Migration[8.1]
   def change
     add_column :users, :some_column, :uuid, default: "gen_random_uuid()"
   end
@@ -645,7 +646,7 @@ end
 Instead, add the column without a default value, then change the default.
 
 ```ruby
-class AddSomeColumnToUsers < ActiveRecord::Migration[8.0]
+class AddSomeColumnToUsers < ActiveRecord::Migration[8.1]
   def up
     add_column :users, :some_column, :uuid
     change_column_default :users, :some_column, from: nil, to: "gen_random_uuid()"
@@ -684,34 +685,56 @@ A safer approach is to:
 5. Stop writing to the old schema
 6. Drop the old schema
 
-### Changing the default value of a column
+### Using the COPY algorithm
 
 #### Bad
 
-Rails < 7 enables partial writes by default, which can cause incorrect values to be inserted when changing the default value of a column.
+In MySQL and MariaDB, using the `COPY` algorithm blocks writes.
 
 ```ruby
-class ChangeSomeColumnDefault < ActiveRecord::Migration[6.1]
+class AddSomeIndexToUsers < ActiveRecord::Migration[8.1]
   def change
-    change_column_default :users, :some_column, from: "old", to: "new"
+    add_index :users, :some_column, algorithm: :copy
   end
 end
-
-User.create!(some_column: "old") # can insert "new"
 ```
 
 #### Good
 
-Disable partial writes in `config/application.rb`. For Rails < 7, use:
+Use the default algorithm.
+
+```ruby
+class AddSomeIndexToUsers < ActiveRecord::Migration[8.1]
+  def change
+    add_index :users, :some_column
+  end
+end
+```
+
+### Using shared or exclusive locking
+
+#### Bad
+
+In MySQL and MariaDB, using shared locking blocks writes, and using exclusive locking blocks reads and writes.
 
 ```ruby
-config.active_record.partial_writes = false
+class AddSomeIndexToUsers < ActiveRecord::Migration[8.2]
+  def change
+    add_index :users, :some_column, lock: :shared
+  end
+end
 ```
 
-For Rails 7+, use:
+#### Good
+
+Use the default locking or no locking.
 
 ```ruby
-config.active_record.partial_inserts = false
+class AddSomeIndexToUsers < ActiveRecord::Migration[8.2]
+  def change
+    add_index :users, :some_column
+  end
+end
 ```
 
 ### Keeping non-unique indexes to three columns or less
@@ -721,7 +744,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[8.0]
+class AddSomeIndexToUsers < ActiveRecord::Migration[8.1]
   def change
     add_index :users, [:a, :b, :c, :d]
   end
@@ -733,7 +756,7 @@ end
 Instead, start an index with columns that narrow down the results the most.
 
 ```ruby
-class AddSomeIndexToUsers < ActiveRecord::Migration[8.0]
+class AddSomeIndexToUsers < ActiveRecord::Migration[8.1]
   def change
     add_index :users, [:d, :b]
   end
@@ -747,7 +770,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[8.0]
+class MySafeMigration < ActiveRecord::Migration[8.1]
   def change
     safety_assured { remove_column :users, :some_column }
   end
@@ -944,7 +967,7 @@ Use the version from your latest migration.
 If your development database version is different from production, you can specify the production version so the right checks run in development.
 
 ```ruby
-StrongMigrations.target_version = 10 # or 8.0, 10.5, etc
+StrongMigrations.target_version = 16
 ```
 
 The major version works well for Postgres, while the major and minor version is recommended for MySQL and MariaDB.
@@ -954,7 +977,7 @@ For safety, this option only affects development and test environments. In other
 If your app has multiple databases with different versions, you can use:
 
 ```ruby
-StrongMigrations.target_version = {primary: 13, catalog: 15}
+StrongMigrations.target_version = {primary: 16, catalog: 18}
 ```
 
 ## Analyze Tables
@@ -967,15 +990,20 @@ StrongMigrations.auto_analyze = true
 
 ## Faster Migrations
 
-Only dump the schema when adding a new migration. If you use Git, add to `config/environments/development.rb`:
+Only dump the schema when adding a new migration. If you use Git, add to the end of your `Rakefile`:
 
 ```rb
-config.active_record.dump_schema_after_migration = `git status db/migrate/ --porcelain`.present?
+task :faster_migrations do
+  ActiveRecord.dump_schema_after_migration = Rails.env.development? &&
+    `git status db/migrate/ --porcelain`.present?
+end
+
+task "db:migrate" => "faster_migrations"
 ```
 
 ## Schema Sanity
 
-Columns can flip order in `db/schema.rb` when you have multiple developers. One way to prevent this is to [alphabetize them](https://www.pgrs.net/2008/03/12/alphabetize-schema-rb-columns/). Add to `config/initializers/strong_migrations.rb`:
+With Active Record < 8.1, columns can flip order in `db/schema.rb` when you have multiple developers. One way to prevent this is to [alphabetize them](https://www.pgrs.net/2008/03/12/alphabetize-schema-rb-columns/). Add to `config/initializers/strong_migrations.rb`:
 
 ```ruby
 StrongMigrations.alphabetize_schema = true

data/lib/generators/strong_migrations/install_generator.rb

@@ -24,9 +24,9 @@ module StrongMigrations
         when /mysql|trilogy/
           # could try to connect to database and check for MariaDB
           # but this should be fine
-          "8.0"
+          "8.4"
         else
-          "10"
+          "18"
         end
       end
 

data/lib/strong_migrations/checks.rb

@@ -76,6 +76,11 @@ module StrongMigrations
           rewrite_blocks: adapter.rewrite_blocks,
           append: append
       end
+
+      check_algorithm_option("add_column", *args, **options)
+
+      # not necessarily dangerous, but not necessary
+      check_lock_option("add_column", *args, **options)
     end
 
     def check_add_exclusion_constraint(*args)
@@ -138,6 +143,10 @@ module StrongMigrations
 
         raise_error :add_index, command: command_str("add_index", [table, columns, options.merge(algorithm: :concurrently)])
       end
+
+      check_algorithm_option("add_index", *args, **options)
+
+      check_lock_option("add_index", *args, **options)
     end
 
     def check_add_reference(method, *args)
@@ -147,11 +156,15 @@ module StrongMigrations
       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
+        index_unsafe = index_value && !concurrently_set
 
-        if bad_index || options[:foreign_key]
+        foreign_key_value = options[:foreign_key]
+        validate_false = foreign_key_value.is_a?(Hash) && foreign_key_value[:validate] == false
+        foreign_key_unsafe = foreign_key_value && !validate_false
+
+        if index_unsafe || foreign_key_unsafe
           if index_value.is_a?(Hash)
-            options[:index] = options[:index].merge(algorithm: :concurrently)
+            options = options.merge(index: index_value.merge(algorithm: :concurrently))
           elsif index_value
             options = options.merge(index: {algorithm: :concurrently})
           end
@@ -161,7 +174,8 @@ module StrongMigrations
             throw :safe
           end
 
-          if options.delete(:foreign_key)
+          if foreign_key_unsafe
+            options.delete(:foreign_key)
             headline = "Adding a foreign key blocks writes on both tables."
             append = "\n\nThen add the foreign key in separate migrations."
           else
@@ -174,6 +188,41 @@ module StrongMigrations
             append: append
         end
       end
+
+      check_algorithm_option("add_reference", *args, **options)
+
+      # not necessarily dangerous, but not necessary
+      check_lock_option("add_reference", *args, **options)
+
+      if (mysql? || mariadb?) && !new_table?(table)
+        index_value = options[:index]
+        copy_set = index_value.is_a?(Hash) && index_value[:algorithm] == :copy
+        if copy_set
+          index_value = index_value.except(:algorithm)
+          if index_value.empty?
+            options = options.except(:index)
+          else
+            options = options.merge(index: index_value)
+          end
+          raise_error :copy_algorithm, command: command_str("add_reference", args + [options])
+        end
+
+        if ar_version >= 8.2
+          lock = index_value.is_a?(Hash) && index_value[:lock]
+          if [:shared, :exclusive].include?(lock)
+            index_value = index_value.except(:lock)
+            if index_value.empty?
+              options = options.except(:index)
+            else
+              options = options.merge(index: index_value)
+            end
+            raise_error :lock_option,
+              command: command_str(method, args + [options]),
+              lock_type: lock.to_s,
+              lock_blocks: lock == :shared ? "reads" : "reads and writes"
+          end
+        end
+      end
     end
 
     def check_add_unique_constraint(*args)
@@ -185,9 +234,9 @@ module StrongMigrations
       if column && !new_table?(table)
         index_name = connection.index_name(table, {column: column})
         raise_error :add_unique_constraint,
-          index_command: command_str(:add_index, [table, column, {unique: true, algorithm: :concurrently}]),
-          constraint_command: command_str(:add_unique_constraint, [table, {using_index: index_name}]),
-          remove_command: command_str(:remove_unique_constraint, [table, column])
+          index_command: command_str("add_index", [table, column, {unique: true, algorithm: :concurrently}]),
+          constraint_command: command_str("add_unique_constraint", [table, {using_index: index_name}]),
+          remove_command: command_str("remove_unique_constraint", [table, column])
       end
     end
 
@@ -219,16 +268,16 @@ module StrongMigrations
         if constraints.any?
           change_commands = []
           constraints.each do |c|
-            change_commands << command_str(:remove_check_constraint, [table, c.expression, {name: c.name}])
+            change_commands << command_str("remove_check_constraint", [table, c.expression, {name: c.name}])
           end
-          change_commands << command_str(:change_column, args + [options])
+          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}])
+            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}])
+            validate_commands << command_str("validate_check_constraint", [table, {name: c.name}])
           end
 
           raise_error :change_column_constraint,
@@ -236,6 +285,11 @@ module StrongMigrations
             validate_constraint_code: validate_commands.join("\n    ")
         end
       end
+
+      check_algorithm_option("change_column", *args, **options)
+
+      # not necessarily dangerous, but not necessary
+      check_lock_option("change_column", *args, **options)
     end
 
     def check_change_column_default(*args)
@@ -281,12 +335,12 @@ module StrongMigrations
               throw :safe
             end
 
-            add_constraint_code = command_str(:add_check_constraint, add_args)
+            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])}"
+            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,
@@ -332,6 +386,7 @@ module StrongMigrations
       raise_error :execute, header: "Possibly dangerous operation"
     end
 
+    # supports algorithm and lock options, but always raises
     def check_remove_column(method, *args)
       columns =
         case method
@@ -378,8 +433,14 @@ module StrongMigrations
 
         raise_error :remove_index, command: command_str("remove_index", args + [options.merge(algorithm: :concurrently)])
       end
+
+      check_algorithm_option("remove_index", *args, **options)
+
+      # not necessarily dangerous, but not necessary
+      check_lock_option("remove_index", *args, **options)
     end
 
+    # supports algorithm and lock options, but always raises
     def check_rename_column
       raise_error :rename_column
     end
@@ -437,6 +498,21 @@ module StrongMigrations
       @migration.stop!(message, header: header || "Dangerous operation detected")
     end
 
+    def check_algorithm_option(method, *args, **options)
+      if (mysql? || mariadb?) && options[:algorithm] == :copy && !new_table?(args[0]) && (ar_version >= 8.2 || method == "add_index")
+        raise_error :copy_algorithm, command: command_str(method, args + [options.except(:algorithm)])
+      end
+    end
+
+    def check_lock_option(method, *args, **options)
+      if (mysql? || mariadb?) && [:shared, :exclusive].include?(options[:lock]) && !new_table?(args[0]) && ar_version >= 8.2
+        raise_error :lock_option,
+          command: command_str(method, args + [options.except(:lock)]),
+          lock_type: options[:lock].to_s,
+          lock_blocks: options[:lock] == :shared ? "reads" : "reads and writes"
+      end
+    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) }

data/lib/strong_migrations/error_messages.rb

@@ -281,6 +281,24 @@ class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
   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

data/lib/strong_migrations/version.rb

@@ -1,3 +1,3 @@
 module StrongMigrations
-  VERSION = "2.5.1"
+  VERSION = "2.6.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: strong_migrations
 version: !ruby/object:Gem::Version
-  version: 2.5.1
+  version: 2.6.0
 platform: ruby
 authors:
 - Andrew Kane
@@ -17,14 +17,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
 email:
 - andrew@ankane.org
 - bob.remeika@gmail.com
@@ -65,14 +65,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Catch unsafe migrations in development
 test_files: []