[mysql] backported bulk change table support from Rails (fixes #469)

Author: kares

lib/arjdbc/mysql/adapter.rb

@@ -3,11 +3,13 @@
 require 'bigdecimal'
 require 'active_record/connection_adapters/abstract/schema_definitions'
 require 'arjdbc/mysql/column'
+require 'arjdbc/mysql/bulk_change_table'
 require 'arjdbc/mysql/explain_support'
 require 'arjdbc/mysql/schema_creation' # AR 4.x
 
 module ArJdbc
   module MySQL
+    include BulkChangeTable if const_defined? :BulkChangeTable
 
     # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
     def self.jdbc_connection_class
@@ -179,11 +181,6 @@ def supports_primary_key?
       true
     end
 
-    # @override
-    def supports_bulk_alter?
-      true
-    end
-
     # @override
     def supports_index_sort_order?
       # Technically MySQL allows to create indexes with the sort order syntax

lib/arjdbc/mysql/bulk_change_table.rb

@@ -0,0 +1,107 @@
+module ArJdbc
+  module MySQL
+    module BulkChangeTable
+
+      # @override
+      def supports_bulk_alter?
+        true
+      end
+
+      def bulk_change_table(table_name, operations)
+        sqls = operations.map do |command, args|
+          table, arguments = args.shift, args
+          method = :"#{command}_sql"
+
+          if respond_to?(method, true)
+            send(method, table, *arguments)
+          else
+            raise "Unknown method called : #{method}(#{arguments.inspect})"
+          end
+        end
+        sqls.flatten!
+
+        execute("ALTER TABLE #{quote_table_name(table_name)} #{sqls.join(", ")}")
+      end
+
+      protected
+
+      def add_column_sql(table_name, column_name, type, options = {})
+        add_column_sql = "ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+        add_column_options!(add_column_sql, options)
+        add_column_position!(add_column_sql, options)
+        add_column_sql
+      end
+
+      def change_column_sql(table_name, column_name, type, options = {})
+        column = column_for(table_name, column_name)
+
+        unless options_include_default?(options)
+          options[:default] = column.default
+        end
+
+        unless options.has_key?(:null)
+          options[:null] = column.null
+        end
+
+        change_column_sql = "CHANGE #{quote_column_name(column_name)} #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+        add_column_options!(change_column_sql, options)
+        add_column_position!(change_column_sql, options)
+        change_column_sql
+      end
+
+      def rename_column_sql(table_name, column_name, new_column_name)
+        options = {}
+
+        if column = columns(table_name).find { |c| c.name == column_name.to_s }
+          options[:default] = column.default
+          options[:null] = column.null
+          options[:auto_increment] = (column.extra == "auto_increment")
+        else
+          raise ActiveRecordError, "No such column: #{table_name}.#{column_name}"
+        end
+
+        current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'", 'SCHEMA')["Type"]
+        rename_column_sql = "CHANGE #{quote_column_name(column_name)} #{quote_column_name(new_column_name)} #{current_type}"
+        add_column_options!(rename_column_sql, options)
+        rename_column_sql
+      end
+
+      def remove_column_sql(table_name, column_name, type = nil, options = {})
+        "DROP #{quote_column_name(column_name)}"
+      end
+
+      def remove_columns_sql(table_name, *column_names)
+        column_names.map {|column_name| remove_column_sql(table_name, column_name) }
+      end
+
+      def add_index_sql(table_name, column_name, options = {})
+        index_name, index_type, index_columns = add_index_options(table_name, column_name, options)
+        "ADD #{index_type} INDEX #{index_name} (#{index_columns})"
+      end
+
+      def remove_index_sql(table_name, options = {})
+        index_name = index_name_for_remove(table_name, options)
+        "DROP INDEX #{index_name}"
+      end
+
+      def add_timestamps_sql(table_name)
+        [add_column_sql(table_name, :created_at, :datetime), add_column_sql(table_name, :updated_at, :datetime)]
+      end
+
+      def remove_timestamps_sql(table_name)
+        [remove_column_sql(table_name, :updated_at), remove_column_sql(table_name, :created_at)]
+      end
+
+      private
+
+      def add_column_position!(sql, options)
+        if options[:first]
+          sql << " FIRST"
+        elsif options[:after]
+          sql << " AFTER #{quote_column_name(options[:after])}"
+        end
+      end
+
+    end
+  end
+end

lib/arjdbc/mysql/explain_support.rb

@@ -1,4 +1,4 @@
-module ::ArJdbc
+module ArJdbc
   module MySQL
     module ExplainSupport
       def supports_explain?

test/db/mysql/simple_test.rb

@@ -246,6 +246,114 @@ def test_mysql_indexes
     end
   end if defined? JRUBY_VERSION
 
+  test 'bulk change table' do
+    assert ActiveRecord::Base.connection.supports_bulk_alter?
+
+    begin
+      connection.create_table(:bulks, :force => true) { |t| t.string :it }
+
+      assert_queries(1) do
+        with_bulk_change_table(:bulks) do |t|
+          t.column :name, :string
+          t.string :qualification, :experience
+          t.integer :age, :default => 0
+          t.date :birthdate
+          t.timestamps
+        end
+      end
+      assert_equal 9, connection.columns(:bulks).size
+
+      column = lambda do |name|
+        indexes = connection.columns(:bulks)
+        indexes.detect { |c| c.name == name.to_s }
+      end
+
+      [:qualification, :experience].each { |c| assert column.call(c) }
+
+      assert_queries(1) do
+        with_bulk_change_table('bulks') do |t|
+          t.remove :qualification, :experience
+          t.string :qualification_experience
+        end
+      end
+
+      [:qualification, :experience].each { |c| assert ! column.call(c) }
+      assert column.call(:qualification_experience)
+
+      assert ! column.call(:name).default
+      assert_equal :date, column.call(:birthdate).type
+
+      # One query for columns (delete_me table)
+      # One query for primary key (delete_me table)
+      # One query to do the bulk change
+      #assert_queries(3, :ignore_none => true) do
+        with_bulk_change_table('bulks') do |t|
+          t.change :name, :string, :default => 'NONAME'
+          t.change :birthdate, :datetime
+        end
+      #end
+
+      assert_equal 'NONAME', column.call(:name).default
+      assert_equal :datetime, column.call(:birthdate).type
+
+      # test_adding_indexes
+      with_bulk_change_table(:bulks) do |t|
+        t.string :username # t.string :name t.integer :age
+      end
+
+      index = lambda do |name|
+        indexes = connection.indexes(:bulks)
+        indexes.detect { |i| i.name == name.to_s }
+      end
+
+      # Adding an index fires a query every time to check if an index already exists or not
+      assert_queries(3) do
+        with_bulk_change_table(:bulks) do |t|
+          t.index :username, :unique => true, :name => :awesome_username_index
+          t.index [:name, :age]
+        end
+      end
+
+      assert_equal 2, connection.indexes(:bulks).size
+
+      assert name_age_index = index.call(:index_bulks_on_name_and_age)
+      assert_equal ['name', 'age'].sort, name_age_index.columns.sort
+      assert ! name_age_index.unique
+
+      assert index.call(:awesome_username_index).unique
+
+      # test_removing_index
+      with_bulk_change_table('bulks') do |t|
+        t.string :name2; t.index :name2
+      end
+
+      assert index.call(:index_bulks_on_name2)
+
+      assert_queries(3) do
+        with_bulk_change_table('bulks') do |t|
+          t.remove_index :name2
+          t.index :name2, :name => :new_name2_index, :unique => true
+        end
+      end
+
+      assert ! index.call(:index_bulks_on_name2)
+
+      new_name_index = index.call(:new_name2_index)
+      assert new_name_index.unique
+
+    ensure
+      connection.drop_table(:bulks) rescue nil
+    end
+  end if ar_version('3.2')
+
+  protected
+
+  def with_bulk_change_table(table)
+    connection.change_table(table, :bulk => true) do |t|
+      yield t
+    end
+  end
+
   private
 
   def mysql_adapter_class