online_migrations 0.9.2 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 579a0db844c82c2c9153a1a3f44bfcffe929011112b132afe73b1dfdf68f4583
-  data.tar.gz: b88f26034f0c1d044607ef191ca3feae71e3c6093cb05bd9a277790447da01af
+  metadata.gz: 966629fafbc4d8c9de88240bc705799f66ab205754cd1acc99a1ae129d737de5
+  data.tar.gz: 61379d6eeec17e532314551d5a643ed465ba23bac69739be063f2fd704657451
 SHA512:
-  metadata.gz: 229a2a31c44a358425a684ea8d1771d98ecee6412c9b4480e30e2cd68e53c0c9e77039959fa8f379ad0a83fb9f592d133d29fe43e2c79ae4dbf674cd9c210598
-  data.tar.gz: 9255d5ad7b7d350021cc553b5d91bec852cfbecc0b9c7d6296606beffae266de72096cdf5a4d12dd88d921fb0af60a9e870d08a676a90fad552c5bd2d36096f6
+  metadata.gz: ae49cb8499bc7b086d9b1883106926d150a1227f495e1aff7e1f259197d68065a20b819797d5e7c9199d413be746e9deb94f7c9bc6005a53b9b94bbefd2d88cb
+  data.tar.gz: 4c36ad512328174d04600b7d10001721ed985ab73184cbfd7c2f2cde70788a32ef4a4e8de754134206510b29e17920da06820903f86a809766aa3c5aa4005408

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## master (unreleased)
 
+## 0.10.0 (2023-12-12)
+
+- Add `auto_analyze` configuration option
+- Add `alphabetize_schema` configuration option
+- Fix `backfill_column_for_type_change_in_background` for cast expressions
+- Fix copying indexes with long names when changing column type
+- Enhance error messages with the link to the detailed description
+
 ## 0.9.2 (2023-11-02)
 
 - Fix checking which expression indexes to copy when changing column type

data/README.md

@@ -90,7 +90,7 @@ class AddAdminToUsers < ActiveRecord::Migration[7.1]
     execute "SET statement_timeout TO '5s'"
     change_column_null :users, :admin, false
   end
-  
+
   def down
     remove_column :users, :admin
   end
@@ -177,30 +177,30 @@ end
 
 1. Ignore the column:
 
-  ```ruby
-  # For Active Record 5+
-  class User < ApplicationRecord
-    self.ignored_columns = ["name"]
-  end
+   ```ruby
+   # For Active Record 5+
+   class User < ApplicationRecord
+     self.ignored_columns = ["name"]
+   end
 
-  # For Active Record < 5
-  class User < ActiveRecord::Base
-    def self.columns
-      super.reject { |c| c.name == "name" }
-    end
-  end
-  ```
+   # For Active Record < 5
+   class User < ActiveRecord::Base
+     def self.columns
+       super.reject { |c| c.name == "name" }
+     end
+   end
+   ```
 
 2. Deploy
 3. Wrap column removing in a `safety_assured` block:
 
-  ```ruby
-  class RemoveNameFromUsers < ActiveRecord::Migration[7.1]
-    def change
-      safety_assured { remove_column :users, :name }
-    end
-  end
-  ```
+   ```ruby
+   class RemoveNameFromUsers < ActiveRecord::Migration[7.1]
+     def change
+       safety_assured { remove_column :users, :name }
+     end
+   end
+   ```
 
 4. Remove column ignoring from `User` model
 5. Deploy
@@ -322,59 +322,59 @@ 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.1]
-    def change
-      initialize_column_type_change :files, :size, :bigint
-    end
-  end
-  ```
+   ```ruby
+   class InitializeChangeFilesSizeType < ActiveRecord::Migration[7.1]
+     def change
+       initialize_column_type_change :files, :size, :bigint
+     end
+   end
+   ```
 
-**Note**: `initialize_column_type_change` accepts additional options (like `:limit`, `:default` etc)
-which will be passed to `add_column` when creating a new column, so you can override previous values.
+   **Note**: `initialize_column_type_change` accepts additional options (like `:limit`, `:default` etc)
+   which will be passed to `add_column` when creating a new column, so you can override previous values.
 
 2. Backfill data from the old column to the new column:
 
-  ```ruby
-  class BackfillChangeFilesSizeType < ActiveRecord::Migration[7.1]
-    disable_ddl_transaction!
+   ```ruby
+   class BackfillChangeFilesSizeType < ActiveRecord::Migration[7.1]
+     disable_ddl_transaction!
 
-    def up
-      backfill_column_for_type_change :files, :size
-    end
+     def up
+       backfill_column_for_type_change :files, :size
+     end
 
-    def down
-      # no op
-    end
-  end
-  ```
+     def down
+       # no op
+     end
+   end
+   ```
 
 3. Copy indexes, foreign keys, check constraints, NOT NULL constraint, swap new column in place:
 
-  ```ruby
-  class FinalizeChangeFilesSizeType < ActiveRecord::Migration[7.1]
-    disable_ddl_transaction!
+   ```ruby
+   class FinalizeChangeFilesSizeType < ActiveRecord::Migration[7.1]
+     disable_ddl_transaction!
 
-    def change
-      finalize_column_type_change :files, :size
-    end
-  end
-  ```
+     def change
+       finalize_column_type_change :files, :size
+     end
+   end
+   ```
 
 4. Deploy
 5. Finally, if everything is working as expected, remove copy trigger and old column:
 
-  ```ruby
-  class CleanupChangeFilesSizeType < ActiveRecord::Migration[7.1]
-    def up
-      cleanup_column_type_change :files, :size
-    end
+   ```ruby
+   class CleanupChangeFilesSizeType < ActiveRecord::Migration[7.1]
+     def up
+       cleanup_column_type_change :files, :size
+     end
 
-    def down
-      initialize_column_type_change :files, :size, :integer
-    end
-  end
-  ```
+     def down
+       initialize_column_type_change :files, :size, :integer
+     end
+   end
+   ```
 
 6. Deploy
 
@@ -430,67 +430,69 @@ To work around this limitation, we need to tell Active Record to acquire this in
 
 1. Instruct Rails that you are going to rename a column:
 
-```ruby
-OnlineMigrations.config.column_renames = {
-  "users" => {
-    "name" => "first_name"
-  }
-}
-```
-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.
-```ruby
-# config/application.rb
-# For Active Record >= 7
-config.active_record.partial_inserts = true
+   ```ruby
+   OnlineMigrations.config.column_renames = {
+     "users" => {
+       "name" => "first_name"
+     }
+   }
+   ```
 
-# Or for Active Record < 7
-config.active_record.partial_writes = true
-```
+   **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.
+
+   ```ruby
+   # config/application.rb
+   # For Active Record >= 7
+   config.active_record.partial_inserts = true
+
+   # Or for Active Record < 7
+   config.active_record.partial_writes = true
+   ```
 
 2. Deploy
 3. Tell the database that you are going to rename a column. This will not actually rename any columns,
 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.1]
-  def change
-    initialize_column_rename :users, :name, :first_name
-  end
-end
-```
+   ```ruby
+   class InitializeRenameUsersNameToFirstName < ActiveRecord::Migration[7.1]
+     def change
+       initialize_column_rename :users, :name, :first_name
+     end
+   end
+   ```
 
 4. Replace usages of the old column with a new column in the codebase
 5. If you enabled Active Record `enumerate_columns_in_select_statements` setting in your application
-  (is disabled by default in Active Record >= 7), then you need to ignore old column:
-
-  ```ruby
-  # For Active Record 5+
-  class User < ApplicationRecord
-    self.ignored_columns = ["name"]
-  end
-
-  # For Active Record < 5
-  class User < ActiveRecord::Base
-    def self.columns
-      super.reject { |c| c.name == "name" }
-    end
-  end
-  ```
+   (is disabled by default in Active Record >= 7), then you need to ignore old column:
+
+   ```ruby
+   # For Active Record 5+
+   class User < ApplicationRecord
+     self.ignored_columns = ["name"]
+   end
+
+   # For Active Record < 5
+   class User < ActiveRecord::Base
+     def self.columns
+       super.reject { |c| c.name == "name" }
+     end
+   end
+   ```
 
 6. Deploy
 7. Remove the column rename config from step 1
 8. Remove the column ignore from step 5, if added
 9. Remove the VIEW created in step 3 and finally rename the column:
 
-```ruby
-class FinalizeRenameUsersNameToFirstName < ActiveRecord::Migration[7.1]
-  def change
-    finalize_column_rename :users, :name, :first_name
-  end
-end
-```
+   ```ruby
+   class FinalizeRenameUsersNameToFirstName < ActiveRecord::Migration[7.1]
+     def change
+       finalize_column_rename :users, :name, :first_name
+     end
+   end
+   ```
 
 10. Deploy
 
@@ -546,35 +548,35 @@ To work around this limitation, we need to tell Active Record to acquire this in
 
 1. Instruct Rails that you are going to rename a table:
 
-```ruby
-OnlineMigrations.config.table_renames = {
-  "clients" => "users"
-}
-```
+   ```ruby
+   OnlineMigrations.config.table_renames = {
+     "clients" => "users"
+   }
+   ```
 
 2. Deploy
 3. Create a VIEW:
 
-```ruby
-class InitializeRenameClientsToUsers < ActiveRecord::Migration[7.1]
-  def change
-    initialize_table_rename :clients, :users
-  end
-end
-```
+   ```ruby
+   class InitializeRenameClientsToUsers < ActiveRecord::Migration[7.1]
+     def change
+       initialize_table_rename :clients, :users
+     end
+   end
+   ```
 
 4. Replace usages of the old table with a new table in the codebase
 5. Remove the table rename config from step 1
 6. Deploy
 7. Remove the VIEW created in step 3:
 
-```ruby
-class FinalizeRenameClientsToUsers < ActiveRecord::Migration[7.1]
-  def change
-    finalize_table_rename :clients, :users
-  end
-end
-```
+   ```ruby
+   class FinalizeRenameClientsToUsers < ActiveRecord::Migration[7.1]
+     def change
+       finalize_table_rename :clients, :users
+     end
+   end
+   ```
 
 8. Deploy
 
@@ -1157,19 +1159,19 @@ A safer approach is to:
 
 1. ignore the column:
 
-  ```ruby
-  # For Active Record 5+
-  class User < ApplicationRecord
-    self.ignored_columns = ["type"]
-  end
+   ```ruby
+   # For Active Record 5+
+   class User < ApplicationRecord
+     self.ignored_columns = ["type"]
+   end
 
-  # For Active Record < 5
-  class User < ActiveRecord::Base
-    def self.columns
-      super.reject { |c| c.name == "type" }
-    end
-  end
-  ```
+   # For Active Record < 5
+   class User < ActiveRecord::Base
+     def self.columns
+       super.reject { |c| c.name == "type" }
+     end
+   end
+   ```
 
 2. deploy
 3. remove the column ignoring from step 1 and apply initial code changes
@@ -1281,18 +1283,18 @@ The main differences are:
 
 1. `strong_migrations` provides you **text guidance** on how to run migrations safer and you should implement them yourself. This new gem has actual [**code helpers**](https://github.com/fatkodima/online_migrations/blob/master/lib/online_migrations/schema_statements.rb) (and suggests them when fails on unsafe migrations) you can use to do what you want. See [example](#example) for an example.
 
-It has migrations helpers for:
+   It has migrations helpers for:
 
-* renaming tables/columns
-* changing columns types (including changing primary/foreign keys from `integer` to `bigint`)
-* adding columns with default values
-* backfilling data
-* adding different types of constraints
-* and others
+     * renaming tables/columns
+     * changing columns types (including changing primary/foreign keys from `integer` to `bigint`)
+     * adding columns with default values
+     * backfilling data
+     * adding different types of constraints
+     * and others
 
 2. This gem has a [powerful internal framework](https://github.com/fatkodima/online_migrations/blob/master/docs/background_migrations.md) for running data migrations on very large tables using background migrations.
 
-For example, you can use background migrations to migrate data that’s stored in a single JSON column to a separate table instead; backfill values from one column to another (as one of the steps when changing column type); or backfill some column’s value from an API.
+   For example, you can use background migrations to migrate data that’s stored in a single JSON column to a separate table instead; backfill values from one column to another (as one of the steps when changing column type); or backfill some column’s value from an API.
 
 3. Yet, it has more checks for unsafe changes (see [checks](#checks)).
 

data/docs/background_migrations.md

@@ -137,17 +137,18 @@ require "test_helper"
 module OnlineMigrations
   module BackgroundMigrations
     class BackfillProjectIssuesCountTest < ActiveSupport::TestCase
-      test "#process_batch performs a background migration iteration" do
-        rails = Project.create!(name: "rails")
+      test "#process_batch performs an iteration" do
+        rails = Project.create!(name: "Ruby on Rails")
         postgres = Project.create!(name: "PostgreSQL")
 
         2.times { rails.issues.create! }
-        _postgres_issue = postgres.issues.create!
+        postgres.issues.create!
 
-        BackfillProjectIssuesCount.new.process_batch(Project.all)
+        migration = BackfillProjectIssuesCount.new
+        migration.process_batch(migration.relation)
 
-        assert_equal 2, rails.issues_count
-        assert_equal 1, postgres.issues_count
+        assert_equal 2, rails.reload.issues_count
+        assert_equal 1, postgres.reload.issues_count
       end
     end
   end

data/docs/configuring.md

@@ -3,6 +3,8 @@
 There are a few configurable options for the gem. Custom configurations should be placed in a `online_migrations.rb` initializer.
 
 ```ruby
+# config/initializers/online_migrations.rb
+
 OnlineMigrations.configure do |config|
   # ...
 end
@@ -15,8 +17,6 @@ end
 Add your own custom checks with:
 
 ```ruby
-# config/initializers/online_migrations.rb
-
 config.add_check do |method, args|
   if method == :add_column && args[0].to_s == "users"
     stop!("No more columns on the users table")
@@ -33,8 +33,6 @@ Use the `stop!` method to stop migrations.
 Disable specific checks with:
 
 ```ruby
-# config/initializers/online_migrations.rb
-
 config.disable_check(:remove_index)
 ```
 
@@ -45,8 +43,6 @@ Check the [source code](https://github.com/fatkodima/online_migrations/blob/mast
 By default, checks are disabled when migrating down. Enable them with:
 
 ```ruby
-# config/initializers/online_migrations.rb
-
 config.check_down = true
 ```
 
@@ -55,8 +51,6 @@ config.check_down = true
 You can customize specific error messages:
 
 ```ruby
-# config/initializers/online_migrations.rb
-
 config.error_messages[:add_column_default] = "Your custom instructions"
 ```
 
@@ -88,8 +82,6 @@ ALTER ROLE myuser SET statement_timeout = '15s';
 You can configure this gem to automatically retry statements that exceed the lock timeout:
 
 ```ruby
-# config/initializers/online_migrations.rb
-
 config.lock_retrier = OnlineMigrations::ExponentialLockRetrier.new(
   attempts: 30,                # attempt 30 retries
   base_delay: 0.01.seconds,    # starting with delay of 10ms between each unsuccessful try, increasing exponentially
@@ -110,8 +102,6 @@ To temporarily disable lock retries while running migrations, set `DISABLE_LOCK_
 To mark migrations as safe that were created before installing this gem, configure the migration version starting after which checks are performed:
 
 ```ruby
-# config/initializers/online_migrations.rb
-
 config.start_after = 20220101000000
 
 # or if you use multiple databases (Active Record 6+)
@@ -125,8 +115,6 @@ 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
-# config/initializers/online_migrations.rb
-
 config.target_version = 10 # or "12.9" etc
 
 # or if you use multiple databases (Active Record 6+)
@@ -200,9 +188,25 @@ So you can actually check which steps are performed.
 To enable verbose sql logs:
 
 ```ruby
-# config/initializers/online_migrations.rb
-
 config.verbose_sql_logs = true
 ```
 
 This feature is enabled by default in a production Rails environment. You can override this setting via `ONLINE_MIGRATIONS_VERBOSE_SQL_LOGS` environment variable.
+
+## Analyze Tables
+
+Analyze tables automatically (to update planner statistics) after an index is added.
+Add to an initializer file:
+
+```ruby
+config.auto_analyze = true
+```
+
+## Schema Sanity
+
+Columns can flip order in `db/schema.rb` when you have multiple developers. One way to prevent this is to [alphabetize them](https://www.pgrs.net/2008/03/12/alphabetize-schema-rb-columns/).
+To alphabetize columns:
+
+```ruby
+config.alphabetize_schema = true
+```

data/lib/generators/online_migrations/templates/initializer.rb.tt

@@ -23,6 +23,13 @@ OnlineMigrations.configure do |config|
   # It is considered safe to perform most of the dangerous operations on them.
   # config.small_tables = []
 
+  # Analyze tables after indexes are added.
+  # Outdated statistics can sometimes hurt performance.
+  # config.auto_analyze = true
+
+  # Alphabetize table columns when dumping the schema.
+  # config.alphabetize_schema = true
+
   # Disable specific checks.
   # For the list of available checks look at `lib/error_messages` folder.
   # config.disable_check(:remove_index)

data/lib/online_migrations/background_migrations/copy_column.rb

@@ -42,12 +42,18 @@ module OnlineMigrations
         old_values = copy_from.map do |from_column|
           old_value = arel_table[from_column]
           if (type_cast_function = type_cast_functions[from_column])
-            if Utils.ar_version <= 5.2
-              # 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])
-            end
+            old_value =
+              if type_cast_function =~ /\A\w+\z/
+                if Utils.ar_version <= 5.2
+                  # Active Record <= 5.2 does not support quoting of Arel::Nodes::NamedFunction
+                  Arel.sql("#{type_cast_function}(#{connection.quote_column_name(from_column)})")
+                else
+                  Arel::Nodes::NamedFunction.new(type_cast_function, [old_value])
+                end
+              else
+                # We got a cast expression.
+                Arel.sql(type_cast_function)
+              end
           end
           old_value
         end

data/lib/online_migrations/change_column_type_helpers.rb

@@ -415,13 +415,13 @@ module OnlineMigrations
               end
             end
 
-          # This is necessary as we can't properly rename indexes such as "taggings_idx".
-          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."
+          if index.name.include?(from_column)
+            name = index.name.gsub(from_column, to_column)
           end
 
-          name = index.name.gsub(from_column, to_column)
+          # Generate a shorter name if needed.
+          max_identifier_length = 63 # could use just `max_identifier_length` method for ActiveRecord >= 5.0.
+          name = index_name(table_name, new_columns) if !name || name.length > max_identifier_length
 
           options = {
             unique: index.unique,

data/lib/online_migrations/command_checker.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "erb"
-require "openssl"
 require "set"
 
 module OnlineMigrations
@@ -53,6 +52,36 @@ module OnlineMigrations
     end
 
     private
+      ERROR_MESSAGE_TO_LINK = {
+        multiple_foreign_keys: "adding-multiple-foreign-keys",
+        create_table: "creating-a-table-with-the-force-option",
+        short_primary_key_type: "using-primary-key-with-short-integer-type",
+        drop_table_multiple_foreign_keys: "removing-a-table-with-multiple-foreign-keys",
+        rename_table: "renaming-a-table",
+        add_column_with_default_null: "adding-a-column-with-a-default-value",
+        add_column_with_default: "adding-a-column-with-a-default-value",
+        add_column_generated_stored: "adding-a-stored-generated-column",
+        add_column_json: "adding-a-json-column",
+        rename_column: "renaming-a-column",
+        change_column: "changing-the-type-of-a-column",
+        change_column_default: "changing-the-default-value-of-a-column",
+        change_column_null: "setting-not-null-on-an-existing-column",
+        remove_column: "removing-a-column",
+        add_timestamps_with_default: "adding-a-column-with-a-default-value",
+        add_hash_index: "hash-indexes",
+        add_reference: "adding-a-reference",
+        add_index: "adding-an-index-non-concurrently",
+        replace_index: "replacing-an-index",
+        remove_index: "removing-an-index-non-concurrently",
+        add_foreign_key: "adding-a-foreign-key",
+        add_exclusion_constraint: "adding-an-exclusion-constraint",
+        add_check_constraint: "adding-a-check-constraint",
+        add_unique_constraint: "adding-a-unique-constraint",
+        execute: "executing-SQL-directly",
+        add_inheritance_column: "adding-a-single-table-inheritance-column",
+        mismatched_foreign_key_type: "mismatched-reference-column-types",
+      }
+
       def check_database_version
         return if defined?(@database_version_checked)
 
@@ -522,6 +551,11 @@ module OnlineMigrations
               end
             end
           end
+
+          # Outdated statistics + a new index can hurt performance of existing queries.
+          if OnlineMigrations.config.auto_analyze && direction == :up
+            connection.execute("ANALYZE #{table_name}")
+          end
         end
       end
 
@@ -586,7 +620,7 @@ module OnlineMigrations
       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)
+        index_name = Utils.index_name(table_name, column_name)
 
         raise_error :add_unique_constraint,
           add_index_code: command_str(:add_index, table_name, column_name, unique: true, name: index_name, algorithm: :concurrently),
@@ -594,22 +628,6 @@ module OnlineMigrations
           remove_code: command_str(:remove_unique_constraint, 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
@@ -735,6 +753,10 @@ module OnlineMigrations
           message = ERB.new(template, nil, "<>").result(b)
         end
 
+        if (link = ERROR_MESSAGE_TO_LINK[message_key])
+          message += "\nFor more details, see https://github.com/fatkodima/online_migrations##{link}"
+        end
+
         @migration.stop!(message, header: header || "Dangerous operation detected")
       end
 

data/lib/online_migrations/config.rb

@@ -84,6 +84,16 @@ module OnlineMigrations
     #
     attr_accessor :error_messages
 
+    # Whether to automatically run ANALYZE on the table after the index was added
+    # @return [Boolean]
+    #
+    attr_accessor :auto_analyze
+
+    # Whether to alphabetize schema
+    # @return [Boolean]
+    #
+    attr_accessor :alphabetize_schema
+
     # Maximum allowed lock timeout value (in seconds)
     #
     # If set lock timeout is greater than this value, the migration will fail.
@@ -184,6 +194,8 @@ module OnlineMigrations
       @target_version = nil
       @small_tables = []
       @check_down = false
+      @auto_analyze = false
+      @alphabetize_schema = false
       @enabled_checks = @error_messages.keys.map { |k| [k, {}] }.to_h
       @verbose_sql_logs = defined?(Rails.env) && Rails.env.production?
     end

data/lib/online_migrations/schema_dumper.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module OnlineMigrations
+  module SchemaDumper
+    def initialize(connection, *args, **options)
+      if OnlineMigrations.config.alphabetize_schema
+        connection = WrappedConnection.new(connection)
+      end
+
+      super
+    end
+  end
+
+  class WrappedConnection < SimpleDelegator
+    def columns(table_name)
+      super.sort_by(&:name)
+    end
+  end
+end

data/lib/online_migrations/schema_statements.rb

@@ -777,6 +777,22 @@ module OnlineMigrations
       end
     end
 
+    # @private
+    # From ActiveRecord. Will not be needed for ActiveRecord >= 7.1.
+    def index_name(table_name, options)
+      if options.is_a?(Hash)
+        if options[:column]
+          Utils.index_name(table_name, options[:column])
+        elsif options[:name]
+          options[:name]
+        else
+          raise ArgumentError, "You must specify the index name"
+        end
+      else
+        index_name(table_name, column: options)
+      end
+    end
+
     # 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

data/lib/online_migrations/utils.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "openssl"
+
 module OnlineMigrations
   # @private
   module Utils
@@ -78,6 +80,23 @@ module OnlineMigrations
         end
       end
 
+      # Implementation is from ActiveRecord.
+      # This is not needed for ActiveRecord < 7.1 (https://github.com/rails/rails/pull/47753).
+      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 ar_partial_writes?
         ActiveRecord::Base.public_send(ar_partial_writes_setting)
       end

data/lib/online_migrations/version.rb

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

data/lib/online_migrations.rb

@@ -16,6 +16,7 @@ module OnlineMigrations
   autoload :VerboseSqlLogs
   autoload :Migration
   autoload :Migrator
+  autoload :SchemaDumper
   autoload :DatabaseTasks
   autoload :ForeignKeyDefinition
   autoload :ForeignKeysCollector
@@ -81,6 +82,7 @@ module OnlineMigrations
 
       ActiveRecord::Migration.prepend(OnlineMigrations::Migration)
       ActiveRecord::Migrator.prepend(OnlineMigrations::Migrator)
+      ActiveRecord::SchemaDumper.prepend(OnlineMigrations::SchemaDumper)
 
       ActiveRecord::Tasks::DatabaseTasks.singleton_class.prepend(OnlineMigrations::DatabaseTasks)
       ActiveRecord::Migration::CommandRecorder.include(OnlineMigrations::CommandRecorder)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: online_migrations
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.10.0
 platform: ruby
 authors:
 - fatkodima
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-02 00:00:00.000000000 Z
+date: 2023-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -76,6 +76,7 @@ files:
 - lib/online_migrations/migration.rb
 - lib/online_migrations/migrator.rb
 - lib/online_migrations/schema_cache.rb
+- lib/online_migrations/schema_dumper.rb
 - lib/online_migrations/schema_statements.rb
 - lib/online_migrations/utils.rb
 - lib/online_migrations/verbose_sql_logs.rb