strong_migrations 2.5.2 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c7db529b15ac630f2f6c9e284b185ca5affbdb275c2d34d26e508317f6e2fa4
-  data.tar.gz: 8b00a79a0f4cb787d43de827cbafe495c081b5250db4f08d75a893953778d72a
+  metadata.gz: 250e255ba679a0e581fb86ed13b2824cf5749b7dc3ac5bf0a26bfffebe314fb8
+  data.tar.gz: d91882cb145d2f59a688e41e0d20301c6ca41d3e5e9790be9996eb256cc26dd2
 SHA512:
-  metadata.gz: 73091c6f13637427c09ed2dc013f804ac1ce91d78844b6dc10b7deb89aeb4d391123c4f16e661b34a1fd9e8013f5c6c50295e2a45824ca042e9418d3c6cd338d
-  data.tar.gz: 96bbd494942e1a9f3a529f2ee7453fb693e9ec61aba22846d6be9c5a986b9213053142f9f06a87dc16dbc9361520ae9ae84e32c72e43654fdd0f2da921590cdb
+  metadata.gz: b0bba6d87fd23e3bf68d8a8274cc6d22346a73f0001e8078f99f3c7a039772e39ded14138a2ad87eb7476f855a56647a1e07f84e7dadc96d5f3df53aebd27c9a
+  data.tar.gz: b985a53c42f12ec3268f6fd2570bdb2cdf777f80217b17a68872e86d4366b5939a702c0b8551b0ddab4f44ddfb9ef5da8a3f74ca97365124a086d46c2fe66f10

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 2.7.0 (2026-04-25)
+
+- Added check for `add_foreign_key` with MySQL and MariaDB
+- Added check for `add_column` with callable default value with MySQL and MariaDB
+
+## 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}`

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

@@ -66,6 +66,7 @@ Potentially dangerous operations:
 - [creating a table with the force option](#creating-a-table-with-the-force-option)
 - [adding an auto-incrementing column](#adding-an-auto-incrementing-column)
 - [adding a stored generated column](#adding-a-stored-generated-column)
+- [adding a foreign key](#adding-a-foreign-key)
 - [adding a check constraint](#adding-a-check-constraint)
 - [executing SQL directly](#executing-SQL-directly)
 - [backfilling data](#backfilling-data)
@@ -74,14 +75,19 @@ Postgres-specific checks:
 
 - [adding an index non-concurrently](#adding-an-index-non-concurrently)
 - [adding a reference](#adding-a-reference)
-- [adding a foreign key](#adding-a-foreign-key)
 - [adding a unique constraint](#adding-a-unique-constraint)
 - [adding an exclusion constraint](#adding-an-exclusion-constraint)
 - [adding a json column](#adding-a-json-column)
-- [setting NOT NULL on an existing column](#setting-not-null-on-an-existing-column)
 - [adding a column with a volatile default value](#adding-a-column-with-a-volatile-default-value)
+- [setting NOT NULL on an existing column](#setting-not-null-on-an-existing-column)
 - [renaming a schema](#renaming-a-schema)
 
+MySQL and MariaDB-specific checks:
+
+- [using the COPY algorithm](#using-the-copy-algorithm)
+- [using shared or exclusive locking](#using-shared-or-exclusive-locking)
+- [adding a column with an expression default value](#adding-a-column-with-an-expression-default-value)
+
 Best practices:
 
 - [keeping non-unique indexes to three columns or less](#keeping-non-unique-indexes-to-three-columns-or-less)
@@ -146,14 +152,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:
 
@@ -292,9 +298,80 @@ end
 
 Add a non-generated column and use callbacks or triggers instead (or a virtual generated column with MySQL and MariaDB).
 
+### Adding a foreign key
+
+:turtle: Safe by default available for Postgres
+
+#### Bad
+
+Adding a foreign key blocks writes on both tables.
+
+```ruby
+class AddForeignKeyOnUsers < ActiveRecord::Migration[8.1]
+  def change
+    add_foreign_key :users, :orders
+  end
+end
+```
+
+or
+
+```ruby
+class AddReferenceToUsers < ActiveRecord::Migration[8.1]
+  def change
+    add_reference :users, :order, foreign_key: true
+  end
+end
+```
+
+#### Good - Postgres
+
+Add the foreign key without validating existing rows:
+
+```ruby
+class AddForeignKeyOnUsers < ActiveRecord::Migration[8.1]
+  def change
+    add_foreign_key :users, :orders, validate: false
+  end
+end
+```
+
+Then validate them in a separate migration.
+
+```ruby
+class ValidateForeignKeyOnUsers < ActiveRecord::Migration[8.1]
+  def change
+    validate_foreign_key :users, :orders
+  end
+end
+```
+
+#### Good - MySQL and MariaDB
+
+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:
+
+```ruby
+class AddForeignKeyOnUsers < ActiveRecord::Migration[8.1]
+  def up
+    safety_assured do
+      begin
+        execute "SET SESSION foreign_key_checks = 0"
+        add_foreign_key :users, :orders
+      ensure
+        execute "SET SESSION foreign_key_checks = 1"
+      end
+    end
+  end
+
+  def down
+    remove_foreign_key :users, :orders
+  end
+end
+```
+
 ### Adding a check constraint
 
-:turtle: Safe by default available
+:turtle: Safe by default available for Postgres
 
 #### Bad
 
@@ -384,6 +461,8 @@ 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.
 
+## Postgres Checks
+
 ### Adding an index non-concurrently
 
 :turtle: Safe by default available
@@ -452,54 +531,6 @@ class AddReferenceToUsers < ActiveRecord::Migration[8.1]
 end
 ```
 
-### Adding a foreign key
-
-:turtle: Safe by default available
-
-#### Bad
-
-In Postgres, adding a foreign key blocks writes on both tables.
-
-```ruby
-class AddForeignKeyOnUsers < ActiveRecord::Migration[8.1]
-  def change
-    add_foreign_key :users, :orders
-  end
-end
-```
-
-or
-
-```ruby
-class AddReferenceToUsers < ActiveRecord::Migration[8.1]
-  def change
-    add_reference :users, :order, foreign_key: true
-  end
-end
-```
-
-#### Good
-
-Add the foreign key without validating existing rows:
-
-```ruby
-class AddForeignKeyOnUsers < ActiveRecord::Migration[8.1]
-  def change
-    add_foreign_key :users, :orders, validate: false
-  end
-end
-```
-
-Then validate them in a separate migration.
-
-```ruby
-class ValidateForeignKeyOnUsers < ActiveRecord::Migration[8.1]
-  def change
-    validate_foreign_key :users, :orders
-  end
-end
-```
-
 ### Adding a unique constraint
 
 #### Bad
@@ -577,6 +608,39 @@ class AddPropertiesToUsers < ActiveRecord::Migration[8.1]
 end
 ```
 
+### Adding a column with a volatile default value
+
+#### Bad
+
+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.1]
+  def change
+    add_column :users, :some_column, :uuid, default: "gen_random_uuid()"
+  end
+end
+```
+
+#### Good
+
+Instead, add the column without a default value, then change the default.
+
+```ruby
+class AddSomeColumnToUsers < ActiveRecord::Migration[8.1]
+  def up
+    add_column :users, :some_column, :uuid
+    change_column_default :users, :some_column, "gen_random_uuid()"
+  end
+
+  def down
+    remove_column :users, :some_column
+  end
+end
+```
+
+Then [backfill the data](#backfilling-data).
+
 ### Setting NOT NULL on an existing column
 
 :turtle: Safe by default available
@@ -622,63 +686,119 @@ class ValidateSomeColumnNotNull < ActiveRecord::Migration[8.1]
 end
 ```
 
-### Adding a column with a volatile default value
+### Renaming a schema
 
 #### Bad
 
-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.
+Renaming a schema that’s in use will cause errors in your application.
 
 ```ruby
-class AddSomeColumnToUsers < ActiveRecord::Migration[8.1]
+class RenameUsersToCustomers < ActiveRecord::Migration[8.1]
   def change
-    add_column :users, :some_column, :uuid, default: "gen_random_uuid()"
+    rename_schema :users, :customers
   end
 end
 ```
 
 #### Good
 
-Instead, add the column without a default value, then change the default.
+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
+
+## MySQL and MariaDB Checks
+
+### Using the COPY algorithm
+
+#### Bad
+
+In MySQL and MariaDB, using the `COPY` algorithm blocks writes.
 
 ```ruby
-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()"
+class AddSomeIndexToUsers < ActiveRecord::Migration[8.1]
+  def change
+    add_index :users, :some_column, algorithm: :copy
   end
+end
+```
 
-  def down
-    remove_column :users, :some_column
+#### Good
+
+Use the default algorithm.
+
+```ruby
+class AddSomeIndexToUsers < ActiveRecord::Migration[8.1]
+  def change
+    add_index :users, :some_column
   end
 end
 ```
 
-Then [backfill the data](#backfilling-data).
+### Using shared or exclusive locking
 
-### Renaming a schema
+#### Bad
+
+In MySQL and MariaDB, using shared locking blocks writes, and using exclusive locking blocks reads and writes.
+
+```ruby
+class AddSomeIndexToUsers < ActiveRecord::Migration[8.2]
+  def change
+    add_index :users, :some_column, lock: :shared
+  end
+end
+```
+
+#### Good
+
+Use the default locking or no locking.
+
+```ruby
+class AddSomeIndexToUsers < ActiveRecord::Migration[8.2]
+  def change
+    add_index :users, :some_column
+  end
+end
+```
+
+### Adding a column with an expression default value
 
 #### Bad
 
-Renaming a schema that’s in use will cause errors in your application.
+In MySQL and MariaDB, adding a column with an expression default value to an existing table causes the entire table to be rewritten. During this time, writes are blocked.
 
 ```ruby
-class RenameUsersToCustomers < ActiveRecord::Migration[8.1]
+class AddSomeColumnToUsers < ActiveRecord::Migration[8.1]
   def change
-    rename_schema :users, :customers
+    add_column :users, :some_column, :datetime, default: -> { "(now())" }
   end
 end
 ```
 
 #### Good
 
-A safer approach is to:
+Instead, add the column without a default value, then change the default.
 
-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
+```ruby
+class AddSomeColumnToUsers < ActiveRecord::Migration[8.1]
+  def up
+    add_column :users, :some_column, :datetime
+    change_column_default :users, :some_column, -> { "(now())" }
+  end
+
+  def down
+    remove_column :users, :some_column
+  end
+end
+```
+
+Then [backfill the data](#backfilling-data).
+
+## Best Practices
 
 ### Keeping non-unique indexes to three columns or less
 
@@ -819,7 +939,7 @@ ALTER ROLE myuser SET lock_timeout = '10s';
 ALTER ROLE myuser SET statement_timeout = '1h';
 ```
 
-Note: If you use PgBouncer in transaction mode, you must set timeouts on the database user.
+Note: If you use a connection pooler like PgBouncer in transaction mode, you must set timeouts on the database user.
 
 ## App Timeouts
 
@@ -835,7 +955,7 @@ production:
     lock_timeout: 10s
 ```
 
-Note: If you use PgBouncer in transaction mode, you must set the statement and lock timeouts on the database user as shown above.
+Note: If you use a connection pooler like PgBouncer in transaction mode, you must set the statement and lock timeouts on the database user as shown above.
 
 For MySQL:
 
@@ -910,7 +1030,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.
@@ -920,7 +1040,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

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

@@ -35,9 +35,18 @@ module StrongMigrations
       # keep track of new columns of change_column_default check
       @new_columns << [table.to_s, column.to_s]
 
-      # Check key since DEFAULT NULL behaves differently from no default
+      # adding a column with a volatile default is not safe with Postgres
+      # https://www.postgresql.org/docs/current/sql-altertable.html#SQL-ALTERTABLE-NOTES
+      # functions like random() and clock_timestamp() are volatile
+      # functions like concat('A', 'B') are safe
+      # default expressions in Postgres cannot reference other columns
       #
-      # Also, Active Record has special case for uuid columns that allows function default values
+      # adding a column with an expression default is not safe with MySQL
+      # even constant expressions like (3) are not safe
+      # literals like 3 are safe
+      #
+      # Active Record quotes default values except for procs
+      # there is also a special case for uuid columns
       # https://github.com/rails/rails/blob/v7.0.3.1/activerecord/lib/active_record/connection_adapters/postgresql/quoting.rb#L92-L93
       if !default.nil? && (!adapter.add_column_default_safe? || (volatile = (postgresql? && type.to_s == "uuid" && default.to_s.include?("()") && adapter.default_volatile?(default))))
         if options[:null] == false
@@ -52,13 +61,14 @@ module StrongMigrations
           code: backfill_code(table, column, default, volatile),
           append: append,
           rewrite_blocks: adapter.rewrite_blocks,
-          default_type: (volatile ? "volatile" : "non-null")
-      elsif default.is_a?(Proc) && postgresql?
-        # adding a column with a VOLATILE default is not safe
-        # https://www.postgresql.org/docs/current/sql-altertable.html#SQL-ALTERTABLE-NOTES
-        # functions like random() and clock_timestamp() are VOLATILE
+          default_type: volatile ? "volatile" : "non-null"
+      elsif default.is_a?(Proc)
         # check for Proc to match Active Record
-        raise_error :add_column_default_callable
+        raise_error :add_column_default_callable,
+          add_command: command_str("add_column", [table, column, type, options.except(:default)]),
+          change_command: command_str("change_column_default", [table, column]),
+          remove_command: command_str("remove_column", [table, column]),
+          default_type: postgresql? ? "volatile" : "an expression"
       end
 
       if type.to_s == "json" && postgresql?
@@ -76,6 +86,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)
@@ -112,6 +127,11 @@ module StrongMigrations
         raise_error :add_foreign_key,
           add_foreign_key_code: command_str("add_foreign_key", [from_table, to_table, options.merge(validate: false)]),
           validate_foreign_key_code: command_str("validate_foreign_key", [from_table, to_table])
+      elsif mysql? || mariadb?
+        raise_error :add_foreign_key_mysql,
+          add_foreign_key_code: command_str("add_foreign_key", [from_table, to_table, options]),
+          # TODO exclude some options?
+          remove_foreign_key_code: command_str("remove_foreign_key", [from_table, to_table, options])
       end
     end
 
@@ -138,6 +158,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)
@@ -155,7 +179,7 @@ module StrongMigrations
 
         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
@@ -178,6 +202,48 @@ module StrongMigrations
             command: command_str(method, [table, reference, options]),
             append: append
         end
+      elsif mysql? || mariadb?
+        if options[:foreign_key]
+          raise_error :add_reference,
+            headline: "Adding a foreign key blocks writes on both tables.",
+            command: command_str(method, [table, reference, options.except(:foreign_key)]),
+            append: "\n\nThen add the foreign key in a separate migration."
+        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
 
@@ -190,9 +256,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
 
@@ -224,16 +290,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,
@@ -241,6 +307,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)
@@ -286,12 +357,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,
@@ -337,6 +408,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
@@ -383,8 +455,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
@@ -442,6 +520,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

@@ -27,8 +27,23 @@ 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.",
+
+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 up
+    %{add_command}
+    %{change_command}, -> { ... }
+  end
+
+  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
@@ -235,6 +250,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.",
@@ -281,6 +318,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.2"
+  VERSION = "2.7.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: strong_migrations
 version: !ruby/object:Gem::Version
-  version: 2.5.2
+  version: 2.7.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: []