online_migrations 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 625229a6ef3cc2b9a6a6201ae2033b4560ca395482d797115563abd1dace6716
-  data.tar.gz: bc24c264f8a6be48e9232959a6e654e5a814c9872317d88e788eca8260dd6a7e
+  metadata.gz: '029dd11fe1935f72c4933c081b45c972613caa252c578a005b34a902122923d6'
+  data.tar.gz: 04d66e91c1c54f1fe19d8a743d4b6f70ef218bbe2310eb58a779602a92e72736
 SHA512:
-  metadata.gz: 8054e3f5fec6fbc066cc3d6184a3002a2e77b21dee5ee7adca1025fa907c3e2263fae206b25150b662e37cd1dfac46cd66a54c82d725848020c30ed0cecef5c9
-  data.tar.gz: 2ad342552fbf328c341875192aba31c441b2bd5a72d3fac9edfef9caa9fa2eab003c9ae7d441d4778b3425f82aed140290de82df3291c030e0b1e7867871ae47
+  metadata.gz: '07865cb5068a3cba7956db786f78d0999070b9445798af0df17f9360fa9b3e5b3f19409756f383b9eb402fa8cfa0a2b2bb6ca57475267f915844a248598004b5'
+  data.tar.gz: 0f44b2cd5bd9bad6f85c2980da2ea41ad79c100c46bdce0c4be2d9630cc239b42a0217ae07fd6f568503a42a640da6b63a2840d3b714994fce65708bd8dbf289

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## master (unreleased)
 
+## 0.7.0 (2023-02-14)
+
+- Add support for renaming multiple columns at once in the same table
+- Fix quoting table/column names across the library
+- Fix deffered foreign keys support in `add_foreign_key` (Active Record >= 7)
+- Reset attempts of failing jobs before executing background migration inline
+
 ## 0.6.0 (2023-02-04)
 
 - Ignore internal Active Record migrations compatibility related options when suggesting a safe column type change

data/lib/online_migrations/background_migrations/migration.rb

@@ -123,6 +123,14 @@ module OnlineMigrations
         end
       end
 
+      # @private
+      def reset_failed_jobs_attempts
+        iterator = BatchIterator.new(migration_jobs.failed.attempts_exceeded)
+        iterator.each_batch(of: 100) do |relation|
+          relation.update_all(attempts: 0)
+        end
+      end
+
       # @private
       def next_batch_range
         iterator = BatchIterator.new(migration_relation)

data/lib/online_migrations/background_migrations/migration_job.rb

@@ -36,6 +36,7 @@ module OnlineMigrations
       end
 
       scope :except_succeeded, -> { where("status != ?", statuses[:succeeded]) }
+      scope :attempts_exceeded, -> { where("attempts >= max_attempts") }
 
       enum status: STATUSES.map { |status| [status, status.to_s] }.to_h
 

data/lib/online_migrations/background_migrations/migration_runner.rb

@@ -67,6 +67,7 @@ module OnlineMigrations
         # Mark is as finishing to avoid being picked up
         # by the background migrations scheduler.
         migration.finishing!
+        migration.reset_failed_jobs_attempts
 
         while migration.finishing?
           run_migration_job

data/lib/online_migrations/change_column_type_helpers.rb

@@ -570,7 +570,7 @@ module OnlineMigrations
               transaction do
                 # We'll need ACCESS EXCLUSIVE lock on the related tables,
                 # lets make sure it can be acquired from the start.
-                execute("LOCK TABLE #{table_name}, #{referencing_table_name} IN ACCESS EXCLUSIVE MODE")
+                execute("LOCK TABLE #{quote_table_name(table_name)}, #{quote_table_name(referencing_table_name)} IN ACCESS EXCLUSIVE MODE")
 
                 remove_foreign_key(referencing_table_name, name: existing_name)
                 __rename_constraint(referencing_table_name, tmp_name, existing_name)

data/lib/online_migrations/command_recorder.rb

@@ -6,9 +6,13 @@ module OnlineMigrations
     REVERSIBLE_AND_IRREVERSIBLE_METHODS = [
       :update_column_in_batches,
       :initialize_column_rename,
+      :initialize_columns_rename,
       :revert_initialize_column_rename,
+      :revert_initialize_columns_rename,
       :finalize_column_rename,
+      :finalize_columns_rename,
       :revert_finalize_column_rename,
+      :revert_finalize_columns_rename,
       :initialize_table_rename,
       :revert_initialize_table_rename,
       :finalize_table_rename,
@@ -49,7 +53,9 @@ module OnlineMigrations
       module StraightReversions
         {
           initialize_column_rename:           :revert_initialize_column_rename,
+          initialize_columns_rename:          :revert_initialize_columns_rename,
           finalize_column_rename:             :revert_finalize_column_rename,
+          finalize_columns_rename:            :revert_finalize_columns_rename,
           initialize_table_rename:            :revert_initialize_table_rename,
           finalize_table_rename:              :revert_finalize_table_rename,
           add_not_null_constraint:            :remove_not_null_constraint,
@@ -84,11 +90,20 @@ module OnlineMigrations
         _table, column, new_column = args
         if !column || !new_column
           raise ActiveRecord::IrreversibleMigration,
-            "invert_revert_initialize_column_rename is only reversible if given a column and new_column."
+            "revert_initialize_column_rename is only reversible if given a column and new_column."
         end
         [:initialize_column_rename, args]
       end
 
+      def invert_revert_initialize_columns_rename(args)
+        _table, old_new_column_hash = args
+        unless old_new_column_hash
+          raise ActiveRecord::IrreversibleMigration,
+            "revert_initialize_columns_rename is only reversible if given a hash of old and new columns."
+        end
+        [:initialize_columns_rename, args]
+      end
+
       def invert_finalize_table_rename(args)
         _table_name, new_name = args
         unless new_name

data/lib/online_migrations/schema_cache.rb

@@ -18,17 +18,10 @@ module OnlineMigrations
         super(renamed_tables[table_name])
       elsif renamed_columns.key?(table_name)
         columns = super(column_rename_table(table_name))
-
-        old_column_name, new_column_name = renamed_columns[table_name].first.to_a
-
-        old_column = columns.find { |column| column.name == old_column_name }
-        new_column = old_column.dup
-
-        # ActiveRecord defines only reader for :name
-        new_column.instance_variable_set(:@name, new_column_name)
-
-        # Correspond to the ActiveRecord freezing of each column
-        columns << new_column.freeze
+        renamed_columns[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
@@ -94,5 +87,14 @@ module OnlineMigrations
         @renamed_columns = nil
         @renamed_tables = nil
       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
+        # ActiveRecord defines only reader for :name
+        new_column.instance_variable_set(:@name, new_column_name)
+        # Correspond to the ActiveRecord freezing of each column
+        columns << new_column.freeze
+      end
   end
 end

data/lib/online_migrations/schema_statements.rb

@@ -177,20 +177,34 @@ module OnlineMigrations
     #   until `finalize_column_rename` is run
     #
     def initialize_column_rename(table_name, column_name, new_column_name)
-      tmp_table = "#{table_name}_column_rename"
+      initialize_columns_rename(table_name, { column_name => new_column_name })
+    end
 
+    # Same as `initialize_column_rename` but for multiple columns.
+    #
+    # This is useful to avoid multiple iterations of the safe column rename steps
+    # when renaming multiple columns.
+    #
+    # @param table_name [String, Symbol] table name
+    # @param old_new_column_hash [Hash] the hash of old and new columns
+    #
+    # @example
+    #   initialize_columns_rename(:users, { fname: :first_name, lname: :last_name })
+    #
+    # @see #initialize_column_rename
+    #
+    def initialize_columns_rename(table_name, old_new_column_hash)
       transaction do
-        rename_table(table_name, tmp_table)
-        execute("CREATE VIEW #{table_name} AS SELECT *, #{column_name} AS #{new_column_name} FROM #{tmp_table}")
+        rename_table_create_view(table_name, old_new_column_hash)
       end
     end
 
     # Reverts operations performed by initialize_column_rename
     #
     # @param table_name [String, Symbol] table name
-    # @param _column_name [String, Symbol] the name of the column to be renamed.
+    # @param column_name [String, Symbol] the name of the column to be renamed.
     #     Passing this argument will make this change reversible in migration
-    # @param _new_column_name [String, Symbol] new new name of the column.
+    # @param new_column_name [String, Symbol] new new name of the column.
     #     Passing this argument will make this change reversible in migration
     #
     # @return [void]
@@ -198,9 +212,24 @@ module OnlineMigrations
     # @example
     #   revert_initialize_column_rename(:users, :name, :first_name)
     #
-    def revert_initialize_column_rename(table_name, _column_name = nil, _new_column_name = nil)
+    def revert_initialize_column_rename(table_name, column_name = nil, new_column_name = nil)
+      revert_initialize_columns_rename(table_name, { column_name => new_column_name })
+    end
+
+    # Same as `revert_initialize_column_rename` but for multiple columns.
+    #
+    # @param table_name [String, Symbol] table name
+    # @param _old_new_column_hash [Hash] the hash of old and new columns
+    #     Passing this argument will make this change reversible in migration
+    #
+    # @return [void]
+    #
+    # @example
+    #   revert_initialize_columns_rename(:users, { fname: :first_name, lname: :last_name })
+    #
+    def revert_initialize_columns_rename(table_name, _old_new_column_hash = nil)
       transaction do
-        execute("DROP VIEW #{table_name}")
+        execute("DROP VIEW #{quote_table_name(table_name)}")
         rename_table("#{table_name}_column_rename", table_name)
       end
     end
@@ -214,10 +243,24 @@ module OnlineMigrations
     #   finalize_column_rename(:users, :name, :first_name)
     #
     def finalize_column_rename(table_name, column_name, new_column_name)
+      finalize_columns_rename(table_name, { column_name => new_column_name })
+    end
+
+    # Same as `finalize_column_rename` but for multiple columns.
+    #
+    # @param (see #initialize_columns_rename)
+    # @return [void]
+    #
+    # @example
+    #   finalize_columns_rename(:users, { fname: :first_name, lname: :last_name })
+    #
+    def finalize_columns_rename(table_name, old_new_column_hash)
       transaction do
-        execute("DROP VIEW #{table_name}")
+        execute("DROP VIEW #{quote_table_name(table_name)}")
         rename_table("#{table_name}_column_rename", table_name)
-        rename_column(table_name, column_name, new_column_name)
+        old_new_column_hash.each do |column_name, new_column_name|
+          rename_column(table_name, column_name, new_column_name)
+        end
       end
     end
 
@@ -230,12 +273,23 @@ module OnlineMigrations
     #   revert_finalize_column_rename(:users, :name, :first_name)
     #
     def revert_finalize_column_rename(table_name, column_name, new_column_name)
-      tmp_table = "#{table_name}_column_rename"
+      revert_finalize_columns_rename(table_name, { column_name => new_column_name })
+    end
 
+    # Same as `revert_finalize_column_rename` but for multiple columns.
+    #
+    # @param (see #initialize_columns_rename)
+    # @return [void]
+    #
+    # @example
+    #   revert_finalize_columns_rename(:users, { fname: :first_name, lname: :last_name })
+    #
+    def revert_finalize_columns_rename(table_name, old_new_column_hash)
       transaction do
-        rename_column(table_name, new_column_name, column_name)
-        rename_table(table_name, tmp_table)
-        execute("CREATE VIEW #{table_name} AS SELECT *, #{column_name} AS #{new_column_name} FROM #{tmp_table}")
+        old_new_column_hash.each do |column_name, new_column_name|
+          rename_column(table_name, new_column_name, column_name)
+        end
+        rename_table_create_view(table_name, old_new_column_hash)
       end
     end
 
@@ -286,7 +340,7 @@ module OnlineMigrations
     def initialize_table_rename(table_name, new_name)
       transaction do
         rename_table(table_name, new_name)
-        execute("CREATE VIEW #{table_name} AS SELECT * FROM #{new_name}")
+        execute("CREATE VIEW #{quote_table_name(table_name)} AS SELECT * FROM #{quote_table_name(new_name)}")
       end
     end
 
@@ -300,7 +354,7 @@ module OnlineMigrations
     #
     def revert_initialize_table_rename(table_name, new_name)
       transaction do
-        execute("DROP VIEW IF EXISTS #{table_name}")
+        execute("DROP VIEW IF EXISTS #{quote_table_name(table_name)}")
         rename_table(new_name, table_name)
       end
     end
@@ -316,7 +370,7 @@ module OnlineMigrations
     #   finalize_table_rename(:users, :clients)
     #
     def finalize_table_rename(table_name, _new_name = nil)
-      execute("DROP VIEW IF EXISTS #{table_name}")
+      execute("DROP VIEW IF EXISTS #{quote_table_name(table_name)}")
     end
 
     # Reverts operations performed by finalize_table_rename
@@ -329,7 +383,7 @@ module OnlineMigrations
     #   revert_finalize_table_rename(:users, :clients)
     #
     def revert_finalize_table_rename(table_name, new_name)
-      execute("CREATE VIEW #{table_name} AS SELECT * FROM #{new_name}")
+      execute("CREATE VIEW #{quote_table_name(table_name)} AS SELECT * FROM #{quote_table_name(new_name)}")
     end
 
     # Swaps two column names in a table
@@ -738,14 +792,18 @@ module OnlineMigrations
         options[:name] ||= __foreign_key_name(to_table, options[:column])
 
         query = <<-SQL.strip_heredoc.dup
-          ALTER TABLE #{from_table}
-          ADD CONSTRAINT #{options[:name]}
-          FOREIGN KEY (#{options[:column]})
-          REFERENCES #{to_table} (#{options[:primary_key]})
+          ALTER TABLE #{quote_table_name(from_table)}
+          ADD CONSTRAINT #{quote_column_name(options[:name])}
+          FOREIGN KEY (#{quote_column_name(options[:column])})
+          REFERENCES #{quote_table_name(to_table)} (#{quote_column_name(options[:primary_key])})
         SQL
         query << "#{__action_sql('DELETE', options[:on_delete])}\n" if options[:on_delete].present?
         query << "#{__action_sql('UPDATE', options[:on_update])}\n" if options[:on_update].present?
         query << "NOT VALID\n" if !validate
+        if Utils.ar_version >= 7.0 && options[:deferrable]
+          query << " DEFERRABLE"
+          query << " INITIALLY #{options[:deferrable].to_s.upcase}\n" if options[:deferrable] != true
+        end
 
         execute(query.squish)
       end
@@ -766,7 +824,7 @@ module OnlineMigrations
         # "VALIDATE CONSTRAINT" requires a "SHARE UPDATE EXCLUSIVE" lock.
         # It only conflicts with other validations, creating/removing indexes,
         # and some other "ALTER TABLE"s.
-        execute("ALTER TABLE #{from_table} VALIDATE CONSTRAINT #{fk_name_to_validate}")
+        execute("ALTER TABLE #{quote_table_name(from_table)} VALIDATE CONSTRAINT #{quote_column_name(fk_name_to_validate)}")
       end
     end
 
@@ -786,7 +844,10 @@ module OnlineMigrations
         Utils.say("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}, constraint name: #{constraint_name}")
       else
-        query = "ALTER TABLE #{table_name} ADD CONSTRAINT #{constraint_name} CHECK (#{expression})"
+        query = <<-SQL.squish
+          ALTER TABLE #{quote_table_name(table_name)}
+            ADD CONSTRAINT #{quote_column_name(constraint_name)} CHECK (#{expression})
+        SQL
         query += " NOT VALID" if !validate
 
         execute(query)
@@ -808,7 +869,10 @@ module OnlineMigrations
         # "VALIDATE CONSTRAINT" requires a "SHARE UPDATE EXCLUSIVE" lock.
         # It only conflicts with other validations, creating/removing indexes,
         # and some other "ALTER TABLE"s.
-        execute("ALTER TABLE #{table_name} VALIDATE CONSTRAINT #{constraint_name}")
+        execute(<<-SQL.squish)
+          ALTER TABLE #{quote_table_name(table_name)}
+            VALIDATE CONSTRAINT #{quote_column_name(constraint_name)}
+        SQL
       end
     end
 
@@ -818,7 +882,10 @@ module OnlineMigrations
       #
       def remove_check_constraint(table_name, expression = nil, **options)
         constraint_name = __check_constraint_name!(table_name, expression: expression, **options)
-        execute("ALTER TABLE #{table_name} DROP CONSTRAINT #{constraint_name}")
+        execute(<<-SQL.squish)
+          ALTER TABLE #{quote_table_name(table_name)}
+            DROP CONSTRAINT #{quote_column_name(constraint_name)}
+        SQL
       end
     end
 
@@ -1084,5 +1151,19 @@ module OnlineMigrations
         _, schema = table_name.to_s.split(".").reverse
         schema ? quote(schema) : "current_schema()"
       end
+
+      def rename_table_create_view(table_name, old_new_column_hash)
+        tmp_table = "#{table_name}_column_rename"
+        rename_table(table_name, tmp_table)
+        column_mapping = old_new_column_hash.map do |column_name, new_column_name|
+          "#{quote_column_name(column_name)} AS #{quote_column_name(new_column_name)}"
+        end.join(", ")
+
+        execute(<<-SQL.squish)
+          CREATE VIEW #{quote_table_name(table_name)} AS
+            SELECT *, #{column_mapping}
+            FROM #{quote_table_name(tmp_table)}
+        SQL
+      end
   end
 end

data/lib/online_migrations/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: online_migrations
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - fatkodima
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-04 00:00:00.000000000 Z
+date: 2023-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord