fast_change_table 0.0.6 → 1.0.0

data/Gemfile.lock

@@ -1,18 +1,43 @@
 PATH
   remote: .
   specs:
-    fast_change_table (0.0.2)
-      activerecord (~> 2.3)
+    fast_change_table (1.0.0)
+      activerecord (>= 2.3)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    activerecord (2.3.14)
-      activesupport (= 2.3.14)
-    activesupport (2.3.14)
+    activemodel (3.2.0)
+      activesupport (= 3.2.0)
+      builder (~> 3.0.0)
+    activerecord (3.2.0)
+      activemodel (= 3.2.0)
+      activesupport (= 3.2.0)
+      arel (~> 3.0.0)
+      tzinfo (~> 0.3.29)
+    activesupport (3.2.0)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    arel (3.0.0)
+    builder (3.0.0)
+    diff-lcs (1.1.3)
+    i18n (0.6.0)
+    multi_json (1.0.4)
+    mysql2 (0.3.11)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+    tzinfo (0.3.31)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   fast_change_table!
+  mysql2
+  rspec

data/README.md

@@ -0,0 +1,54 @@
+#Fast Change Table
+
+Use fast\_change\_table instead of change_table in your migrations on large tables of data. Uses a duplication pattern to speed things up.
+
+
+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
+
+__Example:__
+
+    fast_change_table :table_name, :disable_keys => true do |t|
+      t.change :old_string, :string, :limit => 64
+      t.rename :old_string, :new_string
+      t.integer :an_integer
+    end
+
+
+__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
+  
+copy\_table(from\_table, to\_table, remaps = [])
+  
+* copies rows from one table into another.  this probably only works with Mysql.
+  by default copies data from column of from_table to to_table of same name.
+  will not copy data where there is no corresponding column.
+  the remaps argument can be supplied to tell copy table how to handle unmatched columns or override this behavior
+  
+__Examples:__
+
+  
+    copy_table(old_users_without_email_hash, new_table, ['MD5(email)', 'email_hash'])
+  
+    copy_table(old_users_without_total, new_table, ['sum(payments)', 'total_payments'])

data/Rakefile

@@ -1 +1,7 @@
 require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+# If you want to make this the default task
+task :default => :spec

data/fast_change_table.gemspec

@@ -21,7 +21,11 @@ Gem::Specification.new do |s|
   # specify any dependencies here; for example:
   if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
     s.add_runtime_dependency('activerecord', '>= 2.3')
+    s.add_development_dependency("rspec")
+    s.add_development_dependency("mysql2")
   else
     s.add_dependency('activerecord', '>= 2.3')
+    s.add_development_dependency("rspec")
+    s.add_development_dependency("mysql2")
   end
 end

data/lib/fast_change_table.rb

@@ -1,164 +1,12 @@
-module ActiveRecord
-  module ConnectionAdapters #:nodoc:
-    
-    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
+require 'active_record'
+require 'fast_change_table/connection_adapters'
+require 'fast_change_table/fast_change_table'
+require 'fast_change_table/version'
 
 module FastChangeTable
   def self.included(base)
     base.extend ClassMethods
   end
-  
-  module ClassMethods
-    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
-       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 table_schema_code(table)
-      dumper = ActiveRecord::SchemaDumper.send(:new, connection)
-      stream = StringIO.new
-      dumper.send(:table, table.to_s, stream)
-      stream.rewind
-      code = stream.read
-    end
-
-    #removes all the indexes 
-    def disable_indexes(table)
-      list = connection.indexes(table)
-      list.each do |i|
-        remove_index table, :name => i.name
-      end
-      list
-    end
-
-    #
-    def enable_indexes(table, list)
-      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
-      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
 end
 
 ::ActiveRecord::Migration.send :include, FastChangeTable

data/lib/fast_change_table/connection_adapters.rb

@@ -0,0 +1,31 @@
+module ActiveRecord
+  module ConnectionAdapters #:nodoc:
+    
+    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

data/lib/fast_change_table/fast_change_table.rb

@@ -0,0 +1,132 @@
+
+
+module FastChangeTable
+  def self.included(base)
+    base.extend ClassMethods
+  end
+  
+  module ClassMethods
+    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
+       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 table_schema_code(table)
+      dumper = ActiveRecord::SchemaDumper.send(:new, connection)
+      stream = StringIO.new
+      dumper.send(:table, table.to_s, stream)
+      stream.rewind
+      code = stream.read
+    end
+
+    #removes all the indexes 
+    def disable_indexes(table)
+      list = connection.indexes(table)
+      list.each do |i|
+        remove_index table, :name => i.name
+      end
+      list
+    end
+
+    #
+    def enable_indexes(table, list)
+      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
+      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
+end

data/lib/fast_change_table/version.rb

@@ -1,3 +1,3 @@
 module FastChangeTable
-  VERSION = "0.0.6"
+  VERSION = "1.0.0"
 end

data/spec/fast_change_table_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe ActiveRecord::Migration do
+  before(:each) do
+    ActiveRecord::Migration.create_table :my_table, :force => true do |t|
+      t.integer :an_integer
+      t.string :a_string
+      t.string :a_name
+    end
+    @connection = ActiveRecord::Migration.connection
+  end
+  
+  after(:each) do
+    ActiveRecord::Migration.drop_table(:my_copied_table) rescue nil
+  end
+
+  describe "initialize table" do
+    it "should have expected starting table" do
+      @connection.columns("my_table").all? do |c| 
+        ["id", "an_integer", "a_string", "a_name"].include?(c.name)
+      end.should eq(true)
+    end
+  end
+    
+  describe "#create_table_like" do
+    it "should create an identical table" do
+      ActiveRecord::Migration.create_table_like(:my_table, :my_copied_table)
+      
+      @connection.columns("my_copied_table").all? do |c| 
+        ["id", "an_integer", "a_string", "a_name"].include?(c.name.to_s)
+      end.should eq(true)
+    end
+  end
+  
+  describe "#fast_add_indexes, #disable_indexes, #enable_indexes" do
+    it "should add index, remove it then put it back" do
+      ActiveRecord::Migration.fast_add_indexes :my_table do |t|
+        t.index :an_integer, :name => "an_index"
+      end
+      @connection.indexes("my_table").collect(&:name).include?("an_index").should eq(true)
+      
+      indexes = ActiveRecord::Migration.disable_indexes("my_table")
+      @connection.indexes("my_table").collect(&:name).include?("an_index").should eq(false)
+      
+      ActiveRecord::Migration.enable_indexes("my_table", indexes)
+      @connection.indexes("my_table").collect(&:name).include?("an_index").should eq(true)
+    end
+  end
+  
+  describe "#copy_table" do
+    it "should copy the records from one table to another" do
+      @connection.execute "INSERT my_table (an_integer, a_string, a_name) VALUES (1,'String','Name')"
+      ActiveRecord::Migration.create_table_like(:my_table, :my_copied_table)
+      ActiveRecord::Migration.add_column(:my_copied_table, :new_column, :string)
+      ActiveRecord::Migration.copy_table(:my_table, :my_copied_table, [["'Nothing'", "new_column"]])
+      record = @connection.select_all("select * from my_copied_table").first
+      record['an_integer'].should eq(1)
+      record['a_string'].should eq('String')
+      record['a_name'].should eq('Name')
+      record['new_column'].should eq('Nothing')
+    end
+  end
+  
+  describe "#fast_change_table" do
+    it "should bring it all together" do
+      @connection.execute "INSERT my_table (an_integer, a_string, a_name) VALUES (1,'String','Name')"
+      ActiveRecord::Migration.add_index :my_table, :an_integer, :name => "an_index"
+      ActiveRecord::Migration.fast_change_table :my_table, :remove_keys => true do |t|
+        t.change :an_integer, :integer
+        t.change :a_string, :string
+        t.change :a_name, :string
+        t.string :new_column
+      end
+      record = @connection.select_all("select * from my_table").first
+      record['an_integer'].should eq(1)
+      record['a_string'].should eq('String')
+      record['a_name'].should eq('Name')
+      record['new_column'].should eq(nil)
+      @connection.indexes("my_table").empty?.should eq(true)
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'fast_change_table'
+
+RSpec.configure do |config|
+  # some (optional) config here
+end
+
+ActiveRecord::Base.establish_connection(
+:adapter => "mysql2",
+:database => "fast_change_table_test"
+)
+
+

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: fast_change_table
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 23
   prerelease: 
   segments: 
+  - 1
   - 0
   - 0
-  - 6
-  version: 0.0.6
+  version: 1.0.0
 platform: ruby
 authors: 
 - Grady Griffin
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-23 00:00:00 Z
+date: 2012-02-02 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
@@ -32,6 +32,34 @@ dependencies:
         version: "2.3"
   type: :runtime
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mysql2
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
 description: Uses table duplication to speed up migrations on large tables
 email: 
 - gradyg@izea.com
@@ -45,12 +73,15 @@ files:
 - .gitignore
 - Gemfile
 - Gemfile.lock
-- README
+- README.md
 - Rakefile
 - fast_change_table.gemspec
 - lib/fast_change_table.rb
+- lib/fast_change_table/connection_adapters.rb
+- lib/fast_change_table/fast_change_table.rb
 - lib/fast_change_table/version.rb
-- test/fast_change_table_test.rb
+- spec/fast_change_table_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/moxie/fast_change_table
 licenses: []
 
@@ -85,4 +116,5 @@ signing_key:
 specification_version: 3
 summary: Faster table changes
 test_files: 
-- test/fast_change_table_test.rb
+- spec/fast_change_table_spec.rb
+- spec/spec_helper.rb

data/README

@@ -1,39 +0,0 @@
-Use fast_change_table instead of change_table in your migrations on large tables of data. Uses a duplication pattern to speed things up.
-
-# Known issues
-- 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
-  
-copy_table(from_table, to_table, remaps = [])
-  copies rows from one table into another.  this probably only works with Mysql.
-  by default copies data from column of from_table to to_table of same name.
-  will not copy data where there is no corresponding column.
-  the remaps argument can be supplied to tell copy table how to handle unmatched columns or override this behavior
-  examples
-  
-  copy_table(old_users_without_email_hash, new_table, ['MD5(email)', 'email_hash'])
-  
-  copy_table(old_users_without_total, new_table, ['sum(payments)', 'total_payments'])

data/test/fast_change_table_test.rb

@@ -1 +0,0 @@
-require 'test/unit'