departure 4.0.1 → 6.3.0

data/departure.gemspec

@@ -1,30 +1,35 @@
 # coding: utf-8
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 require 'departure/version'
 
+# This environment variable is set on CI to facilitate testing with multiple
+# versions of Rails.
+RAILS_DEPENDENCY_VERSION = ENV.fetch('RAILS_VERSION', ['>= 5.2.0', '<= 6.1'])
+
 Gem::Specification.new do |spec|
   spec.name          = 'departure'
   spec.version       = Departure::VERSION
-  spec.authors       = ['Ilya Zayats', 'Pau Pérez', 'Fran Casas', 'Jorge Morante', 'Enrico Stano', 'Adrian Serafin']
-  spec.email         = ['ilya.zayats@redbooth.com', 'pau.perez@redbooth.com', 'fran.casas@redbooth.com', 'jorge.morante@redbooth.com', 'adrian@softmad.pl']
+  spec.authors       = ['Ilya Zayats', 'Pau Pérez', 'Fran Casas', 'Jorge Morante', 'Enrico Stano', 'Adrian Serafin', 'Kirk Haines', 'Guillermo Iguaran']
+  spec.email         = ['ilya.zayats@redbooth.com', 'pau.perez@redbooth.com', 'nflamel@gmail.com', 'jorge.morante@redbooth.com', 'adrian@softmad.pl', 'wyhaines@gmail.com', 'guilleiguaran@gmail.com']
 
-  spec.summary       = %q{pt-online-schema-change runner for ActiveRecord migrations}
-  spec.description   = %q{Execute your ActiveRecord migrations with Percona's pt-online-schema-change. Formerly known as Percona Migrator.}
-  spec.homepage      = 'http://github.com/redbooth/departure'
+  spec.summary       = %q(pt-online-schema-change runner for ActiveRecord migrations)
+  spec.description   = %q(Execute your ActiveRecord migrations with Percona's pt-online-schema-change. Formerly known as Percona Migrator.)
+  spec.homepage      = 'https://github.com/departurerb/departure'
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency 'rails', '~> 4.2.0'
-  spec.add_runtime_dependency 'mysql2', '~> 0.4.0'
+  spec.add_runtime_dependency 'railties', *Array(RAILS_DEPENDENCY_VERSION)
+  spec.add_runtime_dependency 'activerecord', *Array(RAILS_DEPENDENCY_VERSION)
+  spec.add_runtime_dependency 'mysql2', '>= 0.4.0', '<= 0.5.3'
 
-  spec.add_development_dependency 'bundler', '~> 1.10'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.4', '>= 3.4.0'
   spec.add_development_dependency 'rspec-its', '~> 1.2'
-  spec.add_development_dependency 'byebug', '~> 8.2', '>= 8.2.1'
+  spec.add_development_dependency 'pry-byebug'
   spec.add_development_dependency 'climate_control', '~> 0.0.3'
 end

data/docker-compose.yml

@@ -0,0 +1,23 @@
+version: '2'
+services:
+  db:
+    image: mysql/mysql-server
+    ports: 
+      - "3306:3306"
+    environment:
+      MYSQL_DATABASE: departure_test
+      MYSQL_ALLOW_EMPTY_PASSWORD: 'yes'
+      MYSQL_ROOT_HOST: '%'
+  rails:
+    build: .
+    links:
+      - db
+    depends_on:
+      - db
+    tty: true
+    stdin_open: true
+    environment:
+      PERCONA_DB_USER: root
+      PERCONA_DB_HOST: db
+      PERCONA_DB_PASSWORD:
+      PERCONA_DB_NAME: departure_test

data/lib/active_record/connection_adapters/for_alter.rb

@@ -0,0 +1,91 @@
+require 'active_record/connection_adapters/mysql/schema_statements'
+
+module ForAlterStatements
+  class << self
+    def included(_)
+      STDERR.puts 'Including for_alter statements'
+    end
+  end
+
+  def bulk_change_table(table_name, operations) #:nodoc:
+    sqls = operations.flat_map do |command, args|
+      table = args.shift
+      arguments = args
+
+      method = :"#{command}_for_alter"
+
+      raise "Unknown method called : #{method}(#{arguments.inspect})" unless respond_to?(method, true)
+      public_send(method, table, *arguments)
+    end.join(', ')
+
+    execute("ALTER TABLE #{quote_table_name(table_name)} #{sqls}")
+  end
+
+  def change_column_for_alter(table_name, column_name, type, options = {})
+    column = column_for(table_name, column_name)
+    type ||= column.sql_type
+
+    options = {
+      default: column.default,
+      null: column.null,
+      comment: column.comment
+    }.merge(options)
+
+    td = create_table_definition(table_name)
+    cd = td.new_column_definition(column.name, type, options)
+    schema_creation.accept(ActiveRecord::ConnectionAdapters::ChangeColumnDefinition.new(cd, column.name))
+  end
+
+  def rename_column_for_alter(table_name, column_name, new_column_name)
+    column  = column_for(table_name, column_name)
+    options = {
+      default: column.default,
+      null: column.null,
+      auto_increment: column.auto_increment?
+    }
+
+    columns_sql = "SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE #{quote(column_name)}"
+    current_type = exec_query(columns_sql, 'SCHEMA').first['Type']
+    td = create_table_definition(table_name)
+    cd = td.new_column_definition(new_column_name, current_type, options)
+    schema_creation.accept(ActiveRecord::ConnectionAdapters::ChangeColumnDefinition.new(cd, column.name))
+  end
+
+  def add_index_for_alter(table_name, column_name, options = {})
+    index_name, index_type, index_columns, _,
+      index_algorithm, index_using = add_index_options(table_name, column_name, options)
+
+    index_algorithm[0, 0] = ', ' if index_algorithm.present?
+    "ADD #{index_type} INDEX #{quote_column_name(index_name)} #{index_using} (#{index_columns})#{index_algorithm}"
+  end
+
+  def remove_index_for_alter(table_name, options = {})
+    index_name = index_name_for_remove(table_name, options)
+    "DROP INDEX #{quote_column_name(index_name)}"
+  end
+
+  def add_timestamps_for_alter(table_name, options = {})
+    [
+      add_column_for_alter(table_name, :created_at, :datetime, options),
+      add_column_for_alter(table_name, :updated_at, :datetime, options)
+    ]
+  end
+
+  def remove_timestamps_for_alter(table_name, _options = {})
+    [remove_column_for_alter(table_name, :updated_at), remove_column_for_alter(table_name, :created_at)]
+  end
+
+  def add_column_for_alter(table_name, column_name, type, options = {})
+    td = create_table_definition(table_name)
+    cd = td.new_column_definition(column_name, type, options)
+    schema_creation.accept(ActiveRecord::ConnectionAdapters::AddColumnDefinition.new(cd))
+  end
+
+  def remove_column_for_alter(_table_name, column_name, _type = nil, _options = {})
+    "DROP COLUMN #{quote_column_name(column_name)}"
+  end
+
+  def remove_columns_for_alter(table_name, *column_names)
+    column_names.map { |column_name| remove_column_for_alter(table_name, column_name) }
+  end
+end

data/lib/active_record/connection_adapters/percona_adapter.rb

@@ -9,10 +9,12 @@ module ActiveRecord
     # Establishes a connection to the database that's used by all Active
     # Record objects.
     def percona_connection(config)
+      if config[:username].nil?
+        config = config.dup if config.frozen?
+        config[:username] = 'root'
+      end
       mysql2_connection = mysql2_connection(config)
 
-      config[:username] = 'root' if config[:username].nil?
-
       connection_details = Departure::ConnectionDetails.new(config)
       verbose = ActiveRecord::Migration.verbose
       sanitizers = [
@@ -40,32 +42,54 @@ module ActiveRecord
 
   module ConnectionAdapters
     class DepartureAdapter < AbstractMysqlAdapter
-
-      class Column < AbstractMysqlAdapter::Column
+      class Column < ActiveRecord::ConnectionAdapters::MySQL::Column
         def adapter
           DepartureAdapter
         end
       end
 
+      class SchemaCreation < ActiveRecord::ConnectionAdapters::MySQL::SchemaCreation
+        def visit_DropForeignKey(name) # rubocop:disable Naming/MethodName
+          fk_name =
+            if name =~ /^__(.+)/
+              Regexp.last_match(1)
+            else
+              "_#{name}"
+            end
+
+          "DROP FOREIGN KEY #{fk_name}"
+        end
+      end
+
       extend Forwardable
 
+      unless method_defined?(:change_column_for_alter)
+        include ForAlterStatements
+      end
+
       ADAPTER_NAME = 'Percona'.freeze
 
       def_delegators :mysql_adapter, :last_inserted_id, :each_hash, :set_field_encoding
 
       def initialize(connection, _logger, connection_options, _config)
+        @mysql_adapter = connection_options[:mysql_adapter]
         super
         @prepared_statements = false
-        @mysql_adapter = connection_options[:mysql_adapter]
+      end
+
+      def write_query?(sql) # :nodoc:
+        !ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+          :desc, :describe, :set, :show, :use
+        ).match?(sql)
       end
 
       def exec_delete(sql, name, binds)
         execute(to_sql(sql, binds), name)
         @connection.affected_rows
       end
-      alias :exec_update :exec_delete
+      alias exec_update exec_delete
 
-      def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
+      def exec_insert(sql, name, binds, pk = nil, sequence_name = nil) # rubocop:disable Lint/UnusedMethodArgument, Metrics/LineLength
         execute(to_sql(sql, binds), name)
       end
 
@@ -76,8 +100,9 @@ module ActiveRecord
 
       # Executes a SELECT query and returns an array of rows. Each row is an
       # array of field values.
-      def select_rows(sql, name = nil)
-        execute(sql, name).to_a
+
+      def select_rows(arel, name = nil, binds = [])
+        select_all(arel, name, binds).rows
       end
 
       # Executes a SELECT query and returns an array of record hashes with the
@@ -91,9 +116,11 @@ module ActiveRecord
         true
       end
 
-      def new_column(field, default, cast_type, sql_type = nil, null = true, collation = '', extra = '')
-        Column.new(field, default, cast_type, sql_type, null, collation, strict_mode?, extra)
+      # rubocop:disable Metrics/ParameterLists
+      def new_column(field, default, type_metadata, null, table_name, default_function, collation, comment)
+        Column.new(field, default, type_metadata, null, table_name, default_function, collation, comment)
       end
+      # rubocop:enable Metrics/ParameterLists
 
       # Adds a new index to the table
       #
@@ -101,25 +128,56 @@ module ActiveRecord
       # @param column_name [String, Symbol]
       # @param options [Hash] optional
       def add_index(table_name, column_name, options = {})
-        index_name, index_type, index_columns, index_options = add_index_options(table_name, column_name, options)
-        execute "ALTER TABLE #{quote_table_name(table_name)} ADD #{index_type} INDEX #{quote_column_name(index_name)} (#{index_columns})#{index_options}"
+        if ActiveRecord::VERSION::STRING >= '6.1'
+          index, algorithm, if_not_exists = add_index_options(table_name, column_name, options)
+          create_index = CreateIndexDefinition.new(index, algorithm, if_not_exists)
+          execute schema_creation.accept(create_index)
+        else
+          index_name, index_type, index_columns, index_options = add_index_options(table_name, column_name, options)
+          execute "ALTER TABLE #{quote_table_name(table_name)} ADD #{index_type} INDEX #{quote_column_name(index_name)} (#{index_columns})#{index_options}" # rubocop:disable Metrics/LineLength
+        end
       end
 
       # Remove the given index from the table.
       #
       # @param table_name [String, Symbol]
       # @param options [Hash] optional
-      def remove_index(table_name, options = {})
-        index_name = index_name_for_remove(table_name, options)
+      def remove_index(table_name, *args, **options)
+        column_name = args.first
+        if column_name
+          return if options[:if_exists] && !index_exists?(table_name, column_name, **options)
+          index_name = index_name_for_remove(table_name, column_name, **options)
+        else
+          index_name = index_name_for_remove(table_name, options)
+        end
         execute "ALTER TABLE #{quote_table_name(table_name)} DROP INDEX #{quote_column_name(index_name)}"
       end
 
+      def schema_creation
+        SchemaCreation.new(self)
+      end
+
+      def change_table(table_name, _options = {})
+        recorder = ActiveRecord::Migration::CommandRecorder.new(self)
+        yield update_table_definition(table_name, recorder)
+        bulk_change_table(table_name, recorder.commands)
+      end
+
       # Returns the MySQL error number from the exception. The
       # AbstractMysqlAdapter requires it to be implemented
-      def error_number(_exception)
-      end
+      def error_number(_exception); end
 
       def full_version
+        if ActiveRecord::VERSION::MAJOR < 6
+          get_full_version
+        else
+          schema_cache.database_version.full_version_string
+        end
+      end
+
+      # This is a method defined in Rails 6.0, and we have no control over the
+      # naming of this method.
+      def get_full_version # rubocop:disable Naming/AccessorMethodName
         mysql_adapter.raw_connection.server_info[:version]
       end
 

data/lib/departure.rb

@@ -1,6 +1,8 @@
 require 'active_record'
 require 'active_support/all'
 
+require 'active_record/connection_adapters/for_alter'
+
 require 'departure/version'
 require 'departure/log_sanitizers/password_sanitizer'
 require 'departure/runner'
@@ -11,12 +13,20 @@ require 'departure/logger_factory'
 require 'departure/configuration'
 require 'departure/errors'
 require 'departure/command'
+require 'departure/connection_base'
+require 'departure/migration'
 
 require 'departure/railtie' if defined?(Rails)
 
 # We need the OS not to buffer the IO to see pt-osc's output while migrating
 $stdout.sync = true
 
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::Migration.class_eval do
+    include Departure::Migration
+  end
+end
+
 module Departure
   class << self
     attr_accessor :configuration
@@ -27,55 +37,7 @@ module Departure
     yield(configuration)
   end
 
-  # Hooks Percona Migrator into Rails migrations by replacing the configured
-  # database adapter
   def self.load
-    ActiveRecord::Migrator.instance_eval do
-      class << self
-        alias_method(:original_migrate, :migrate)
-      end
-
-      # Checks whether arguments are being passed through PERCONA_ARGS when running
-      # the db:migrate rake task
-      #
-      # @raise [ArgumentsNotSupported] if PERCONA_ARGS has any value
-      def migrate(migrations_paths, target_version = nil, &block)
-        raise ArgumentsNotSupported if ENV['PERCONA_ARGS'].present?
-        original_migrate(migrations_paths, target_version, &block)
-      end
-    end
-
-    ActiveRecord::Migration.class_eval do
-      alias_method :original_migrate, :migrate
-
-      # Replaces the current connection adapter with the PerconaAdapter and
-      # patches LHM, then it continues with the regular migration process.
-      #
-      # @param direction [Symbol] :up or :down
-      def migrate(direction)
-        reconnect_with_percona
-        include_foreigner if defined?(Foreigner)
-
-        ::Lhm.migration = self
-        original_migrate(direction)
-      end
-
-      # Includes the Foreigner's Mysql2Adapter implemention in
-      # DepartureAdapter to support foreign keys
-      def include_foreigner
-        Foreigner::Adapter.safe_include(
-          :DepartureAdapter,
-          Foreigner::ConnectionAdapters::Mysql2Adapter
-        )
-      end
-
-      # Make all connections in the connection pool to use PerconaAdapter
-      # instead of the current adapter.
-      def reconnect_with_percona
-        connection_config = ActiveRecord::Base
-          .connection_config.merge(adapter: 'percona')
-        ActiveRecord::Base.establish_connection(connection_config)
-      end
-    end
+    # No-op left for compatibility
   end
 end

data/lib/departure/alter_argument.rb

@@ -4,7 +4,7 @@ module Departure
   # Represents the '--alter' argument of Percona's pt-online-schema-change
   # See https://www.percona.com/doc/percona-toolkit/2.0/pt-online-schema-change.html
   class AlterArgument
-    ALTER_TABLE_REGEX = /\AALTER TABLE `(\w+)` /
+    ALTER_TABLE_REGEX = /\AALTER TABLE [^\s]*[\n]* /
 
     attr_reader :table_name
 
@@ -17,8 +17,12 @@ module Departure
 
       match = statement.match(ALTER_TABLE_REGEX)
       raise InvalidAlterStatement unless match
-
-      @table_name = match.captures[0]
+      # Separates the ALTER TABLE from the table_name
+      #
+      # Removes the grave marks, if they are there, so we can get the table_name
+      @table_name = String(match)
+                      .split(' ')[2]
+                      .delete('`')
     end
 
     # Returns the '--alter' pt-online-schema-change argument as a string. See
@@ -37,7 +41,9 @@ module Departure
     def parsed_statement
       @parsed_statement ||= statement
         .gsub(ALTER_TABLE_REGEX, '')
-        .gsub('`','\\\`')
+        .gsub('`', '\\\`')
+        .gsub(/\\n/, '')
+        .gsub('"', '\\\"')
     end
   end
 end

data/lib/departure/cli_generator.rb

@@ -5,12 +5,11 @@ require 'departure/connection_details'
 require 'departure/user_options'
 
 module Departure
-
   # Generates the equivalent Percona's pt-online-schema-change command to the
   # given SQL statement
   #
-  # --no-check-alter is used to allow running CHANGE COLUMN statements. For
-  #   more details, check: www.percona.com/doc/percona-toolkit/2.2/pt-online-schema-change.html#cmdoption-pt-online-schema-change--[no]check-alter
+  # --no-check-alter is used to allow running CHANGE COLUMN statements. For more details, check:
+  # www.percona.com/doc/percona-toolkit/2.2/pt-online-schema-change.html#cmdoption-pt-online-schema-change--[no]check-alter # rubocop:disable Metrics/LineLength
   #
   class CliGenerator
     COMMAND_NAME = 'pt-online-schema-change'.freeze