online_migrations 0.8.1 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bfe87b009fa9199b4deb0a1bf7e63dac043fa8f29c25f4f93c55fd136155f2d
-  data.tar.gz: 0a95c4b4de358769bce7d3855f7df67c08d027279b523d0ea550a383b60cd6a8
+  metadata.gz: b4f89ce12461dd3b786e98ecbc1afc315a5013a0967e90b9307d47b080924723
+  data.tar.gz: 797f19c861514e843a7d6e6f3222d19f36b77fc30ff3cc1ac2808591fa339f75
 SHA512:
-  metadata.gz: 95b0d869484b407b295426bf1b836f00ce71c297fc1ef35fe817e449f126ccbc7e7df512efc30c16cda9dfb9755c86e1b409f9787f40708341aba422128b0d60
-  data.tar.gz: 42b829796b7fd0503416460775ac1c7596fce43621667a9144cd06b9000e35f8054398cadbf82f370b3e8ca988bcd7ce53b505982e8e5b3ed7e6991c71f373aa
+  metadata.gz: c4458f5096fc180bb27411fc800db6dce588473373c0945abf2121b67591dc031badb498582681e55128055a85105600be1de8851818e93bf1108f42d43dd24c
+  data.tar.gz: ec49dd203d5ded9638d623af2b35b6ca1980a182a54ecf57bcbaf9d910cfe8f3e2cbd0f90c7e4d94f76236be91ef373b50e29a65e59be6e12ef6b55ad21de91b

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## master (unreleased)
 
+## 0.8.2 (2023-09-26)
+
+- Promote check constraint to `NOT NULL` on PostgreSQL >= 12 when changing column type
+- Fix `safety_assured` with `revert`
+
 ## 0.8.1 (2023-08-04)
 
 - Fix `update_columns_in_batches` when multiple columns are passed
@@ -8,7 +13,7 @@
 ## 0.8.0 (2023-07-24)
 
 - Add check for `change_column_default`
-- Add check for `add_unique_key` (Active Record >= 7.1)
+- Add check for `add_unique_constraint` (Active Record >= 7.1)
 - Add check for `add_column` with stored generated columns
 
 ## 0.7.3 (2023-05-30)

data/README.md

@@ -143,7 +143,7 @@ Potentially dangerous operations:
 - [adding a reference](#adding-a-reference)
 - [adding a foreign key](#adding-a-foreign-key)
 - [adding an exclusion constraint](#adding-an-exclusion-constraint)
-- [adding a unique key](#adding-a-unique-key)
+- [adding a unique constraint](#adding-a-unique-constraint)
 - [adding a json column](#adding-a-json-column)
 - [adding a stored generated column](#adding-a-stored-generated-column)
 - [using primary key with short integer type](#using-primary-key-with-short-integer-type)
@@ -880,16 +880,16 @@ end
 
 [Let us know](https://github.com/fatkodima/online_migrations/issues/new) if you have a safe way to do this (exclusion constraints cannot be marked `NOT VALID`).
 
-### Adding a unique key
+### Adding a unique constraint
 
 :x: **Bad**
 
-Adding a unique key blocks reads and writes while the underlying index is being built.
+Adding a unique constraint blocks reads and writes while the underlying index is being built.
 
 ```ruby
-class AddUniqueKey < ActiveRecord::Migration[7.1]
+class AddUniqueConstraint < ActiveRecord::Migration[7.1]
   def change
-    add_unique_key :sections, :position, deferrable: :deferred
+    add_unique_constraint :sections, :position, deferrable: :deferred
   end
 end
 ```
@@ -899,7 +899,7 @@ end
 A safer approach is to create a unique index first, and then create a unique key using that index.
 
 ```ruby
-class AddUniqueKeyAddIndex < ActiveRecord::Migration[7.1]
+class AddUniqueConstraintAddIndex < ActiveRecord::Migration[7.1]
   disable_ddl_transaction!
 
   def change
@@ -909,13 +909,13 @@ end
 ```
 
 ```ruby
-class AddUniqueKey < ActiveRecord::Migration[7.1]
+class AddUniqueConstraint < ActiveRecord::Migration[7.1]
   def up
-    add_unique_key :sections, :position, deferrable: :deferred, using_index: "index_sections_on_position"
+    add_unique_constraint :sections, :position, deferrable: :deferred, using_index: "index_sections_on_position"
   end
 
   def down
-    remove_unique_key :sections, :position
+    remove_unique_constraint :sections, :position
   end
 end
 ```

data/lib/online_migrations/background_migration.rb

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

data/lib/online_migrations/background_migrations/background_migration_class_validator.rb

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

data/lib/online_migrations/background_migrations/config.rb

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

data/lib/online_migrations/background_migrations/delete_associated_records.rb

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

data/lib/online_migrations/background_migrations/delete_orphaned_records.rb

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

data/lib/online_migrations/background_migrations/migration_job_status_validator.rb

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

data/lib/online_migrations/background_migrations/migration_status_validator.rb

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

data/lib/online_migrations/background_migrations/reset_counters.rb

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

data/lib/online_migrations/batch_iterator.rb

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

data/lib/online_migrations/change_column_type_helpers.rb

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

data/lib/online_migrations/command_checker.rb

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

data/lib/online_migrations/command_recorder.rb

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

data/lib/online_migrations/config.rb

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

data/lib/online_migrations/error_messages.rb

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

data/lib/online_migrations/migration.rb

@@ -36,7 +36,7 @@ module OnlineMigrations
     #   safety_assured { remove_column(:users, :some_column) }
     #
     def safety_assured(&block)
-      command_checker.safety_assured(&block)
+      command_checker.class.safety_assured(&block)
     end
 
     # Stop running migrations.

data/lib/online_migrations/schema_statements.rb

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

data/lib/online_migrations/utils.rb

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

data/lib/online_migrations/verbose_sql_logs.rb

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

data/lib/online_migrations/version.rb

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

metadata

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