dbdiff 0.1.0

data/CHANGELOG

@@ -0,0 +1,6 @@
+= DbDiff CHANGELOG
+
+== 0.1.0
+
+* Initial Release
+

data/LICENSE

@@ -0,0 +1,58 @@
+DbDiff is copyrighted free software by Eric Kolve <ekolve@gmail.com>.
+You can redistribute it and/or modify it under either the terms of the GPL
+(see COPYING file), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+	  with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under this terms.
+
+     They are gc.c(partly), utils.c(partly), regex.[ch], st.[ch] and some
+     files under the ./missing directory.  See each file for the copying
+     condition.
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.
+

data/README

@@ -0,0 +1,29 @@
+= DbDiff
+
+ 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.  
+
+ Ultimately, I would like to be able to compare two completely different
+ types of DBs (i.e. Oracle <=> MySQL) and bring them up to date as much
+ as possible.  Things like stored procs and triggers may be out of the realm
+ of possibility, since they may not directly translate.
+
+
+== Dependencies
+
+* ruby 1.8.4
+* mysql client
+
+
+== Authors
+
+Copyright (c) 2006 by Eric Kolve <ekolve@gmail.com>
+
+
+== License
+
+This library is distributed under the same terms as Ruby.  
+Please see the LICENSE file.
+

data/lib/dbdiff/column.rb

@@ -0,0 +1,69 @@
+class DbDiff
+  class Column < TableElement
+    attr_reader :data_type, :default, :numeric_precision, :column_type, :length, :not_null
+    attr_accessor :auto_increment
+
+    def initialize(info = {})
+      super
+
+      @name = info['COLUMN_NAME']
+      @data_type = info['DATA_TYPE']
+      @column_type = info['COLUMN_TYPE']
+      @numeric_precision = info['NUMERIC_PRECISION']
+
+      @default = (info['COLUMN_DEFAULT'] == 'NULL' ? nil : info['COLUMN_DEFAULT'])
+
+      # XXX add type and length parsing
+      @not_null = (info['IS_NULLABLE'] == 'NO' ? true : false)
+      @auto_increment = (info['EXTRA'] == 'auto_increment' ? true : false)
+    end
+
+
+    def modify_delta(new_element)
+      Delta::ModifyColumn.new(new_element)
+    end
+
+    def drop_delta
+      if self.auto_increment
+        clone = self.deep_clone 
+        clone.auto_increment = false
+
+        # we have to change this to auto_increment = false
+        # since its the primary key and we can't drop a primary key without disabling
+        # auto_increment
+        return [Delta::ModifyColumnRemoveAI.new(clone), Delta::DropColumn.new(clone)]
+      else
+        return Delta::DropColumn.new(self)
+      end
+    end
+
+    def add_delta
+      if self.auto_increment
+        [Delta::AddColumn.new(self), Delta::ModifyColumnAddAI.new(self)]
+      else
+        Delta::AddColumn.new(self)
+      end
+    end
+
+
+    def definition(add_sql = false)
+     sql = "`%s` %s" % [self.name, self.column_type]
+
+     sql += (@not_null ? ' NOT NULL' : ' NULL ')
+
+     sql += (@default ?  " default '#{default}' " : '')
+     sql += " auto_increment" if !add_sql && self.auto_increment
+
+     sql
+    end
+
+    def ==(other)
+      attribs = %w(column_type default name not_null auto_increment)
+
+      matches = attribs.find_all{|a|  self.send(a.to_sym) == other.send(a.to_sym)}
+      matches.size == attribs.size
+    end
+
+  end
+
+end

data/lib/dbdiff/database.rb

@@ -0,0 +1,169 @@
+require 'rubygems'
+require 'mysql'
+require 'dbdiff/delta'
+require 'dbdiff/table_element'
+require 'dbdiff/table'
+require 'dbdiff/column'
+require 'dbdiff/foreign_key'
+require 'dbdiff/key'
+require 'dbdiff/row'
+class DbDiff
+
+  # XXX validate state of information_schema?
+  class Database
+    attr_reader :dbh, :tables, :name, :host, :user, :password
+    attr_accessor :deltas
+
+    # XXX add version check
+    def initialize(params = {})
+      @dbh = Mysql.real_connect(params[:host], params[:user], params[:password], 'information_schema')
+      @name = params[:name]
+      @host = params[:host]
+      @user = params[:user]
+      @password = params[:password]
+      @deltas = []
+
+      initialize_tables
+      initialize_columns
+      initialize_keys
+      initialize_foreign_keys
+    end
+
+    # XXX may be able to get rid of this
+    def all_tables
+      @tables + @deltas.find_all{|d| d.class == Delta::AddTable }.map {|x| x.element}
+    end
+
+    def initialize_tables
+      @tables = []
+      select_is(:tables, :table_schema => self.name) do |h|
+        t = Table.new(h)
+        t.charset = charset(t.collation)
+
+        @tables << t
+      end
+    end
+
+    def charset(collation)
+      hash = select_is(:character_sets, :default_collate_name => collation)
+      return hash['CHARACTER_SET_NAME']
+    end
+
+    def table(name)
+      @tables.find{|t| t.name == name}
+    end
+
+    def initialize_columns
+      # puts "table name => #{self.name}"
+
+      select_is(:columns)  do |h|
+        c = Column.new(h)
+        table(c.table_name).columns << c
+      end
+    end
+
+    def initialize_keys
+
+      @tables.each do|t|
+        @dbh.select_db(name)
+        res = @dbh.query("SHOW INDEXES FROM #{t.name}")
+        res.each_hash do |h|
+          k = Key.new(t.name, h)
+          if y = t.keys.find {|z| z.name == k.name}
+            y.merge(k)
+          else
+            t.keys << k
+          end
+        end
+
+      end
+    end
+
+    def initialize_foreign_keys
+      select_is(:key_column_usage) do |h|
+        next unless h['REFERENCED_TABLE_NAME']
+
+        c =  ForeignKey.new(h)
+
+        t = table(c.table_name)
+
+        if y = t.foreign_keys.find {|z| z.name == c.name}
+          y.merge(c)
+        else
+          t.foreign_keys << c
+        end
+
+
+      end
+    end
+
+    def select_is(table, where = {}, &block)
+      @dbh.select_db('information_schema')
+
+      # XXX
+      where[:table_schema] = self.name unless table == :character_sets
+
+      self._select(table, where, &block)
+    end
+
+    def select(table, where = {}, &block)
+      @dbh.select_db(self.name)
+      self._select(table, where, &block)
+    end
+
+    # easy way of selecting
+    def _select(table, where = {}, &block)
+      query = "SELECT * from #{table} "
+      if where.length > 0
+         query += " WHERE "
+         query += 
+         where.map do |k,v|
+           if v
+           "#{k}='" + Mysql.escape_string(v) + "'"
+           else
+             "#{k} IS NULL"
+           end
+         end.join(" AND ") 
+
+      end
+
+      # puts "sending query #{query}"
+      result = @dbh.query(query)
+      if block
+        result.each_hash do |h|
+          yield(h)
+        end
+      else
+        return result.fetch_hash
+      end
+    end
+
+    def add(element)
+      @deltas += element.add_delta.to_a
+    end
+
+    def modify(element, new_element)
+      @deltas += element.modify_delta(new_element).to_a
+    end
+
+    def drop(element)
+      @deltas += element.drop_delta.to_a
+    end
+
+    def load_rows(t)
+      t.each do |table_name|
+
+        table = table(table_name)
+
+        if table
+          select(table_name) do |h|
+            table.rows << Row.new(table, h)
+          end
+        end
+
+      end
+    end
+
+  end
+end
+

data/lib/dbdiff/delta.rb

@@ -0,0 +1,266 @@
+class DbDiff
+  class Delta
+    attr_reader :element
+  
+    def initialize(element)
+      @element = element.deep_clone
+    end
+
+    def to_a
+      [self]
+    end
+
+    def table(database)
+      database.table(element.table_name)
+    end
+
+
+    class DropColumn < Delta
+
+
+      def sql
+        "ALTER TABLE #{element.table_name} DROP COLUMN `#{element.name}`"
+      end
+
+      def process(database)
+        table = table(database)
+        table.columns.delete(element)
+      end
+
+    end
+
+
+    class ModifyColumn < Delta
+
+      def sql
+         "ALTER table #{element.table_name} MODIFY COLUMN " + element.definition
+      end
+
+      def process(database)
+        table = table(database)
+        old_column = table.columns.find{|c| c.name == element.name}
+        table.columns.delete(old_column)
+        table.columns << element
+      end
+    end
+
+    class ModifyColumnRemoveAI < ModifyColumn
+
+    end
+  
+    class ModifyColumnAddAI < ModifyColumn
+
+    end
+  
+    class AddColumn < Delta
+
+      def initialize(element)
+        super
+        @element.auto_increment = false
+      end
+
+      def sql
+        "ALTER TABLE #{element.table_name} ADD COLUMN " + element.definition(true)
+      end
+
+      def process(database)
+        table = table(database)
+        table.columns << element
+      end
+    end
+  
+
+    class ModifyRow < Delta
+
+      def sql
+        data = element.data
+        where = element.primary_key.map {|k| "#{k}=" + Mysql.escape_string(data[k]) }.join(" AND ")
+        sql = "UPDATE #{element.table_name} SET "
+
+        updates = data.keys.map do |c|
+          if data[c]
+            " #{c}='" +  Mysql.escape_string(data[c]) + "'"
+          else
+            " #{c}= NULL"
+          end
+        end
+
+        sql += updates.join(",") + " WHERE #{where}"
+
+        return sql
+      end
+
+      def process(database)
+        table = table(database)
+        old_row = table.rows.find{|r| r.name == element.name}
+        table.rows.delete(old_row)
+        table.rows << element 
+      end
+
+    end
+  
+    class AddRow < Delta
+
+      def sql
+        sql = "INSERT INTO #{element.table_name}"
+        data = element.data
+        columns = data.keys
+
+        sql += " (" + columns.join(",") + ")"
+
+        values = columns.map do |c|
+          if data[c]
+            "'" + Mysql.escape_string(data[c]) + "'"
+          else
+            "NULL"
+          end
+        end
+
+        sql += " VALUES (" + values.join(",") + ")"
+  
+        return sql
+      end
+
+      def process(database)
+        table = table(database)
+        table.rows.delete(element)
+        table.rows << element # XXX test this to make sure modifys work
+      end
+
+    end
+  
+    class DropRow < Delta
+
+      def sql
+        data = element.data
+        where = element.primary_key.map {|k| "#{k}=" + Mysql.escape_string(data[k]) }.join(" AND ")
+        return "DELETE FROM #{element.table_name} WHERE #{where}"
+      end
+
+      def process(database)
+        table = table(database)
+        table.rows.delete(element)
+      end
+    end
+
+  
+    class AddKey < Delta
+
+      def sql
+        "ALTER table #{element.table_name} ADD" + element.definition
+      end
+
+      def process(database)
+        table = table(database)
+        table.keys << element
+      end
+    end
+
+  
+    class ModifyKey < Delta
+
+      def sql
+        "ALTER TABLE #{element.table_name} DROP KEY `#{element.name}`, ADD" + element.definition
+      end
+
+      def process(database)
+        table = table(database)
+        old_key = table.keys.find{|k| k.name == element.name}
+        table.keys.delete(old_key)
+        table.keys << element
+      end
+    end
+
+    class DropKey < Delta
+
+      def sql
+        "ALTER TABLE #{element.table_name} DROP KEY `#{element.name}`"
+      end
+
+      def process(database)
+        table = table(database)
+        table.keys.delete(element)
+      end
+    end
+  
+    class AddForeignKey < Delta
+
+      def sql
+       "ALTER table #{element.table_name} ADD " + element.definition
+      end
+
+      def process(database)
+        table(database).foreign_keys << element
+      end
+
+    end
+  
+  
+    class DropForeignKey < Delta
+
+      def sql
+        "ALTER table #{element.table_name} DROP FOREIGN KEY `#{element.name}`;\n"
+      end
+
+      def process(database)
+        table(database).foreign_keys.delete(element) 
+      end
+    end
+  
+    class AddTable < Delta
+
+      def initialize(element)
+        super
+        # we don't clone foreign_keys or rows since
+        # the table_elements diff will take care of them
+        @element.rows = []
+        @element.foreign_keys = []
+      end
+
+      def sql
+        # XXX may need to  SET FOREIGN_KEY_CHECKS = 0;
+        sql = "CREATE TABLE `%s` (\n" % element.name
+  
+        # intentionally skip foreign_keys to avoid missing tables
+        # foreign_keys get picked up with the table_element diff
+        sql += (element.columns.map{|c| c.definition} + 
+               element.keys.map{|k| k.definition}).join(",\n")
+  
+        sql += "\n) ENGINE=%s DEFAULT CHARSET=%s" % [element.engine, element.charset]
+        sql
+      end
+
+      def process(database)
+        database.tables << element
+      end
+  
+    end
+  
+    class ModifyTable < Delta
+
+      def sql
+        "ALTER TABLE #{element.name} ENGINE=%s DEFAULT CHARSET=%s" % [element.engine, element.charset] 
+      end
+
+      def process(database)
+        cur_table = database.tables.find{|t| t.name == element.name}
+        # need full copy of meta-data, but can't swap out the deltas or columns
+        cur_table.engine = element.engine.dup
+        cur_table.collation = element.collation.dup
+      end
+    end
+  
+    class DropTable < Delta
+
+      def sql
+        "DROP TABLE #{element.name}"
+      end
+
+      def process(database)
+        database.tables.delete(element)
+      end
+    end
+  end
+end
+
+

data/lib/dbdiff/foreign_key.rb

@@ -0,0 +1,68 @@
+
+require 'dbdiff/table_element'
+class DbDiff
+  class ForeignKey < TableElement
+    attr_reader :ref_table, :ref_column_data,  :column_data, :name
+    
+    def initialize(info = {})
+      super
+
+      # XXX need to work on tihs
+      @name = info['CONSTRAINT_NAME']
+      seq_index = info['ORDINAL_POSITION'].to_i - 1
+      @column_data = {}
+      @ref_column_data = {}
+
+      @column_data[seq_index] = info['COLUMN_NAME']
+
+      ref_seq_index = info['POSITION_IN_UNIQUE_CONSTRAINT'].to_i - 1
+      @ref_table = info['REFERENCED_TABLE_NAME']
+      @ref_column_data[ref_seq_index] = info['REFERENCED_COLUMN_NAME']
+    end
+
+    def merge(fk)
+
+      unless fk.name == self.name
+        raise "Error - names don't match #{fk.name} #{self.name}"
+      end
+
+      @column_data.merge!(fk.column_data)
+      @ref_column_data.merge!(fk.ref_column_data)
+    end
+
+    def ref_columns
+      @ref_column_data.keys.sort.map {|k| @ref_column_data[k]}
+    end
+
+    def columns
+      @column_data.keys.sort.map {|k| @column_data[k]}
+    end
+
+    def definition
+      return "CONSTRAINT `#{self.name}` FOREIGN KEY  (`" + self.columns.join("`,`") + "`) references #{self.ref_table}(`" + 
+             self.ref_columns.join("`,`") + "`)"
+    end
+
+    def modify_delta(new_element)
+      [self.drop_delta, new_element.add_delta]
+    end
+
+    def drop_delta
+      Delta::DropForeignKey.new(self)
+    end
+
+    def add_delta
+      Delta::AddForeignKey.new(self)
+    end
+
+    def ==(other)
+
+      self.name == other.name && 
+      self.columns == other.columns && 
+      self.table_name == other.table_name && 
+      self.ref_table == other.ref_table && 
+      self.ref_columns == other.ref_columns
+    end
+  end
+
+end