mysql2mysql 0.0.1 → 0.0.2

data/Changelog

@@ -1,2 +1,5 @@
+v0.0.2
+  lots of small fixes and improvements
+
 v0.0.1
-   first release
+  first release

data/INSTALL

@@ -6,4 +6,4 @@ true
 > require 'mysql2mysql'
 true
 > Mysql2Mysql.version 
-0.0.1
+0.0.2

data/README.rdoc

@@ -1,19 +1,141 @@
 == Description
 
-dump table's structure and data between mysql servers and databases.
+Dump table's structure and data between MySql servers and databases.
+
+== INSTALL
+
+$ [sudo] gem install mysql2mysql
+
+== Requirements
+
+Sequel with the mysql driver.
+
+== Examples
 
-== Example
   require 'rubygems'
   require 'mysql2mysql' 
   Mysql2Mysql.new.
     from('mysql://mysql.server1/test?user=root&password=pass').
     to('mysql://mysql.server2/test?user=root&password=pass').
-    tables('test' => :all, 'mysql' => /^time_zone/).
-    dump(:charset => 'utf8', 'with_data' => true)
+    tables('dbname').
+    dump(:charset => 'utf8')
+
+== Methods 
+
+   from: parameters for connect to the source MySql server, it's used for Sequel.connect
+   to: parameters for connect to the target MySql server, it's used for Sequel.connect
+   tables: databases/tables need to dump
+   exclude: databases/tables need to exclude
+   dump: do the clone databases/tables action with some options
+
+== Connection 
+
+  The "from" and "to" methods provide a DSN String or Hash for the database connection.
+    Mysql2Mysql.new.from('mysql://localhost/test?user=root&password=pass')
+  It's same as below
+    Mysql2Mysql.new.from(:host => 'localhost', :user => 'root', :password => 'pass)
+
+  BTW: if the source and target server in the same manchine, please don't use the "localhost" for 2 connections,
+  but it works if one connection use "localhost", another use "127.0.0.1".
+
+== tables && exclude
+
+  Both methods are very similar, but the "exclude" method will take some tables out from the "tables" method. So,
+  finall_tables_to_dump = tables - exclude
+
+  String, Hash, Array are supported. e.g.
+
+  # all databases/tables
+  tables('*')
+
+  # all tables in the database "dbname"
+  tables('dbname')
+
+  # same as above
+  tables(:dbname)
+
+  # all tables in the database "blog" and "log"
+  tables(['blog', 'log']) 
+
+  # same as above
+  tables({'blog' => '*', 'log' => '*'})
+
+  # tables "posts" and "comments" in the database "blog" and
+  # all tables in the database "log"
+  tables({'blog' => ['posts', 'comments'], 'log' => '*'})
+
+  # Regular expression supported
+
+  # all tables with prefix 'wp_' in the database 'blog'
+  tables({:blog => /^(wp)_/})
+
+  # all tables with prefix 'wp_' in the database 'blog' and
+  # all tables only contains 26 lowercase letters in the database "log"
+  tables({:blog => /^(wp)_/, :log => /^[a-z]+$/})
+
+  # all databaes with prefix "www_"
+  tables({/^(www)_/ => '*')
+
+  # exclude
+
+  # only the 'log' database's tables will be cloned 
+  tables('blog', 'log').exclude('blog')
+
+  # all databases/tables exclude the database "mysql", "test" and "information_schema"
+  tables('*').exclude(['mysql', 'test', 'information_schema'])
+
+  # all tables in the database "blog" exclude the "comments" table
+  tables('blog').exclude({'blog' => 'comments'})
+
+== dump
+
+  The "dump" method is expect a Hash as it's parameter, defualt is {}. options:
+
+    :charset          => "utf8", "latin" or any other valid charsets, default is nil
+    :with_data        => Dump data if it's true, otherwise only tables' structure will be dumped, default is true
+    :drop_table_first => Drop the table first if the table is already exists, default is true
+    :rows_per_select  => Number of rows pre select from the source server for the import, default is 1000
+    :before_all       => Proc style call back, it can be executed before the dump action started, default is nil
+    :after_all        => Proc style call back, it can be executed after the dump action finished, default is nil
+    :before_each      => Proc style call back, it can be executed before each table dump started, default is nil
+    :aftere_each      => Proc style call back, it can be executed after each table dump finished,, default is nil
+
+== Cases
+
+  clone 2 databases:
+    
+    Mysql2Mysql.new.
+      from('mysql://localhost:3306/test?user=root&password=').
+      to('mysql://127.0.0.1:3307/test?user=root&password=').
+      tables(['db1', 'db2']).
+      dump
+
+  clone all databases exclude "mysql", "test" and "information_schema":
+    Mysql2Mysql.new.
+      from('mysql://localhost:3306/test?user=root&password=').
+      to('mysql://127.0.0.1:3307/test?user=root&password=').
+      tables(:all).
+      exclude([:mysql, :test, :information_schema]).
+      dump(:charset => 'utf8')
+
+  clone all tables in the database "blog" and rename it to "blog2" in the same server:
+    Mysql2Mysql.new.
+      from('mysql://localhost:3306/test?user=root&password=').
+      to('mysql://localhost:3306/test?user=root&password=').
+      tables('blog').
+      dump(:charset => 'utf8', :before_each => lambda {|db, tb|
+        # change the target database name here from "blog" to "blog2"
+        # the table name can be changed as well, but we keep the table name here
+        return "blog2", tb
+      })
 
 == Version
 
-v0.0.1
+v0.0.2
+
+== TODO
+
+more docs and specs
 
 == Author
 

data/lib/mysql_2_mysql.rb

@@ -9,7 +9,7 @@
 #
 # == Version
 # 
-#   v0.0.1
+#   v0.0.2
 #
 # == Author
 #
@@ -19,7 +19,7 @@ require 'sequel'
 
 class Mysql2Mysql 
 
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 
   def self.version
     VERSION
@@ -68,12 +68,15 @@ class Mysql2Mysql
         if opts[:after_each].respond_to? :call
           opts[:after_each].call(database, table)
         end
+
       end
     end
 
     # after all callback
     after_dump opts
 
+    # disconnect
+    free_db_connection
   end
 
   private
@@ -81,13 +84,16 @@ class Mysql2Mysql
   def dump_opts(opts)
     {
       # it's used for "SET NAMES #{charset}"
-      :charset => 'utf8',
+      :charset => nil,
 
       # dump data or just table structure
       :with_data => true,
 
       # drop the table before do dump the table
-      :drop_table_first => false,
+      :drop_table_first => true,
+
+      # number of rows per select
+      :rows_per_select => 1000,
 
       # callbacks
       :before_all => nil,
@@ -99,14 +105,21 @@ class Mysql2Mysql
 
   def before_dump(opts)
     # prepare dump 
-    [
-      "SET NAMES #{opts[:charset]}",
+    sqls = [
       "SET FOREIGN_KEY_CHECKS = 0",
       "SET UNIQUE_CHECKS = 0"
-    ].each do |sql|
+    ]
+
+    if opts[:charset]
+      sql = "SET NAMES #{opts[:charset]}"
+      run_sql sql, :on_connection => @from_db
+      sqls << sql 
+    end
+
+    sqls.each do |sql|
       run_sql sql, :on_connection => @to_db
     end
-    opts[:before_all].call(@from_db, @to_db) if opts[:after_all].respond_to? :call
+    opts[:before_all].call(@from_db, @to_db) if opts[:before_all].respond_to? :call
   end
 
   def after_dump(opts)
@@ -118,13 +131,22 @@ class Mysql2Mysql
       run_sql sql, :on_connection => @to_db
     end
     opts[:after_all].call(@from_db, @to_db) if opts[:after_all].respond_to? :call 
+
+    @from_db.disconnect
+    @to_db.disconnect
   end
 
   def dump_table(from_database, from_table, to_database, to_table, opts = {})
     use_db from_database, :on_connection => @from_db
-    create_table_ddl = @from_db.fetch("SHOW CREATE TABLE #{from_table}").first[:'Create Table']
 
-    # create database 
+    create_database to_database
+
+    create_table from_table, to_table, opts 
+
+    dump_table_data @from_db[from_table.to_sym], @to_db[to_table.to_sym], opts
+  end
+
+  def create_database(to_database)
     begin
       use_db to_database, :on_connection => @to_db
     rescue Sequel::DatabaseError => e
@@ -135,21 +157,46 @@ class Mysql2Mysql
         raise Mysql2MysqlException.new "create database #{to_database} failed\n  DSN info: #{@to_db}"
       end
     end
+    to_database
+  end
 
-    # create table
-    unless @to_db.table_exists? to_table.to_sym
+  def create_table(from_table, to_table, opts)
+    create_table_ddl = @from_db.fetch("SHOW CREATE TABLE #{from_table}").
+      first[:'Create Table'].
+      gsub("`#{from_table}`", "`#{to_table}`")
+
+    run_sql "DROP TABLE IF EXISTS #{to_table}", :on_connection => @to_db if opts[:drop_table_first]
+    if opts[:drop_table_first] or not @to_db.table_exists?(to_table.to_sym)
       begin
-        run_sql create_table_ddl.gsub("`#{from_table}`", "`#{to_table}`"), :on_connection => @to_db
+        run_sql create_table_ddl, :on_connection => @to_db
       rescue Exception => e
         raise Mysql2MysqlException.new "create table #{to_table} failed in the database #{to_database}\n  DSN info: #{@to_db}\n: message: #{e}"
       end
     end
+  end
 
+  def dump_table_data(from_db_table, to_db_table, opts)
     return unless opts[:with_data] 
 
-    # dump data
-    @from_db.fetch("SELECT * FROM #{from_table}").each do |row|
-      @to_db[to_table.to_sym].insert row
+    total = from_db_table.count
+    return if total == 0
+
+    limit = opts[:rows_per_select]
+    limit = total if limit >= total
+
+    columns = from_db_table.columns
+
+    # temp variables
+    rows = []
+    offset = 0
+    row = {}
+
+    0.step(total - 1, limit) do |offset|
+      rows = from_db_table.limit(limit, offset).collect do |row|
+        row.values
+      end
+
+      to_db_table.import columns, rows
     end
   end
 
@@ -162,8 +209,13 @@ class Mysql2Mysql
   end
 
   def init_db_connection
-    @from_db = db_connection @from
-    @to_db = db_connection @to
+    @from_db = db_connection(@from)
+    @to_db = db_connection(@to)
+  end
+
+  def free_db_connection
+    @from_db.disconnect if @from_db
+    @to_db.disconnect if @to_db
   end
 
   def db_connection(dsn)
@@ -173,7 +225,7 @@ class Mysql2Mysql
 
   def tables_list
     raise Mysql2MysqlException.new 'No tables need to dump' if @tables.nil?
-    filter_tables
+    filter all_valid_tables
   end
 
   def all_databases
@@ -182,45 +234,45 @@ class Mysql2Mysql
     end
   end
 
-  def filter_tables 
-    all_valid_tables = \
-      if is_all? @tables
-        all_databases.inject({}) do |all_tables, dbname|
-          all_tables.merge dbname => get_tables_by_db(dbname)
+  def all_valid_tables
+    orig_tables = convert_tables @tables
+
+    if is_all? orig_tables
+      return all_databases.inject({}) do |all_tables, dbname|
+        all_tables.merge dbname => get_tables_by_db(dbname)
+      end
+    end
+
+    all_tables = {}
+
+    all_databases.each do |dbname|
+      orig_tables.each do |orig_dbname, orig_tbname|
+        next unless is_eql_or_match?(orig_dbname, dbname)
+
+        tables = get_tables_by_db dbname 
+
+        if is_all? orig_tbname
+          all_tables[dbname] = tables
+          break
         end
-      else
-        all_tables = {}
-        all_databases.each do |dbname|
-          @tables.each do |orig_dbname, orig_tbname|
-            next unless is_eql_or_match?(orig_dbname, dbname)
-
-            tables = get_tables_by_db dbname 
-
-            if is_all? orig_tbname
-              all_tables[dbname] = tables
-              break
-            end
-
-            orig_tbnames = [orig_tbname] unless orig_tbname.is_a? Array
-            tables = tables.find_all do |tbname|
-              orig_tbnames.find do |orig_tbname|
-                is_eql_or_match?(orig_tbname, tbname)
-              end
-            end
-
-            all_tables[dbname] = tables
+
+        orig_tbnames = [orig_tbname] unless orig_tbname.is_a? Array
+        tables = tables.find_all do |tbname|
+          orig_tbnames.find do |orig_tbname|
+            is_eql_or_match?(orig_tbname, tbname)
           end
         end
 
-        all_tables
+        all_tables[dbname] = tables
       end
+    end
 
-    filter all_valid_tables
+    all_tables
   end
 
   def is_eql_or_match?(origin, current)
     if origin.is_a? Regexp
-      origin.match current 
+      origin.match current.to_s 
     else
       origin.to_s == current.to_s
     end
@@ -236,42 +288,51 @@ class Mysql2Mysql
   end
 
   def filter(origin_tables)
-    need_exclude = lambda do |origin, exclude|
-      is_eql_or_match? origin.to_s, exclude
-    end
-
     return origin_tables if @exclude.nil?
 
-    exclude_tables = case @exclude
-                    when String
-                      {@exclude => '*'}
-                    when Array
-                      @exclude.inject({}) do |items, it|
-                        items[it] = '*'
-                      end
-                    when Hash 
-                      @exclude
-                    else
-                      raise Mysql2MysqlException.new 'Invalid exclude parameters given'
-                    end
-
-    reject_action = lambda do |dbname, tbname|
-      exclude_tables.each do |exclude_dbname, exclude_tbname|
-        if need_exclude.call(dbname, exclude_dbname)
-          if is_all?(exclude_tbname) or need_exclude.call(tbname, exclude_tbname)
-            return true
-          end
-        end
+    exclude_tables = convert_tables @exclude
+
+    reject_table = lambda do |dbname, tbname|
+      exclude_tables.each do |exclude_dbname, exclude_tbnames|
+        next unless is_eql_or_match?(exclude_dbname, dbname)
+
+        return true if is_all?(exclude_tbnames)
+
+        exclude_tbnames = [exclude_tbnames] unless exclude_tbnames.is_a? Array
+        return true if exclude_tbnames.find {|exclude_tbname|
+          is_eql_or_match? exclude_tbname, tbname
+        }
       end
 
       false
     end
 
-    origin_tables.reject do |dbname, tbname|
-      reject_action.call(dbname, tbname)
+    origin_tables.each do |dbname, tbnames|
+      origin_tables[dbname] = tbnames.find_all do |tbname|
+        not reject_table.call(dbname, tbname)
+      end
+    end
+  end
+
+  def convert_tables(tables)
+    case tables
+    when Symbol, String
+      if is_all? tables
+        tables
+      else
+        {tables.to_s => '*'}
+      end
+    when Array
+      tables.inject({}) do |items, it|
+        items.merge it.to_s => '*'
+      end
+    when Hash 
+      tables
+    else
+      raise Mysql2MysqlException.new 'Invalid "tables" or "exclude" parameters given'
     end
   end
-end
 
-class Mysql2MysqlException < Exception
 end
+
+class Mysql2MysqlException < Exception; end

data/spec/mysql_2_mysql_spec.rb

@@ -0,0 +1,402 @@
+require File.dirname(__FILE__) + '/../lib/mysql_2_mysql.rb'
+
+require 'sequel'
+$from_dsn = 'mysql://localhost:3306/test?user=root&password='
+$to_dsn = 'mysql://127.0.0.1:3307/test?user=root&password='
+
+def disconnect(m2m)
+    m2m.instance_variable_get('@from_db').disconnect
+    m2m.instance_variable_get('@to_db').disconnect
+end
+
+describe Mysql2Mysql, 'initialize' do
+  it "can initialize some parameters" do
+
+    m2m = Mysql2Mysql.new :from => $from_dsn, :to => $to_dsn, :tables => {:test => '*'}, :exclude => {}
+    m2m.instance_variable_get('@from').should == $from_dsn
+    m2m.instance_variable_get('@to').should == $to_dsn
+    m2m.instance_variable_get('@tables').should == {:test => '*'} 
+    m2m.instance_variable_get('@exclude').should == {} 
+
+    m2m.from($from_dsn + '1').instance_variable_get('@from').should == $from_dsn + '1'
+    m2m.to($to_dsn + '1').instance_variable_get('@to').should == $to_dsn + '1'
+  end
+end 
+
+describe Mysql2Mysql, 'dump_opts' do
+  it "should have some pre-defined options" do
+    m2m = Mysql2Mysql.new
+    m2m.send(:dump_opts, {}).should == {   
+      :charset => nil,
+      :with_data => true,
+      :drop_table_first => true,
+      :rows_per_select => 1000,
+      :before_all => nil,
+      :after_all => nil,
+      :before_each => nil,
+      :after_each => nil 
+    }
+
+   m2m.send(:dump_opts, {:charset => 'utf8'})[:charset].should == 'utf8' 
+   m2m.send(:dump_opts, {:before_all => lambda{}})[:before_all].should == lambda{} 
+  end
+end
+
+describe Mysql2Mysql, 'before_dump' do
+  it "can change some mysql variables" do
+    m2m = Mysql2Mysql.new :from => $from_dsn, :to => $to_dsn 
+    m2m.send :init_db_connection
+    m2m.send(:before_dump, m2m.send(:dump_opts, {:charset => 'utf8'}))
+    to_db = m2m.instance_variable_get('@to_db')
+
+    to_db.fetch("SHOW VARIABLES LIKE 'FOREIGN_KEY_CHECKS'").first[:Value].should == 'OFF'
+    to_db.fetch("SHOW VARIABLES LIKE 'UNIQUE_CHECKS'").first[:Value].should == 'OFF'
+    to_db.fetch("SHOW VARIABLES LIKE 'CHARACTER_SET_CLIENT'").first[:Value].should == 'utf8'
+    to_db.fetch("SHOW VARIABLES LIKE 'CHARACTER_SET_CONNECTION'").first[:Value].should == 'utf8'
+
+    disconnect(m2m)
+  end
+
+  it "can execute the code hook 'before_all'" do
+    m2m = Mysql2Mysql.new :from => $from_dsn, :to => $to_dsn 
+    m2m.send :init_db_connection
+    $mysql_expr = nil
+    m2m.send(:before_dump, m2m.send(:dump_opts, {:before_all => lambda{|from_db, to_db|
+      $mysql_expr = from_db.fetch("SELECT 1+1 AS num").first[:num]
+    }}))
+    $mysql_expr.should == 2
+  end
+end
+
+describe Mysql2Mysql, 'after_dump' do
+  it "can revert some mysql variable" do
+    m2m = Mysql2Mysql.new :from => $from_dsn, :to => $to_dsn 
+    m2m.send :init_db_connection
+    m2m.send(:after_dump, m2m.send(:dump_opts, {}))
+    to_db = m2m.instance_variable_get('@to_db')
+
+    to_db.fetch("SHOW VARIABLES LIKE 'FOREIGN_KEY_CHECKS'").first[:Value].should == 'ON'
+    to_db.fetch("SHOW VARIABLES LIKE 'UNIQUE_CHECKS'").first[:Value].should == 'ON'
+
+    disconnect(m2m)
+  end
+
+  it "can execute the code hook 'after_all'" do
+    m2m = Mysql2Mysql.new :from => $from_dsn, :to => $to_dsn 
+    m2m.send :init_db_connection
+    $mysql_expr = nil
+    m2m.send(:after_dump, m2m.send(:dump_opts, {:after_all => lambda{|from_db, to_db|
+      $mysql_expr = from_db.fetch("SELECT 1+1 AS num").first[:num]
+    }}))
+    $mysql_expr.should == 2
+    disconnect(m2m)
+  end
+end
+
+describe Mysql2Mysql, 'create_database' do
+  it "can create a new database on the target mysql server" do
+    db_name = 'db_m2m'
+    m2m = Mysql2Mysql.new :from => $from_dsn, :to => $to_dsn 
+    m2m.send :init_db_connection
+
+    to_db = m2m.instance_variable_get('@to_db')
+    to_db.run "DROP DATABASE IF EXISTS #{db_name}"
+
+    m2m.send :create_database, db_name 
+    to_db.fetch("SHOW DATABASES").all.collect{|row|row.values.first}.should include(db_name)
+
+    # do it again
+    m2m.send :create_database, db_name 
+    to_db.fetch("SHOW DATABASES").all.collect{|row|row.values.first}.should include(db_name)
+
+    # clean up
+    to_db.run "DROP DATABASE #{db_name}"
+    disconnect(m2m)
+  end
+end
+
+describe Mysql2Mysql, 'create_table' do
+  it "can create a new table on the target mysql server according to the source mysql server" do
+    db_name = 'db_m2m'
+    m2m = Mysql2Mysql.new :from => $from_dsn, :to => $to_dsn 
+    m2m.send :init_db_connection
+
+    from_db = m2m.instance_variable_get('@from_db')
+    to_db = m2m.instance_variable_get('@to_db')
+
+    from_db.run "DROP DATABASE IF EXISTS #{db_name}"
+    to_db.run "DROP DATABASE IF EXISTS #{db_name}"
+
+    from_db.run "CREATE DATABASE #{db_name}"
+    from_db.run "USE #{db_name}"
+    from_db.run "CREATE TABLE t(id INT)"
+
+    # use the same table name
+    m2m.send :create_database, db_name
+    m2m.send :create_table, 't', 't', m2m.send(:dump_opts, {})
+    to_db.tables.should include(:t)
+
+    # use different table name
+    m2m.send :create_table, 't', 't2', m2m.send(:dump_opts, {})
+    to_db.tables.should include(:t2)
+
+    from_db.run "DROP DATABASE #{db_name}"
+    to_db.run "DROP DATABASE #{db_name}"
+
+    disconnect(m2m)
+  end
+end
+
+describe Mysql2Mysql, 'dump_table_data' do
+  it "can copy table's data from one server to another server" do
+    db_name = 'db_m2m'
+    m2m = Mysql2Mysql.new :from => $from_dsn, :to => $to_dsn 
+    m2m.send :init_db_connection
+
+    from_db = m2m.instance_variable_get('@from_db')
+    to_db = m2m.instance_variable_get('@to_db')
+
+    from_db.run "DROP DATABASE IF EXISTS #{db_name}"
+    to_db.run "DROP DATABASE IF EXISTS #{db_name}"
+
+    from_db.run "CREATE DATABASE #{db_name}"
+    from_db.run "USE #{db_name}"
+    from_db.run "CREATE TABLE t(id INT)"
+
+    m2m.send :create_database, db_name
+    m2m.send :create_table, 't', 't', m2m.send(:dump_opts, {})
+
+    # 1 row
+    from_db.run "INSERT INTO t(id) VALUES(1)"
+    m2m.send :dump_table_data, from_db[:t], to_db[:t], m2m.send(:dump_opts, {})
+    to_db[:t].first.should == {:id => 1}
+
+    # 2 rows now
+    from_db.run "INSERT INTO t(id) VALUES(2)"
+    m2m.send :dump_table_data, from_db[:t], to_db[:t], m2m.send(:dump_opts, {})
+    to_db[:t].all == [{:id => 1}, {:id => 2}]
+
+    # 2010 rows
+    from_db.run "TRUNCATE TABLE t"
+    to_db.run "TRUNCATE TABLE t"
+    1.upto(2010) do |i|
+      from_db[:t].insert :id => i
+    end
+    m2m.send :dump_table_data, from_db[:t], to_db[:t], m2m.send(:dump_opts, {})
+    to_db[:t].count.should == 2010
+
+    from_db.run "DROP DATABASE #{db_name}"
+    to_db.run "DROP DATABASE #{db_name}"
+
+    disconnect(m2m)
+  end
+end
+
+describe Mysql2Mysql, 'convert_tables' do
+  it "should support several different types" do
+    m2m = Mysql2Mysql.new
+    m2m.send(:convert_tables, '*').should == '*'
+    m2m.send(:convert_tables, :all).should == :all 
+    m2m.send(:convert_tables, 'db_m2m' => '*').should == {'db_m2m' => '*'}
+    m2m.send(:convert_tables, 'db_m2m').should == {'db_m2m' => '*'}
+    m2m.send(:convert_tables, :db_m2m).should == {'db_m2m' => '*'}
+    m2m.send(:convert_tables, [:db1, :db2]).should == {'db1' => '*', 'db2' => '*'}
+    m2m.send(:convert_tables, {:db1 => ['tb1', 'tb2'], :db2 => '*'}).should == {:db1 => ['tb1', 'tb2'], :db2 => '*'}
+    lambda{m2m.send(:convert_tables, lambda{})}.should raise_error(Mysql2MysqlException)
+  end
+end
+
+describe Mysql2Mysql, 'is_eql_or_match?' do
+  it "should support regular expression, symbol and string compare" do
+    m2m = Mysql2Mysql.new
+    m2m.send(:is_eql_or_match?, 'abc', 'abc').should be_true
+    m2m.send(:is_eql_or_match?, :abc, 'abc').should be_true
+    m2m.send(:is_eql_or_match?, 'abc', :abc).should be_true
+    m2m.send(:is_eql_or_match?, 10, "10").should be_true
+    m2m.send(:is_eql_or_match?, /^[0-9]$/, 9).should be_true
+    m2m.send(:is_eql_or_match?, /^[0-9]$/, 0).should be_true
+    m2m.send(:is_eql_or_match?, /^[0-9]$/, "3").should be_true
+    m2m.send(:is_eql_or_match?, /^[0-9]$/, 10).should be_false
+  end
+end
+
+describe Mysql2Mysql, 'is_all?' do
+  it "should support '*' and ':all'" do
+    m2m = Mysql2Mysql.new
+    m2m.send(:is_all?, '*').should be_true
+    m2m.send(:is_all?, :all).should be_true
+    m2m.send(:is_all?, 'all').should be_false
+  end
+end
+
+describe Mysql2Mysql do
+  it "can clone one database" do
+    db_name = 'db_m2m'
+
+    sequel = Sequel.connect $from_dsn
+    sequel.run "CREATE DATABASE #{db_name}"
+    sequel.run "USE #{db_name}"
+    sequel.run "CREATE TABLE t(id INT)"
+
+    m2m = Mysql2Mysql.new :from => $from_dsn, :to => $to_dsn, :tables => {db_name => '*'}
+    m2m.dump
+    from_db = m2m.instance_variable_get('@from_db')
+    to_db = m2m.instance_variable_get('@to_db')
+    to_db.fetch("SHOW DATABASES").all.collect{|row|row.values.first}.should include(db_name)
+
+    from_db.run "DROP DATABASE #{db_name}"
+    to_db.run "DROP DATABASE #{db_name}"
+    sequel.disconnect
+    disconnect(m2m)
+  end
+
+  it "can clone two databases" do
+    db1_name = 'db_m2m_a'
+    db2_name = 'db_m2m_b'
+
+    sequel = Sequel.connect $from_dsn
+    sequel.run "DROP DATABASE IF EXISTS #{db1_name}"
+    sequel.run "DROP DATABASE IF EXISTS #{db2_name}"
+    sequel.run "CREATE DATABASE #{db1_name}"
+    sequel.run "CREATE DATABASE #{db2_name}"
+    sequel.run "USE #{db1_name}"
+    sequel.run "CREATE TABLE t1(id INT)"
+    sequel.run "USE #{db2_name}"
+    sequel.run "CREATE TABLE t2(id INT)"
+
+    m2m = Mysql2Mysql.new :from => $from_dsn, :to => $to_dsn, :tables => [db1_name, db2_name] 
+    m2m.dump
+    from_db = m2m.instance_variable_get('@from_db')
+    to_db = m2m.instance_variable_get('@to_db')
+    to_db.fetch("SHOW DATABASES").all.collect{|row|row.values.first}.should include(db1_name)
+    to_db.fetch("SHOW DATABASES").all.collect{|row|row.values.first}.should include(db2_name)
+    to_db.run "use #{db1_name}"
+    to_db.tables.should include(:t1)
+    to_db.run "use #{db2_name}"
+    to_db.tables.should include(:t2)
+
+    from_db.run "DROP DATABASE #{db1_name}"
+    from_db.run "DROP DATABASE #{db2_name}"
+    to_db.run "DROP DATABASE #{db1_name}"
+    to_db.run "DROP DATABASE #{db2_name}"
+    sequel.disconnect
+    disconnect(m2m)
+  end
+
+  it "can clone 1 table from 2 tables" do
+    db_name = 'db_m2m_a'
+    sequel = Sequel.connect $from_dsn
+    sequel.run "DROP DATABASE IF EXISTS #{db_name}"
+    sequel.run "CREATE DATABASE #{db_name}"
+    sequel.run "USE #{db_name}"
+    sequel.run "CREATE TABLE t1(id INT)"
+    sequel.run "CREATE TABLE t2(id INT)"
+
+    m2m = Mysql2Mysql.new :from => $from_dsn, :to => $to_dsn, :tables => {db_name => 't1'}
+    m2m.dump
+    from_db = m2m.instance_variable_get('@from_db')
+    to_db = m2m.instance_variable_get('@to_db')
+
+    to_db.fetch("SHOW DATABASES").all.collect{|row|row.values.first}.should include(db_name)
+    to_db.run "USE #{db_name}"
+    to_db.tables.should == [:t1] 
+
+    to_db.run "DROP DATABASE #{db_name}"
+    disconnect(m2m)
+
+    m2m = Mysql2Mysql.new :from => $from_dsn, :to => $to_dsn, :tables => {db_name => 't2'}
+    m2m.dump
+    from_db = m2m.instance_variable_get('@from_db')
+    to_db = m2m.instance_variable_get('@to_db')
+    to_db.run "USE #{db_name}"
+    to_db.tables.should == [:t2] 
+
+    from_db.run "DROP DATABASE #{db_name}"
+    to_db.run "DROP DATABASE #{db_name}"
+    sequel.disconnect
+    disconnect(m2m)
+  end
+
+  it "should support regular expression" do
+    db1_name = "db_m2m_a"
+    db2_name = "db_m2m_b"
+    db3_name = "db_2m2"
+
+    sequel = Sequel.connect $from_dsn
+    sequel.run "DROP DATABASE IF EXISTS #{db1_name}"
+    sequel.run "DROP DATABASE IF EXISTS #{db2_name}"
+    sequel.run "DROP DATABASE IF EXISTS #{db3_name}"
+    sequel.run "CREATE DATABASE #{db1_name}"
+    sequel.run "CREATE DATABASE #{db2_name}"
+    sequel.run "CREATE DATABASE #{db3_name}"
+    sequel.run "USE #{db1_name}"
+    sequel.run "CREATE TABLE t1(id INT)"
+    sequel.run "CREATE TABLE t2(id INT)"
+    sequel.run "CREATE TABLE t10(id INT)"
+    sequel.run "USE #{db2_name}"
+    sequel.run "CREATE TABLE t3(id INT)"
+
+    m2m = Mysql2Mysql.new :from => $from_dsn, :to => $to_dsn, :tables => {/^(db_m2m)/ => /^t[0-9]$/}
+    m2m.dump
+    from_db = m2m.instance_variable_get('@from_db')
+    to_db = m2m.instance_variable_get('@to_db')
+
+    to_db.fetch("SHOW DATABASES").all.collect{|row|row.values.first}.should include(db1_name)
+    to_db.fetch("SHOW DATABASES").all.collect{|row|row.values.first}.should include(db2_name)
+    to_db.fetch("SHOW DATABASES").all.collect{|row|row.values.first}.should_not include(db3_name)
+
+    to_db.run "use #{db1_name}"
+    to_db.tables.should include(:t1)
+    to_db.tables.should include(:t2)
+    to_db.tables.should_not include(:t10)
+    to_db.run "use #{db2_name}"
+    to_db.tables.should include(:t3)
+
+    from_db.run "DROP DATABASE #{db1_name}"
+    from_db.run "DROP DATABASE #{db2_name}"
+    from_db.run "DROP DATABASE #{db3_name}"
+    to_db.run "DROP DATABASE #{db1_name}"
+    to_db.run "DROP DATABASE #{db2_name}"
+    sequel.disconnect
+    disconnect(m2m)
+  end
+
+  it "can clone one database to another database in the same server" do
+    dbname = 'db_m2m'
+    new_dbname = 'db_2m2'
+
+    sequel = Sequel.connect $from_dsn
+    sequel.run "DROP DATABASE IF EXISTS #{dbname}"
+    sequel.run "DROP DATABASE IF EXISTS #{new_dbname}"
+    sequel.run "CREATE DATABASE #{dbname}"
+    sequel.run "USE #{dbname}"
+    sequel.run "CREATE TABLE t1(id INT)"
+    sequel.run "CREATE TABLE t2(id INT)"
+
+    m2m = Mysql2Mysql.new :from => $from_dsn, :to => $from_dsn, :tables => dbname 
+    m2m.dump({
+      :before_each => lambda do |db, tb|
+        return new_dbname, "new_#{tb}" 
+      end
+    })
+    from_db = m2m.instance_variable_get('@from_db')
+    to_db = m2m.instance_variable_get('@to_db')
+
+    to_db.fetch("SHOW DATABASES").all.collect{|row|row.values.first}.should include(dbname)
+    to_db.fetch("SHOW DATABASES").all.collect{|row|row.values.first}.should include(new_dbname)
+    to_db.run "use #{dbname}"
+    to_db.tables.should include(:t1)
+    to_db.tables.should include(:t2)
+    to_db.run "use #{new_dbname}"
+    to_db.tables.should include(:new_t1)
+    to_db.tables.should include(:new_t2)
+
+    from_db.run "DROP DATABASE #{dbname}"
+    from_db.run "DROP DATABASE #{new_dbname}"
+    to_db.fetch("SHOW DATABASES").all.collect{|row|row.values.first}.should_not include(dbname)
+    to_db.fetch("SHOW DATABASES").all.collect{|row|row.values.first}.should_not include(new_dbname)
+
+    sequel.disconnect
+    from_db.disconnect
+  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: 
 - xianhua.zhou
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-18 00:00:00 +08:00
+date: 2010-11-28 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -61,6 +61,7 @@ files:
 - INSTALL
 - lib/mysql2mysql.rb
 - lib/mysql_2_mysql.rb
+- spec/mysql_2_mysql_spec.rb
 has_rdoc: true
 homepage: http://github.com/xianhuazhou
 licenses: []