fast_innodb_import 0.0.1 → 0.0.2

data/bin/fast_innodb_import

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
 require "fast_innodb_import"
 
-FastInnodbImport.new(ARGV).execute
+FastInnodbImport.execute(ARGV, $stdout)

data/lib/fast_innodb_import.rb

@@ -3,36 +3,27 @@ $:.unshift(File.dirname(__FILE__)) unless
 
 require "mysql2"
 class FastInnodbImport
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
   CMD_MAPPING = { "u" => :username, "h" => :host, "d" => :database, "p" => "password" }
   
-  def initialize(argv = {})
-    @options = options_from_argv(argv)
+  attr_accessor :options, :stream
+  
+  def initialize(options = {})
+    self.options = options
+  end
+  
+  def self.execute(argv, stream = nil)
+    importer = self.new(options_from_argv(argv))
+    importer.stream = stream
+    importer.execute
   end
   
   def execute
-    print_usage_and_exit if missing_options?
+    print_usage_and_exit_if_missing_options
     file_paths.each do |path|
       import_data_from_file_path(path)
     end
   end
-
-private
-  def index_definitions_from_table(table)
-    query("SHOW CREATE TABLE #{table}").to_a.first["Create Table"].split("\n").map do |line|
-      if line.match(/^\s*KEY \`(.*?)\` \((.*?)\)/)
-        { :name => $1, :columns => $2 }
-      end
-    end.compact
-  end
-  
-  def index_drop_statement_for_table(table_name)
-    "ALTER TABLE #{table_name} " + index_definitions_from_table(table_name).map { |config| "\nDROP INDEX #{config[:name]}" }.join(", ")
-  end
-  
-  def index_create_statement_for_table(table_name)
-    "ALTER TABLE #{table_name} " + index_definitions_from_table(table_name).map { |config| "\nADD INDEX #{config[:name]} (#{config[:columns]})" }.join(", ")
-  end
   
   def import_data_from_file_path(path)
     file_path = File.expand_path(path)
@@ -40,54 +31,57 @@ private
     table_name = table_name_from_file_path(file_path)
     wc = `wc -l #{file_path}`.strip.to_i
     started = Time.now
-    print "import %d rows from %s: " % [wc, file_path]
-    $stdout.flush
+    if stream
+      stream.print "import %d rows from %s: " % [wc, file_path] if stream
+      stream.flush
+    end
     
     # create drop and create statements as long as we can
     drop_statement = index_drop_statement_for_table(table_name)
     create_statement = index_create_statement_for_table(table_name)
     
     query("TRUNCATE `#{table_name}`")
+    query(drop_statement) if drop_keys?
+    `#{self.class.import_command_prefix_from_options(options)} #{file_path}`
+    query(create_statement) if drop_keys?
     
-    # drop keys if asked
-    if drop_keys?
-      query(drop_statement)
-    end
-    
-    query("LOAD DATA INFILE '#{file_path}' INTO TABLE `#{table_name}`")
-    
-    # recreate keys if asked
-    if drop_keys?
-      query(create_statement)
+    # print stats if stream given
+    if stream
+      diff = Time.now - started
+      per_sec = wc / diff
+      stream.puts "%d (%d/sec)" % [diff, per_sec]
     end
-    
-    # print stats
-    diff = Time.now - started
-    per_sec = wc / diff
-    puts "%d (%d/sec)" % [diff, per_sec]
   end
   
-  def missing_options?
-    !file_paths.respond_to?(:empty?) || file_paths.empty?
+  def options
+    @options || {}
   end
   
-  def db_options
-    @options[:db] if @options
-  end
-  
-  def table_name_from_file_path(path)
-    File.basename(path).gsub(".txt", "")
+  def self.options_from_argv(argv)
+    options = { :db => {} }
+    %w(u h d p).each do |key|
+      if idx = argv.index("-#{key}")
+        value = argv.at(idx + 1)
+        options[:db][CMD_MAPPING[key]] = value if !value.match(/^\-/)
+        argv.delete_at(idx)
+        argv.delete_at(idx)
+      end
+    end
+    options[:drop_keys] = argv.delete("--without-drop-keys").nil?
+    options[:file_paths] = argv
+    options
   end
-  
-  def file_paths
-    @options[:file_paths] if @options
+
+private
+  def print_usage_and_exit_if_missing_options
+    self.class.print_usage_and_exit if missing_options?
   end
   
-  def drop_keys?
-    @options[:drop_keys] if @options
+  def missing_options?
+    !file_paths.respond_to?(:empty?) || file_paths.empty? || db_options[:username].nil? || db_options[:database].nil?
   end
   
-  def print_usage_and_exit
+  def self.print_usage_and_exit
     puts "Usage: #{File.basename(__FILE__)} [OPTIONS] [dumpfile]"
     puts "  -h                    Database Host"
     puts "  -u                    Database User"
@@ -97,19 +91,46 @@ private
     exit
   end
   
-  def options_from_argv(argv)
-    options = { :db => {} }
-    %w(u h d p).each do |key|
-      if idx = argv.index("-#{key}")
-        value = argv.at(idx + 1)
-        options[:db][CMD_MAPPING[key]] = value if !value.match(/^\-/)
-        argv.delete_at(idx)
-        argv.delete_at(idx)
+  def index_definitions_from_table(table)
+    query("SHOW CREATE TABLE #{table}").to_a.first["Create Table"].split("\n").map do |line|
+      if line.match(/^\s*KEY \`(.*?)\` \((.*?)\)/)
+        { :name => $1, :columns => $2 }
       end
+    end.compact
+  end
+  
+  def index_drop_statement_for_table(table_name)
+    "ALTER TABLE #{table_name} " + index_definitions_from_table(table_name).map { |config| "\nDROP INDEX #{config[:name]}" }.join(", ")
+  end
+  
+  def index_create_statement_for_table(table_name)
+    "ALTER TABLE #{table_name} " + index_definitions_from_table(table_name).map { |config| "\nADD INDEX #{config[:name]} (#{config[:columns]})" }.join(", ")
+  end
+  
+  def db_options
+    options[:db] || {}
+  end
+  
+  def self.import_command_prefix_from_options(options)
+    cmd = "mysqlimport -L"
+    if db_options = options[:db]
+      cmd << " -u #{db_options[:username]}" if db_options[:username]
+      cmd << " -p#{db_options[:password]}" if db_options[:password]
+      cmd << " #{db_options[:database]}" if db_options[:database]
     end
-    options[:drop_keys] = argv.delete("--without-drop-keys").nil?
-    options[:file_paths] = argv
-    options
+    cmd
+  end
+  
+  def table_name_from_file_path(path)
+    File.basename(path).gsub(".txt", "")
+  end
+  
+  def file_paths
+    options[:file_paths]
+  end
+  
+  def drop_keys?
+    options[:drop_keys]
   end
   
   def client

data/spec/fast_innodb_import_spec.rb

@@ -1,11 +1,50 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+require "fileutils"
 
 # Time to add your specs!
 # http://rspec.info/
 describe "Place your specs here" do
-  
-  it "find this spec in spec directory" do
-    # violated "Be sure to write your specs"
+  { { :username => "root" } => "-u root",
+    { :username => "root", :database => "some_db" } => "-u root some_db",
+    { :username => "root", :password => "secret", :database => "some_db" } => "-u root -psecret some_db",
+  }.each do |db_options, string|
+    it "should constract the correct mysqlimport command prefix for db_options #{db_options.inspect}" do
+      FastInnodbImport.send(:import_command_prefix_from_options, { :db => db_options }).should == "mysqlimport -L #{string}"
+    end
   end
   
+  describe "import from a file" do
+    before(:each) do
+      @database = "fast_innodb_import_test"
+      @username = "root"
+      @client = Mysql2::Client.new(:database => @database, :username => @username)
+      @client.query("TRUNCATE albums")
+      violated if @client.query("SELECT * FROM albums").to_a.length != 0
+    end
+    
+    it "should import a dummy file" do
+      importer = FastInnodbImport.new(:db => { :username => @username, :database => @database })
+      importer.import_data_from_file_path("spec/fixtures/albums.txt")
+      @client.query("SELECT * FROM albums ORDER BY id").to_a.should == [
+        { "id" => 1, "artist_name" => "Jay-Z", "title" => "Black Album" },
+        { "id" => 2, "artist_name" => "Mos Def", "title" => "Black on Both Sides" },
+      ]
+    end
+    
+    it "should write log to stream" do
+      FileUtils.rm_f("tmp/import.log")
+      stream = File.open("tmp/import.log", "w")
+      importer = FastInnodbImport.new(:db => { :username => @username, :database => @database })
+      importer.stream = stream
+      importer.import_data_from_file_path("spec/fixtures/albums.txt")
+      stream.close
+      File.read("tmp/import.log").should match(/import 2 rows .*?\/spec\/fixtures\/albums\.txt: \d+ \(\d+\/sec\)/)
+      FileUtils.rm_f("tmp/import.log")
+    end
+    
+    it "should import data when called with ARGV options" do
+      FastInnodbImport.execute(["-u", @username, "-d", @database, "spec/fixtures/albums.txt"])
+      @client.query("SELECT * FROM albums").to_a.length.should == 2
+    end
+  end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Tobias Schwab
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-22 00:00:00 +02:00
+date: 2010-09-23 00:00:00 +02:00
 default_executable: fast_innodb_import
 dependencies: 
 - !ruby/object:Gem::Dependency