dbdiff 0.1.0 → 0.2.0

data/test/procedure/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;
+
+CREATE PROCEDURE simpleproc (OUT param1 INT) BEGIN SELECT COUNT(*) INTO param1 FROM authors; END;

data/test/procedure/target.sql

@@ -0,0 +1 @@
+

data/test/suite.rb

@@ -3,5 +3,8 @@ require 'test_table'
 require 'test_row'
 require 'test_foreign_key'
 require 'test_key'
+require 'test_procedure'
+require 'test_function'
+require 'test_trigger'
 require 'test_column'
 require 'test_dbdiff'

data/test/test_dbdiff.rb

@@ -38,7 +38,7 @@ class TestDbDiff < Test::Unit::TestCase
   def apply_sql(dbh, database, sql)
 
     dbh.select_db(database)
-    sql.split(";").each do |q|
+    sql.split(/;$/).each do |q|
       q.strip!
       next unless q.length > 0
       dbh.query(q)
@@ -47,8 +47,14 @@ class TestDbDiff < Test::Unit::TestCase
 
   def process_diff
 
+    logger =Logger.new('out.log')
+    logger.level = Logger::DEBUG
+
     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'])
+                     {:host => '127.0.0.1', :password => nil, :user => 'root', :name => TARGET_DB}, 
+                     :replicate_tables => ['authors'],
+                     :logger => logger
+                     )
 
     dbdiff.dry_run = false
     dbdiff.diff
@@ -62,7 +68,7 @@ class TestDbDiff < Test::Unit::TestCase
     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))
+                     {:host => '127.0.0.1', :password => nil, :user => 'root', :name => TARGET_DB}, :replicate_tables => %w(authors))
 
     dbdiff.diff
 
@@ -73,14 +79,16 @@ class TestDbDiff < Test::Unit::TestCase
   def run_diff(dbh, dir)
     source = File.open("./test/" + dir + "/source.sql").read
     target = File.open("./test/" + dir + "/target.sql").read
+    #return unless dir == 'procedure'
 
-    #puts "processing #{dir}"
+#
+#    puts "processing #{dir}"
 
     prep_databases(dbh, source, target)
 
     process_diff
 
-    # puts "processing opposite #{dir}"
+#    puts "processing opposite #{dir}"
 
     prep_databases(dbh, target, source)
 

data/test/test_function.rb

@@ -0,0 +1,69 @@
+require 'dbdiff'
+require 'test/unit'
+
+class TestFunction < Test::Unit::TestCase
+
+  def test_load
+    f = DbDiff::Function.new( 
+      'name' => 'my_func',
+      'body' => %q|return concat('hello, ', s , '!')|,
+      'param_list' => 's char(20)',
+      'type' => 'FUNCTION',
+      'returns'   => 'char(50)'
+    )
+
+    assert(f.definition ==  %q|return concat('hello, ', s , '!')|)
+    assert(f.param_list == 's char(20)')
+    assert(f.routine_type == 'FUNCTION')
+    assert(f.name == 'my_func')
+    assert(f.returns == 'char(50)')
+
+  end
+
+
+
+  def test_not_equal
+    f1 = DbDiff::Function.new( 
+      'name' => 'my_func',
+      'body' => %q|return concat('hello, ', s , '!')|,
+      'param_list' => 's char(20)',
+      'type' => 'FUNCTION',
+      'returns'   => 'char(50)'
+    )
+
+    f2 = DbDiff::Function.new( 
+      'name' => 'my_func2',
+      'body' => %q|return concat('hello, ', s , '!')|,
+      'param_list' => 's char(20)',
+      'type' => 'FUNCTION',
+      'returns'   => 'char(50)'
+    )
+
+    assert(f1 != f2)
+
+  end
+
+
+  def test_equal
+
+    f1 = DbDiff::Function.new( 
+      'name' => 'my_func',
+      'body' => %q|return concat('hello, ', s , '!')|,
+      'param_list' => 's char(20)',
+      'type' => 'FUNCTION',
+      'returns'   => 'char(50)'
+    )
+
+    f2 = DbDiff::Function.new( 
+      'name' => 'my_func',
+      'body' => %q|return concat('hello, ', s , '!')|,
+      'param_list' => 's char(20)',
+      'type' => 'FUNCTION',
+      'returns'   => 'char(50)'
+    )
+
+    assert(f1 == f2)
+  end
+
+end
+

data/test/test_procedure.rb

@@ -0,0 +1,64 @@
+require 'dbdiff'
+require 'test/unit'
+
+class TestProcedure < Test::Unit::TestCase
+
+  def test_load
+    p = DbDiff::Procedure.new( 
+      'name' => 'simpleproc',
+      'body' => %q(BEGIN SELECT COUNT(*) INTO param1 FROM authors2; END),
+      'param_list' => 'OUT param1 INT',
+      'type' => 'PROCEDURE'
+    )
+
+    assert(p.definition ==  %q|BEGIN SELECT COUNT(*) INTO param1 FROM authors2; END|)
+    assert(p.param_list == 'OUT param1 INT')
+    assert(p.routine_type == 'PROCEDURE')
+    assert(p.name == 'simpleproc')
+    assert(p.returns == nil)
+
+  end
+
+
+
+  def test_not_equal
+
+    p1 = DbDiff::Procedure.new( 
+      'name' => 'simpleproc',
+      'body' => %q|BEGIN SELECT COUNT(*) INTO param1 FROM authors2; END|,
+      'param_list' => 'OUT param1 INT',
+      'type' => 'PROCEDURE'
+    )
+
+    p2 = DbDiff::Procedure.new( 
+      'name' => 'simpleproc2',
+      'body' => %q|BEGIN SELECT COUNT(*) INTO param1 FROM authors2; END|,
+      'param_list' => 'OUT param1 INT',
+      'type' => 'PROCEDURE'
+    )
+
+    assert(p1 != p2)
+
+  end
+
+
+  def test_equal
+    p1 = DbDiff::Procedure.new( 
+      'name' => 'simpleproc',
+      'body' => %q|BEGIN SELECT COUNT(*) INTO param1 FROM authors2; END|,
+      'param_list' => 'OUT param1 INT',
+      'type' => 'PROCEDURE'
+    )
+
+    p2 = DbDiff::Procedure.new( 
+      'name' => 'simpleproc',
+      'body' => %q|BEGIN SELECT COUNT(*) INTO param1 FROM authors2; END|,
+      'param_list' => 'OUT param1 INT',
+      'type' => 'PROCEDURE'
+    )
+
+    assert(p1 == p2)
+  end
+
+end
+

data/test/test_row.rb

@@ -6,13 +6,14 @@ class TestRow < Test::Unit::TestCase
   def test_load
 
     t = DbDiff::Table.new( 'ENGINE' => 'InnoDB', 'TABLE_COLLATION' => 'latin1', 'TABLE_NAME' => 'mytable')
-    t.keys << DbDiff::Key.new(t.name, 
+    t.keys << DbDiff::Key.new(t.name,
       'Key_name' => 'PRIMARY',
       'Seq_in_index' => '1',
       'Column_name' => 'id',
       'Non_unique' => '0'
      )
 
+
     row = DbDiff::Row.new( 
       t,
       'id' => '1',
@@ -28,13 +29,15 @@ class TestRow < Test::Unit::TestCase
 
 
   def test_not_equal
-    t = DbDiff::Table.new( 'ENGINE' => 'InnoDB', 'TABLE_COLLATION' => 'latin1', 'TABLE_NAME' => 'mytable')
-    t.keys << DbDiff::Key.new(t.name, 
-      'Key_name' => 'PRIMARY',
-      'Seq_in_index' => '1',
-      'Column_name' => 'id',
-      'Non_unique' => '0'
-     )
+  t = DbDiff::Table.new( 'ENGINE' => 'InnoDB', 'TABLE_COLLATION' => 'latin1', 'TABLE_NAME' => 'mytable')
+  t.keys << DbDiff::Key.new(t.name,
+    'Key_name' => 'PRIMARY',
+    'Seq_in_index' => '1',
+    'Column_name' => 'id',
+    'Non_unique' => '0'
+   )
+
+
 
     r1 = DbDiff::Row.new( 
       t,
@@ -54,15 +57,48 @@ class TestRow < Test::Unit::TestCase
 
   end
 
+  def test_equal_dates
+    t = DbDiff::Table.new( 'ENGINE' => 'InnoDB', 'TABLE_COLLATION' => 'latin1', 'TABLE_NAME' => 'mytable')
+    t.keys << DbDiff::Key.new(t.name,
+      'Key_name' => 'PRIMARY',
+      'Seq_in_index' => '1',
+      'Column_name' => 'id',
+      'Non_unique' => '0'
+     )
+
+
+
+    r1 = DbDiff::Row.new( 
+      t,
+      'id' => '1',
+      'name' => 'foo',
+      'address' => 'blah',
+      'created_on' => '2006-08-01 11:11:11',
+      'updated_on' => '2006-08-02 11:11:11'
+    )
+
+    r2 = DbDiff::Row.new( 
+      t,
+      'id' => '1',
+      'name' => 'foo',
+      'address' => 'blah',
+      'created_on' => '2006-08-08 11:11:11',
+      'updated_on' => '2006-08-08 11:11:11'
+    )
+
+    assert(r1 == r2)
+  end
+
   def test_equal
     t = DbDiff::Table.new( 'ENGINE' => 'InnoDB', 'TABLE_COLLATION' => 'latin1', 'TABLE_NAME' => 'mytable')
-    t.keys << DbDiff::Key.new(t.name, 
+    t.keys << DbDiff::Key.new(t.name,
       'Key_name' => 'PRIMARY',
       'Seq_in_index' => '1',
       'Column_name' => 'id',
       'Non_unique' => '0'
      )
 
+
     r1 = DbDiff::Row.new( 
       t,
       'id' => '1',

data/test/test_trigger.rb

@@ -0,0 +1,68 @@
+require 'dbdiff'
+require 'test/unit'
+
+class TestTrigger < Test::Unit::TestCase
+
+  def test_load
+    t = DbDiff::Trigger.new( 
+      'TRIGGER_NAME' => 'my_trig',
+      'EVENT_OBJECT_TABLE' => 'authors',
+      'ACTION_STATEMENT' => 'BEGIN INSERT INTO blah SET id = NEW.id; END',
+      'ACTION_TIMING' => 'BEFORE',
+      'EVENT_MANIPULATION' => 'INSERT'
+    )
+
+    assert(t.table_name == 'authors')
+
+    assert(t.definition == 'BEGIN INSERT INTO blah SET id = NEW.id; END')
+    assert(t.timing == 'BEFORE')
+    assert(t.event == 'INSERT')
+
+  end
+
+
+
+  def test_not_equal
+    t1 = DbDiff::Trigger.new( 
+      'TRIGGER_NAME' => 'my_trig',
+      'EVENT_OBJECT_TABLE' => 'authors',
+      'ACTION_STATMENT' => 'BEGIN INSERT INTO blah SET id = NEW.id; END',
+      'ACTION_TIMING' => 'BEFORE',
+      'EVENT_MANIPULATION' => 'INSERT'
+    )
+
+    t2 = DbDiff::Trigger.new( 
+      'TRIGGER_NAME' => 'my_trig2',
+      'EVENT_OBJECT_TABLE' => 'authors',
+      'ACTION_STATMENT' => 'BEGIN INSERT INTO blah SET id = NEW.id; END',
+      'ACTION_TIMING' => 'BEFORE',
+      'EVENT_MANIPULATION' => 'INSERT'
+    )
+
+    assert(t1 != t2)
+
+  end
+
+
+  def test_equal
+    t1 = DbDiff::Trigger.new( 
+      'TRIGGER_NAME' => 'my_trig',
+      'EVENT_OBJECT_TABLE' => 'authors',
+      'ACTION_STATMENT' => 'BEGIN INSERT INTO blah SET id = NEW.id; END',
+      'ACTION_TIMING' => 'BEFORE',
+      'EVENT_MANIPULATION' => 'INSERT'
+    )
+
+    t2 = DbDiff::Trigger.new( 
+      'TRIGGER_NAME' => 'my_trig',
+      'EVENT_OBJECT_TABLE' => 'authors',
+      'ACTION_STATMENT' => 'BEGIN INSERT INTO blah SET id = NEW.id; END',
+      'ACTION_TIMING' => 'BEFORE',
+      'EVENT_MANIPULATION' => 'INSERT'
+    )
+
+    assert(t1 == t2)
+  end
+
+end
+

data/test/trigger/source.sql

@@ -0,0 +1,9 @@
+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;
+
+create trigger my_auth BEFORE INSERT on authors FOR EACH ROW BEGIN SET NEW.name = 'fOO'; END;
+

data/test/trigger/target.sql

@@ -0,0 +1,7 @@
+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;
+

data/test/view/source.sql

@@ -0,0 +1,7 @@
+CREATE TABLE authors (
+  `id` int(11) NOT NULL auto_increment,
+  `name` char(60) NOT NULL,
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+CREATE VIEW authors_v as (SELECT * FROM authors);

data/test/view/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=innodb DEFAULT CHARSET=latin1;
+
+
+
+

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: dbdiff
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2006-09-10 00:00:00 -07:00
+  version: 0.2.0
+date: 2006-09-19 00:00:00 -07:00
 summary: DbDiff performs diffs between two databases and applies changes
 require_paths: 
 - lib
@@ -31,6 +31,7 @@ authors:
 files: 
 - test/column
 - test/multi_unique_key
+- test/procedure
 - test/test_row.rb
 - test/multi_key
 - test/test_key.rb
@@ -38,27 +39,39 @@ files:
 - test/suite.rb
 - test/test_column.rb
 - test/unique_key
+- test/test_procedure.rb
 - test/table_fk2
 - test/table_fk
 - test/modify_key_fk
+- test/view
 - test/test_dbdiff.rb
 - test/test_table.rb
 - test/modify_table
 - test/ai_column
 - test/modify_column
+- test/modify_view
+- test/test_function.rb
+- test/trigger
 - test/fk
 - test/modify_key_fk_ref
 - test/change_pk
 - test/key
 - test/row
 - test/table
+- test/test_trigger.rb
+- test/modify_function
+- test/modify_procedure
 - test/test_foreign_key.rb
 - test/modify_fk
+- test/modify_trigger
+- test/function
 - test/modify_row
 - test/column/source.sql
 - test/column/target.sql
 - test/multi_unique_key/source.sql
 - test/multi_unique_key/target.sql
+- test/procedure/source.sql
+- test/procedure/target.sql
 - test/multi_key/source.sql
 - test/multi_key/target.sql
 - test/multi_fk/source.sql
@@ -71,12 +84,18 @@ files:
 - test/table_fk/target.sql
 - test/modify_key_fk/source.sql
 - test/modify_key_fk/target.sql
+- test/view/source.sql
+- test/view/target.sql
 - test/modify_table/source.sql
 - test/modify_table/target.sql
 - test/ai_column/source.sql
 - test/ai_column/target.sql
 - test/modify_column/source.sql
 - test/modify_column/target.sql
+- test/modify_view/source.sql
+- test/modify_view/target.sql
+- test/trigger/source.sql
+- test/trigger/target.sql
 - test/fk/source.sql
 - test/fk/target.sql
 - test/modify_key_fk_ref/source.sql
@@ -89,8 +108,16 @@ files:
 - test/row/target.sql
 - test/table/source.sql
 - test/table/target.sql
+- test/modify_function/source.sql
+- test/modify_function/target.sql
+- test/modify_procedure/source.sql
+- test/modify_procedure/target.sql
 - test/modify_fk/source.sql
 - test/modify_fk/target.sql
+- test/modify_trigger/source.sql
+- test/modify_trigger/target.sql
+- test/function/source.sql
+- test/function/target.sql
 - test/modify_row/source.sql
 - test/modify_row/target.sql
 - lib/dbdiff.rb
@@ -98,14 +125,21 @@ files:
 - lib/dbdiff/key.rb
 - lib/dbdiff/row.rb
 - lib/dbdiff/foreign_key.rb
+- lib/dbdiff/dbdiff_version.rb
 - lib/dbdiff/database.rb
 - lib/dbdiff/column.rb
+- lib/dbdiff/routine.rb
 - lib/dbdiff/delta.rb
 - lib/dbdiff/table_element.rb
+- lib/dbdiff/function.rb
+- lib/dbdiff/procedure.rb
 - lib/dbdiff/table.rb
+- lib/dbdiff/view.rb
+- lib/dbdiff/trigger.rb
 - README
 - CHANGELOG
 - LICENSE
+- COPYING
 test_files: []
 
 rdoc_options: 
@@ -117,6 +151,7 @@ extra_rdoc_files:
 - README
 - CHANGELOG
 - LICENSE
+- COPYING
 executables: []
 
 extensions: []