dbdiff 0.1.0

data/lib/dbdiff/key.rb

@@ -0,0 +1,69 @@
+class DbDiff
+  class Key < TableElement
+    attr_reader :column_data, :unique, :primary
+
+    def initialize(table_name, info= {})
+       @table_name = table_name
+
+
+      # XXX need to work on tihs
+      @name = info['Key_name']
+
+      @primary = (@name == 'PRIMARY' ? true : false) 
+      seq_index = info['Seq_in_index'].to_i - 1
+      @unique = (info['Non_unique'].to_i == 1 ? false : true)
+      @column_data = {}
+      @column_data[seq_index] = info['Column_name']
+    end
+
+    def columns
+      @column_data.keys.sort.map {|k| @column_data[k]}
+    end
+
+    def merge(key)
+
+      unless key.name == self.name
+        raise "Error - names don't match #{key.name} #{self.name}"
+      end
+
+      @column_data.merge!(key.column_data)
+    end
+
+    def definition
+    
+      sql = ""
+      if @primary
+        sql += " PRIMARY KEY "
+      elsif @unique 
+        sql += " UNIQUE KEY `%s`" % self.name
+      else
+        sql += " KEY `%s`" % self.name
+      end
+
+      sql += " (" + self.columns.map{|c| '`' + c + '`' }.join(",") + " )"
+    
+      sql
+    end
+
+    def modify_delta(new_element)
+      Delta::ModifyKey.new(new_element)
+    end
+
+    def drop_delta
+      Delta::DropKey.new(self)
+    end
+
+    def add_delta
+      Delta::AddKey.new(self)
+    end
+
+    def ==(other)
+      self.columns == other.columns && 
+      self.table_name == other.table_name && 
+      self.primary == other.primary && 
+      self.unique == other.unique &&
+      self.name == other.name
+    end
+
+  end
+end

data/lib/dbdiff/row.rb

@@ -0,0 +1,32 @@
+require 'dbdiff/table_element'
+
+class DbDiff
+
+  class Row < TableElement
+    attr_reader :primary_key, :data
+
+    def initialize(table, info = {})
+      @data = info.dup  
+      @primary_key = table.primary_key
+      @name = @primary_key.map {|k|@data[k] }.join("|") # XXX fix this to be more unique of a name
+      @table_name = table.name
+    end
+
+
+    def add_delta
+      Delta::AddRow.new(self)
+    end
+
+    def modify_delta(new_element)
+      Delta::ModifyRow.new(new_element)
+    end
+
+    def drop_delta
+      Delta::DropRow.new(self)
+    end
+
+    def ==(other)
+      self.data == other.data
+    end
+  end
+end

data/lib/dbdiff/table.rb

@@ -0,0 +1,50 @@
+class DbDiff
+  class Table
+    attr_reader :name 
+    attr_accessor :charset, :rows, :keys, :foreign_keys, :columns, :collation, :engine
+
+    def initialize(info = {})
+      @data = {}
+
+      @rows = []
+      @foreign_keys = []
+      @keys = []
+      @columns = []
+
+      @engine = info['ENGINE']
+      @collation = info['TABLE_COLLATION']
+      @name = info['TABLE_NAME']
+    end
+
+    alias :table_name :name
+
+    def primary_key
+      pk = keys.find{|k| k.primary}
+      return (pk  ? pk.columns : nil)
+    end
+
+    def ==(other)
+      self.engine    == other.engine &&
+      self.collation == other.collation &&
+      self.name      == other.name
+    end
+
+    def deep_clone
+      t = Marshal::load(Marshal.dump(self))
+      # must clear rows out since they won't necessary be in the copy
+    end
+
+    def add_delta
+      Delta::AddTable.new(self)
+    end
+
+    def modify_delta(new_element)
+      Delta::ModifyTable.new(new_element)
+    end
+
+    def drop_delta
+      Delta::DropTable.new(self)
+    end
+  end
+
+end

data/lib/dbdiff/table_element.rb

@@ -0,0 +1,16 @@
+class DbDiff
+  class TableElement
+    attr_reader :name, :table_name
+
+    def initialize(info = {})
+      @table_name = info['TABLE_NAME']
+    end
+
+
+    def deep_clone
+      Marshal::load(Marshal.dump(self))
+    end
+
+  end
+end
+

data/lib/dbdiff.rb

@@ -0,0 +1,207 @@
+require 'dbdiff/database'
+require 'logger'
+
+# = Synopsis
+# DbDiff allows you to compare two different databases (currently MySQL),
+# determine the differences between the two, and apply the deltas.
+#  Currently the following types of deltas are supported: tables, 
+#  columns, keys, foreign keys and rows.  
+#
+#  Specifying tables in the constructor causes these tables to be 
+#  replicated.
+#
+#  Nothing in dropped or removed unless you explicitly pass :drop_row, 
+#  :drop_column or :drop_table.  
+#
+#  By default, calling apply_diffs does nothing - you must explicitly
+#  set dry_run to false on the dbdiff object.
+#
+#
+# == Example
+#  require 'rubygems'
+#  require 'dbdiff'
+#
+#  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'},
+#                        :logger => Logger.new(STDOUT),
+#                        :tables => %w(authors books)
+#                      )
+#  # don't actually execute any SQL against the target
+#  dbdiff.dry_run = true
+# 
+#  # perform diff between source and target
+#  dbiff.diff
+# 
+#  # process diffs - arguments indicate that drop_column, drop_row (only for replicated tables), 
+#  # and drop_table are allowed within diffs
+#  # are allowed
+#  diff.apply_diffs(:drop_column, :drop_row, :drop_table)
+#
+
+class DbDiff
+  attr_reader :source, :target, :tables, :logger
+  attr_accessor :dry_run
+
+  # Creates a new dbdiff object with the connect strings s/t (source/target)
+  def initialize(s, t, params = {})
+    @source = DbDiff::Database.new(s)
+    @target = DbDiff::Database.new(t)
+    @tables = params[:tables] || []
+    @logger = params[:logger] || Logger.new(nil)
+
+    @source.load_rows(@tables)
+    @target.load_rows(@tables)
+    @dry_run = true
+  end
+
+  # Compare tables and all elements (columns, rows, keys, foreign keys)
+  # differences are stored on the deltas attribute of the target
+  # database
+  def diff
+    compare_tables
+    compare_elements(:columns, :rows, :keys, :foreign_keys)
+  end
+
+  # Apply deltas stored on the target
+  # all SQL executed will be sent to the logger as info messages
+  def apply_diffs (*allowed_deltas)
+
+  
+    # these deltas must be manually
+    # resolved or explicitly allowed
+    confirm_deltas = {
+      :drop_row    => DbDiff::Delta::DropRow,
+      :drop_column => DbDiff::Delta::DropColumn,
+      :drop_table  => DbDiff::Delta::DropTable
+    }
+
+    confirm_deltas = confirm_deltas.delete_if {|k,v| allowed_deltas.include?(k)}
+
+
+    delta_order = [
+      DbDiff::Delta::AddTable, 
+      DbDiff::Delta::ModifyTable, 
+      DbDiff::Delta::DropForeignKey, 
+      DbDiff::Delta::DropTable,   # can only drop a table after foreign keys have been dropped
+
+      DbDiff::Delta::AddColumn, 
+  
+      DbDiff::Delta::ModifyColumnRemoveAI, # ai must be removed before we can drop/modify a pk 
+
+      DbDiff::Delta::ModifyKey,     # must have columns exist prior to adding a key
+      DbDiff::Delta::AddKey,        # must have new keys before old ones can be dropped
+                                    # to support FKs
+
+      DbDiff::Delta::DropKey,       # must have FK dropped before we drop a key
+
+      DbDiff::Delta::ModifyColumnAddAI, # ai must be added before we can add a pk 
+  
+      DbDiff::Delta::DropRow,  
+      DbDiff::Delta::ModifyColumn,  
+  
+      DbDiff::Delta::AddForeignKey, 
+      DbDiff::Delta::DropColumn,
+      DbDiff::Delta::AddRow,  
+      DbDiff::Delta::ModifyRow
+    ]
+
+    drop_deltas = target.deltas.find_all {|d| confirm_deltas.values.include?(d.class) }
+
+    if drop_deltas && drop_deltas.size > 0
+      message = "The following deltas must be either handled by a rename or explicitly allowed"
+      drop_deltas.each do|d|
+        message += "\n #{d.class.name}: " + d.sql
+      end
+      raise message
+    end
+  
+    target.dbh.query("SET FOREIGN_KEY_CHECKS = 0")
+  
+    target.deltas.sort_by {|d| delta_order.index(d.class) }.each do |d|
+        logger.info("processing #{d.sql}")
+        d.process(target) 
+        run_sql(d.sql) unless @dry_run
+    end
+  
+    target.dbh.query("SET FOREIGN_KEY_CHECKS = 1")
+  
+    target.deltas = []
+  end
+  
+  private 
+
+  def run_sql(sql)
+    begin
+      target.dbh.select_db(target.name)
+       logger.info("executing #{sql}")
+       result = target.dbh.query(sql)
+    rescue => e
+      raise "error executing query '#{sql}': #{e}"
+    end
+  end
+
+  def compare_elements(*elements)
+  
+    elements.each do |e|
+      diff_table_elements(source, target, e, :diff_add_modify)
+      diff_table_elements(target, source, e, :diff_drop)
+    end
+  end
+  
+  def compare_tables
+  
+    # only handle modify/add
+    source.tables.each do |t|
+      # XXX add authors2
+      diff_add_modify(source, target, t, target.tables.find{|x| x.name == t.name})
+    end
+  
+    ## only handle removals here
+    target.tables.each do |t|
+      # xxx drop authors
+      diff_drop(target, source, t, source.tables.find{|x| x.name == t.name})
+    end
+  
+  end
+  
+  def diff_drop(a, b, element, target_element)
+    if !target_element
+      # source is actually the target database
+      logger.info("dropping #{element.class.name} #{element.name} #{element.table_name} from #{a.class.name} #{a.name}")
+      a.drop(element)
+    end
+  end
+  
+  def diff_add_modify(a, b, element, target_element)
+  
+    if !target_element
+      logger.info("adding element #{element.class.name} #{element.name} #{element.table_name} > #{b.name}")
+      b.add(element)
+    elsif target_element != element
+      logger.info("modifying element #{element.class.name} #{element.name} #{element.table_name} > #{b.name}")
+      b.modify(target_element, element)
+    end
+  
+  end
+
+  def diff_table_elements(a, b, table_method, diff_method)
+  
+
+    # all_tables allows us to add the FKs after adding the tables 
+    # otherwise the table won't be there to add the FK 
+    a.all_tables.each do |at|
+      bt = b.all_tables.find{|z| z.name == at.name}
+      # XXX possibly skip this and make the add check determine whether 
+      # we can skip the add because we have already encountered the add
+      next unless bt
+  
+      at.send(table_method).each do |ae|
+        be = bt.send(table_method).find{|x| x.name == ae.name}
+        send(diff_method, a, b, ae, be)
+      end
+    end
+  
+  end
+
+end
+

data/test/ai_column/source.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/ai_column/target.sql

@@ -0,0 +1,7 @@
+
+CREATE TABLE authors (
+  `name` char(60) NOT NULL,
+  `address1` char(60) NOT NULL
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+

data/test/change_pk/source.sql

@@ -0,0 +1,11 @@
+CREATE TABLE authors (
+  dim_id int not null,
+  res_id int not null,
+  name char(60) NOT NULL,
+  address1 char(60) NOT NULL,
+  PRIMARY KEY  (`dim_id`, `res_id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+
+
+

data/test/change_pk/target.sql

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

data/test/column/source.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/column/target.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/fk/source.sql

@@ -0,0 +1,19 @@
+
+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,
+  FOREIGN KEY (author_id) references authors(id),
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+
+

data/test/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/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),
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+

data/test/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/modify_column/source.sql

@@ -0,0 +1,9 @@
+
+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/modify_column/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(40) NOT NULL,
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+

data/test/modify_fk/source.sql

@@ -0,0 +1,20 @@
+
+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,
+  new_id    int not null,
+  name char(60) NOT NULL,
+  pages int not null,
+  CONSTRAINT `author_fk1` FOREIGN KEY (new_id) references authors(id),
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+
+

data/test/modify_fk/target.sql

@@ -0,0 +1,22 @@
+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,
+  new_id    int not null,
+  name char(60) NOT NULL,
+  pages int not null,
+  CONSTRAINT `author_fk1` FOREIGN KEY (author_id) references authors(id),
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+
+
+

data/test/modify_key_fk/source.sql

@@ -0,0 +1,19 @@
+
+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,
+  unique(author_id),
+  FOREIGN KEY (author_id) references authors(id),
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+
+

data/test/modify_key_fk/target.sql

@@ -0,0 +1,20 @@
+
+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,
+  index(author_id),
+  FOREIGN KEY (author_id) references authors(id),
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+
+
+

data/test/modify_key_fk_ref/source.sql

@@ -0,0 +1,18 @@
+
+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,
+  address_id int not null,
+  name char(60) NOT NULL,
+  unique(author_id),
+  FOREIGN KEY (author_id) references authors(id),
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+

data/test/modify_key_fk_ref/target.sql

@@ -0,0 +1,20 @@
+
+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,
+  index(author_id),
+  FOREIGN KEY (author_id) references authors(id),
+  PRIMARY KEY  (`id`)
+) ENGINE=innodb DEFAULT CHARSET=latin1;
+
+
+
+

data/test/modify_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/modify_row/target.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;
+
+INSERT INTO authors (id, name, address) values (1, 'BAR', 'BLAh');
+

data/test/modify_table/source.sql

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