strong_migrations 1.6.0 → 2.8.0

data/lib/generators/strong_migrations/install_generator.rb

@@ -21,21 +21,17 @@ module StrongMigrations
 
       def target_version
         case adapter
-        when /mysql/
+        when /mysql|trilogy/
           # could try to connect to database and check for MariaDB
           # but this should be fine
-          '"8.0.12"'
+          "8.4"
         else
-          "10"
+          "18"
         end
       end
 
       def adapter
-        if ActiveRecord::VERSION::STRING.to_f >= 6.1
-          ActiveRecord::Base.connection_db_config.adapter.to_s
-        else
-          ActiveRecord::Base.connection_config[:adapter].to_s
-        end
+        ActiveRecord::Base.connection_db_config.adapter.to_s
       end
 
       def postgresql?

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

@@ -20,6 +20,9 @@ StrongMigrations.auto_analyze = true
 #   end
 # end<% if postgresql? %>
 
+# Remove invalid indexes when rerunning migrations
+# StrongMigrations.remove_invalid_indexes = true
+
 # Make some operations safe by default
 # See https://github.com/ankane/strong_migrations#safe-by-default
 # StrongMigrations.safe_by_default = true<% end %>

data/lib/strong_migrations/adapters/abstract_adapter.rb

@@ -13,11 +13,15 @@ module StrongMigrations
       end
 
       def set_statement_timeout(timeout)
-        raise StrongMigrations::Error, "Statement timeout not supported for this database"
+        # do nothing
+      end
+
+      def set_transaction_timeout(timeout)
+        # do nothing
       end
 
       def set_lock_timeout(timeout)
-        raise StrongMigrations::Error, "Lock timeout not supported for this database"
+        # do nothing
       end
 
       def check_lock_timeout(limit)
@@ -36,6 +40,13 @@ module StrongMigrations
         "reads and writes"
       end
 
+      def auto_incrementing_types
+        ["primary_key"]
+      end
+
+      def max_constraint_name_length
+      end
+
       private
 
       def connection
@@ -51,14 +62,6 @@ module StrongMigrations
         version =
           if target_version && StrongMigrations.developer_env?
             if target_version.is_a?(Hash)
-              # Active Record 6.0 supports multiple databases
-              # but connection.pool.spec.name always returns "primary"
-              # in migrations with rails db:migrate
-              if ActiveRecord::VERSION::STRING.to_f < 6.1
-                # error class is not shown in db:migrate output so ensure message is descriptive
-                raise StrongMigrations::Error, "StrongMigrations.target_version does not support multiple databases for Active Record < 6.1"
-              end
-
               db_config_name = connection.pool.db_config.name
               target_version.stringify_keys.fetch(db_config_name) do
                 # error class is not shown in db:migrate output so ensure message is descriptive

data/lib/strong_migrations/adapters/mariadb_adapter.rb

@@ -6,7 +6,7 @@ module StrongMigrations
       end
 
       def min_version
-        "10.2"
+        "10.5"
       end
 
       def server_version
@@ -25,7 +25,7 @@ module StrongMigrations
       end
 
       def add_column_default_safe?
-        server_version >= Gem::Version.new("10.3.2")
+        true
       end
     end
   end

data/lib/strong_migrations/adapters/mysql_adapter.rb

@@ -8,7 +8,7 @@ module StrongMigrations
       end
 
       def min_version
-        "5.7"
+        "8.0"
       end
 
       def server_version
@@ -44,7 +44,7 @@ module StrongMigrations
       end
 
       def add_column_default_safe?
-        server_version >= Gem::Version.new("8.0.12")
+        true
       end
 
       def change_type_safe?(table, column, type, options, existing_column, existing_type)
@@ -65,9 +65,10 @@ module StrongMigrations
             sql = <<~SQL
               SELECT cs.MAXLEN
               FROM INFORMATION_SCHEMA.CHARACTER_SETS cs
-              INNER JOIN INFORMATION_SCHEMA.COLLATIONS c ON c.CHARACTER_SET_NAME = cs.CHARACTER_SET_NAME
-              INNER JOIN INFORMATION_SCHEMA.TABLES t ON t.TABLE_COLLATION = c.COLLATION_NAME
-              WHERE t.TABLE_SCHEMA = database() AND t.TABLE_NAME = #{connection.quote(table)}
+              INNER JOIN INFORMATION_SCHEMA.COLUMNS c ON c.CHARACTER_SET_NAME = cs.CHARACTER_SET_NAME
+              WHERE c.TABLE_SCHEMA = database() AND
+              c.TABLE_NAME = #{connection.quote(table)} AND
+              c.COLUMN_NAME = #{connection.quote(column)}
             SQL
             row = connection.select_all(sql).first
             if row
@@ -91,6 +92,10 @@ module StrongMigrations
         "writes"
       end
 
+      def max_constraint_name_length
+        64
+      end
+
       private
 
       # do not memoize

data/lib/strong_migrations/adapters/postgresql_adapter.rb

@@ -6,7 +6,7 @@ module StrongMigrations
       end
 
       def min_version
-        "10"
+        "12"
       end
 
       def server_version
@@ -23,6 +23,11 @@ module StrongMigrations
         set_timeout("statement_timeout", timeout)
       end
 
+      def set_transaction_timeout(timeout)
+        # TODO make sure true version supports it as well?
+        set_timeout("transaction_timeout", timeout) if server_version >= Gem::Version.new("17")
+      end
+
       def set_lock_timeout(timeout)
         set_timeout("lock_timeout", timeout)
       end
@@ -42,7 +47,7 @@ module StrongMigrations
       end
 
       def add_column_default_safe?
-        server_version >= Gem::Version.new("11")
+        true
       end
 
       def change_type_safe?(table, column, type, options, existing_column, existing_type)
@@ -95,7 +100,7 @@ module StrongMigrations
             "timestamp" => "timestamp without time zone",
             "timestamptz" => "timestamp with time zone"
           }
-          maybe_safe = type_map.values.include?(existing_type) && precision >= existing_precision
+          maybe_safe = type_map.value?(existing_type) && precision >= existing_precision
 
           if maybe_safe
             new_type = type.to_s == "datetime" ? datetime_type : type.to_s
@@ -103,7 +108,7 @@ module StrongMigrations
             # resolve with fallback
             new_type = type_map[new_type] || new_type
 
-            safe = new_type == existing_type || (server_version >= Gem::Version.new("12") && time_zone == "UTC")
+            safe = new_type == existing_type || time_zone == "UTC"
           end
         when "time"
           precision = options[:precision] || options[:limit] || 6
@@ -127,21 +132,6 @@ module StrongMigrations
         safe
       end
 
-      def constraints(table_name)
-        query = <<~SQL
-          SELECT
-            conname AS name,
-            pg_get_constraintdef(oid) AS def
-          FROM
-            pg_constraint
-          WHERE
-            contype = 'c' AND
-            convalidated AND
-            conrelid = #{connection.quote(connection.quote_table_name(table_name))}::regclass
-        SQL
-        select_all(query.squish).to_a
-      end
-
       def writes_blocked?
         query = <<~SQL
           SELECT
@@ -169,6 +159,19 @@ module StrongMigrations
         rows.empty? || rows.any? { |r| r["provolatile"] == "v" }
       end
 
+      def auto_incrementing_types
+        ["primary_key", "serial", "bigserial"]
+      end
+
+      def max_constraint_name_length
+        63
+      end
+
+      def constraints(table, column)
+        # TODO improve column check
+        connection.check_constraints(table).select { |c| /\b#{Regexp.escape(column.to_s)}\b/.match?(c.expression) }
+      end
+
       private
 
       def set_timeout(setting, timeout)
@@ -206,15 +209,9 @@ module StrongMigrations
       end
 
       def datetime_type
-        key =
-          if ActiveRecord::VERSION::MAJOR >= 7
-            # https://github.com/rails/rails/pull/41084
-            # no need to support custom datetime_types
-            connection.class.datetime_type
-          else
-            # https://github.com/rails/rails/issues/21126#issuecomment-327895275
-            :datetime
-          end
+        # https://github.com/rails/rails/pull/41084
+        # no need to support custom datetime_types
+        key = connection.class.datetime_type
 
         # could be timestamp, timestamp without time zone, timestamp with time zone, etc
         connection.class.const_get(:NATIVE_DATABASE_TYPES).fetch(key).fetch(:name)

data/lib/strong_migrations/checker.rb

@@ -5,26 +5,38 @@ module StrongMigrations
 
     attr_accessor :direction, :transaction_disabled, :timeouts_set
 
+    class << self
+      attr_accessor :safe
+    end
+
     def initialize(migration)
       @migration = migration
+      reset
+    end
+
+    def reset
       @new_tables = []
       @new_columns = []
-      @safe = false
       @timeouts_set = false
       @committed = false
+      @transaction_disabled = false
+      @skip_retries = false
     end
 
-    def safety_assured
-      previous_value = @safe
+    def self.safety_assured
+      previous_value = safe
       begin
-        @safe = true
+        self.safe = true
         yield
       ensure
-        @safe = previous_value
+        self.safe = previous_value
       end
     end
 
-    def perform(method, *args)
+    def perform(method, *args, &block)
+      return yield if skip?
+
+      check_adapter
       check_version_supported
       set_timeouts
       check_lock_timeout
@@ -45,6 +57,8 @@ module StrongMigrations
           check_add_index(*args)
         when :add_reference, :add_belongs_to
           check_add_reference(method, *args)
+        when :add_unique_constraint
+          check_add_unique_constraint(*args)
         when :change_column
           check_change_column(*args)
         when :change_column_default
@@ -65,6 +79,10 @@ module StrongMigrations
           check_remove_index(*args)
         when :rename_column
           check_rename_column
+        when :rename_enum_value
+          check_rename_enum_value(*args)
+        when :rename_schema
+          check_rename_schema
         when :rename_table
           check_rename_table
         when :validate_check_constraint
@@ -78,9 +96,11 @@ module StrongMigrations
           @committed = true
         end
 
-        # custom checks
-        StrongMigrations.checks.each do |check|
-          @migration.instance_exec(method, args, &check)
+        if !safe?
+          # custom checks
+          StrongMigrations.checks.each do |check|
+            @migration.instance_exec(method, args, &check)
+          end
         end
       end
 
@@ -89,19 +109,26 @@ module StrongMigrations
           # TODO figure out how to handle methods that generate multiple statements
           # like add_reference(table, ref, index: {algorithm: :concurrently})
           # lock timeout after first statement will cause retry to fail
-          retry_lock_timeouts { yield }
+          retry_lock_timeouts { perform_method(method, *args, &block) }
         else
-          yield
+          perform_method(method, *args, &block)
         end
 
       # outdated statistics + a new index can hurt performance of existing queries
-      if StrongMigrations.auto_analyze && direction == :up && method == :add_index
+      if StrongMigrations.auto_analyze && direction == :up && adds_index?(method, *args)
         adapter.analyze_table(args[0])
       end
 
       result
     end
 
+    def perform_method(method, *args)
+      if StrongMigrations.remove_invalid_indexes && direction == :up && method == :add_index && postgresql?
+        remove_invalid_index_if_needed(*args)
+      end
+      yield
+    end
+
     def retry_lock_timeouts(check_committed: false)
       retries = 0
       begin
@@ -118,8 +145,36 @@ module StrongMigrations
       end
     end
 
+    def version_safe?
+      version && version <= StrongMigrations.start_after
+    end
+
+    def skip?
+      StrongMigrations.skipped_databases.map(&:to_s).include?(db_config_name)
+    end
+
+    def set_transaction_timeout
+      return if defined?(@transaction_timeout_set)
+
+      if StrongMigrations.transaction_timeout
+        adapter.set_transaction_timeout(StrongMigrations.transaction_timeout)
+      end
+
+      @transaction_timeout_set = true
+    end
+
     private
 
+    def check_adapter
+      return if defined?(@adapter_checked)
+
+      if adapter.instance_of?(Adapters::AbstractAdapter)
+        warn "[strong_migrations] Unsupported adapter: #{connection.adapter_name}. Use StrongMigrations.skip_database(#{db_config_name.to_sym.inspect}) to silence this warning."
+      end
+
+      @adapter_checked = true
+    end
+
     def check_version_supported
       return if defined?(@version_checked)
 
@@ -158,11 +213,7 @@ module StrongMigrations
     end
 
     def safe?
-      @safe || ENV["SAFETY_ASSURED"] || (direction == :down && !StrongMigrations.check_down) || version_safe?
-    end
-
-    def version_safe?
-      version && version <= StrongMigrations.start_after
+      self.class.safe || ENV["SAFETY_ASSURED"] || (direction == :down && !StrongMigrations.check_down) || version_safe? || @migration.reverting?
     end
 
     def version
@@ -175,7 +226,7 @@ module StrongMigrations
           case connection.adapter_name
           when /postg/i # PostgreSQL, PostGIS
             Adapters::PostgreSQLAdapter
-          when /mysql/i
+          when /mysql|trilogy/i
             if connection.try(:mariadb?)
               Adapters::MariaDBAdapter
             else
@@ -193,12 +244,57 @@ module StrongMigrations
       @migration.connection
     end
 
+    def db_config_name
+      connection.pool.db_config.name
+    end
+
     def retry_lock_timeouts?(method)
       (
         StrongMigrations.lock_timeout_retries > 0 &&
         !in_transaction? &&
-        method != :transaction
+        method != :transaction &&
+        !@skip_retries
       )
     end
+
+    def without_retries
+      previous_value = @skip_retries
+      begin
+        @skip_retries = true
+        yield
+      ensure
+        @skip_retries = previous_value
+      end
+    end
+
+    def adds_index?(method, *args)
+      case method
+      when :add_index
+        true
+      when :add_reference, :add_belongs_to
+        options = args.extract_options!
+        !!options.fetch(:index, true)
+      else
+        false
+      end
+    end
+
+    # REINDEX INDEX CONCURRENTLY leaves a new invalid index if it fails, so use remove_index instead
+    def remove_invalid_index_if_needed(*args)
+      options = args.extract_options!
+
+      # ensures has same options as existing index
+      # check args to avoid errors with index_exists?
+      return unless args.size == 2 && connection.index_exists?(*args, **options.merge(valid: false))
+
+      table, columns = args
+      index_name = options.fetch(:name, connection.index_name(table, columns))
+
+      @migration.say("Attempting to remove invalid index")
+      without_retries do
+        # TODO pass index schema for extra safety?
+        @migration.remove_index(table, **{name: index_name}.merge(options.slice(:algorithm)))
+      end
+    end
   end
 end