dbdiff 0.1.0

data/test/modify_table/target.sql

@@ -0,0 +1,9 @@
+
+CREATE TABLE authors (
+  `id` int(11) NOT NULL auto_increment,
+  `name` char(60) NOT NULL,
+  PRIMARY KEY  (`id`)
+) ENGINE=myisam DEFAULT CHARSET=latin1;
+
+
+

data/test/multi_fk/source.sql

@@ -0,0 +1,22 @@
+
+CREATE TABLE authors (
+  `id` int(11) NOT NULL,
+  id2  int not null,
+  `name` char(60) NOT NULL,
+  `address1` char(60) NOT NULL,
+  unique(id, id2),
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+CREATE TABLE books (
+  id int(11) NOT NULL auto_increment,
+  author_id int not null,
+  author_id2 int not null,
+  name char(60) NOT NULL,
+  pages int not null,
+  FOREIGN KEY (author_id, author_id2) references authors(id, id2),
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+
+

data/test/multi_fk/target.sql

@@ -0,0 +1,20 @@
+DROP TABLE IF EXISTS `authors`;
+
+CREATE TABLE authors (
+  `id` int(11) NOT NULL auto_increment,
+  `name` char(60) NOT NULL,
+  `address1` char(60) NOT NULL,
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+CREATE TABLE books (
+  id int(11) NOT NULL auto_increment,
+  author_id int not null,
+  name char(60) NOT NULL,
+  pages int not null,
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+
+
+

data/test/multi_key/source.sql

@@ -0,0 +1,11 @@
+DROP TABLE IF EXISTS `authors`;
+
+CREATE TABLE authors (
+  `id` int(11) NOT NULL auto_increment,
+  `name` char(60) NOT NULL,
+  `address1` char(60) NOT NULL,
+  index(name, address1),
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+

data/test/multi_key/target.sql

@@ -0,0 +1,10 @@
+DROP TABLE IF EXISTS `authors`;
+
+CREATE TABLE authors (
+  `id` int(11) NOT NULL auto_increment,
+  `name` char(60) NOT NULL,
+  `address1` char(60) NOT NULL,
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+

data/test/multi_unique_key/source.sql

@@ -0,0 +1,11 @@
+DROP TABLE IF EXISTS `authors`;
+
+CREATE TABLE authors (
+  `id` int(11) NOT NULL auto_increment,
+  `name` char(60) NOT NULL,
+  `address1` char(60) NOT NULL,
+  unique(name, address1),
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+

data/test/multi_unique_key/target.sql

@@ -0,0 +1,10 @@
+DROP TABLE IF EXISTS `authors`;
+
+CREATE TABLE authors (
+  `id` int(11) NOT NULL auto_increment,
+  `name` char(60) NOT NULL,
+  `address1` char(60) NOT NULL,
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+

data/test/row/source.sql

@@ -0,0 +1,8 @@
+CREATE TABLE authors (
+  `id` int(11) NOT NULL auto_increment,
+  `name` char(60) NOT NULL,
+  `address` char(60) NULL,
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+INSERT INTO authors (id, name, address) values (1, 'FOO', NULL);

data/test/row/target.sql

@@ -0,0 +1,6 @@
+CREATE TABLE authors (
+  `id` int(11) NOT NULL auto_increment,
+  `name` char(60) NOT NULL,
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+

data/test/suite.rb

@@ -0,0 +1,7 @@
+require 'test/unit'
+require 'test_table'
+require 'test_row'
+require 'test_foreign_key'
+require 'test_key'
+require 'test_column'
+require 'test_dbdiff'

data/test/table/source.sql

@@ -0,0 +1,9 @@
+DROP TABLE IF EXISTS `authors`;
+
+CREATE TABLE authors (
+  `id` int(11) NOT NULL auto_increment,
+  `name` char(60) NOT NULL,
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+

data/test/table_fk/source.sql

@@ -0,0 +1,13 @@
+
+CREATE TABLE books (
+  id int(11) NOT NULL auto_increment,
+  author_id int not null,
+  name char(60) NOT NULL,
+  pages int not null,
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+
+
+
+

data/test/table_fk/target.sql

@@ -0,0 +1,20 @@
+
+CREATE TABLE authors (
+  `id` int(11) NOT NULL auto_increment,
+  `name` char(60) NOT NULL,
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+
+CREATE TABLE books (
+  id int(11) NOT NULL auto_increment,
+  author_id int not null,
+  name char(60) NOT NULL,
+  pages int not null,
+  FOREIGN KEY (author_id) references authors(id),
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+
+
+

data/test/table_fk2/source.sql

@@ -0,0 +1,17 @@
+
+CREATE TABLE authors (
+  `id` int(11) NOT NULL auto_increment,
+  `name` char(60) NOT NULL,
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+
+CREATE TABLE books (
+  id int(11) NOT NULL auto_increment,
+  author_id int not null,
+  name char(60) NOT NULL,
+  pages int not null,
+  FOREIGN KEY (author_id) references authors(id),
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+

data/test/table_fk2/target.sql

@@ -0,0 +1,5 @@
+CREATE TABLE authors (
+  `id` int(11) NOT NULL auto_increment,
+  `name` char(60) NOT NULL,
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;

data/test/test_column.rb

@@ -0,0 +1,93 @@
+require 'dbdiff'
+require 'test/unit'
+
+class TestColumn < Test::Unit::TestCase
+
+  def test_load
+    c_ai = DbDiff::Column.new( 
+      'TABLE_NAME'   => 'mytable',
+      'COLUMN_NAME' => 'thisid',
+      'DATA_TYPE' => 'int',
+      'COLUMN_TYPE' => 'int(11)',
+      'NUMERIC_PRECISION' => '10',
+      'COLUMN_DEFAULT' => '5',
+      'EXTRA' => 'auto_increment',
+      'IS_NULLABLE' => 'NO'
+    )
+
+    assert(c_ai.table_name == 'mytable')
+    assert(c_ai.auto_increment )
+    assert(c_ai.not_null)
+    assert(c_ai.name == 'thisid')
+    assert(c_ai.default == '5')
+    assert(c_ai.column_type == 'int(11)')
+    assert(c_ai.data_type == 'int')
+
+    c = DbDiff::Column.new( 
+      'COLUMN_NAME' => 'thisid',
+      'DATA_TYPE' => 'int',
+      'COLUMN_TYPE' => 'int(11)',
+      'NUMERIC_PRECISION' => '10',
+      'COLUMN_DEFAULT' => '5'
+    )
+
+    assert(!c.auto_increment )
+    assert(!c.not_null)
+    assert(c.name == 'thisid')
+    assert(c.default == '5')
+    assert(c.column_type == 'int(11)')
+    assert(c.data_type == 'int')
+  end
+
+
+
+  def test_not_equal
+    c2 = DbDiff::Column.new( 
+      'COLUMN_NAME' => 'thatid',
+      'DATA_TYPE' => 'int',
+      'COLUMN_TYPE' => 'int(11)',
+      'NUMERIC_PRECISION' => '10',
+      'COLUMN_DEFAULT' => '5',
+      'EXTRA' => 'auto_increment',
+      'IS_NULLABLE' => 'NO'
+    )
+    c1 = DbDiff::Column.new( 
+      'COLUMN_NAME' => 'thisid',
+      'DATA_TYPE' => 'int',
+      'COLUMN_TYPE' => 'int(11)',
+      'NUMERIC_PRECISION' => '10',
+      'COLUMN_DEFAULT' => '5',
+      'EXTRA' => 'auto_increment',
+      'IS_NULLABLE' => 'NO'
+    )
+
+    assert(c1 != c2)
+
+  end
+
+  def test_equal
+    c2 = DbDiff::Column.new( 
+      'COLUMN_NAME' => 'thisid',
+      'DATA_TYPE' => 'int',
+      'COLUMN_TYPE' => 'int(11)',
+      'NUMERIC_PRECISION' => '10',
+      'COLUMN_DEFAULT' => '5',
+      'EXTRA' => 'auto_increment',
+      'IS_NULLABLE' => 'NO'
+    )
+
+    c1 = DbDiff::Column.new( 
+      'COLUMN_NAME' => 'thisid',
+      'DATA_TYPE' => 'int',
+      'COLUMN_TYPE' => 'int(11)',
+      'NUMERIC_PRECISION' => '10',
+      'COLUMN_DEFAULT' => '5',
+      'EXTRA' => 'auto_increment',
+      'IS_NULLABLE' => 'NO'
+    )
+
+    assert(c1 == c2)
+  end
+
+end
+

data/test/test_dbdiff.rb

@@ -0,0 +1,92 @@
+require 'test/unit'
+require 'mysql'
+require 'dbdiff'
+
+class TestDbDiff < Test::Unit::TestCase
+
+  SOURCE_DB = '__test_source'
+  TARGET_DB = '__test_target'
+
+  def prep_databases(dbh, source_sql, target_sql)
+
+    dbh.query("DROP DATABASE IF EXISTS `#{SOURCE_DB}`")
+    dbh.query("DROP DATABASE IF EXISTS `#{TARGET_DB}`")
+    dbh.query("CREATE DATABASE `#{SOURCE_DB}`")
+    dbh.query("CREATE DATABASE `#{TARGET_DB}`")
+
+    apply_sql(dbh, SOURCE_DB, source_sql)
+    apply_sql(dbh, TARGET_DB, target_sql)
+
+  end
+
+
+  def test_diffs
+    dir = Dir.open("./test")
+
+    dbh = Mysql.real_connect('127.0.0.1', 'root', nil)
+
+    dir.each do |f|
+      if File.stat("./test/" + f).directory? and f !~ /^\./
+        run_diff(dbh, f)
+      end
+    end
+
+  end
+
+  private
+
+  def apply_sql(dbh, database, sql)
+
+    dbh.select_db(database)
+    sql.split(";").each do |q|
+      q.strip!
+      next unless q.length > 0
+      dbh.query(q)
+    end
+  end
+
+  def process_diff
+
+    dbdiff = DbDiff.new( {:host => '127.0.0.1', :password => nil, :user => 'root', :name => SOURCE_DB},
+                     {:host => '127.0.0.1', :password => nil, :user => 'root', :name => TARGET_DB}, :tables => ['authors'])
+
+    dbdiff.dry_run = false
+    dbdiff.diff
+
+    assert(dbdiff.target.deltas.size > 0)
+
+    dbdiff.apply_diffs(:drop_column, :drop_table, :drop_row)
+
+    dbdiff.diff
+
+    assert(dbdiff.target.deltas.size == 0)
+
+    dbdiff = DbDiff.new( {:host => '127.0.0.1', :password => nil, :user => 'root', :name => SOURCE_DB},
+                     {:host => '127.0.0.1', :password => nil, :user => 'root', :name => TARGET_DB}, :tables => %w(authors))
+
+    dbdiff.diff
+
+    assert(dbdiff.target.deltas.size == 0)
+
+  end
+
+  def run_diff(dbh, dir)
+    source = File.open("./test/" + dir + "/source.sql").read
+    target = File.open("./test/" + dir + "/target.sql").read
+
+    #puts "processing #{dir}"
+
+    prep_databases(dbh, source, target)
+
+    process_diff
+
+    # puts "processing opposite #{dir}"
+
+    prep_databases(dbh, target, source)
+
+    process_diff
+
+  end
+
+
+end

data/test/test_foreign_key.rb

@@ -0,0 +1,136 @@
+require 'dbdiff'
+require 'test/unit'
+
+class TestForeignKey < Test::Unit::TestCase
+
+  def test_load
+    fk = DbDiff::ForeignKey.new( 
+      'TABLE_NAME' => 'mytable',
+      'CONSTRAINT_NAME' => 'ifbk_1',
+      'ORDINAL_POSITION' => '1',
+      'COLUMN_NAME' => 'author_id',
+      'POSITION_IN_UNIQUE_CONSTRAINT' => '1',
+      'REFERENCED_TABLE_NAME' => 'authors',
+      'REFERENCED_COLUMN_NAME' => 'id'
+    )
+
+    assert(fk.table_name == 'mytable')
+    assert(fk.name == 'ifbk_1')
+    assert(fk.ref_table == 'authors')
+    assert(fk.columns == ['author_id'])
+    assert(fk.ref_columns == ['id'])
+
+    mfk1 = DbDiff::ForeignKey.new( 
+      'TABLE_NAME' => 'mytable',
+      'CONSTRAINT_NAME' => 'ifbk_1',
+      'ORDINAL_POSITION' => '1',
+      'COLUMN_NAME' => 'author_id',
+      'POSITION_IN_UNIQUE_CONSTRAINT' => '1',
+      'REFERENCED_TABLE_NAME' => 'authors',
+      'REFERENCED_COLUMN_NAME' => 'id'
+    )
+
+    mfk2 = DbDiff::ForeignKey.new( 
+      'TABLE_NAME' => 'mytable',
+      'CONSTRAINT_NAME' => 'ifbk_1',
+      'ORDINAL_POSITION' => '2',
+      'COLUMN_NAME' => 'user_id',
+      'POSITION_IN_UNIQUE_CONSTRAINT' => '2',
+      'REFERENCED_TABLE_NAME' => 'authors',
+      'REFERENCED_COLUMN_NAME' => 'user_id'
+    )
+
+    mfk1.merge(mfk2)
+
+    assert(mfk1.table_name == 'mytable')
+    assert(mfk1.name == 'ifbk_1')
+    assert(mfk1.ref_table == 'authors')
+    assert(mfk1.columns == ['author_id', 'user_id'])
+    assert(mfk1.ref_columns == ['id', 'user_id'])
+
+  end
+
+
+  def test_bad_merge
+
+    k1 = DbDiff::ForeignKey.new( 
+      'TABLE_NAME' => 'mytable',
+      'CONSTRAINT_NAME' => 'ifbk_2',
+      'ORDINAL_POSITION' => '1',
+      'COLUMN_NAME' => 'author_id',
+      'POSITION_IN_UNIQUE_CONSTRAINT' => '1',
+      'REFERENCED_TABLE_NAME' => 'authors',
+      'REFERENCED_COLUMN_NAME' => 'id'
+    )
+
+    k2 = DbDiff::ForeignKey.new( 
+      'TABLE_NAME' => 'mytable',
+      'CONSTRAINT_NAME' => 'ifbk_1',
+      'ORDINAL_POSITION' => '2',
+      'COLUMN_NAME' => 'user_id',
+      'POSITION_IN_UNIQUE_CONSTRAINT' => '2',
+      'REFERENCED_TABLE_NAME' => 'authors',
+      'REFERENCED_COLUMN_NAME' => 'user_id'
+    )
+
+    caught_error = false
+
+    begin
+      k1.merge(k2)
+    rescue => e
+      caught_error = true
+    end
+    assert(caught_error)
+
+  end
+
+  def test_not_equal
+
+    mfk1 = DbDiff::ForeignKey.new( 
+      'TABLE_NAME' => 'mytable',
+      'CONSTRAINT_NAME' => 'ifbk_2',
+      'ORDINAL_POSITION' => '1',
+      'COLUMN_NAME' => 'author_id',
+      'POSITION_IN_UNIQUE_CONSTRAINT' => '1',
+      'REFERENCED_TABLE_NAME' => 'authors',
+      'REFERENCED_COLUMN_NAME' => 'id'
+    )
+
+    mfk2 = DbDiff::ForeignKey.new( 
+      'TABLE_NAME' => 'mytable',
+      'CONSTRAINT_NAME' => 'ifbk_1',
+      'ORDINAL_POSITION' => '2',
+      'COLUMN_NAME' => 'user_id',
+      'POSITION_IN_UNIQUE_CONSTRAINT' => '2',
+      'REFERENCED_TABLE_NAME' => 'authors',
+      'REFERENCED_COLUMN_NAME' => 'user_id'
+    )
+    assert(mfk1 != mfk2)
+  end
+
+  def test_equal
+
+    fk1 = DbDiff::ForeignKey.new( 
+      'TABLE_NAME' => 'mytable',
+      'CONSTRAINT_NAME' => 'ifbk_1',
+      'ORDINAL_POSITION' => '1',
+      'COLUMN_NAME' => 'author_id',
+      'POSITION_IN_UNIQUE_CONSTRAINT' => '1',
+      'REFERENCED_TABLE_NAME' => 'authors',
+      'REFERENCED_COLUMN_NAME' => 'id'
+    )
+
+    fk2 = DbDiff::ForeignKey.new( 
+      'TABLE_NAME' => 'mytable',
+      'CONSTRAINT_NAME' => 'ifbk_1',
+      'ORDINAL_POSITION' => '1',
+      'COLUMN_NAME' => 'author_id',
+      'POSITION_IN_UNIQUE_CONSTRAINT' => '1',
+      'REFERENCED_TABLE_NAME' => 'authors',
+      'REFERENCED_COLUMN_NAME' => 'id'
+    )
+    assert(fk1 == fk2)
+  end
+
+end
+

data/test/test_key.rb

@@ -0,0 +1,116 @@
+require 'dbdiff'
+require 'test/unit'
+
+class TestKey < Test::Unit::TestCase
+
+  def test_load
+    pk = DbDiff::Key.new( 
+      'mytable',
+      'Key_name' => 'PRIMARY',
+      'Seq_in_index' => '1',
+      'Column_name' => 'id',
+      'Non_unique' => '0'
+    )
+
+    assert(pk.table_name == 'mytable')
+    assert(pk.primary)
+    assert(pk.unique)
+    assert(pk.name == 'PRIMARY')
+    assert(pk.columns == ['id'])
+
+    mk1 = DbDiff::Key.new( 
+      'mytable',
+      'Key_name' => 'user_key',
+      'Seq_in_index' => '1',
+      'Column_name' => 'user_id',
+      'Non_unique' => '1'
+    )
+
+    mk2 = DbDiff::Key.new( 
+      'mytable',
+      'Key_name' => 'user_key',
+      'Seq_in_index' => '2',
+      'Column_name' => 'key',
+      'Non_unique' => '1'
+    )
+
+    mk1.merge(mk2)
+
+    assert(!mk1.primary )
+    assert(!mk1.unique)
+    assert(mk1.name == 'user_key')
+    assert(mk1.columns == ['user_id', 'key'])
+  end
+
+
+
+  def test_not_equal
+    k1 = DbDiff::Key.new( 
+      'mytable',
+      'Key_name' => 'user_key',
+      'Seq_in_index' => '1',
+      'Column_name' => 'user_id',
+      'Non_unique' => '1'
+    )
+
+    k2 = DbDiff::Key.new( 
+      'mytable',
+      'Key_name' => 'user_keyAA',
+      'Seq_in_index' => '1',
+      'Column_name' => 'user_id',
+      'Non_unique' => '1'
+    )
+    require 'pp'
+
+    assert(k1 != k2)
+
+  end
+
+  def test_bad_merge
+    k1 = DbDiff::Key.new( 
+      'mytable',
+      'Key_name' => 'user_key',
+      'Seq_in_index' => '1',
+      'Column_name' => 'user_id',
+      'Non_unique' => '1'
+    )
+
+    k2 = DbDiff::Key.new( 
+      'mytable',
+      'Key_name' => 'key_x',
+      'Seq_in_index' => '1',
+      'Column_name' => 'user_id',
+      'Non_unique' => '1'
+    )
+
+    caught_error = false
+    begin 
+      k1.merge(k2)
+    rescue => e
+      caught_error = true
+    end
+    assert(caught_error)
+  end
+
+  def test_equal
+    k1 = DbDiff::Key.new( 
+      'mytable',
+      'Key_name' => 'user_key',
+      'Seq_in_index' => '1',
+      'Column_name' => 'user_id',
+      'Non_unique' => '1'
+    )
+
+    k2 = DbDiff::Key.new( 
+      'mytable',
+      'Key_name' => 'user_key',
+      'Seq_in_index' => '1',
+      'Column_name' => 'user_id',
+      'Non_unique' => '1'
+    )
+
+    assert(k1 == k2)
+  end
+
+end
+