fast_change_table 0.0.3 → 0.0.4

data/.gitignore

@@ -1,3 +1,4 @@
 *.gem
 .bundle
 pkg/*
+.rvmrc

data/README

@@ -2,4 +2,28 @@ Use fast_change_table instead of change_table in your migrations on large tables
 
 # Known issues
 - Probably only works with MySQL
-- Not tested
+- Not tested
+
+uses ordinary change_table syntax but adds two options
+- "replace_keys" to remove all indexes; new indexes will be specified
+- "disable_keys" to remove indexes and apply them after data load; this is a tremendous performance enhancement for a dbms with fast index creation
+
+other methods:
+
+create_table_like(orignal_table, table_to_copy_to)
+  creates a table with the same structure
+  
+disable_indexes(table)
+  removes all indexes from a table, returns a list of index objects removed
+  
+enable_indexes(table, list_of_indexes)
+  restores a list of indexes to a table
+  
+fast_add_indexes(table, &block)
+  allows you to pass a block to add indexes.  For mysql creates specified indexes in one statement; allows the data to be scanned once.
+  example
+  
+  fast_add_indexes :sometable do |t|
+    t.index :some_column
+    t.index [:some_other_column, :column_three], :name => "a_multicolumn_index"
+  end

data/lib/fast_change_table/version.rb

@@ -1,3 +1,3 @@
 module FastChangeTable
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/fast_change_table.rb

@@ -1,5 +1,44 @@
-require "activerecord"
-require "fast_change_table/version"
+module ActiveRecord
+  module ConnectionAdapters #:nodoc:
+    
+    class MysqlAdapter < AbstractAdapter
+      def tables_without_views(name = nil) #:nodoc:
+        tables = []
+        result = execute("SHOW FULL TABLES WHERE Table_type = 'BASE TABLE'", name)
+        result.each { |field| tables << field[0] }
+        result.free
+        tables
+      end
+    end
+    
+    module SchemaStatements
+      def change_table_with_remaps(table_name)
+        t = Table.new(table_name, self)
+        yield t
+        return t.renamed_columns
+      end
+    end
+    
+    class Table
+      
+      def initialize(table_name, base)
+        @table_name = table_name
+        @base = base
+        @renamed_columns = []
+      end
+      
+      def renamed_columns
+        @renamed_columns
+      end
+      
+      def rename(column_name, new_column_name)
+        @renamed_columns << [column_name, new_column_name]
+        @base.rename_column(@table_name, column_name, new_column_name)
+      end
+      
+    end
+  end
+end
 
 module FastChangeTable
   def self.included(base)
@@ -7,22 +46,145 @@ module FastChangeTable
   end
   
   module ClassMethods
-    def fast_change_table(table_name, &block)
+    def fast_change_table(table_name, options = {}, &block)
+      options.symbolize_keys!
       old_table_name = "old_#{table_name}"
       rename_table(table_name, old_table_name)
       begin
-         execute "CREATE TABLE #{table_name} LIKE #{old_table_name}" 
-         change_table(table_name, &block)
-         #prepare the columns names for the insert statements
-         old = connection.columns(old_table_name).collect(&:name)
-         current = connection.columns(table_name).collect(&:name)
-         common = (current & old).sort
-         columns_to_s = common.collect {|c| "`#{c}`"}.join(',')
-         execute "INSERT INTO #{table_name}(#{columns_to_s}) SELECT #{columns_to_s} FROM #{old_table_name}" 
-         drop_table(old_table_name)
-      rescue
-         drop_table(table_name) if table_exists?(table_name)
-         rename_table(old_table_name, table_name)
+       create_table_like(old_table_name, table_name, options)
+       renamed_columns = change_table_with_remaps(table_name, &block)
+       index_list = options[:disable_keys]  ? disable_indexes(table_name) : []
+       #prepare the columns names for the insert statements
+       copy_table(old_table_name, table_name, renamed_columns)
+       enable_indexes(table_name, index_list) if options[:disable_keys]
+       drop_table(old_table_name)
+      rescue Exception => e
+        puts "#{e}\n#{e.backtrace}"
+        drop_table(table_name) if table_exists?(table_name)
+        rename_table(old_table_name, table_name)
+        raise e
+      end
+    end
+
+    def fast_add_indexes(table, &blk)
+      phoney = PhoneyTable.new(table.to_s)
+      yield phoney
+      enable_indexes(table, phoney.indexes)
+    end
+    
+    #create_table_like( :sometable, :newtable, :remove_keys => true)
+    def create_table_like(like_table, table, options = {})
+      options.symbolize_keys!
+      code = table_schema_code(like_table)
+      code.gsub!(/create_table\s+"#{like_table}"/, "create_table :#{table}")
+      if options[:replace_keys] or options[:remove_keys]
+        code.gsub!(/add_index\s+"#{like_table}"/, "#add_index :#{table}")
+      else
+        code.gsub!(/add_index\s+"#{like_table}"/, "add_index :#{table}")
+      end
+      class_eval(code)
+      true
+    end
+
+    #copy_table( :sometable, :newtable, [[:old_column, :new_column]])
+    def copy_table(from, to, remaps = [])
+      old = connection.columns(from).collect(&:name)
+      current = connection.columns(to).collect(&:name)
+      remapped_columns = remaps.collect {|c| c.first.to_s}.compact
+      common = (current & old).sort - remapped_columns
+      from_columns = common.collect {|c| "`#{c}`"}
+      to_columns = common.collect {|c| "`#{c}`"}
+      remaps.each do |remap|
+        remap = [remap].flatten
+        next if remap.length != 2
+        from_columns << remap.first
+        to_columns << remap.last
+      end
+      from_columns_to_s = from_columns.join(', ')
+      to_columns_to_s   = to_columns.join(', ')
+      execute "INSERT INTO #{to}(#{to_columns_to_s}) SELECT #{from_columns_to_s} FROM #{from}"
+    end
+    
+    def create_table(table_name, options = {})
+      rtn = super
+      execute "alter table `#{table_name}` row_format=dynamic" if connection.adapter_name =~ /^mysql/i
+      rtn
+    end
+
+    def table_schema_code(table)
+      dumper = ActiveRecord::SchemaDumper.send(:new, connection)
+      stream = StringIO.new
+      dumper.table(table.to_s,stream)
+      stream.rewind
+      code = stream.read
+    end
+
+    #removes all the indexes 
+    def disable_indexes(table)
+      list = connection.indexes(table)
+      if connection.adapter_name =~ /^mysql/i
+        sql = list.collect { |i| "DROP INDEX #{i.name}"}.join(', ')
+        execute "ALTER TABLE #{table} #{sql}"
+      else
+        list.each do |i|
+          remove_index table, :name => i.name
+        end
+      end  
+      list
+    end
+
+    #
+    def enable_indexes(table, list)
+      if connection.adapter_name =~ /^mysql/i
+        sql = list.collect do |i|
+          cols = i.columns.collect {|c| i.lengths ? "`#{c}`(#{i.lengths[c]})" : "`#{c}`"}.join(',')
+          "ADD #{'UNIQUE ' if i.unique}INDEX #{i.name} (#{cols})"
+        end.join(', ')
+        execute "ALTER TABLE #{table} #{sql}"
+      else
+        list.each do |i|
+          options = {}
+          options[:name]    = i.name    if i.name
+          options[:length]  = i.lengths if i.lengths
+          options[:unique]  = i.unique  if i.unique
+          add_index table, i.columns, options
+        end
+      end
+      true
+    end
+
+    class PhoneyTable
+
+      attr_accessor :indexes
+
+      def initialize(tablename)
+        @table = tablename
+        @indexes = []
+      end
+
+      def index(columns, options = {})
+        new_index = PhoneyIndex.new(@table, columns, options)
+        @indexes << new_index unless @indexes.to_a.any? {|i| i == new_index}
+      end
+
+      def indexes; @indexes.to_a.uniq end
+    end
+
+    class PhoneyIndex
+
+      attr_accessor :columns, :lengths, :name, :unique
+
+      def initialize(table, cols, options)
+        cols = [cols].flatten
+        self.columns = cols.collect(&:to_s)
+        self.lengths = options[:length]
+        self.unique = !!options[:unique]
+        self.name = options[:name] || "index_#{table}_on_#{columns.join('_and_')}"
+        self.name = "#{columns.join('_')}_idx" if name.length > 64
+      end
+
+      def ==(val)
+        columns == val.columns rescue false
       end
     end
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: fast_change_table
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: 
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Grady Griffin
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-30 00:00:00 -04:00
+date: 2012-01-09 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -44,7 +44,6 @@ extra_rdoc_files: []
 
 files: 
 - .gitignore
-- .rvmrc
 - Gemfile
 - Gemfile.lock
 - README
@@ -83,7 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: fast_change_table
-rubygems_version: 1.4.2
+rubygems_version: 1.5.3
 signing_key: 
 specification_version: 3
 summary: Faster table changes

data/.rvmrc

@@ -1 +0,0 @@
-rvm use default@fast_change_table