online_migrations 0.25.0 → 0.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6b7685527d71319ba50e3a5c29744d9ef28103c1cacfdc650cba12c276782d8
-  data.tar.gz: e10e0d1dfb1c807b05927189f682633a7ab17c53f37974c5df5a2b452d78ab92
+  metadata.gz: cbca384d5eaf4ab575e80c60160d42326ef86f1baf21419f290663e0d9698eb0
+  data.tar.gz: b90abf4e278ee1b2ab27e60472f6bb127b124797084f53205a0929a5cc98268b
 SHA512:
-  metadata.gz: d7c62d15765a2837cf0dcba5e9a0c63c89ecc73f33fbd5500284184a78027f80a4ad12d980b5ac5de8235550384bd123708a075adab0243a06202154348268a3
-  data.tar.gz: 24449c58e1bec9b3a31e925a27df17c56c7cd923f2cdd33a5d6781f1f253204776901e92fd4024d3340e4eeb533b043a71a1afeaacb046bcc6ea62d5e5444668
+  metadata.gz: eea056dd2b0c5a24213543d96d6b2ca5a1c230c38aa37f475d674157bc354a8d0c1cb39e6e2c0a6e86867b184e82b51ec9ad0452eed00e1a7b7a6098b203c3ff
+  data.tar.gz: 9636d4b788d655ad04d0141cd28ae61c053b15d83f00c63b236ee181feeb438c18f2a8f34da49b26d955ff3c004c053f0d570d00ff6801e47e15c438b09f2c51

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## master (unreleased)
 
+## 0.26.0 (2025-04-28)
+
+- Drop support for Ruby < 3.1 and Rails < 7.1
+- Add check for `change_column` for columns with check constraints
+
+- Allow to require safety reason explanation when calling `safery_assured`
+
+  ```ruby
+  # config/initializers/online_migrations.rb
+  config.require_safety_assured_reason = true
+
+  # in migration
+  safety_assured("Table is small") do
+    add_index :users, :email, unique: true
+  end
+  ```
+
 ## 0.25.0 (2025-02-03)
 
 - Track start/finish time of background data migrations

data/README.md

@@ -16,8 +16,8 @@ See [comparison to `strong_migrations`](#comparison-to-strong_migrations)
 
 ## Requirements
 
-- Ruby 3.0+
-- Rails 7.0+
+- Ruby 3.1+
+- Rails 7.1+
 - PostgreSQL 12+
 
 For older Ruby and Rails versions you can use older versions of this gem.
@@ -64,76 +64,32 @@ An operation is classified as dangerous if it either:
 
 ## Example
 
-Consider the following migration:
-
-```ruby
-class AddAdminToUsers < ActiveRecord::Migration[8.0]
-  def change
-    add_column :users, :admin, :boolean, default: false, null: false
-  end
-end
-```
-
-If the `users` table is large, running this migration on a live PostgreSQL < 11 database will likely cause downtime.
-
-A safer approach would be to run something like the following:
-
-```ruby
-class AddAdminToUsers < ActiveRecord::Migration[8.0]
-  # Do not wrap the migration in a transaction so that locks are held for a shorter time.
-  disable_ddl_transaction!
-
-  def up
-    # Lower PostgreSQL's lock timeout to avoid statement queueing.
-    execute "SET lock_timeout TO '5s'" # The lock_timeout duration is customizable.
-
-    # Add the column without the default value and the not-null constraint.
-    add_column :users, :admin, :boolean
-
-    # Set the column's default value.
-    change_column_default :users, :admin, false
-
-    # Backfill the column in batches.
-    User.in_batches.update_all(admin: false)
-
-    # Add the not-null constraint. Beforehand, set a short statement timeout so that
-    # Postgres does not spend too much time performing the full table scan to verify
-    # the column contains no nulls.
-    execute "SET statement_timeout TO '5s'"
-    change_column_null :users, :admin, false
-  end
-
-  def down
-    remove_column :users, :admin
-  end
-end
-```
-
-When you actually run the original migration, you will get an error message:
+When you run a migration that's potentially dangerous, you'll see an error message like:
 
 ```txt
 ⚠️  [online_migrations] Dangerous operation detected ⚠️
 
-Adding a column with a non-null default blocks reads and writes while the entire table is rewritten.
-
+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. add the column without a default value
-2. change the column default
-3. backfill existing rows with the new value
-4. add the NOT NULL constraint
 
-add_column_with_default takes care of all this steps:
+1. Ignore the column:
 
-class AddAdminToUsers < ActiveRecord::Migration[8.0]
-  disable_ddl_transaction!
+  class User < ApplicationRecord
+    self.ignored_columns += ["name"]
+  end
 
-  def change
-    add_column_with_default :users, :admin, :boolean, default: false, null: false
+2. Deploy
+3. Wrap column removing in a safety_assured { ... } block
+
+  class RemoveColumn < ActiveRecord::Migration[8.0]
+    def change
+      safety_assured { remove_column :users, :name }
+    end
   end
-end
-```
 
-It suggests how to safely implement a migration, which essentially runs the steps similar to described in the previous example.
+4. Remove column ignoring from step 1
+5. Deploy
+```
 
 ## Checks
 
@@ -1278,17 +1234,6 @@ Interesting reads:
 - [Stop worrying about PostgreSQL locks in your Rails migrations](https://medium.com/doctolib/stop-worrying-about-postgresql-locks-in-your-rails-migrations-3426027e9cc9)
 - [Avoiding integer overflows with zero downtime](https://buildkite.com/blog/avoiding-integer-overflows-with-zero-downtime)
 
-## Maybe TODO
-
-- support MySQL
-- support other ORMs
-
-Background migrations:
-
-- extract as a separate gem
-- add UI
-- support batching over non-integer and multiple columns
-
 ## Comparison to `strong_migrations`
 
 This gem was heavily inspired by the `strong_migrations` and GitLab's approaches to database migrations. This gem is a superset of `strong_migrations`, feature-wise, and has the same APIs.

data/docs/configuring.md

@@ -38,6 +38,14 @@ config.disable_check(:remove_index)
 
 Check the [source code](https://github.com/fatkodima/online_migrations/blob/master/lib/online_migrations/error_messages.rb) for the list of keys.
 
+## Requiring safety_assured reason
+
+To require safety reason explanation when calling `safery_assured` (disabled by default):
+
+```ruby
+config.require_safety_assured_reason = true
+```
+
 ## Down Migrations / Rollbacks
 
 By default, checks are disabled when migrating down. Enable them with:

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

@@ -1,6 +1,6 @@
 class AddShardingToOnlineMigrations < <%= migration_parent %>
   def change
-    safety_assured do
+    safety_assured("Table is small") do
       remove_index :background_migrations, [:migration_name, :arguments], unique: true
 
       change_table :background_migrations do |t|

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

@@ -1,6 +1,6 @@
 class AddTimestampsToBackgroundMigrations < <%= migration_parent %>
   def change
-    safety_assured do
+    safety_assured("Table is small") do
       add_column :background_migrations, :started_at, :datetime
       add_column :background_migrations, :finished_at, :datetime
 

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

@@ -1,6 +1,6 @@
 class BackgroundSchemaMigrationsChangeUniqueIndex < <%= migration_parent %>
   def change
-    safety_assured do
+    safety_assured("Table is small") do
       remove_index :background_schema_migrations, name: :index_background_schema_migrations_on_unique_configuration
       add_index :background_schema_migrations, [:migration_name, :shard, :connection_class_name], unique: true,
         name: :index_background_schema_migrations_on_unique_configuration

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

@@ -12,6 +12,9 @@ OnlineMigrations.configure do |config|
   # Set the version of the production database so the right checks are run in development.
   # config.target_version = 17
 
+  # Configure whether to require safety reason explanation when calling #safery_assured.
+  config.require_safety_assured_reason = false
+
   # Configure whether to perform checks when migrating down.
   config.check_down = false
 

data/lib/online_migrations/background_schema_migrations/migration.rb

@@ -194,10 +194,7 @@ module OnlineMigrations
               if index_addition?
                 index = connection.indexes(table_name).find { |i| i.name == name }
                 if index
-                  # Use index validity from https://github.com/rails/rails/pull/45160
-                  # when switching to ActiveRecord >= 7.1.
-                  schema = connection.send(:__schema_for_table, table_name)
-                  if connection.send(:__index_valid?, name, schema: schema)
+                  if index.valid?
                     return
                   else
                     connection.remove_index(table_name, name: name, algorithm: :concurrently)
@@ -206,6 +203,11 @@ module OnlineMigrations
               end
 
               connection.execute(definition)
+
+              # Outdated statistics + a new index can hurt performance of existing queries.
+              if OnlineMigrations.config.auto_analyze
+                connection.execute("ANALYZE #{table_name}")
+              end
             end
           end
         end

data/lib/online_migrations/background_schema_migrations/migration_helpers.rb

@@ -19,7 +19,7 @@ module OnlineMigrations
           return
         end
 
-        if index_exists?(table_name, column_name, **options)
+        if index_exists?(table_name, column_name, name: index.name, **options)
           Utils.raise_or_say("Index creation was not enqueued because the index already exists.")
           return
         end

data/lib/online_migrations/batch_iterator.rb

@@ -19,8 +19,7 @@ module OnlineMigrations
       end
 
       relation = apply_limits(self.relation, column, start, finish, order)
-      unscopes = Utils.ar_version < 7.1 ? [:includes] : [:includes, :preload, :eager_load]
-      base_relation = relation.unscope(*unscopes).reselect(column).reorder(column => order)
+      base_relation = relation.unscope(:includes, :preload, :eager_load).reselect(column).reorder(column => order)
 
       start_id = start || begin
         start_row = base_relation.uncached { base_relation.first }
@@ -84,12 +83,16 @@ module OnlineMigrations
 
     private
       def apply_limits(relation, column, start, finish, order)
+        arel_column = relation.arel_table[column]
+
         if start
-          relation = relation.where(relation.arel_table[column].public_send((order == :asc ? :gteq : :lteq), start))
+          predicate = order == :asc ? :gteq : :lteq
+          relation = relation.where(arel_column.public_send(predicate, start))
         end
 
         if finish
-          relation = relation.where(relation.arel_table[column].public_send((order == :asc ? :lteq : :gteq), finish))
+          predicate = order == :asc ? :lteq : :gteq
+          relation = relation.where(arel_column.public_send(predicate, finish))
         end
 
         relation

data/lib/online_migrations/change_column_type_helpers.rb

@@ -267,11 +267,7 @@ module OnlineMigrations
         __copy_indexes(table_name, column_name, tmp_column_name)
         __copy_foreign_keys(table_name, column_name, tmp_column_name)
         __copy_check_constraints(table_name, column_name, tmp_column_name)
-
-        # Exclusion constraints were added in https://github.com/rails/rails/pull/40224.
-        if Utils.ar_version >= 7.1
-          __copy_exclusion_constraints(table_name, column_name, tmp_column_name)
-        end
+        __copy_exclusion_constraints(table_name, column_name, tmp_column_name)
 
         if column_name == primary_key
           __finalize_primary_key_type_change(table_name, column_name, column_names)
@@ -358,13 +354,22 @@ module OnlineMigrations
     # @see #cleanup_column_type_change
     #
     def cleanup_columns_type_change(table_name, *column_names)
-      conversions = column_names.index_with do |column_name|
-        __change_type_column(column_name)
+      tmp_column_names = column_names.map { |column_name| __change_type_column(column_name) }
+
+      # Safely remove existing indexes and foreign keys first, if any.
+      tmp_column_names.each do |column_name|
+        __indexes_for(table_name, column_name).each do |index|
+          remove_index(table_name, name: index.name, algorithm: :concurrently)
+        end
+
+        __foreign_keys_for(table_name, column_name).each do |fk|
+          remove_foreign_key(table_name, name: fk.name)
+        end
       end
 
       transaction do
-        __remove_copy_triggers(table_name, conversions.keys, conversions.values)
-        remove_columns(table_name, *conversions.values)
+        __remove_copy_triggers(table_name, column_names, tmp_column_names)
+        remove_columns(table_name, *tmp_column_names)
       end
     end
 
@@ -401,12 +406,13 @@ module OnlineMigrations
         to_column    = to_column.to_s
 
         __indexes_for(table_name, from_column).each do |index|
+          columns = index.columns
           new_columns =
             # Expression index.
-            if index.columns.is_a?(String)
-              index.columns.gsub(/\b#{from_column}\b/, to_column)
+            if columns.is_a?(String)
+              columns.gsub(/\b#{from_column}\b/, to_column)
             else
-              index.columns.map do |column|
+              columns.map do |column|
                 column == from_column ? to_column : column
               end
             end
@@ -429,6 +435,16 @@ module OnlineMigrations
             options[:opclass] = opclasses
           end
 
+          # If the index name is custom - do not rely on auto generated index names, because this
+          # doesn't work (idempotency check does not work, rails does not consider ':where' option)
+          # when there are partial and "classic" indexes on the same columns.
+          if index.name == index_name(table_name, columns)
+            options[:name] = index_name(table_name, new_columns)
+          else
+            truncated_index_name = index.name[0, max_identifier_length - "_2".length]
+            options[:name] = "#{truncated_index_name}_2"
+          end
+
           add_index(table_name, new_columns, **options, algorithm: :concurrently)
         end
       end
@@ -511,6 +527,13 @@ module OnlineMigrations
           # Lock the table explicitly to prevent new rows being inserted
           execute("LOCK TABLE #{quoted_table_name} IN ACCESS EXCLUSIVE MODE")
 
+          # https://stackoverflow.com/questions/47301722/how-can-view-depends-on-primary-key-constraint-in-postgres
+          #
+          # PG::DependentObjectsStillExist: ERROR:  cannot drop constraint appointments_pkey on table appointments because other objects depend on it (PG::DependentObjectsStillExist)
+          # DETAIL:  view appointment_statuses depends on constraint appointments_pkey on table appointments
+          # HINT:  Use DROP ... CASCADE to drop the dependent objects too.
+          views = __drop_dependent_views(table_name)
+
           swap_column_names(table_name, column_name, tmp_column_name)
 
           # We need to update the trigger function in order to make PostgreSQL to
@@ -530,6 +553,8 @@ module OnlineMigrations
           execute("ALTER TABLE #{quoted_table_name} DROP CONSTRAINT #{quote_table_name(pkey_constraint_name)}")
           rename_index(table_name, pkey_index_name, pkey_constraint_name)
           execute("ALTER TABLE #{quoted_table_name} ADD CONSTRAINT #{quote_table_name(pkey_constraint_name)} PRIMARY KEY USING INDEX #{quote_table_name(pkey_constraint_name)}")
+
+          __recreate_views(views)
         end
       end
 
@@ -579,5 +604,40 @@ module OnlineMigrations
         function_name = __copy_triggers_name(table_name, column_names, tmp_column_names)
         execute("ALTER FUNCTION #{quote_table_name(function_name)}() RESET ALL")
       end
+
+      # https://stackoverflow.com/questions/69458819/is-there-any-way-to-list-all-the-views-related-to-a-table-in-the-existing-postgr
+      def __drop_dependent_views(table_name)
+        views = select_all(<<~SQL)
+          SELECT
+            u.view_schema AS schema,
+            u.view_name AS name,
+            v.view_definition AS definition,
+            c.relkind = 'm' AS materialized
+          FROM information_schema.view_table_usage u
+            JOIN information_schema.views v ON u.view_schema = v.table_schema
+              AND u.view_name = v.table_name
+            JOIN pg_class c ON c.relname = u.view_name
+          WHERE u.table_schema NOT IN ('information_schema', 'pg_catalog')
+            AND u.table_name = #{quote(table_name)}
+          ORDER BY u.view_schema, u.view_name
+        SQL
+
+        views.each do |row|
+          execute("DROP VIEW #{quote_table_name(row['schema'])}.#{quote_table_name(row['name'])}")
+        end
+
+        views
+      end
+
+      def __recreate_views(views)
+        views.each do |row|
+          schema, name, definition, materialized = row.values_at("schema", "name", "definition", "materialized")
+
+          execute(<<~SQL)
+            CREATE#{' MATERIALIZED' if materialized} VIEW #{quote_table_name(schema)}.#{quote_table_name(name)} AS
+            #{definition}
+          SQL
+        end
+      end
   end
 end

data/lib/online_migrations/command_checker.rb

@@ -80,6 +80,7 @@ module OnlineMigrations
         add_inheritance_column: "adding-a-single-table-inheritance-column",
         mismatched_foreign_key_type: "mismatched-reference-column-types",
       }
+      private_constant :ERROR_MESSAGE_TO_LINK
 
       def check_database_version
         return if defined?(@database_version_checked)
@@ -375,6 +376,31 @@ module OnlineMigrations
               cleanup_code: command_str(:cleanup_column_type_change, table_name, column_name),
               cleanup_down_code: command_str(:initialize_column_type_change, table_name, column_name, existing_type)
           end
+
+          # Constraints must be rechecked.
+          # PostgreSQL recommends dropping constraints before and adding them back.
+          # https://www.postgresql.org/docs/current/ddl-alter.html#DDL-ALTER-COLUMN-TYPE
+          constraints = connection.check_constraints(table_name).select do |c|
+            c.validated? && c.expression.match?(/\b#{column_name}\b/)
+          end
+
+          if constraints.any?
+            change_commands = constraints.map do |c|
+              command_str(:remove_check_constraint, table_name, c.expression, { name: c.name })
+            end
+            change_commands << command_str(:change_column, table_name, column_name, type, **options)
+            constraints.each do |c|
+              change_commands << command_str(:add_check_constraint, table_name, c.expression, { name: c.name, validate: false })
+            end
+
+            validate_commands = constraints.map do |c|
+              command_str(:validate_check_constraint, table_name, { name: c.name })
+            end
+
+            raise_error :change_column_constraint,
+              change_column_code: change_commands.join("\n    "),
+              validate_constraint_code: validate_commands.join("\n    ")
+          end
         end
       end
 
@@ -388,9 +414,9 @@ module OnlineMigrations
         if !allow_null && !new_or_small_table?(table_name)
           # In PostgreSQL 12+ you can add a check constraint to the table
           # and then "promote" it to NOT NULL for the column.
-          safe = check_constraints(table_name).any? do |c|
-            c["def"] == "CHECK ((#{column_name} IS NOT NULL))" ||
-              c["def"] == "CHECK ((#{connection.quote_column_name(column_name)} IS NOT NULL))"
+          safe = connection.check_constraints(table_name).select(&:validated?).any? do |c|
+            c.expression == "#{column_name} IS NOT NULL" ||
+              c.expression == "#{connection.quote_column_name(column_name)} IS NOT NULL"
           end
 
           if !safe
@@ -601,7 +627,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 = Utils.index_name(table_name, column_name)
+        index_name = connection.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),
@@ -765,18 +791,6 @@ module OnlineMigrations
         "chk_rails_#{hashed_identifier}"
       end
 
-      def check_constraints(table_name)
-        constraints_query = <<~SQL
-          SELECT pg_get_constraintdef(oid) AS def
-          FROM pg_constraint
-          WHERE contype = 'c'
-            AND convalidated
-            AND conrelid = #{connection.quote(table_name)}::regclass
-        SQL
-
-        connection.select_all(constraints_query).to_a
-      end
-
       def check_inheritance_column(table_name, column_name, default)
         if column_name.to_s == ActiveRecord::Base.inheritance_column && !default.nil?
           raise_error :add_inheritance_column,
@@ -834,10 +848,8 @@ module OnlineMigrations
       end
 
       def index_include_column?(index, column)
-        # Expression index
-        (index.columns.is_a?(String) && index.columns.include?(column)) ||
-          index.columns.include?(column) ||
-          (Utils.ar_version >= 7.1 && index.include && index.include.include?(column)) ||
+        index.columns.include?(column) ||
+          (index.include && index.include.include?(column)) ||
           (index.where && index.where.include?(column))
       end
 

data/lib/online_migrations/config.rb

@@ -73,6 +73,13 @@ module OnlineMigrations
       end
     end
 
+    # Whether to require safety reason explanation when calling #safery_assured
+    #
+    # Disabled by default
+    # @return [Boolean]
+    #
+    attr_accessor :require_safety_assured_reason
+
     # Whether to perform checks when migrating down
     #
     # Disabled by default
@@ -230,6 +237,7 @@ module OnlineMigrations
       @start_after = 0
       @target_version = nil
       @small_tables = []
+      @require_safety_assured_reason = false
       @check_down = false
       @auto_analyze = false
       @alphabetize_schema = false

data/lib/online_migrations/error_messages.rb

@@ -242,6 +242,22 @@ during writes works automatically). For most column type changes, this does not
 8. Remove changes from step 3, if any
 9. Deploy",
 
+      change_column_constraint: "Changing the type of a column that has check constraints blocks reads and writes
+while every row is checked. Drop the check constraints on the column before
+changing the type and add them back afterwards.
+
+class <%= migration_name %> < <%= migration_parent %>
+  def change
+    <%= change_column_code %>
+  end
+end
+
+class Validate<%= migration_name %> < <%= migration_parent %>
+  def change
+    <%= validate_constraint_code %>
+  end
+end",
+
       change_column_default:
 "Partial writes are enabled, which can cause incorrect values
 to be inserted when changing the default value of a column.

data/lib/online_migrations/index_definition.rb

@@ -20,7 +20,7 @@ module OnlineMigrations
       # For ActiveRecord::ConnectionAdapters::IndexDefinition is for expression indexes,
       # `columns` is a string
       table == other.table &&
-        (columns & Array(other.columns)).any?
+        columns.intersect?(Array(other.columns))
     end
 
     # @param other [OnlineMigrations::IndexDefinition, ActiveRecord::ConnectionAdapters::IndexDefinition]

data/lib/online_migrations/migration.rb

@@ -45,7 +45,14 @@ module OnlineMigrations
     # @example
     #   safety_assured { remove_column(:users, :some_column) }
     #
-    def safety_assured(&block)
+    def safety_assured(reason = nil, &block)
+      config = OnlineMigrations.config
+      safe_version = version && version <= config.start_after
+
+      if config.require_safety_assured_reason && reason.blank? && !safe_version
+        raise OnlineMigrations::Error, "Specify a safety reason explanation when calling #safety_assured."
+      end
+
       command_checker.class.safety_assured(&block)
     end
 

data/lib/online_migrations/schema_cache.rb

@@ -3,84 +3,6 @@
 module OnlineMigrations
   # @private
   module SchemaCache
-    def primary_keys(table_name)
-      if (renamed_table = renamed_table?(table_name))
-        super(renamed_table)
-      elsif renamed_column?(table_name)
-        super(column_rename_table(table_name))
-      else
-        super
-      end
-    end
-
-    def columns(table_name)
-      if (renamed_table = renamed_table?(table_name))
-        super(renamed_table)
-      elsif renamed_column?(table_name)
-        columns = super(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(table_name)
-      if (renamed_table = renamed_table?(table_name))
-        super(renamed_table)
-      elsif renamed_column?(table_name)
-        super(column_rename_table(table_name))
-      else
-        super
-      end
-    end
-
-    def clear_data_source_cache!(name)
-      if (renamed_table = renamed_table?(name))
-        super(renamed_table)
-      end
-
-      if renamed_column?(name)
-        super(column_rename_table(name))
-      end
-
-      super
-    end
-
-    private
-      def renamed_table?(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?(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
-
-  # @private
-  module SchemaCache71
-    # 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)

data/lib/online_migrations/schema_statements.rb

@@ -568,8 +568,8 @@ module OnlineMigrations
     #
     def add_text_limit_constraint(table_name, column_name, limit, name: nil, validate: true)
       column = column_for(table_name, column_name)
-      if column.type != :text
-        raise "add_text_limit_constraint must be used only with :text columns"
+      if column.type != :text && column.type != :string
+        raise "add_text_limit_constraint must be used only with :text or :string columns"
       end
 
       name ||= __text_limit_constraint_name(table_name, column_name)
@@ -710,16 +710,12 @@ module OnlineMigrations
           index_name = (options[:name] || index_name(table_name, column_name)).to_s
           indexes(table_name).find { |i| i.name == index_name }
         else
-          # Rewrite this with `IndexDefinition#defined_for?` when Active Record >= 7.1 is supported.
-          # See https://github.com/rails/rails/pull/45160.
-          indexes(table_name).find { |i| __index_defined_for?(i, column_name, **options) }
+          indexes(table_name).find { |i| i.defined_for?(column_name, **options) }
         end
 
       if index
-        schema = __schema_for_table(table_name)
-
-        if __index_valid?(index.name, schema: schema)
-          Utils.say("Index was not created because it already exists.")
+        if index.valid?
+          Utils.say("Index #{index.name} was not created because it already exists.")
           return
         else
           Utils.say("Recreating invalid index: table_name: #{table_name}, column_name: #{column_name}")
@@ -764,22 +760,6 @@ 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.
     #
     # @see https://edgeapi.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_foreign_key
@@ -833,7 +813,7 @@ module OnlineMigrations
     # @see https://edgeapi.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-add_check_constraint
     #
     def add_check_constraint(table_name, expression, **options)
-      if __check_constraint_exists?(table_name, expression: expression, **options)
+      if check_constraint_exists?(table_name, expression: expression, **options)
         Utils.say(<<~MSG.squish)
           Check constraint was not created because it already exists (this may be due to an aborted migration or similar).
           table_name: #{table_name}, expression: #{expression}
@@ -864,7 +844,7 @@ module OnlineMigrations
     # @see https://edgeapi.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-remove_check_constraint
     #
     def remove_check_constraint(table_name, expression = nil, **options)
-      if __check_constraint_exists?(table_name, expression: expression, **options)
+      if check_constraint_exists?(table_name, expression: expression, **options)
         super
       else
         Utils.say(<<~MSG.squish)
@@ -874,16 +854,14 @@ module OnlineMigrations
       end
     end
 
-    if Utils.ar_version >= 7.1
-      def add_exclusion_constraint(table_name, expression, **options)
-        if __exclusion_constraint_exists?(table_name, expression: expression, **options)
-          Utils.say(<<~MSG.squish)
-            Exclusion constraint was not created because it already exists (this may be due to an aborted migration or similar).
-            table_name: #{table_name}, expression: #{expression}
-          MSG
-        else
-          super
-        end
+    def add_exclusion_constraint(table_name, expression, **options)
+      if __exclusion_constraint_exists?(table_name, expression: expression, **options)
+        Utils.say(<<~MSG.squish)
+          Exclusion constraint was not created because it already exists (this may be due to an aborted migration or similar).
+          table_name: #{table_name}, expression: #{expression}
+        MSG
+      else
+        super
       end
     end
 
@@ -932,20 +910,9 @@ module OnlineMigrations
         end
       end
 
-      # Will not be needed for Active Record >= 7.1
-      def __index_defined_for?(index, columns = nil, name: nil, unique: nil, valid: nil, include: nil, nulls_not_distinct: nil, **options)
-        columns = options[:column] if columns.blank?
-        (columns.nil? || Array(index.columns) == Array(columns).map(&:to_s)) &&
-          (name.nil? || index.name == name.to_s) &&
-          (unique.nil? || index.unique == unique) &&
-          (valid.nil? || index.valid == valid) &&
-          (include.nil? || Array(index.include) == Array(include).map(&:to_s)) &&
-          (nulls_not_distinct.nil? || index.nulls_not_distinct == nulls_not_distinct)
-      end
-
       def __not_null_constraint_exists?(table_name, column_name, name: nil)
         name ||= __not_null_constraint_name(table_name, column_name)
-        __check_constraint_exists?(table_name, name: name)
+        check_constraint_exists?(table_name, name: name)
       end
 
       def __not_null_constraint_name(table_name, column_name)
@@ -958,21 +925,7 @@ module OnlineMigrations
 
       def __text_limit_constraint_exists?(table_name, column_name, name: nil)
         name ||= __text_limit_constraint_name(table_name, column_name)
-        __check_constraint_exists?(table_name, name: name)
-      end
-
-      # Can use index validity attribute for Active Record >= 7.1.
-      def __index_valid?(index_name, schema:)
-        select_value(<<~SQL)
-          SELECT indisvalid
-          FROM pg_index i
-          JOIN pg_class c
-            ON i.indexrelid = c.oid
-          JOIN pg_namespace n
-            ON c.relnamespace = n.oid
-          WHERE n.nspname = #{schema}
-            AND c.relname = #{quote(index_name)}
-        SQL
+        check_constraint_exists?(table_name, name: name)
       end
 
       def __copy_foreign_key(fk, to_column, **options)
@@ -996,15 +949,6 @@ module OnlineMigrations
         end
       end
 
-      # Can be replaced by native method in Active Record >= 7.1.
-      def __check_constraint_exists?(table_name, **options)
-        if !options.key?(:name) && !options.key?(:expression)
-          raise ArgumentError, "At least one of :name or :expression must be supplied"
-        end
-
-        check_constraint_for(table_name, **options).present?
-      end
-
       def __exclusion_constraint_exists?(table_name, **options)
         if !options.key?(:name) && !options.key?(:expression)
           raise ArgumentError, "At least one of :name or :expression must be supplied"

data/lib/online_migrations/utils.rb

@@ -69,23 +69,6 @@ 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
-
       # Returns estimated rows count for a table.
       # https://www.citusdata.com/blog/2016/10/12/count-performance/
       def estimated_count(connection, table_name)
@@ -144,9 +127,7 @@ module OnlineMigrations
           # This is the way that currently is used in ActiveRecord tests themselves.
           pool_manager = ActiveRecord::Base.connection_handler.send(:get_pool_manager, ancestor.name)
 
-          # .uniq call is not needed for Active Record 7.1+
-          # See https://github.com/rails/rails/pull/49284.
-          return pool_manager.shard_names.uniq if pool_manager
+          return pool_manager.shard_names if pool_manager
         end
       end
 

data/lib/online_migrations/verbose_sql_logs.rb

@@ -14,13 +14,7 @@ module OnlineMigrations
         stdout_logger.level = @activerecord_logger_was.level
         stdout_logger = ActiveSupport::TaggedLogging.new(stdout_logger)
 
-        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
+        combined_logger = ActiveSupport::BroadcastLogger.new(stdout_logger, @activerecord_logger_was)
 
         ActiveRecord::Base.logger = combined_logger
         ActiveRecord.verbose_query_logs = false

data/lib/online_migrations/version.rb

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

data/lib/online_migrations.rb

@@ -102,12 +102,7 @@ module OnlineMigrations
     end
 
     def deprecator
-      @deprecator ||=
-        if Utils.ar_version >= 7.1
-          ActiveSupport::Deprecation.new(nil, "online_migrations")
-        else
-          ActiveSupport::Deprecation
-        end
+      @deprecator ||= ActiveSupport::Deprecation.new(nil, "online_migrations")
     end
 
     # @private
@@ -124,8 +119,6 @@ module OnlineMigrations
 
       if OnlineMigrations::Utils.ar_version >= 7.2
         ActiveRecord::ConnectionAdapters::SchemaCache.prepend(OnlineMigrations::SchemaCache72)
-      elsif OnlineMigrations::Utils.ar_version >= 7.1
-        ActiveRecord::ConnectionAdapters::SchemaCache.prepend(OnlineMigrations::SchemaCache71)
       else
         ActiveRecord::ConnectionAdapters::SchemaCache.prepend(OnlineMigrations::SchemaCache)
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: online_migrations
 version: !ruby/object:Gem::Version
-  version: 0.25.0
+  version: 0.26.0
 platform: ruby
 authors:
 - fatkodima
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-03 00:00:00.000000000 Z
+date: 2025-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
 description:
 email:
 - fatkodima123@gmail.com
@@ -107,7 +107,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="