online_migrations 0.8.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bfe87b009fa9199b4deb0a1bf7e63dac043fa8f29c25f4f93c55fd136155f2d
-  data.tar.gz: 0a95c4b4de358769bce7d3855f7df67c08d027279b523d0ea550a383b60cd6a8
+  metadata.gz: 3f7396712072756a2c7de52a7057f0c46da8ce26bf59270f0f2dea42bf43d0b3
+  data.tar.gz: a3a26397aa2a279e996e8af2e7c698ebabc73ee38bad89b84e98cbddb609feb4
 SHA512:
-  metadata.gz: 95b0d869484b407b295426bf1b836f00ce71c297fc1ef35fe817e449f126ccbc7e7df512efc30c16cda9dfb9755c86e1b409f9787f40708341aba422128b0d60
-  data.tar.gz: 42b829796b7fd0503416460775ac1c7596fce43621667a9144cd06b9000e35f8054398cadbf82f370b3e8ca988bcd7ce53b505982e8e5b3ed7e6991c71f373aa
+  metadata.gz: d897c787f1b4e23436ecc362dd49a97eba529e7f0613fe71d38b4fde1cd740a40e0fa6ba2ef59d32f0ab6c1050ebc98728a1830d22679f98671305e1d82d6eb3
+  data.tar.gz: 10c2d6cc695042052c994111f71df5e19d17cf2b81a72b4ca2bce835ecced1a91dad0bfe5d2091079661c1d97dbbf066e641b80ceca196be7dd5c0e859f8ea09

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 ## master (unreleased)
 
+## 0.9.0 (2023-10-27)
+
+- Add ability to use custom raw sql for `backfill_column_for_type_change`'s `type_cast_function`
+
+    ```ruby
+    backfill_column_for_type_change(:users, :company_id, type_cast_function: Arel.sql("company_id::integer"))
+    ```
+
+- Fix version safety with `revert`
+
+## 0.8.2 (2023-09-26)
+
+- Promote check constraint to `NOT NULL` on PostgreSQL >= 12 when changing column type
+- Fix `safety_assured` with `revert`
+
 ## 0.8.1 (2023-08-04)
 
 - Fix `update_columns_in_batches` when multiple columns are passed
@@ -8,7 +23,7 @@
 ## 0.8.0 (2023-07-24)
 
 - Add check for `change_column_default`
-- Add check for `add_unique_key` (Active Record >= 7.1)
+- Add check for `add_unique_constraint` (Active Record >= 7.1)
 - Add check for `add_column` with stored generated columns
 
 ## 0.7.3 (2023-05-30)

data/README.md

@@ -55,7 +55,7 @@ An operation is classified as dangerous if it either:
 Consider the following migration:
 
 ```ruby
-class AddAdminToUsers < ActiveRecord::Migration[7.0]
+class AddAdminToUsers < ActiveRecord::Migration[7.1]
   def change
     add_column :users, :admin, :boolean, default: false, null: false
   end
@@ -67,7 +67,7 @@ If the `users` table is large, running this migration on a live PostgreSQL < 11
 A safer approach would be to run something like the following:
 
 ```ruby
-class AddAdminToUsers < ActiveRecord::Migration[7.0]
+class AddAdminToUsers < ActiveRecord::Migration[7.1]
   # Do not wrap the migration in a transaction so that locks are held for a shorter time.
   disable_ddl_transaction!
 
@@ -112,7 +112,7 @@ A safer approach is to:
 
 add_column_with_default takes care of all this steps:
 
-class AddAdminToUsers < ActiveRecord::Migration[7.0]
+class AddAdminToUsers < ActiveRecord::Migration[7.1]
   disable_ddl_transaction!
 
   def change
@@ -143,7 +143,7 @@ Potentially dangerous operations:
 - [adding a reference](#adding-a-reference)
 - [adding a foreign key](#adding-a-foreign-key)
 - [adding an exclusion constraint](#adding-an-exclusion-constraint)
-- [adding a unique key](#adding-a-unique-key)
+- [adding a unique constraint](#adding-a-unique-constraint)
 - [adding a json column](#adding-a-json-column)
 - [adding a stored generated column](#adding-a-stored-generated-column)
 - [using primary key with short integer type](#using-primary-key-with-short-integer-type)
@@ -166,7 +166,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 RemoveNameFromUsers < ActiveRecord::Migration[7.0]
+class RemoveNameFromUsers < ActiveRecord::Migration[7.1]
   def change
     remove_column :users, :name
   end
@@ -195,7 +195,7 @@ end
 3. Wrap column removing in a `safety_assured` block:
 
   ```ruby
-  class RemoveNameFromUsers < ActiveRecord::Migration[7.0]
+  class RemoveNameFromUsers < ActiveRecord::Migration[7.1]
     def change
       safety_assured { remove_column :users, :name }
     end
@@ -212,7 +212,7 @@ end
 In earlier versions of PostgreSQL adding a column with a non-null default value to an existing table blocks reads and writes while the entire table is rewritten.
 
 ```ruby
-class AddAdminToUsers < ActiveRecord::Migration[7.0]
+class AddAdminToUsers < ActiveRecord::Migration[7.1]
   def change
     add_column :users, :admin, :boolean, default: false
   end
@@ -232,7 +232,7 @@ A safer approach is to:
 `add_column_with_default` helper takes care of all this steps:
 
 ```ruby
-class AddAdminToUsers < ActiveRecord::Migration[7.0]
+class AddAdminToUsers < ActiveRecord::Migration[7.1]
   disable_ddl_transaction!
 
   def change
@@ -250,7 +250,7 @@ end
 Active Record wraps each migration in a transaction, 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 AddAdminToUsers < ActiveRecord::Migration[7.0]
+class AddAdminToUsers < ActiveRecord::Migration[7.1]
   def change
     add_column :users, :admin, :boolean
     User.update_all(admin: false)
@@ -265,13 +265,13 @@ 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 a `update_column_in_batches` helper in a separate migration with `disable_ddl_transaction!`.
 
 ```ruby
-class AddAdminToUsers < ActiveRecord::Migration[7.0]
+class AddAdminToUsers < ActiveRecord::Migration[7.1]
   def change
     add_column :users, :admin, :boolean
   end
 end
 
-class BackfillUsersAdminColumn < ActiveRecord::Migration[7.0]
+class BackfillUsersAdminColumn < ActiveRecord::Migration[7.1]
   disable_ddl_transaction!
 
   def up
@@ -290,7 +290,7 @@ end
 Changing the type of an existing column blocks reads and writes while the entire table is rewritten.
 
 ```ruby
-class ChangeFilesSizeType < ActiveRecord::Migration[7.0]
+class ChangeFilesSizeType < ActiveRecord::Migration[7.1]
   def change
     change_column :files, :size, :bigint
   end
@@ -323,7 +323,7 @@ A safer approach can be accomplished in several steps:
 1. Create a new column and keep column's data in sync:
 
   ```ruby
-  class InitializeChangeFilesSizeType < ActiveRecord::Migration[7.0]
+  class InitializeChangeFilesSizeType < ActiveRecord::Migration[7.1]
     def change
       initialize_column_type_change :files, :size, :bigint
     end
@@ -336,7 +336,7 @@ which will be passed to `add_column` when creating a new column, so you can over
 2. Backfill data from the old column to the new column:
 
   ```ruby
-  class BackfillChangeFilesSizeType < ActiveRecord::Migration[7.0]
+  class BackfillChangeFilesSizeType < ActiveRecord::Migration[7.1]
     disable_ddl_transaction!
 
     def up
@@ -352,7 +352,7 @@ which will be passed to `add_column` when creating a new column, so you can over
 3. Copy indexes, foreign keys, check constraints, NOT NULL constraint, swap new column in place:
 
   ```ruby
-  class FinalizeChangeFilesSizeType < ActiveRecord::Migration[7.0]
+  class FinalizeChangeFilesSizeType < ActiveRecord::Migration[7.1]
     disable_ddl_transaction!
 
     def change
@@ -365,7 +365,7 @@ which will be passed to `add_column` when creating a new column, so you can over
 5. Finally, if everything is working as expected, remove copy trigger and old column:
 
   ```ruby
-  class CleanupChangeFilesSizeType < ActiveRecord::Migration[7.0]
+  class CleanupChangeFilesSizeType < ActiveRecord::Migration[7.1]
     def up
       cleanup_column_type_change :files, :size
     end
@@ -385,7 +385,7 @@ which will be passed to `add_column` when creating a new column, so you can over
 Renaming a column that's in use will cause errors in your application.
 
 ```ruby
-class RenameUsersNameToFirstName < ActiveRecord::Migration[7.0]
+class RenameUsersNameToFirstName < ActiveRecord::Migration[7.1]
   def change
     rename_column :users, :name, :first_name
   end
@@ -454,7 +454,7 @@ nor any data/indexes/foreign keys copying will be made, so will be instantaneous
 It will use a combination of a VIEW and column aliasing to work with both column names simultaneously
 
 ```ruby
-class InitializeRenameUsersNameToFirstName < ActiveRecord::Migration[7.0]
+class InitializeRenameUsersNameToFirstName < ActiveRecord::Migration[7.1]
   def change
     initialize_column_rename :users, :name, :first_name
   end
@@ -485,7 +485,7 @@ end
 9. Remove the VIEW created in step 3 and finally rename the column:
 
 ```ruby
-class FinalizeRenameUsersNameToFirstName < ActiveRecord::Migration[7.0]
+class FinalizeRenameUsersNameToFirstName < ActiveRecord::Migration[7.1]
   def change
     finalize_column_rename :users, :name, :first_name
   end
@@ -501,7 +501,7 @@ end
 Renaming a table that's in use will cause errors in your application.
 
 ```ruby
-class RenameClientsToUsers < ActiveRecord::Migration[7.0]
+class RenameClientsToUsers < ActiveRecord::Migration[7.1]
   def change
     rename_table :clients, :users
   end
@@ -556,7 +556,7 @@ OnlineMigrations.config.table_renames = {
 3. Create a VIEW:
 
 ```ruby
-class InitializeRenameClientsToUsers < ActiveRecord::Migration[7.0]
+class InitializeRenameClientsToUsers < ActiveRecord::Migration[7.1]
   def change
     initialize_table_rename :clients, :users
   end
@@ -569,7 +569,7 @@ end
 7. Remove the VIEW created in step 3:
 
 ```ruby
-class FinalizeRenameClientsToUsers < ActiveRecord::Migration[7.0]
+class FinalizeRenameClientsToUsers < ActiveRecord::Migration[7.1]
   def change
     finalize_table_rename :clients, :users
   end
@@ -585,7 +585,7 @@ end
 The `force` option can drop an existing table.
 
 ```ruby
-class CreateUsers < ActiveRecord::Migration[7.0]
+class CreateUsers < ActiveRecord::Migration[7.1]
   def change
     create_table :users, force: true do |t|
       # ...
@@ -599,7 +599,7 @@ end
 Create tables without the `force` option.
 
 ```ruby
-class CreateUsers < ActiveRecord::Migration[7.0]
+class CreateUsers < ActiveRecord::Migration[7.1]
   def change
     create_table :users do |t|
       # ...
@@ -617,7 +617,7 @@ If you intend to drop an existing table, run `drop_table` first.
 Adding a check constraint blocks reads and writes while every row is checked.
 
 ```ruby
-class AddCheckConstraint < ActiveRecord::Migration[7.0]
+class AddCheckConstraint < ActiveRecord::Migration[7.1]
   def change
     add_check_constraint :users, "char_length(name) >= 1", name: "name_check"
   end
@@ -629,7 +629,7 @@ end
 Add the check constraint without validating existing rows, and then validate them in a separate transaction:
 
 ```ruby
-class AddCheckConstraint < ActiveRecord::Migration[7.0]
+class AddCheckConstraint < ActiveRecord::Migration[7.1]
   disable_ddl_transaction!
 
   def change
@@ -648,7 +648,7 @@ end
 Setting `NOT NULL` on an existing column blocks reads and writes while every row is checked.
 
 ```ruby
-class ChangeUsersNameNull < ActiveRecord::Migration[7.0]
+class ChangeUsersNameNull < ActiveRecord::Migration[7.1]
   def change
     change_column_null :users, :name, false
   end
@@ -660,7 +660,7 @@ end
 Instead, add a check constraint and validate it in a separate transaction:
 
 ```ruby
-class ChangeUsersNameNull < ActiveRecord::Migration[7.0]
+class ChangeUsersNameNull < ActiveRecord::Migration[7.1]
   disable_ddl_transaction!
 
   def change
@@ -675,7 +675,7 @@ end
 A `NOT NULL` check constraint is functionally equivalent to setting `NOT NULL` on the column (but it won't show up in `schema.rb` in Rails < 6.1). In PostgreSQL 12+, once the check constraint is validated, you can safely set `NOT NULL` on the column and drop the check constraint.
 
 ```ruby
-class ChangeUsersNameNullDropCheck < ActiveRecord::Migration[7.0]
+class ChangeUsersNameNullDropCheck < ActiveRecord::Migration[7.1]
   def change
     # in PostgreSQL 12+, you can then safely set NOT NULL on the column
     change_column_null :users, :name, false
@@ -689,7 +689,7 @@ end
 Online Migrations does not support inspecting what happens inside an `execute` call, so cannot help you here. Make really sure that what you're doing is safe before proceeding, then wrap it in a `safety_assured { ... }` block:
 
 ```ruby
-class ExecuteSQL < ActiveRecord::Migration[7.0]
+class ExecuteSQL < ActiveRecord::Migration[7.1]
   def change
     safety_assured { execute "..." }
   end
@@ -703,7 +703,7 @@ end
 Adding an index non-concurrently blocks writes.
 
 ```ruby
-class AddIndexOnUsersEmail < ActiveRecord::Migration[7.0]
+class AddIndexOnUsersEmail < ActiveRecord::Migration[7.1]
   def change
     add_index :users, :email, unique: true
   end
@@ -715,7 +715,7 @@ end
 Add indexes concurrently.
 
 ```ruby
-class AddIndexOnUsersEmail < ActiveRecord::Migration[7.0]
+class AddIndexOnUsersEmail < ActiveRecord::Migration[7.1]
   disable_ddl_transaction!
 
   def change
@@ -733,7 +733,7 @@ end
 While actual removing of an index is usually fast, removing it non-concurrently tries to obtain an `ACCESS EXCLUSIVE` lock on the table, waiting for all existing queries to complete and blocking all the subsequent queries (even `SELECT`s) on that table until the lock is obtained and index is removed.
 
 ```ruby
-class RemoveIndexOnUsersEmail < ActiveRecord::Migration[7.0]
+class RemoveIndexOnUsersEmail < ActiveRecord::Migration[7.1]
   def change
     remove_index :users, :email
   end
@@ -745,7 +745,7 @@ end
 Remove indexes concurrently.
 
 ```ruby
-class RemoveIndexOnUsersEmail < ActiveRecord::Migration[7.0]
+class RemoveIndexOnUsersEmail < ActiveRecord::Migration[7.1]
   disable_ddl_transaction!
 
   def change
@@ -763,7 +763,7 @@ end
 Removing an old index before replacing it with the new one might result in slow queries while building the new index.
 
 ```ruby
-class AddIndexOnCreationToProjects < ActiveRecord::Migration[7.0]
+class AddIndexOnCreationToProjects < ActiveRecord::Migration[7.1]
   disable_ddl_transaction!
 
   def change
@@ -780,7 +780,7 @@ end
 A safer approach is to create the new index and then delete the old one.
 
 ```ruby
-class AddIndexOnCreationToProjects < ActiveRecord::Migration[7.0]
+class AddIndexOnCreationToProjects < ActiveRecord::Migration[7.1]
   disable_ddl_transaction!
 
   def change
@@ -797,7 +797,7 @@ end
 Rails adds an index non-concurrently to references by default, which blocks writes. Additionally, if `foreign_key` option (without `validate: false`) is provided, both tables are blocked while it is validated.
 
 ```ruby
-class AddUserToProjects < ActiveRecord::Migration[7.0]
+class AddUserToProjects < ActiveRecord::Migration[7.1]
   def change
     add_reference :projects, :user, foreign_key: true
   end
@@ -810,7 +810,7 @@ Make sure the index is added concurrently and the foreign key is added in a sepa
 Or you can use `add_reference_concurrently` helper. It will create a reference and take care of safely adding index and/or foreign key.
 
 ```ruby
-class AddUserToProjects < ActiveRecord::Migration[7.0]
+class AddUserToProjects < ActiveRecord::Migration[7.1]
   disable_ddl_transaction!
 
   def change
@@ -828,7 +828,7 @@ end
 Adding a foreign key blocks writes on both tables.
 
 ```ruby
-class AddForeignKeyToProjectsUser < ActiveRecord::Migration[7.0]
+class AddForeignKeyToProjectsUser < ActiveRecord::Migration[7.1]
   def change
     add_foreign_key :projects, :users
   end
@@ -838,7 +838,7 @@ end
 or
 
 ```ruby
-class AddReferenceToProjectsUser < ActiveRecord::Migration[7.0]
+class AddReferenceToProjectsUser < ActiveRecord::Migration[7.1]
   def change
     add_reference :projects, :user, foreign_key: true
   end
@@ -850,7 +850,7 @@ end
 Add the foreign key without validating existing rows, and then validate them in a separate transaction.
 
 ```ruby
-class AddForeignKeyToProjectsUser < ActiveRecord::Migration[7.0]
+class AddForeignKeyToProjectsUser < ActiveRecord::Migration[7.1]
   disable_ddl_transaction!
 
   def change
@@ -880,16 +880,16 @@ end
 
 [Let us know](https://github.com/fatkodima/online_migrations/issues/new) if you have a safe way to do this (exclusion constraints cannot be marked `NOT VALID`).
 
-### Adding a unique key
+### Adding a unique constraint
 
 :x: **Bad**
 
-Adding a unique key blocks reads and writes while the underlying index is being built.
+Adding a unique constraint blocks reads and writes while the underlying index is being built.
 
 ```ruby
-class AddUniqueKey < ActiveRecord::Migration[7.1]
+class AddUniqueConstraint < ActiveRecord::Migration[7.1]
   def change
-    add_unique_key :sections, :position, deferrable: :deferred
+    add_unique_constraint :sections, :position, deferrable: :deferred
   end
 end
 ```
@@ -899,7 +899,7 @@ end
 A safer approach is to create a unique index first, and then create a unique key using that index.
 
 ```ruby
-class AddUniqueKeyAddIndex < ActiveRecord::Migration[7.1]
+class AddUniqueConstraintAddIndex < ActiveRecord::Migration[7.1]
   disable_ddl_transaction!
 
   def change
@@ -909,13 +909,13 @@ end
 ```
 
 ```ruby
-class AddUniqueKey < ActiveRecord::Migration[7.1]
+class AddUniqueConstraint < ActiveRecord::Migration[7.1]
   def up
-    add_unique_key :sections, :position, deferrable: :deferred, using_index: "index_sections_on_position"
+    add_unique_constraint :sections, :position, deferrable: :deferred, using_index: "index_sections_on_position"
   end
 
   def down
-    remove_unique_key :sections, :position
+    remove_unique_constraint :sections, :position
   end
 end
 ```
@@ -927,7 +927,7 @@ end
 There's no equality operator for the `json` column type, which can cause errors for existing `SELECT DISTINCT` queries in your application.
 
 ```ruby
-class AddSettingsToProjects < ActiveRecord::Migration[7.0]
+class AddSettingsToProjects < ActiveRecord::Migration[7.1]
   def change
     add_column :projects, :settings, :json
   end
@@ -939,7 +939,7 @@ end
 Use `jsonb` instead.
 
 ```ruby
-class AddSettingsToProjects < ActiveRecord::Migration[7.0]
+class AddSettingsToProjects < ActiveRecord::Migration[7.1]
   def change
     add_column :projects, :settings, :jsonb
   end
@@ -953,7 +953,7 @@ end
 Adding a stored generated column causes the entire table to be rewritten. During this time, reads and writes are blocked.
 
 ```ruby
-class AddLowerEmailToUsers < ActiveRecord::Migration[7.0]
+class AddLowerEmailToUsers < ActiveRecord::Migration[7.1]
   def change
     add_column :users, :lower_email, :virtual, type: :string, as: "LOWER(email)", stored: true
   end
@@ -971,7 +971,7 @@ Add a non-generated column and use callbacks or triggers instead.
 When using short integer types as primary key types, [there is a risk](https://m.signalvnoise.com/update-on-basecamp-3-being-stuck-in-read-only-as-of-nov-8-922am-cst/) of running out of IDs on inserts. The default type in Active Record < 5.1 for primary and foreign keys is `INTEGER`, which allows a little over of 2 billion records. Active Record 5.1 changed the default type to `BIGINT`.
 
 ```ruby
-class CreateUsers < ActiveRecord::Migration[7.0]
+class CreateUsers < ActiveRecord::Migration[7.1]
   def change
     create_table :users, id: :integer do |t|
       # ...
@@ -985,7 +985,7 @@ end
 Use one of `bigint`, `bigserial`, `uuid` instead.
 
 ```ruby
-class CreateUsers < ActiveRecord::Migration[7.0]
+class CreateUsers < ActiveRecord::Migration[7.1]
   def change
     create_table :users, id: :bigint do |t| # bigint is the default for Active Record >= 5.1
       # ...
@@ -1001,7 +1001,7 @@ end
 Hash index operations are not WAL-logged, so hash indexes might need to be rebuilt with `REINDEX` after a database crash if there were unwritten changes. Also, changes to hash indexes are not replicated over streaming or file-based replication after the initial base backup, so they give wrong answers to queries that subsequently use them. For these reasons, hash index use is discouraged.
 
 ```ruby
-class AddIndexToUsersOnEmail < ActiveRecord::Migration[7.0]
+class AddIndexToUsersOnEmail < ActiveRecord::Migration[7.1]
   def change
     add_index :users, :email, unique: true, using: :hash
   end
@@ -1013,7 +1013,7 @@ end
 Use B-tree indexes instead.
 
 ```ruby
-class AddIndexToUsersOnEmail < ActiveRecord::Migration[7.0]
+class AddIndexToUsersOnEmail < ActiveRecord::Migration[7.1]
   def change
     add_index :users, :email, unique: true # B-tree by default
   end
@@ -1028,7 +1028,7 @@ Adding multiple foreign keys in a single migration blocks reads and writes on al
 Avoid adding foreign key more than once per migration file, unless the source and target tables are identical.
 
 ```ruby
-class CreateUserProjects < ActiveRecord::Migration[7.0]
+class CreateUserProjects < ActiveRecord::Migration[7.1]
   def change
     create_table :user_projects do |t|
       t.belongs_to :user, foreign_key: true
@@ -1043,7 +1043,7 @@ end
 Add additional foreign keys in separate migration files. See [adding a foreign key](#adding-a-foreign-key) for how to properly add foreign keys.
 
 ```ruby
-class CreateUserProjects < ActiveRecord::Migration[7.0]
+class CreateUserProjects < ActiveRecord::Migration[7.1]
   def change
     create_table :user_projects do |t|
       t.belongs_to :user, foreign_key: true
@@ -1052,7 +1052,7 @@ class CreateUserProjects < ActiveRecord::Migration[7.0]
   end
 end
 
-class AddForeignKeyFromUserProjectsToProject < ActiveRecord::Migration[7.0]
+class AddForeignKeyFromUserProjectsToProject < ActiveRecord::Migration[7.1]
   def change
     add_foreign_key :user_projects, :projects
   end
@@ -1069,7 +1069,7 @@ Remove all the foreign keys first.
 Assuming, `projects` has foreign keys on `users.id` and `repositories.id`:
 
 ```ruby
-class DropProjects < ActiveRecord::Migration[7.0]
+class DropProjects < ActiveRecord::Migration[7.1]
   def change
     drop_table :projects
   end
@@ -1081,13 +1081,13 @@ end
 Remove all the foreign keys first:
 
 ```ruby
-class RemoveProjectsUserFk < ActiveRecord::Migration[7.0]
+class RemoveProjectsUserFk < ActiveRecord::Migration[7.1]
   def change
     remove_foreign_key :projects, :users
   end
 end
 
-class RemoveProjectsRepositoryFk < ActiveRecord::Migration[7.0]
+class RemoveProjectsRepositoryFk < ActiveRecord::Migration[7.1]
   def change
     remove_foreign_key :projects, :repositories
   end
@@ -1097,7 +1097,7 @@ end
 Then remove the table:
 
 ```ruby
-class DropProjects < ActiveRecord::Migration[7.0]
+class DropProjects < ActiveRecord::Migration[7.1]
   def change
     drop_table :projects
   end
@@ -1114,7 +1114,7 @@ Otherwise, there's a risk of bugs caused by IDs representable by one type but no
 Assuming, there is a `users` table with `bigint` primary key type:
 
 ```ruby
-class AddUserIdToProjects < ActiveRecord::Migration[7.0]
+class AddUserIdToProjects < ActiveRecord::Migration[7.1]
   def change
     add_column :projects, :user_id, :integer
   end
@@ -1128,7 +1128,7 @@ Add a reference column of the same type as a referenced primary key.
 Assuming, there is a `users` table with `bigint` primary key type:
 
 ```ruby
-class AddUserIdToProjects < ActiveRecord::Migration[7.0]
+class AddUserIdToProjects < ActiveRecord::Migration[7.1]
   def change
     add_column :projects, :user_id, :bigint
   end
@@ -1142,7 +1142,7 @@ end
 Adding a single table inheritance column might cause errors in old instances of your application.
 
 ```ruby
-class AddTypeToUsers < ActiveRecord::Migration[7.0]
+class AddTypeToUsers < ActiveRecord::Migration[7.1]
   def change
     add_column :users, :string, :type, default: "Member"
   end
@@ -1182,7 +1182,7 @@ A safer approach is to:
 Active Record < 7 enables partial writes by default, which can cause incorrect values to be inserted when changing the default value of a column.
 
 ```ruby
-class ChangeSomeColumnDefault < ActiveRecord::Migration[7.0]
+class ChangeSomeColumnDefault < ActiveRecord::Migration[7.1]
   def change
     change_column_default :users, :some_column, from: "old", to: "new"
   end
@@ -1210,7 +1210,7 @@ config.active_record.partial_inserts = false
 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.0]
+class MySafeMigration < ActiveRecord::Migration[7.1]
   def change
     safety_assured { remove_column :users, :some_column }
   end

data/docs/configuring.md

@@ -154,7 +154,7 @@ This is useful to demystify `online_migrations` inner workings, and to better in
 Consider migration, running on PostgreSQL < 11:
 
 ```ruby
-class AddAdminToUsers < ActiveRecord::Migration[7.0]
+class AddAdminToUsers < ActiveRecord::Migration[7.1]
   disable_ddl_transaction!
 
   def change

data/lib/online_migrations/background_migration.rb

@@ -21,8 +21,8 @@ module OnlineMigrations
         migration = "#{namespace}::#{name}".safe_constantize ||
                     "#{internal_namespace}::#{name}".safe_constantize
 
-        raise NotFoundError.new("Background Migration #{name} not found", name) unless migration
-        unless migration.is_a?(Class) && migration < self
+        raise NotFoundError.new("Background Migration #{name} not found", name) if migration.nil?
+        if !(migration.is_a?(Class) && migration < self)
           raise NotFoundError.new("#{name} is not a Background Migration", name)
         end
 

data/lib/online_migrations/background_migrations/background_migration_class_validator.rb

@@ -8,7 +8,7 @@ module OnlineMigrations
         relation = record.migration_relation
         migration_name = record.migration_name
 
-        unless relation.is_a?(ActiveRecord::Relation)
+        if !relation.is_a?(ActiveRecord::Relation)
           record.errors.add(
             :migration_name,
             "#{migration_name}#relation must return an ActiveRecord::Relation object"

data/lib/online_migrations/background_migrations/config.rb

@@ -87,7 +87,7 @@ module OnlineMigrations
       end
 
       def throttler=(value)
-        unless value.respond_to?(:call)
+        if !value.respond_to?(:call)
           raise ArgumentError, "background_migrations throttler must be a callable."
         end
 

data/lib/online_migrations/background_migrations/delete_associated_records.rb

@@ -13,7 +13,7 @@ module OnlineMigrations
       end
 
       def relation
-        unless @record.respond_to?(association)
+        if !@record.respond_to?(association)
           raise ArgumentError, "'#{@record.class.name}' has no association called '#{association}'"
         end
 

data/lib/online_migrations/background_migrations/delete_orphaned_records.rb

@@ -16,7 +16,7 @@ module OnlineMigrations
         # https://github.com/rails/rails/pull/34727
         associations.inject(model.unscoped) do |relation, association|
           reflection = model.reflect_on_association(association)
-          unless reflection
+          if reflection.nil?
             raise ArgumentError, "'#{model.name}' has no association called '#{association}'"
           end
 

data/lib/online_migrations/background_migrations/migration_job_status_validator.rb

@@ -11,12 +11,12 @@ module OnlineMigrations
       }
 
       def validate(record)
-        return unless record.status_changed?
+        return if !record.status_changed?
 
         previous_status, new_status = record.status_change
         valid_new_statuses = VALID_STATUS_TRANSITIONS.fetch(previous_status, [])
 
-        unless valid_new_statuses.include?(new_status)
+        if !valid_new_statuses.include?(new_status)
           record.errors.add(
             :status,
             "cannot transition background migration job from status #{previous_status} to #{new_status}"

data/lib/online_migrations/background_migrations/migration_status_validator.rb

@@ -29,12 +29,12 @@ module OnlineMigrations
       }
 
       def validate(record)
-        return unless record.status_changed?
+        return if !record.status_changed?
 
         previous_status, new_status = record.status_change
         valid_new_statuses = VALID_STATUS_TRANSITIONS.fetch(previous_status, [])
 
-        unless valid_new_statuses.include?(new_status)
+        if !valid_new_statuses.include?(new_status)
           record.errors.add(
             :status,
             "cannot transition background migration from status #{previous_status} to #{new_status}"

data/lib/online_migrations/background_migrations/reset_counters.rb

@@ -59,7 +59,7 @@ module OnlineMigrations
         def has_many_association(counter_association) # rubocop:disable Naming/PredicateName
           has_many_association = model.reflect_on_association(counter_association)
 
-          unless has_many_association
+          if !has_many_association
             has_many = model.reflect_on_all_associations(:has_many)
 
             has_many_association = has_many.find do |association|
@@ -74,7 +74,7 @@ module OnlineMigrations
 
             counter_association = has_many_association.plural_name if has_many_association
           end
-          raise ArgumentError, "'#{model.name}' has no association called '#{counter_association}'" unless has_many_association
+          raise ArgumentError, "'#{model.name}' has no association called '#{counter_association}'" if !has_many_association
 
           if has_many_association.is_a?(ActiveRecord::Reflection::ThroughReflection)
             has_many_association = has_many_association.through_reflection

data/lib/online_migrations/batch_iterator.rb

@@ -14,7 +14,7 @@ module OnlineMigrations
     end
 
     def each_batch(of: 1000, column: relation.primary_key, start: nil, finish: nil, order: :asc)
-      unless [:asc, :desc].include?(order)
+      if ![:asc, :desc].include?(order)
         raise ArgumentError, ":order must be :asc or :desc, got #{order.inspect}"
       end
 
@@ -26,7 +26,7 @@ module OnlineMigrations
 
       start_row = base_relation.uncached { base_relation.first }
 
-      return unless start_row
+      return if !start_row
 
       start_id = start_row[column]
       arel_table = relation.arel_table
@@ -67,7 +67,7 @@ module OnlineMigrations
         # Retaining the results in the query cache would undermine the point of batching.
         batch_relation.uncached { yield batch_relation, index }
 
-        break unless stop_row
+        break if !stop_row
       end
     end
 

data/lib/online_migrations/change_column_type_helpers.rb

@@ -113,21 +113,22 @@ module OnlineMigrations
 
           if raw_connection.server_version >= 11_00_00
             if primary_key(table_name) == column_name.to_s && old_col.type == :integer
-              # If the column to be converted is a Primary Key, set it to
-              # `NOT NULL DEFAULT 0` and we'll copy the correct values when backfilling.
-              # That way, we skip the expensive validation step required to add
-              #  a `NOT NULL` constraint at the end of the process.
+              # For PG < 11 and Primary Key conversions, setting a column as the PK
+              # converts even check constraints to NOT NULL column constraints
+              # and forces an inline re-verification of the whole table.
+              # To avoid this, we instead set it to `NOT NULL DEFAULT 0` and we'll
+              # copy the correct values when backfilling.
               add_column(table_name, tmp_column_name, new_type,
                 **old_col_options.merge(column_options).merge(default: old_col.default || 0, null: false))
             else
-              unless old_col.default.nil?
+              if !old_col.default.nil?
                 old_col_options = old_col_options.merge(default: old_col.default, null: old_col.null)
               end
               add_column(table_name, tmp_column_name, new_type, **old_col_options.merge(column_options))
             end
           else
             add_column(table_name, tmp_column_name, new_type, **old_col_options.merge(column_options))
-            change_column_default(table_name, tmp_column_name, old_col.default) unless old_col.default.nil?
+            change_column_default(table_name, tmp_column_name, old_col.default) if !old_col.default.nil?
           end
         end
 
@@ -175,6 +176,7 @@ module OnlineMigrations
     #
     # @example With type casting
     #   backfill_column_for_type_change(:users, :settings, type_cast_function: "jsonb")
+    #   backfill_column_for_type_change(:users, :company_id, type_cast_function: Arel.sql("company_id::integer"))
     #
     # @example Additional batch options
     #   backfill_column_for_type_change(:files, :size, batch_size: 10_000)
@@ -201,7 +203,13 @@ module OnlineMigrations
 
         old_value = Arel::Table.new(table_name)[column_name]
         if (type_cast_function = type_cast_functions.with_indifferent_access[column_name])
-          old_value = Arel::Nodes::NamedFunction.new(type_cast_function.to_s, [old_value])
+          old_value =
+            case type_cast_function
+            when Arel::Nodes::SqlLiteral
+              type_cast_function
+            else
+              Arel::Nodes::NamedFunction.new(type_cast_function.to_s, [old_value])
+            end
         end
 
         [tmp_column, old_value]
@@ -247,22 +255,7 @@ module OnlineMigrations
 
           # At this point we are sure there are no NULLs in this column
           transaction do
-            # For PG < 11 and Primary Key conversions, setting a column as the PK
-            # converts even check constraints to NOT NULL column constraints
-            # and forces an inline re-verification of the whole table.
-            #
-            # For PG >= 12 we can "promote" CHECK constraint to NOT NULL constraint,
-            # but for older versions we can set attribute as NOT NULL directly
-            # through PG internal tables.
-            # In-depth analysis of implications of this was made, so this approach
-            # is considered safe - https://habr.com/ru/company/haulmont/blog/493954/  (in russian).
-            execute(<<-SQL.strip_heredoc)
-              UPDATE pg_catalog.pg_attribute
-              SET attnotnull = true
-              WHERE attrelid = #{quote(table_name)}::regclass
-                AND attname = #{quote(tmp_column_name)}
-            SQL
-
+            __set_not_null(table_name, tmp_column_name)
             remove_not_null_constraint(table_name, tmp_column_name)
           end
         end
@@ -389,7 +382,7 @@ module OnlineMigrations
         options.each do |option|
           if column.respond_to?(option)
             value = column.public_send(option)
-            result[option] = value unless value.nil?
+            result[option] = value if !value.nil?
           end
         end
         result
@@ -417,7 +410,7 @@ module OnlineMigrations
           end
 
           # This is necessary as we can't properly rename indexes such as "taggings_idx".
-          unless index.name.include?(from_column)
+          if !index.name.include?(from_column)
             raise "The index #{index.name} can not be copied as it does not " \
                   "mention the old column. You have to rename this index manually first."
           end
@@ -482,6 +475,29 @@ module OnlineMigrations
         end
       end
 
+      def __set_not_null(table_name, column_name)
+        # For PG >= 12 we can "promote" CHECK constraint to NOT NULL constraint:
+        # https://github.com/postgres/postgres/commit/bbb96c3704c041d139181c6601e5bc770e045d26
+        if raw_connection.server_version >= 12_00_00
+          execute(<<-SQL.strip_heredoc)
+            ALTER TABLE #{quote_table_name(table_name)}
+            ALTER #{quote_column_name(column_name)}
+            SET NOT NULL
+          SQL
+        else
+          # For older versions we can set attribute as NOT NULL directly
+          # through PG internal tables.
+          # In-depth analysis of implications of this was made, so this approach
+          # is considered safe - https://habr.com/ru/company/haulmont/blog/493954/  (in russian).
+          execute(<<-SQL.strip_heredoc)
+            UPDATE pg_catalog.pg_attribute
+            SET attnotnull = true
+            WHERE attrelid = #{quote(table_name)}::regclass
+              AND attname = #{quote(column_name)}
+          SQL
+        end
+      end
+
       def __check_constraints_for(table_name, column_name)
         __check_constraints(table_name).select { |c| c["column_name"] == column_name }
       end

data/lib/online_migrations/command_checker.rb

@@ -7,11 +7,22 @@ require "set"
 module OnlineMigrations
   # @private
   class CommandChecker
+    class << self
+      attr_accessor :safe
+
+      def safety_assured
+        prev_value = safe
+        self.safe = true
+        yield
+      ensure
+        self.safe = prev_value
+      end
+    end
+
     attr_accessor :direction
 
     def initialize(migration)
       @migration = migration
-      @safe = false
       @new_tables = []
       @new_columns = []
       @lock_timeout_checked = false
@@ -19,19 +30,11 @@ module OnlineMigrations
       @removed_indexes = []
     end
 
-    def safety_assured
-      prev_value = @safe
-      @safe = true
-      yield
-    ensure
-      @safe = prev_value
-    end
-
     def check(command, *args, &block)
       check_database_version
       check_lock_timeout
 
-      unless safe?
+      if !safe?
         do_check(command, *args, &block)
 
         run_custom_checks(command, args)
@@ -45,6 +48,10 @@ module OnlineMigrations
     end
     ruby2_keywords(:check) if respond_to?(:ruby2_keywords, true)
 
+    def version_safe?
+      version && version <= OnlineMigrations.config.start_after
+    end
+
     private
       def check_database_version
         return if defined?(@database_version_checked)
@@ -101,10 +108,11 @@ module OnlineMigrations
       end
 
       def safe?
-        @safe ||
+        self.class.safe ||
           ENV["SAFETY_ASSURED"] ||
           (direction == :down && !OnlineMigrations.config.check_down) ||
-          version <= OnlineMigrations.config.start_after
+          version_safe? ||
+          @migration.reverting?
       end
 
       def version
@@ -477,7 +485,7 @@ module OnlineMigrations
             bad_foreign_key: bad_foreign_key
         end
 
-        unless options[:polymorphic]
+        if !options[:polymorphic]
           type = (options[:type] || (Utils.ar_version >= 5.1 ? :bigint : :integer)).to_sym
           column_name = "#{ref_name}_id"
 
@@ -507,9 +515,9 @@ module OnlineMigrations
             existing_indexes = connection.indexes(table_name)
 
             @removed_indexes.each do |removed_index|
-              next unless removed_index.intersect?(index)
+              next if !removed_index.intersect?(index)
 
-              unless existing_indexes.any? { |existing_index| removed_index.covered_by?(existing_index) }
+              if existing_indexes.none? { |existing_index| removed_index.covered_by?(existing_index) }
                 raise_error :replace_index
               end
             end
@@ -560,7 +568,7 @@ module OnlineMigrations
       end
 
       def add_exclusion_constraint(table_name, _expression, **_options)
-        unless new_or_small_table?(table_name)
+        if !new_or_small_table?(table_name)
           raise_error :add_exclusion_constraint
         end
       end
@@ -575,15 +583,15 @@ module OnlineMigrations
         end
       end
 
-      def add_unique_key(table_name, column_name = nil, **options)
+      def add_unique_constraint(table_name, column_name = nil, **options)
         return if new_or_small_table?(table_name) || options[:using_index] || !column_name
 
         index_name = index_name(table_name, column_name)
 
-        raise_error :add_unique_key,
+        raise_error :add_unique_constraint,
           add_index_code: command_str(:add_index, table_name, column_name, unique: true, name: index_name, algorithm: :concurrently),
-          add_code: command_str(:add_unique_key, table_name, **options.merge(using_index: index_name)),
-          remove_code: command_str(:remove_unique_key, table_name, column_name)
+          add_code: command_str(:add_unique_constraint, table_name, **options.merge(using_index: index_name)),
+          remove_code: command_str(:remove_unique_constraint, table_name, column_name)
       end
 
       # Implementation is from Active Record

data/lib/online_migrations/command_recorder.rb

@@ -98,7 +98,7 @@ module OnlineMigrations
 
       def invert_revert_initialize_columns_rename(args)
         _table, old_new_column_hash = args
-        unless old_new_column_hash
+        if !old_new_column_hash
           raise ActiveRecord::IrreversibleMigration,
             "revert_initialize_columns_rename is only reversible if given a hash of old and new columns."
         end
@@ -107,7 +107,7 @@ module OnlineMigrations
 
       def invert_finalize_table_rename(args)
         _table_name, new_name = args
-        unless new_name
+        if !new_name
           raise ActiveRecord::IrreversibleMigration,
             "finalize_table_rename is only reversible if given a new_name."
         end
@@ -115,7 +115,7 @@ module OnlineMigrations
       end
 
       def invert_revert_initialize_column_type_change(args)
-        unless args[2]
+        if !args[2]
           raise ActiveRecord::IrreversibleMigration,
             "revert_initialize_column_type_change is only reversible if given a new_type."
         end
@@ -141,7 +141,7 @@ module OnlineMigrations
       end
 
       def invert_remove_text_limit_constraint(args)
-        unless args[2]
+        if !args[2]
           raise ActiveRecord::IrreversibleMigration, "remove_text_limit_constraint is only reversible if given a limit."
         end
 

data/lib/online_migrations/config.rb

@@ -261,7 +261,7 @@ module OnlineMigrations
 
     private
       def ensure_supports_multiple_dbs
-        unless Utils.supports_multiple_dbs?
+        if !Utils.supports_multiple_dbs?
           raise "OnlineMigrations does not support multiple databases for Active Record < 6.1"
         end
       end

data/lib/online_migrations/error_messages.rb

@@ -438,9 +438,9 @@ class <%= migration_name %> < <%= migration_parent %>
   end
 end",
 
-      add_unique_key:
-"Adding a unique key blocks reads and writes while the underlying index is being built.
-A safer approach is to create a unique index first, and then create a unique key using that index.
+      add_unique_constraint:
+"Adding a unique constraint blocks reads and writes while the underlying index is being built.
+A safer approach is to create a unique index first, and then create a unique constraint using that index.
 
 class <%= migration_name %>AddIndex < <%= migration_parent %>
   disable_ddl_transaction!

data/lib/online_migrations/migration.rb

@@ -30,13 +30,22 @@ module OnlineMigrations
     end
     ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
 
+    # @private
+    def revert(*args)
+      if command_checker.version_safe?
+        safety_assured { super }
+      else
+        super
+      end
+    end
+
     # Mark a command in the migration as safe, despite using a method that might otherwise be dangerous.
     #
     # @example
     #   safety_assured { remove_column(:users, :some_column) }
     #
     def safety_assured(&block)
-      command_checker.safety_assured(&block)
+      command_checker.class.safety_assured(&block)
     end
 
     # Stop running migrations.

data/lib/online_migrations/schema_statements.rb

@@ -87,7 +87,7 @@ module OnlineMigrations
         value = Arel.sql(value.call.to_s) if value.is_a?(Proc)
 
         # Ignore subqueries in conditions
-        unless value.is_a?(Arel::Nodes::SqlLiteral) && value.to_s =~ /select\s+/i
+        if !value.is_a?(Arel::Nodes::SqlLiteral) || value.to_s !~ /select\s+/i
           arel_column = model.arel_table[column_name]
           if value.nil?
             arel_column.not_eq(nil)
@@ -665,7 +665,7 @@ module OnlineMigrations
       __ensure_not_in_transaction!
 
       column_name = "#{ref_name}_id"
-      unless column_exists?(table_name, column_name)
+      if !column_exists?(table_name, column_name)
         type = options[:type] || (Utils.ar_version >= 5.1 ? :bigint : :integer)
         allow_null = options.fetch(:null, true)
         add_column(table_name, column_name, type, null: allow_null)

data/lib/online_migrations/utils.rb

@@ -139,7 +139,7 @@ module OnlineMigrations
       private_constant :FUNCTION_CALL_RE
 
       def volatile_default?(connection, type, value)
-        return false unless value.is_a?(Proc) || (type.to_s == "uuid" && value.is_a?(String))
+        return false if !(value.is_a?(Proc) || (type.to_s == "uuid" && value.is_a?(String)))
 
         value = value.call if value.is_a?(Proc)
         return false if !value.is_a?(String)

data/lib/online_migrations/verbose_sql_logs.rb

@@ -13,7 +13,13 @@ module OnlineMigrations
         stdout_logger.level = @activerecord_logger_was.level
         stdout_logger = ActiveSupport::TaggedLogging.new(stdout_logger)
 
-        combined_logger = stdout_logger.extend(ActiveSupport::Logger.broadcast(@activerecord_logger_was))
+        combined_logger =
+          # Broadcasting logs API was changed in https://github.com/rails/rails/pull/48615.
+          if Utils.ar_version >= 7.1
+            ActiveSupport::BroadcastLogger.new(stdout_logger, @activerecord_logger_was)
+          else
+            stdout_logger.extend(ActiveSupport::Logger.broadcast(@activerecord_logger_was))
+          end
 
         ActiveRecord::Base.logger = combined_logger
         set_verbose_query_logs(false)

data/lib/online_migrations/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OnlineMigrations
-  VERSION = "0.8.1"
+  VERSION = "0.9.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: online_migrations
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.9.0
 platform: ruby
 authors:
 - fatkodima
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-04 00:00:00.000000000 Z
+date: 2023-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -102,7 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Catch unsafe PostgreSQL migrations in development and run them easier in