strong_migrations 1.6.0 → 2.8.0

data/lib/strong_migrations/checks.rb

@@ -10,7 +10,7 @@ module StrongMigrations
       if !new_table?(table)
         if postgresql? && options[:validate] != false
           add_options = options.merge(validate: false)
-          name = options[:name] || @migration.check_constraint_options(table, expression, options)[:name]
+          name = options[:name] || connection.check_constraint_options(table, expression, options)[:name]
           validate_options = {name: name}
 
           if StrongMigrations.safe_by_default
@@ -35,39 +35,40 @@ module StrongMigrations
       # keep track of new columns of change_column_default check
       @new_columns << [table.to_s, column.to_s]
 
-      # Check key since DEFAULT NULL behaves differently from no default
+      # adding a column with a volatile default is not safe with Postgres
+      # https://www.postgresql.org/docs/current/sql-altertable.html#SQL-ALTERTABLE-NOTES
+      # functions like random() and clock_timestamp() are volatile
+      # functions like concat('A', 'B') are safe
+      # default expressions in Postgres cannot reference other columns
       #
-      # Also, Active Record has special case for uuid columns that allows function default values
+      # adding a column with an expression default is not safe with MySQL
+      # even constant expressions like (3) are not safe
+      # literals like 3 are safe
+      #
+      # Active Record quotes default values except for procs
+      # there is also a special case for uuid columns
       # https://github.com/rails/rails/blob/v7.0.3.1/activerecord/lib/active_record/connection_adapters/postgresql/quoting.rb#L92-L93
-      if options.key?(:default) && (!adapter.add_column_default_safe? || (volatile = (postgresql? && type.to_s == "uuid" && default.to_s.include?("()") && adapter.default_volatile?(default))))
+      if !default.nil? && (!adapter.add_column_default_safe? || (volatile = (postgresql? && type.to_s == "uuid" && default.to_s.include?("()") && adapter.default_volatile?(default))))
         if options[:null] == false
           options = options.except(:null)
-          append = "
-
-Then add the NOT NULL constraint in separate migrations."
+          append = "\n\nThen add the NOT NULL constraint in separate migrations."
         end
 
-        if default.nil?
-          raise_error :add_column_default_null,
-            command: command_str("add_column", [table, column, type, options.except(:default)]),
-            append: append,
-            rewrite_blocks: adapter.rewrite_blocks
-        else
-          raise_error :add_column_default,
-            add_command: command_str("add_column", [table, column, type, options.except(:default)]),
-            change_command: command_str("change_column_default", [table, column, default]),
-            remove_command: command_str("remove_column", [table, column]),
-            code: backfill_code(table, column, default, volatile),
-            append: append,
-            rewrite_blocks: adapter.rewrite_blocks,
-            default_type: (volatile ? "volatile" : "non-null")
-        end
-      elsif default.is_a?(Proc) && postgresql?
-        # adding a column with a VOLATILE default is not safe
-        # https://www.postgresql.org/docs/current/sql-altertable.html#SQL-ALTERTABLE-NOTES
-        # functions like random() and clock_timestamp() are VOLATILE
+        raise_error :add_column_default,
+          add_command: command_str("add_column", [table, column, type, options.except(:default)]),
+          change_command: command_str("change_column_default", [table, column, default]),
+          remove_command: command_str("remove_column", [table, column]),
+          code: backfill_code(table, column, default, volatile),
+          append: append,
+          rewrite_blocks: adapter.rewrite_blocks,
+          default_type: volatile ? "volatile" : "non-null"
+      elsif default.is_a?(Proc)
         # check for Proc to match Active Record
-        raise_error :add_column_default_callable
+        raise_error :add_column_default_callable,
+          add_command: command_str("add_column", [table, column, type, options.except(:default)]),
+          change_command: command_str("change_column_default", [table, column]),
+          remove_command: command_str("remove_column", [table, column]),
+          default_type: postgresql? ? "volatile" : "an expression"
       end
 
       if type.to_s == "json" && postgresql?
@@ -78,6 +79,18 @@ Then add the NOT NULL constraint in separate migrations."
       if type.to_s == "virtual" && options[:stored]
         raise_error :add_column_generated_stored, rewrite_blocks: adapter.rewrite_blocks
       end
+
+      if adapter.auto_incrementing_types.include?(type.to_s)
+        append = (mysql? || mariadb?) ? "\n\nIf using statement-based replication, this can also generate different values on replicas." : ""
+        raise_error :add_column_auto_incrementing,
+          rewrite_blocks: adapter.rewrite_blocks,
+          append: append
+      end
+
+      check_algorithm_option("add_column", *args, **options)
+
+      # not necessarily dangerous, but not necessary
+      check_lock_option("add_column", *args, **options)
     end
 
     def check_add_exclusion_constraint(*args)
@@ -114,6 +127,11 @@ Then add the NOT NULL constraint in separate migrations."
         raise_error :add_foreign_key,
           add_foreign_key_code: command_str("add_foreign_key", [from_table, to_table, options.merge(validate: false)]),
           validate_foreign_key_code: command_str("validate_foreign_key", [from_table, to_table])
+      elsif mysql? || mariadb?
+        raise_error :add_foreign_key_mysql,
+          add_foreign_key_code: command_str("add_foreign_key", [from_table, to_table, options]),
+          # TODO exclude some options?
+          remove_foreign_key_code: command_str("remove_foreign_key", [from_table, to_table, options])
       end
     end
 
@@ -140,6 +158,10 @@ Then add the NOT NULL constraint in separate migrations."
 
         raise_error :add_index, command: command_str("add_index", [table, columns, options.merge(algorithm: :concurrently)])
       end
+
+      check_algorithm_option("add_index", *args, **options)
+
+      check_lock_option("add_index", *args, **options)
     end
 
     def check_add_reference(method, *args)
@@ -149,11 +171,15 @@ Then add the NOT NULL constraint in separate migrations."
       if postgresql?
         index_value = options.fetch(:index, true)
         concurrently_set = index_value.is_a?(Hash) && index_value[:algorithm] == :concurrently
-        bad_index = index_value && !concurrently_set
+        index_unsafe = index_value && !concurrently_set
+
+        foreign_key_value = options[:foreign_key]
+        validate_false = foreign_key_value.is_a?(Hash) && foreign_key_value[:validate] == false
+        foreign_key_unsafe = foreign_key_value && !validate_false
 
-        if bad_index || options[:foreign_key]
+        if index_unsafe || foreign_key_unsafe
           if index_value.is_a?(Hash)
-            options[:index] = options[:index].merge(algorithm: :concurrently)
+            options = options.merge(index: index_value.merge(algorithm: :concurrently))
           elsif index_value
             options = options.merge(index: {algorithm: :concurrently})
           end
@@ -163,11 +189,10 @@ Then add the NOT NULL constraint in separate migrations."
             throw :safe
           end
 
-          if options.delete(:foreign_key)
+          if foreign_key_unsafe
+            options.delete(:foreign_key)
             headline = "Adding a foreign key blocks writes on both tables."
-            append = "
-
-Then add the foreign key in separate migrations."
+            append = "\n\nThen add the foreign key in separate migrations."
           else
             headline = "Adding an index non-concurrently locks the table."
           end
@@ -177,6 +202,63 @@ Then add the foreign key in separate migrations."
             command: command_str(method, [table, reference, options]),
             append: append
         end
+      elsif mysql? || mariadb?
+        if options[:foreign_key]
+          raise_error :add_reference,
+            headline: "Adding a foreign key blocks writes on both tables.",
+            command: command_str(method, [table, reference, options.except(:foreign_key)]),
+            append: "\n\nThen add the foreign key in a separate migration."
+        end
+      end
+
+      check_algorithm_option("add_reference", *args, **options)
+
+      # not necessarily dangerous, but not necessary
+      check_lock_option("add_reference", *args, **options)
+
+      if (mysql? || mariadb?) && !new_table?(table)
+        index_value = options[:index]
+        copy_set = index_value.is_a?(Hash) && index_value[:algorithm] == :copy
+        if copy_set
+          index_value = index_value.except(:algorithm)
+          if index_value.empty?
+            options = options.except(:index)
+          else
+            options = options.merge(index: index_value)
+          end
+          raise_error :copy_algorithm, command: command_str("add_reference", args + [options])
+        end
+
+        if ar_version >= 8.2
+          lock = index_value.is_a?(Hash) && index_value[:lock]
+          if [:shared, :exclusive].include?(lock)
+            index_value = index_value.except(:lock)
+            if index_value.empty?
+              options = options.except(:index)
+            else
+              options = options.merge(index: index_value)
+            end
+            raise_error :lock_option,
+              command: command_str(method, args + [options]),
+              lock_type: lock.to_s,
+              lock_blocks: lock == :shared ? "reads" : "reads and writes"
+          end
+        end
+      end
+    end
+
+    def check_add_unique_constraint(*args)
+      args.extract_options!
+      table, column = args
+
+      # column and using_index cannot be used together
+      # check for column to ensure error message can be generated
+      if column && !new_table?(table)
+        index_name = connection.index_name(table, {column: column})
+        raise_error :add_unique_constraint,
+          index_command: command_str("add_index", [table, column, {unique: true, algorithm: :concurrently}]),
+          constraint_command: command_str("add_unique_constraint", [table, {using_index: index_name}]),
+          remove_command: command_str("remove_unique_constraint", [table, column])
       end
     end
 
@@ -199,17 +281,48 @@ Then add the foreign key in separate migrations."
       end
 
       raise_error :change_column, rewrite_blocks: adapter.rewrite_blocks unless safe
+
+      # constraints must be rechecked
+      # Postgres recommends dropping constraints before and adding them back
+      # https://www.postgresql.org/docs/current/ddl-alter.html#DDL-ALTER-COLUMN-TYPE
+      if postgresql?
+        constraints = adapter.constraints(table, column)
+        if constraints.any?
+          change_commands = []
+          constraints.each do |c|
+            change_commands << command_str("remove_check_constraint", [table, c.expression, {name: c.name}])
+          end
+          change_commands << command_str("change_column", args + [options])
+          constraints.each do |c|
+            change_commands << command_str("add_check_constraint", [table, c.expression, {name: c.name, validate: false}])
+          end
+
+          validate_commands = []
+          constraints.each do |c|
+            validate_commands << command_str("validate_check_constraint", [table, {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
+
+      check_algorithm_option("change_column", *args, **options)
+
+      # not necessarily dangerous, but not necessary
+      check_lock_option("change_column", *args, **options)
     end
 
     def check_change_column_default(*args)
       table, column, _default_or_changes = args
 
       # just check ActiveRecord::Base, even though can override on model
-      partial_inserts = ar_version >= 7 ? ActiveRecord::Base.partial_inserts : ActiveRecord::Base.partial_writes
+      partial_inserts = ActiveRecord::Base.partial_inserts
 
       if partial_inserts && !new_column?(table, column)
         raise_error :change_column_default,
-          config: ar_version >= 7 ? "partial_inserts" : "partial_writes"
+          config: "partial_inserts"
       end
     end
 
@@ -217,60 +330,40 @@ Then add the foreign key in separate migrations."
       table, column, null, default = args
       if !null
         if postgresql?
-          safe = false
-          safe_with_check_constraint = adapter.server_version >= Gem::Version.new("12")
-          if safe_with_check_constraint
-            safe = adapter.constraints(table).any? { |c| c["def"] == "CHECK ((#{column} IS NOT NULL))" || c["def"] == "CHECK ((#{connection.quote_column_name(column)} IS NOT NULL))" }
-          end
+          constraints = connection.check_constraints(table)
+          safe = constraints.any? { |c| c.options[:validate] && (c.expression == "#{column} IS NOT NULL" || c.expression == "#{connection.quote_column_name(column)} IS NOT NULL") }
 
           unless safe
+            expression = "#{quote_column_if_needed(column)} IS NOT NULL"
+
             # match https://github.com/nullobject/rein
             constraint_name = "#{table}_#{column}_null"
+            if adapter.max_constraint_name_length && constraint_name.bytesize > adapter.max_constraint_name_length
+              constraint_name = connection.check_constraint_options(table, expression, {})[:name]
 
-            add_code = constraint_str("ALTER TABLE %s ADD CONSTRAINT %s CHECK (%s IS NOT NULL) NOT VALID", [table, constraint_name, column])
-            validate_code = constraint_str("ALTER TABLE %s VALIDATE CONSTRAINT %s", [table, constraint_name])
-            remove_code = constraint_str("ALTER TABLE %s DROP CONSTRAINT %s", [table, constraint_name])
-
-            constraint_methods = ar_version >= 6.1
-
-            validate_constraint_code =
-              if constraint_methods
-                String.new(command_str(:validate_check_constraint, [table, {name: constraint_name}]))
-              else
-                String.new(safety_assured_str(validate_code))
-              end
-
-            if safe_with_check_constraint
-              change_args = [table, column, null]
-
-              validate_constraint_code << "\n    #{command_str(:change_column_null, change_args)}"
-
-              if constraint_methods
-                validate_constraint_code << "\n    #{command_str(:remove_check_constraint, [table, {name: constraint_name}])}"
-              else
-                validate_constraint_code << "\n    #{safety_assured_str(remove_code)}"
+              # avoid collision with Active Record naming for safe_by_default
+              if StrongMigrations.safe_by_default
+                constraint_name = constraint_name.sub("rails", "strong_migrations")
               end
             end
 
+            add_args = [table, expression, {name: constraint_name, validate: false}]
+            validate_args = [table, {name: constraint_name}]
+            change_args = [table, column, null]
+            remove_args = [table, {name: constraint_name}]
+
             if StrongMigrations.safe_by_default
-              safe_change_column_null(add_code, validate_code, change_args, remove_code, default)
+              safe_change_column_null(add_args, validate_args, change_args, remove_args, table, column, default, constraints)
               throw :safe
             end
 
-            add_constraint_code =
-              if constraint_methods
-                command_str(:add_check_constraint, [table, "#{quote_column_if_needed(column)} IS NOT NULL", {name: constraint_name, validate: false}])
-              else
-                safety_assured_str(add_code)
-              end
+            add_constraint_code = command_str("add_check_constraint", add_args)
 
-            validate_constraint_code =
-              if safe_with_check_constraint
-                down_code = "#{add_constraint_code}\n    #{command_str(:change_column_null, [table, column, true])}"
-                "def up\n    #{validate_constraint_code}\n  end\n\n  def down\n    #{down_code}\n  end"
-              else
-                "def change\n    #{validate_constraint_code}\n  end"
-              end
+            up_code = String.new(command_str("validate_check_constraint", validate_args))
+            up_code << "\n    #{command_str("change_column_null", change_args)}"
+            up_code << "\n    #{command_str("remove_check_constraint", remove_args)}"
+            down_code = "#{add_constraint_code}\n    #{command_str("change_column_null", [table, column, true])}"
+            validate_constraint_code = "def up\n    #{up_code}\n  end\n\n  def down\n    #{down_code}\n  end"
 
             raise_error :change_column_null_postgresql,
               add_constraint_code: add_constraint_code,
@@ -315,33 +408,33 @@ Then add the foreign key in separate migrations."
       raise_error :execute, header: "Possibly dangerous operation"
     end
 
+    # supports algorithm and lock options, but always raises
     def check_remove_column(method, *args)
       columns =
         case method
         when :remove_timestamps
-          ["created_at", "updated_at"]
+          [:created_at, :updated_at]
         when :remove_column
-          [args[1].to_s]
+          [args[1]]
         when :remove_columns
-          # Active Record 6.1+ supports options
           if args.last.is_a?(Hash)
-            args[1..-2].map(&:to_s)
+            args[1..-2]
           else
-            args[1..-1].map(&:to_s)
+            args[1..-1]
           end
         else
           options = args[2] || {}
           reference = args[1]
           cols = []
-          cols << "#{reference}_type" if options[:polymorphic]
-          cols << "#{reference}_id"
+          cols << "#{reference}_type".to_sym if options[:polymorphic]
+          cols << "#{reference}_id".to_sym
           cols
         end
 
-      code = "self.ignored_columns = #{columns.inspect}"
+      code = "self.ignored_columns += #{columns.map(&:to_s).inspect}"
 
       raise_error :remove_column,
-        model: args[0].to_s.classify,
+        model: model_name(args[0]),
         code: code,
         command: command_str(method, args),
         column_suffix: columns.size > 1 ? "s" : ""
@@ -355,12 +448,6 @@ Then add the foreign key in separate migrations."
         # avoid suggesting extra (invalid) args
         args = args[0..1] unless StrongMigrations.safe_by_default
 
-        # Active Record < 6.1 only supports two arguments (including options)
-        if args.size == 2 && ar_version < 6.1
-          # arg takes precedence over option
-          options[:column] = args.pop
-        end
-
         if StrongMigrations.safe_by_default
           safe_remove_index(*args, **options)
           throw :safe
@@ -368,12 +455,30 @@ Then add the foreign key in separate migrations."
 
         raise_error :remove_index, command: command_str("remove_index", args + [options.merge(algorithm: :concurrently)])
       end
+
+      check_algorithm_option("remove_index", *args, **options)
+
+      # not necessarily dangerous, but not necessary
+      check_lock_option("remove_index", *args, **options)
     end
 
+    # supports algorithm and lock options, but always raises
     def check_rename_column
       raise_error :rename_column
     end
 
+    def check_rename_enum_value(*args)
+      options = args.extract_options!
+      type_name, _ = args
+
+      raise_error :rename_enum_value,
+        command: command_str("add_enum_value", [type_name, options[:to], {after: options[:from]}])
+    end
+
+    def check_rename_schema
+      raise_error :rename_schema
+    end
+
     def check_rename_table
       raise_error :rename_table
     end
@@ -415,7 +520,7 @@ Then add the foreign key in separate migrations."
       message = message + append if append
 
       vars[:migration_name] = @migration.class.name
-      vars[:migration_suffix] = "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      vars[:migration_suffix] = migration_suffix
       vars[:base_model] = "ApplicationRecord"
 
       # escape % not followed by {
@@ -423,6 +528,21 @@ Then add the foreign key in separate migrations."
       @migration.stop!(message, header: header || "Dangerous operation detected")
     end
 
+    def check_algorithm_option(method, *args, **options)
+      if (mysql? || mariadb?) && options[:algorithm] == :copy && !new_table?(args[0]) && (ar_version >= 8.2 || method == "add_index")
+        raise_error :copy_algorithm, command: command_str(method, args + [options.except(:algorithm)])
+      end
+    end
+
+    def check_lock_option(method, *args, **options)
+      if (mysql? || mariadb?) && [:shared, :exclusive].include?(options[:lock]) && !new_table?(args[0]) && ar_version >= 8.2
+        raise_error :lock_option,
+          command: command_str(method, args + [options.except(:lock)]),
+          lock_type: options[:lock].to_s,
+          lock_blocks: options[:lock] == :shared ? "reads" : "reads and writes"
+      end
+    end
+
     def constraint_str(statement, identifiers)
       # not all identifiers are tables, but this method of quoting should be fine
       statement % identifiers.map { |v| connection.quote_table_name(v) }
@@ -456,20 +576,20 @@ Then add the foreign key in separate migrations."
     end
 
     def backfill_code(table, column, default, function = false)
-      model = table.to_s.classify
+      model = model_name(table)
       if function
         # update_all(column: Arel.sql(default)) also works in newer versions of Active Record
         update_expr = "#{quote_column_if_needed(column)} = #{default}"
-        "#{model}.unscoped.in_batches do |relation| \n      relation.where(#{column}: nil).update_all(#{update_expr.inspect})\n      sleep(0.01)\n    end"
+        "#{model}.unscoped.in_batches(of: 10000) do |relation| \n      relation.where(#{column}: nil).update_all(#{update_expr.inspect})\n      sleep(0.01)\n    end"
       else
-        "#{model}.unscoped.in_batches do |relation| \n      relation.update_all #{column}: #{default.inspect}\n      sleep(0.01)\n    end"
+        "#{model}.unscoped.in_batches(of: 10000) do |relation| \n      relation.where(#{column}: nil).update_all #{column}: #{default.inspect}\n      sleep(0.01)\n    end"
       end
     end
 
     # only quote when needed
     # important! only use for display purposes
     def quote_column_if_needed(column)
-      column.to_s =~ /\A[a-z0-9_]+\z/ ? column : connection.quote_column_name(column)
+      /\A[a-z0-9_]+\z/.match?(column.to_s) ? column : connection.quote_column_name(column)
     end
 
     def new_table?(table)
@@ -479,5 +599,13 @@ Then add the foreign key in separate migrations."
     def new_column?(table, column)
       new_table?(table) || @new_columns.include?([table.to_s, column.to_s])
     end
+
+    def migration_suffix
+      "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+    end
+
+    def model_name(table)
+      table.to_s.classify
+    end
   end
 end