online_migrations 0.7.3 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a2724653e4ab4ed21740b3975373aa11fb21e699c3836f4291bd83e5a6ca536
-  data.tar.gz: e5d4bde6ce0555c3fe0de7d728c1637a34a7fda07645afa7a2a78acae8f1e61c
+  metadata.gz: 46406fc60e15af6b4dfec0d548c6ca04f9dc3572eb544046e45f2dbd58cbf2eb
+  data.tar.gz: f969563b52c1dac70ede26c9a5bd2094295e93d5fc61e85056adec6b3b22fa69
 SHA512:
-  metadata.gz: 2790d7953dac93d9f75b4618235771882f630577d76bf301ad2483819aca17310d1e6ce460490230b5961e2f288410b4a2d2eaeda7684a6b44056967ff4f68dd
-  data.tar.gz: 7fdb6ea8f2f85cfa98d13a5d7a7d45ae8b3edc4097316519b950ab6ee6c930f27e8df0d2cc9a8d2948357615090994ef065bcd097346c34e7ab57887061d9f8e
+  metadata.gz: a7e728653580b3a1635b895c4b6efba8425f300a5a239ad8dd0f07cce06503e1f1a994597535c05b4946444c97f6f210c51ece0796799ac7fa8744ff93c1d48c
+  data.tar.gz: 917fc0a780b7bba7050b65c9cdcd1b5544afb87133078cdf833863b892459bc69ae657a365dd72bd5fd856a0a63a3862a4e19e3f9cd282c252a4a60b9415c19b

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## master (unreleased)
 
+## 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_column` with stored generated columns
+
 ## 0.7.3 (2023-05-30)
 
 - Fix removing columns having expression indexes on them

data/README.md

@@ -143,7 +143,9 @@ 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 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)
 - [hash indexes](#hash-indexes)
 - [adding multiple foreign keys](#adding-multiple-foreign-keys)
@@ -151,13 +153,17 @@ Potentially dangerous operations:
 - [mismatched reference column types](#mismatched-reference-column-types)
 - [adding a single table inheritance column](#adding-a-single-table-inheritance-column)
 
+Config-specific checks:
+
+- [changing the default value of a column](#changing-the-default-value-of-a-column)
+
 You can also add [custom checks](#custom-checks) or [disable specific checks](#disable-checks).
 
 ### Removing a column
 
 :x: **Bad**
 
-ActiveRecord caches database columns at runtime, so if you drop a column, it can cause exceptions until your app reboots.
+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]
@@ -172,12 +178,12 @@ end
 1. Ignore the column:
 
   ```ruby
-  # For ActiveRecord 5+
+  # For Active Record 5+
   class User < ApplicationRecord
     self.ignored_columns = ["name"]
   end
 
-  # For ActiveRecord < 5
+  # For Active Record < 5
   class User < ActiveRecord::Base
     def self.columns
       super.reject { |c| c.name == "name" }
@@ -241,7 +247,7 @@ end
 
 :x: **Bad**
 
-ActiveRecord 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/).
+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]
@@ -405,7 +411,7 @@ The technique is built on top of database views, using the following steps:
 
 1. Rename the table to some temporary name
 2. Create a VIEW using the old table name with addition of a new column as an alias of the old one
-3. Add a workaround for ActiveRecord's schema cache
+3. Add a workaround for Active Record's schema cache
 
 For the previous example, to rename `name` column to `first_name` of the `users` table, we can run:
 
@@ -416,9 +422,9 @@ CREATE VIEW users AS SELECT *, first_name AS name FROM users_column_rename;
 COMMIT;
 ```
 
-As database views do not expose the underlying table schema (default values, not null constraints, indexes, etc), further steps are needed to update the application to use the new table name. ActiveRecord heavily relies on this data, for example, to initialize new models.
+As database views do not expose the underlying table schema (default values, not null constraints, indexes, etc), further steps are needed to update the application to use the new table name. Active Record heavily relies on this data, for example, to initialize new models.
 
-To work around this limitation, we need to tell ActiveRecord to acquire this information from original table using the new table name.
+To work around this limitation, we need to tell Active Record to acquire this information from original table using the new table name.
 
 **Online Migrations** provides several helpers to implement column renaming:
 
@@ -460,12 +466,12 @@ end
   (is disabled by default in Active Record >= 7), then you need to ignore old column:
 
   ```ruby
-  # For ActiveRecord 5+
+  # For Active Record 5+
   class User < ApplicationRecord
     self.ignored_columns = ["name"]
   end
 
-  # For ActiveRecord < 5
+  # For Active Record < 5
   class User < ActiveRecord::Base
     def self.columns
       super.reject { |c| c.name == "name" }
@@ -521,7 +527,7 @@ The technique is built on top of database views, using the following steps:
 
 1. Rename the database table
 2. Create a VIEW using the old table name by pointing to the new table name
-3. Add a workaround for ActiveRecord's schema cache
+3. Add a workaround for Active Record's schema cache
 
 For the previous example, to rename `name` column to `first_name` of the `users` table, we can run:
 
@@ -532,9 +538,9 @@ CREATE VIEW clients AS SELECT * FROM users;
 COMMIT;
 ```
 
-As database views do not expose the underlying table schema (default values, not null constraints, indexes, etc), further steps are needed to update the application to use the new table name. ActiveRecord heavily relies on this data, for example, to initialize new models.
+As database views do not expose the underlying table schema (default values, not null constraints, indexes, etc), further steps are needed to update the application to use the new table name. Active Record heavily relies on this data, for example, to initialize new models.
 
-To work around this limitation, we need to tell ActiveRecord to acquire this information from original table using the new table name.
+To work around this limitation, we need to tell Active Record to acquire this information from original table using the new table name.
 
 **Online Migrations** provides several helpers to implement table renaming:
 
@@ -874,6 +880,46 @@ 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
+
+:x: **Bad**
+
+Adding a unique key blocks reads and writes while the underlying index is being built.
+
+```ruby
+class AddUniqueKey < ActiveRecord::Migration[7.1]
+  def change
+    add_unique_key :sections, :position, deferrable: :deferred
+  end
+end
+```
+
+:white_check_mark: **Good**
+
+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]
+  disable_ddl_transaction!
+
+  def change
+    add_index :sections, :position, unique: true, name: "index_sections_on_position", algorithm: :concurrently
+  end
+end
+```
+
+```ruby
+class AddUniqueKey < ActiveRecord::Migration[7.1]
+  def up
+    add_unique_key :sections, :position, deferrable: :deferred, using_index: "index_sections_on_position"
+  end
+
+  def down
+    remove_unique_key :sections, :position
+  end
+end
+```
+
 ### Adding a json column
 
 :x: **Bad**
@@ -900,11 +946,29 @@ class AddSettingsToProjects < ActiveRecord::Migration[7.0]
 end
 ```
 
+### Adding a stored generated column
+
+:x: **Bad**
+
+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]
+  def change
+    add_column :users, :lower_email, :virtual, type: :string, as: "LOWER(email)", stored: true
+  end
+end
+```
+
+:white_check_mark: **Good**
+
+Add a non-generated column and use callbacks or triggers instead.
+
 ### Using primary key with short integer type
 
 :x: **Bad**
 
-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 ActiveRecord < 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`.
+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]
@@ -1094,12 +1158,12 @@ A safer approach is to:
 1. ignore the column:
 
   ```ruby
-  # For ActiveRecord 5+
+  # For Active Record 5+
   class User < ApplicationRecord
     self.ignored_columns = ["type"]
   end
 
-  # For ActiveRecord < 5
+  # For Active Record < 5
   class User < ActiveRecord::Base
     def self.columns
       super.reject { |c| c.name == "type" }
@@ -1111,6 +1175,36 @@ A safer approach is to:
 3. remove the column ignoring from step 1 and apply initial code changes
 4. deploy
 
+### Changing the default value of a column
+
+:x: **Bad**
+
+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]
+  def change
+    change_column_default :users, :some_column, from: "old", to: "new"
+  end
+end
+
+User.create!(some_column: "old") # can insert "new"
+```
+
+:white_check_mark: **Good**
+
+Disable partial writes in `config/application.rb`. For Active Record < 7, use:
+
+```ruby
+config.active_record.partial_writes = false
+```
+
+For Active Record 7, use:
+
+```ruby
+config.active_record.partial_inserts = false
+```
+
 ## Assuring Safety
 
 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.
@@ -1143,7 +1237,7 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/fatkod
 
 ## Development
 
-After checking out the repo, run `bundle install` to install dependencies. Run `createdb online_migrations_test` to create a test database. Then, run `bundle exec rake test` to run the tests. This project uses multiple Gemfiles to test against multiple versions of ActiveRecord; you can run the tests against the specific version with `BUNDLE_GEMFILE=gemfiles/activerecord_61.gemfile bundle exec rake test`.
+After checking out the repo, run `bundle install` to install dependencies. Run `createdb online_migrations_test` to create a test database. Then, run `bundle exec rake test` to run the tests. This project uses multiple Gemfiles to test against multiple versions of Active Record; you can run the tests against the specific version with `BUNDLE_GEMFILE=gemfiles/activerecord_61.gemfile bundle exec rake test`.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 

data/docs/background_migrations.md

@@ -84,7 +84,7 @@ end
 # ...
 ```
 
-`enqueue_background_migration` accepts additional configuration options which controls how the background migration is run. Check the [source code](https://github.com/fatkodima/online_migrations/blob/master/lib/online_migrations/background_migrations/online_migrations.rb) for the list of all available configuration options.
+`enqueue_background_migration` accepts additional configuration options which controls how the background migration is run. Check the [source code](https://github.com/fatkodima/online_migrations/blob/master/lib/online_migrations/background_migrations/migration_helpers.rb) for the list of all available configuration options.
 
 ## Custom Background Migration Arguments
 

data/docs/configuring.md

@@ -114,7 +114,7 @@ To mark migrations as safe that were created before installing this gem, configu
 
 config.start_after = 20220101000000
 
-# or if you use multiple databases (ActiveRecord 6+)
+# or if you use multiple databases (Active Record 6+)
 config.start_after = { primary: 20211112000000, animals: 20220101000000 }
 ```
 
@@ -129,7 +129,7 @@ If your development database version is different from production, you can speci
 
 config.target_version = 10 # or "12.9" etc
 
-# or if you use multiple databases (ActiveRecord 6+)
+# or if you use multiple databases (Active Record 6+)
 config.target_version = { primary: 10, animals: 14.1 }
 ```
 

data/lib/online_migrations/background_migrations/copy_column.rb

@@ -43,7 +43,7 @@ module OnlineMigrations
           old_value = arel_table[from_column]
           if (type_cast_function = type_cast_functions[from_column])
             if Utils.ar_version <= 5.2
-              # ActiveRecord <= 5.2 does not support quoting of Arel::Nodes::NamedFunction
+              # Active Record <= 5.2 does not support quoting of Arel::Nodes::NamedFunction
               old_value = Arel.sql("#{type_cast_function}(#{connection.quote_column_name(from_column)})")
             else
               old_value = Arel::Nodes::NamedFunction.new(type_cast_function, [old_value])

data/lib/online_migrations/background_migrations/delete_orphaned_records.rb

@@ -12,7 +12,7 @@ module OnlineMigrations
       end
 
       def relation
-        # For ActiveRecord 6.1+ we can use `where.missing`
+        # For Active Record 6.1+ we can use `where.missing`
         # https://github.com/rails/rails/pull/34727
         associations.inject(model.unscoped) do |relation, association|
           reflection = model.reflect_on_association(association)
@@ -20,7 +20,7 @@ module OnlineMigrations
             raise ArgumentError, "'#{model.name}' has no association called '#{association}'"
           end
 
-          # left_joins was added in ActiveRecord 5.0 - https://github.com/rails/rails/pull/12071
+          # left_joins was added in Active Record 5.0 - https://github.com/rails/rails/pull/12071
           relation
             .left_joins(association)
             .where(reflection.table_name => { reflection.association_primary_key => nil })
@@ -31,7 +31,7 @@ module OnlineMigrations
         if Utils.ar_version > 5.0
           relation.delete_all
         else
-          # Older ActiveRecord generates incorrect query when running delete_all
+          # Older Active Record generates incorrect query when running delete_all
           primary_key = model.primary_key
           model.unscoped.where(primary_key => relation.select(primary_key)).delete_all
         end

data/lib/online_migrations/background_migrations/migration.rb

@@ -139,7 +139,7 @@ module OnlineMigrations
         # rubocop:disable Lint/UnreachableLoop
         iterator.each_batch(of: batch_size, column: batch_column_name, start: next_min_value) do |relation|
           if Utils.ar_version <= 4.2
-            # ActiveRecord <= 4.2 does not support pluck with Arel nodes
+            # Active Record <= 4.2 does not support pluck with Arel nodes
             quoted_column = self.class.connection.quote_column_name(batch_column_name)
             batch_range = relation.pluck("MIN(#{quoted_column}), MAX(#{quoted_column})").first
           else

data/lib/online_migrations/background_migrations/migration_helpers.rb

@@ -191,7 +191,7 @@ module OnlineMigrations
       # @see https://api.rubyonrails.org/classes/ActiveRecord/CounterCache/ClassMethods.html#method-i-reset_counters
       #
       # @note This method is better suited for large tables (10/100s of millions of records).
-      #     For smaller tables it is probably better and easier to use `reset_counters` from the ActiveRecord.
+      #     For smaller tables it is probably better and easier to use `reset_counters` from the Active Record.
       #
       def reset_counters_in_background(model_name, *counters, touch: nil, **options)
         model_name = model_name.name if model_name.is_a?(Class)
@@ -224,7 +224,7 @@ module OnlineMigrations
       #
       def delete_orphaned_records_in_background(model_name, *associations, **options)
         if Utils.ar_version <= 4.2
-          raise "#{__method__} does not support ActiveRecord <= 4.2 yet"
+          raise "#{__method__} does not support Active Record <= 4.2 yet"
         end
 
         model_name = model_name.name if model_name.is_a?(Class)

data/lib/online_migrations/background_migrations/migration_job.rb

@@ -12,7 +12,7 @@ module OnlineMigrations
 
       self.table_name = :background_migration_jobs
 
-      # For ActiveRecord <= 4.2 needs to fully specify enum values
+      # For Active Record <= 4.2 needs to fully specify enum values
       scope :active, -> { where(status: [statuses[:enqueued], statuses[:running]]) }
       scope :completed, -> { where(status: [statuses[:failed], statuses[:succeeded]]) }
       scope :stuck, -> do
@@ -45,7 +45,7 @@ module OnlineMigrations
 
       belongs_to :migration
 
-      # For ActiveRecord 5.0+ this is validated by default from belongs_to
+      # For Active Record 5.0+ this is validated by default from belongs_to
       validates :migration, presence: true
 
       validates :min_value, :max_value, presence: true, numericality: { greater_than: 0 }

data/lib/online_migrations/background_migrations/reset_counters.rb

@@ -41,7 +41,7 @@ module OnlineMigrations
           names = Array.wrap(names)
           options = names.extract_options!
           touch_updates = touch_attributes_with_time(*names, **options)
-          # In ActiveRecord 4.2 sanitize_sql_for_assignment is protected
+          # In Active Record 4.2 sanitize_sql_for_assignment is protected
           updates << model.send(:sanitize_sql_for_assignment, touch_updates)
         end
 
@@ -65,7 +65,7 @@ module OnlineMigrations
             has_many_association = has_many.find do |association|
               counter_cache_column = association.counter_cache_column
 
-              # ActiveRecord <= 4.2 is able to return only explicitly provided `counter_cache` column.
+              # Active Record <= 4.2 is able to return only explicitly provided `counter_cache` column.
               if !counter_cache_column && Utils.ar_version <= 4.2
                 counter_cache_column = "#{association.name}_count"
               end

data/lib/online_migrations/command_checker.rb

@@ -13,6 +13,7 @@ module OnlineMigrations
       @migration = migration
       @safe = false
       @new_tables = []
+      @new_columns = []
       @lock_timeout_checked = false
       @foreign_key_tables = Set.new
       @removed_indexes = []
@@ -116,7 +117,13 @@ module OnlineMigrations
           check_columns_removal(command, *args, **options)
         else
           if respond_to?(command, true)
-            send(command, *args, **options, &block)
+            if options.any?
+              # Workaround for Active Record < 5 change_column_default
+              # not accepting options.
+              send(command, *args, **options, &block)
+            else
+              send(command, *args, &block)
+            end
           else
             # assume it is safe
             true
@@ -173,19 +180,30 @@ module OnlineMigrations
       end
 
       def add_column(table_name, column_name, type, **options)
+        type = type.to_sym
         default = options[:default]
         volatile_default = false
-        if !new_or_small_table?(table_name) && options.key?(:default) &&
-           (postgresql_version < Gem::Version.new("11") || (!default.nil? && (volatile_default = Utils.volatile_default?(connection, type, default))))
 
-          if default.nil?
-            raise_error :add_column_with_default_null,
-              code: command_str(:add_column, table_name, column_name, type, options.except(:default))
-          else
-            raise_error :add_column_with_default,
-              code: command_str(:add_column_with_default, table_name, column_name, type, options),
-              not_null: options[:null] == false,
-              volatile_default: volatile_default
+        # Keep track of new columns for change_column_default check.
+        @new_columns << [table_name.to_s, column_name.to_s]
+
+        if !new_or_small_table?(table_name)
+          if options.key?(:default) &&
+             (postgresql_version < Gem::Version.new("11") || (!default.nil? && (volatile_default = Utils.volatile_default?(connection, type, default))))
+
+            if default.nil?
+              raise_error :add_column_with_default_null,
+                code: command_str(:add_column, table_name, column_name, type, options.except(:default))
+            else
+              raise_error :add_column_with_default,
+                code: command_str(:add_column_with_default, table_name, column_name, type, options),
+                not_null: options[:null] == false,
+                volatile_default: volatile_default
+            end
+          end
+
+          if type == :virtual && options[:stored]
+            raise_error :add_column_generated_stored
           end
         end
 
@@ -201,6 +219,8 @@ module OnlineMigrations
       end
 
       def add_column_with_default(table_name, column_name, type, **options)
+        type = type.to_sym
+
         if type == :json
           raise_error :add_column_json,
             code: command_str(:add_column_with_default, table_name, column_name, :jsonb, options)
@@ -333,6 +353,13 @@ module OnlineMigrations
         end
       end
 
+      def change_column_default(table_name, column_name, _default_or_changes)
+        if Utils.ar_partial_writes? && !new_column?(table_name, column_name)
+          raise_error :change_column_default,
+            config: Utils.ar_partial_writes_setting
+        end
+      end
+
       def change_column_null(table_name, column_name, allow_null, default = nil, **)
         if !allow_null && !new_or_small_table?(table_name)
           safe = false
@@ -406,6 +433,9 @@ module OnlineMigrations
       end
 
       def add_timestamps(table_name, **options)
+        @new_columns << [table_name.to_s, "created_at"]
+        @new_columns << [table_name.to_s, "updated_at"]
+
         volatile_default = false
         if !new_or_small_table?(table_name) && !options[:default].nil? &&
            (postgresql_version < Gem::Version.new("11") || (volatile_default = Utils.volatile_default?(connection, :datetime, options[:default])))
@@ -448,7 +478,7 @@ module OnlineMigrations
         end
 
         unless options[:polymorphic]
-          type = options[:type] || (Utils.ar_version >= 5.1 ? :bigint : :integer)
+          type = (options[:type] || (Utils.ar_version >= 5.1 ? :bigint : :integer)).to_sym
           column_name = "#{ref_name}_id"
 
           foreign_key_options = foreign_key.is_a?(Hash) ? foreign_key : {}
@@ -545,6 +575,33 @@ module OnlineMigrations
         end
       end
 
+      def add_unique_key(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,
+          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)
+      end
+
+      # Implementation is from Active Record
+      def index_name(table_name, column_name)
+        max_index_name_size = 62
+        name = "index_#{table_name}_on_#{Array(column_name) * '_and_'}"
+        return name if name.bytesize <= max_index_name_size
+
+        # Fallback to short version, add hash to ensure uniqueness
+        hashed_identifier = "_#{OpenSSL::Digest::SHA256.hexdigest(name).first(10)}"
+        name = "idx_on_#{Array(column_name) * '_'}"
+
+        short_limit = max_index_name_size - hashed_identifier.bytesize
+        short_name = name[0, short_limit]
+
+        "#{short_name}#{hashed_identifier}"
+      end
+
       def validate_constraint(*)
         if crud_blocked?
           raise_error :validate_constraint
@@ -619,6 +676,10 @@ module OnlineMigrations
         @new_tables.include?(table_name.to_s)
       end
 
+      def new_column?(table_name, column_name)
+        new_table?(table_name) || @new_columns.include?([table_name.to_s, column_name.to_s])
+      end
+
       def small_table?(table_name)
         OnlineMigrations.config.small_tables.include?(table_name.to_s)
       end
@@ -768,7 +829,7 @@ module OnlineMigrations
         connection.columns(table_name).find { |column| column.name == column_name.to_s }
       end
 
-      # From ActiveRecord
+      # From Active Record
       def derive_join_table_name(table1, table2)
         [table1.to_s, table2.to_s].sort.join("\0").gsub(/^(.*_)(.+)\0\1(.+)/, '\1\2_\3').tr("\0", "_")
       end

data/lib/online_migrations/error_messages.rb

@@ -84,6 +84,10 @@ class <%= migration_name %> < <%= migration_parent %>
   end
 end",
 
+      add_column_generated_stored:
+"Adding a stored generated column blocks reads and writes while the entire table is rewritten.
+Add a non-generated column and use callbacks or triggers instead.",
+
       add_column_json:
 "There's no equality operator for the json column type, which can cause errors for
 existing SELECT DISTINCT queries in your application. Use jsonb instead.
@@ -131,6 +135,7 @@ migration_helpers provides a safer approach to do this:
     }
   }
 <% unless partial_writes %>
+
   NOTE: You also need to temporarily enable partial writes (is disabled by default in Active Record >= 7)
   until the process of column rename is fully done.
   # config/application.rb
@@ -243,6 +248,13 @@ which will be passed to `add_column` when creating a new column, so you can over
 
 6. Deploy",
 
+      change_column_default:
+"Partial writes are enabled, which can cause incorrect values
+to be inserted when changing the default value of a column.
+Disable partial writes in config/application.rb:
+
+config.active_record.<%= config %> = false",
+
       change_column_null:
 "Setting NOT NULL on an existing column blocks reads and writes while every row is checked.
 A safer approach is to add a NOT NULL check constraint and validate it in a separate transaction.
@@ -286,7 +298,7 @@ class <%= migration_name %>RemoveIndexes < <%= migration_parent %>
   end
 end
 <% else %>
-ActiveRecord caches database columns at runtime, so if you drop a column, it can cause exceptions until your app reboots.
+Active Record caches database columns at runtime, so if you drop a column, it can cause exceptions until your app reboots.
 A safer approach is to:
 
 1. Ignore the column(s):
@@ -426,6 +438,28 @@ 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.
+
+class <%= migration_name %>AddIndex < <%= migration_parent %>
+  disable_ddl_transaction!
+
+  def change
+    <%= add_index_code %>
+  end
+end
+
+class <%= migration_name %> < <%= migration_parent %>
+  def up
+    <%= add_code %>
+  end
+
+  def down
+    <%= remove_code %>
+  end
+end",
+
       validate_constraint:
 "Validating a constraint while holding heavy locks on tables is dangerous.
 Use disable_ddl_transaction! or a separate migration.",

data/lib/online_migrations/lock_retrier.rb

@@ -96,7 +96,7 @@ module OnlineMigrations
         else
           yield
         end
-      # ActiveRecord::LockWaitTimeout can be used for ActiveRecord 5.2+
+      # ActiveRecord::LockWaitTimeout can be used for Active Record 5.2+
       rescue ActiveRecord::StatementInvalid => e
         if lock_timeout_error?(e) && current_attempt <= attempts
           current_delay = delay(current_attempt)

data/lib/online_migrations/schema_cache.rb

@@ -49,7 +49,7 @@ module OnlineMigrations
         super(column_rename_table(name))
       end
 
-      super(name)
+      super
     end
 
     private
@@ -73,9 +73,90 @@ module OnlineMigrations
       def duplicate_column(old_column_name, new_column_name, columns)
         old_column = columns.find { |column| column.name == old_column_name }
         new_column = old_column.dup
-        # ActiveRecord defines only reader for :name
+        # Active Record defines only reader for :name
         new_column.instance_variable_set(:@name, new_column_name)
-        # Correspond to the ActiveRecord freezing of each column
+        # Correspond to the Active Record freezing of each column
+        columns << new_column.freeze
+      end
+  end
+
+  # @private
+  module SchemaCache7
+    # Active Record >= 7.1 changed signature of the methods,
+    # see https://github.com/rails/rails/pull/48716.
+    def primary_keys(connection, table_name)
+      if (renamed_table = renamed_table?(connection, table_name))
+        super(connection, renamed_table)
+      elsif renamed_column?(connection, table_name)
+        super(connection, column_rename_table(table_name))
+      else
+        super
+      end
+    end
+
+    def columns(connection, table_name)
+      if (renamed_table = renamed_table?(connection, table_name))
+        super(connection, renamed_table)
+      elsif renamed_column?(connection, table_name)
+        columns = super(connection, column_rename_table(table_name))
+        OnlineMigrations.config.column_renames[table_name].each do |old_column_name, new_column_name|
+          duplicate_column(old_column_name, new_column_name, columns)
+        end
+        columns
+      else
+        super.reject { |column| column.name.end_with?("_for_type_change") }
+      end
+    end
+
+    def indexes(connection, table_name)
+      # Available only in Active Record 6.0+
+      return if !defined?(super)
+
+      if (renamed_table = renamed_table?(connection, table_name))
+        super(connection, renamed_table)
+      elsif renamed_column?(connection, table_name)
+        super(connection, column_rename_table(table_name))
+      else
+        super
+      end
+    end
+
+    def clear_data_source_cache!(connection, name)
+      if (renamed_table = renamed_table?(connection, name))
+        super(connection, renamed_table)
+      end
+
+      if renamed_column?(connection, name)
+        super(connection, column_rename_table(name))
+      end
+
+      super
+    end
+
+    private
+      def renamed_table?(connection, table_name)
+        table_renames = OnlineMigrations.config.table_renames
+        if table_renames.key?(table_name)
+          views = connection.views
+          table_renames[table_name] if views.include?(table_name)
+        end
+      end
+
+      def renamed_column?(connection, table_name)
+        column_renames = OnlineMigrations.config.column_renames
+        column_renames.key?(table_name) && connection.views.include?(table_name)
+      end
+
+      def column_rename_table(table_name)
+        "#{table_name}_column_rename"
+      end
+
+      def duplicate_column(old_column_name, new_column_name, columns)
+        old_column = columns.find { |column| column.name == old_column_name }
+        new_column = old_column.dup
+        # Active Record defines only reader for :name
+        new_column.instance_variable_set(:@name, new_column_name)
+        # Correspond to the Active Record freezing of each column
         columns << new_column.freeze
       end
   end

data/lib/online_migrations/schema_statements.rb

@@ -102,7 +102,7 @@ module OnlineMigrations
           if Utils.ar_version <= 5.2
             columns_and_values.map do |(column_name, value)|
               rhs =
-                # ActiveRecord <= 5.2 can't quote these - we need to handle these cases manually
+                # Active Record <= 5.2 can't quote these - we need to handle these cases manually
                 case value
                 when Arel::Attributes::Attribute
                   quote_column_name(value.name)
@@ -138,7 +138,7 @@ module OnlineMigrations
     # The technique is built on top of database views, using the following steps:
     #   1. Rename the table to some temporary name
     #   2. Create a VIEW using the old table name with addition of a new column as an alias of the old one
-    #   3. Add a workaround for ActiveRecord's schema cache
+    #   3. Add a workaround for Active Record's schema cache
     #
     # For example, to rename `name` column to `first_name` of the `users` table, we can run:
     #
@@ -149,9 +149,9 @@ module OnlineMigrations
     #
     # As database views do not expose the underlying table schema (default values, not null constraints,
     # indexes, etc), further steps are needed to update the application to use the new table name.
-    # ActiveRecord heavily relies on this data, for example, to initialize new models.
+    # Active Record heavily relies on this data, for example, to initialize new models.
     #
-    # To work around this limitation, we need to tell ActiveRecord to acquire this information
+    # To work around this limitation, we need to tell Active Record to acquire this information
     # from original table using the new table name (see notes).
     #
     # @param table_name [String, Symbol] table name
@@ -165,7 +165,7 @@ module OnlineMigrations
     #
     # @note
     #   Prior to using this method, you need to register the database table so that
-    #   it instructs ActiveRecord to fetch the database table information (for SchemaCache)
+    #   it instructs Active Record to fetch the database table information (for SchemaCache)
     #   using the original table name (if it's present). Otherwise, fall back to the old table name:
     #
     #   ```OnlineMigrations.config.column_renames[table_name] = { old_column_name => new_column_name }```
@@ -298,7 +298,7 @@ module OnlineMigrations
     # The technique is built on top of database views, using the following steps:
     #   1. Rename the database table
     #   2. Create a database view using the old table name by pointing to the new table name
-    #   3. Add a workaround for ActiveRecord's schema cache
+    #   3. Add a workaround for Active Record's schema cache
     #
     # For example, to rename `clients` table name to `users`, we can run:
     #
@@ -309,9 +309,9 @@ module OnlineMigrations
     #
     # As database views do not expose the underlying table schema (default values, not null constraints,
     # indexes, etc), further steps are needed to update the application to use the new table name.
-    # ActiveRecord heavily relies on this data, for example, to initialize new models.
+    # Active Record heavily relies on this data, for example, to initialize new models.
     #
-    # To work around this limitation, we need to tell ActiveRecord to acquire this information
+    # To work around this limitation, we need to tell Active Record to acquire this information
     # from original table using the new table name (see notes).
     #
     # @param table_name [String, Symbol]
@@ -324,7 +324,7 @@ module OnlineMigrations
     #
     # @note
     #   Prior to using this method, you need to register the database table so that
-    #   it instructs ActiveRecord to fetch the database table information (for SchemaCache)
+    #   it instructs Active Record to fetch the database table information (for SchemaCache)
     #   using the new table name (if it's present). Otherwise, fall back to the old table name:
     #
     #   ```
@@ -638,7 +638,7 @@ module OnlineMigrations
 
     # Adds a reference to the table with minimal locking
     #
-    # ActiveRecord adds an index non-`CONCURRENTLY` to references by default, which blocks writes.
+    # Active Record adds an index non-`CONCURRENTLY` to references by default, which blocks writes.
     # It also adds a validated foreign key by default, which blocks writes on both tables while
     # validating existing rows.
     #
@@ -730,7 +730,7 @@ module OnlineMigrations
       end
     end
 
-    # Extends default method to be idempotent and accept `:algorithm` option for ActiveRecord <= 4.2.
+    # Extends default method to be idempotent and accept `:algorithm` option for Active Record <= 4.2.
     #
     # @see https://edgeapi.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-remove_index
     #
@@ -760,7 +760,7 @@ module OnlineMigrations
           # It only conflicts with constraint validations, other creating/removing indexes,
           # and some "ALTER TABLE"s.
 
-          # ActiveRecord <= 4.2 does not support removing indexes concurrently
+          # Active Record <= 4.2 does not support removing indexes concurrently
           if Utils.ar_version <= 4.2 && algorithm == :concurrently
             execute("DROP INDEX CONCURRENTLY #{quote_table_name(index_name)}")
           else
@@ -773,7 +773,7 @@ module OnlineMigrations
       end
     end
 
-    # Extends default method to be idempotent and accept `:validate` option for ActiveRecord < 5.2.
+    # Extends default method to be idempotent and accept `:validate` option for Active Record < 5.2.
     #
     # @see https://edgeapi.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_foreign_key
     #
@@ -785,7 +785,7 @@ module OnlineMigrations
 
         Utils.say(message)
       else
-        # ActiveRecord >= 5.2 supports adding non-validated foreign keys natively
+        # Active Record >= 5.2 supports adding non-validated foreign keys natively
         options = options.dup
         options[:column] ||= "#{to_table.to_s.singularize}_id"
         options[:primary_key] ||= "id"
@@ -812,7 +812,7 @@ module OnlineMigrations
     # Extends default method with disabled statement timeout while validation is run
     #
     # @see https://edgeapi.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/PostgreSQL/SchemaStatements.html#method-i-validate_foreign_key
-    # @note This method was added in ActiveRecord 5.2
+    # @note This method was added in Active Record 5.2
     #
     def validate_foreign_key(from_table, to_table = nil, **options)
       fk_name_to_validate = __foreign_key_for!(from_table, to_table: to_table, **options).name
@@ -835,7 +835,7 @@ module OnlineMigrations
     # Extends default method to be idempotent
     #
     # @see https://edgeapi.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_check_constraint
-    # @note This method was added in ActiveRecord 6.1
+    # @note This method was added in Active Record 6.1
     #
     def add_check_constraint(table_name, expression, validate: true, **options)
       constraint_name = __check_constraint_name(table_name, expression: expression, **options)
@@ -857,7 +857,7 @@ module OnlineMigrations
     # Extends default method with disabled statement timeout while validation is run
     #
     # @see https://edgeapi.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/PostgreSQL/SchemaStatements.html#method-i-validate_check_constraint
-    # @note This method was added in ActiveRecord 6.1
+    # @note This method was added in Active Record 6.1
     #
     def validate_check_constraint(table_name, **options)
       constraint_name = __check_constraint_name!(table_name, **options)
@@ -878,7 +878,7 @@ module OnlineMigrations
 
     if Utils.ar_version < 6.1
       # @see https://edgeapi.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-remove_check_constraint
-      # @note This method was added in ActiveRecord 6.1
+      # @note This method was added in Active Record 6.1
       #
       def remove_check_constraint(table_name, expression = nil, **options)
         constraint_name = __check_constraint_name!(table_name, expression: expression, **options)
@@ -963,7 +963,7 @@ module OnlineMigrations
 
     private
       # Private methods are prefixed with `__` to avoid clashes with existing or future
-      # ActiveRecord methods
+      # Active Record methods
       def __ensure_not_in_transaction!(method_name = caller[0])
         if transaction_open?
           raise <<-MSG.strip_heredoc
@@ -1016,7 +1016,7 @@ module OnlineMigrations
       end
 
       def __index_valid?(index_name, schema:)
-        # ActiveRecord <= 4.2 returns a string, instead of automatically casting to boolean
+        # Active Record <= 4.2 returns a string, instead of automatically casting to boolean
         valid = select_value <<-SQL.strip_heredoc
           SELECT indisvalid
           FROM pg_index i

data/lib/online_migrations/version.rb

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

data/lib/online_migrations.rb

@@ -22,9 +22,13 @@ module OnlineMigrations
   autoload :IndexDefinition
   autoload :IndexesCollector
   autoload :CommandChecker
-  autoload :SchemaCache
   autoload :BackgroundMigration
 
+  autoload_at "online_migrations/schema_cache" do
+    autoload :SchemaCache
+    autoload :SchemaCache7
+  end
+
   autoload_at "online_migrations/lock_retrier" do
     autoload :LockRetrier
     autoload :ConstantLockRetrier
@@ -79,9 +83,14 @@ module OnlineMigrations
       ActiveRecord::Migrator.prepend(OnlineMigrations::Migrator)
 
       ActiveRecord::Tasks::DatabaseTasks.singleton_class.prepend(OnlineMigrations::DatabaseTasks)
-      ActiveRecord::ConnectionAdapters::SchemaCache.prepend(OnlineMigrations::SchemaCache)
       ActiveRecord::Migration::CommandRecorder.include(OnlineMigrations::CommandRecorder)
 
+      if OnlineMigrations::Utils.ar_version >= 7.1
+        ActiveRecord::ConnectionAdapters::SchemaCache.prepend(OnlineMigrations::SchemaCache7)
+      else
+        ActiveRecord::ConnectionAdapters::SchemaCache.prepend(OnlineMigrations::SchemaCache)
+      end
+
       if OnlineMigrations::Utils.ar_version <= 5.1
         ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.prepend(OnlineMigrations::ForeignKeyDefinition)
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: online_migrations
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.8.0
 platform: ruby
 authors:
 - fatkodima
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-30 00:00:00.000000000 Z
+date: 2023-07-24 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.12
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: Catch unsafe PostgreSQL migrations in development and run them easier in