dbsketch 0.0.1

data/lib/dbsketch/comparison/index_comparator.rb

@@ -0,0 +1,65 @@
+########################################################################################################################
+# Compute differences between two indexes
+########################################################################################################################
+
+require_relative '../model/index'
+require_relative 'diff'
+
+module Dbsketch
+	module Comparison
+
+		class IndexDiff < Diff
+			def initialize old_index, new_index, columns
+				super old_index, new_index
+				if change?
+					@target = Diff.new(old_index.target, new_index.target) if old_index.target.name != new_index.target.name
+					@columns = columns
+				end
+			end
+
+			attr_reader :target, :columns
+			alias :old_index :old_value
+			alias :new_index :new_value
+		end
+
+	end
+end
+
+module Dbsketch
+	module Comparison
+
+		class IndexComparator
+
+			def are_equivalent? old_index, new_index
+				### Preconditions
+				raise ArgumentError, "old_index is not a Dbsketch::Model::Index" unless nil == old_index or old_index.is_a? Dbsketch::Model::Index
+				raise ArgumentError, "new_index is not a Dbsketch::Model::Index" unless nil == new_index or new_index.is_a? Dbsketch::Model::Index
+				###
+				(nil != old_index and nil != new_index) and
+					old_index.target.name == new_index.target.name and
+					columns(old_index, new_index).empty?
+			end
+
+			def compare old_index, new_index
+				### Preconditions
+				raise ArgumentError, "old_index is not a Dbsketch::Model::Index" unless nil == old_index or old_index.is_a? Dbsketch::Model::Index
+				raise ArgumentError, "new_index is not a Dbsketch::Model::Index" unless nil == new_index or new_index.is_a? Dbsketch::Model::Index
+				###
+				IndexDiff.new(old_index, new_index, columns(old_index, new_index)) if not are_equivalent? old_index, new_index
+			end
+
+			private
+
+			def columns old_index, new_index
+				diffs = []
+				if nil != old_index and nil != new_index
+					diffs << old_index.columns.select { |old_i| not new_index.has_column? old_i.name }.map { |old_i| Diff.new old_i.name, nil }
+					diffs << new_index.columns.select { |new_i| not old_index.has_column? new_i.name }.map { |new_i| Diff.new nil, new_i.name }
+				end
+				diffs.flatten.compact
+			end
+
+		end
+
+	end
+end

data/lib/dbsketch/comparison/primary_key_comparator.rb

@@ -0,0 +1,61 @@
+########################################################################################################################
+# Database differences between two primary keys
+########################################################################################################################
+
+require_relative '../model/primary_key'
+require_relative 'diff'
+
+module Dbsketch
+	module Comparison
+
+		class PrimaryKeyDiff < Diff
+			def initialize old_key, new_key, columns
+				super old_key, new_key
+				### Preconditions
+				columns.each_with_index { |column, index| raise ArgumentError, "columns[#{index}] is not a Dbsketch::Comparison::Diff" unless column.is_a? Dbsketch::Comparison::Diff }
+				###
+				if change?
+					@name = Diff.new(old_key.name, new_key.name) if old_key.name != new_key.name
+				end
+				@columns = columns
+			end
+
+			attr_reader :name, :columns
+			alias :old_key :old_value
+			alias :new_key :new_value
+		end
+
+		class PrimaryKeyComparator
+
+			def are_equivalent? old_key, new_key
+				### Preconditions
+				raise ArgumentError, "old_key is not a Dbsketch::Model::PrimaryKey" unless nil == old_key or old_key.is_a? Dbsketch::Model::PrimaryKey
+				raise ArgumentError, "new_key is not a Dbsketch::Model::PrimaryKey" unless nil == new_key or new_key.is_a? Dbsketch::Model::PrimaryKey
+				###
+				(nil == old_key and nil == new_key) or (nil != old_key and nil != new_key and old_key.name == new_key.name and columns(old_key, new_key).empty?)
+			end
+
+			# Returns a PrimaryKeyDiff if tables are different, nil otherwise
+			def compare old_key, new_key
+				### Preconditions
+				raise ArgumentError, "old_key is not a Dbsketch::Model::PrimaryKey" unless nil == old_key or old_key.is_a? Dbsketch::Model::PrimaryKey
+				raise ArgumentError, "new_key is not a Dbsketch::Model::PrimaryKey" unless nil == new_key or new_key.is_a? Dbsketch::Model::PrimaryKey
+				###
+				PrimaryKeyDiff.new(old_key, new_key, columns(old_key, new_key)) if not are_equivalent? old_key, new_key
+			end
+
+			private
+
+			def columns old_key, new_key
+				diffs = []
+				if nil != old_key and nil != new_key
+					diffs << old_key.columns.select { |old_k| not new_key.has_column? old_k.name }.map { |old_k| Diff.new old_k.name, nil }
+					diffs << new_key.columns.select { |new_k| not old_key.has_column? new_k.name }.map { |new_k| Diff.new nil, new_k.name }
+				end
+				diffs.flatten.compact
+			end
+
+		end
+
+	end
+end

data/lib/dbsketch/comparison/procedure_comparator.rb

@@ -0,0 +1,54 @@
+########################################################################################################################
+# Compute differences between two procedures
+########################################################################################################################
+
+require_relative '../model/procedure'
+require_relative 'diff'
+
+module Dbsketch
+	module Comparison
+
+		class ProcedureDiff < Diff
+			def initialize old_procedure, new_procedure
+				super old_procedure, new_procedure
+				if change?
+					@arguments = Diff.new(old_procedure.arguments, new_procedure.arguments) if old_procedure.arguments != new_procedure.arguments
+					@algo = Diff.new(old_procedure.algo, new_procedure.algo) if old_procedure.algo != new_procedure.algo
+				end
+			end
+
+			attr_reader :arguments, :algo
+			alias :old_procedure :old_value
+			alias :new_procedure :new_value
+		end
+
+	end
+end
+
+module Dbsketch
+	module Comparison
+
+		class ProcedureComparator
+
+			def are_equivalent? old_procedure, new_procedure
+				### Preconditions
+				raise ArgumentError, "old_procedure is not a Dbsketch::Model::Procedure" unless nil == old_procedure or old_procedure.is_a? Dbsketch::Model::Procedure
+				raise ArgumentError, "new_procedure is not a Dbsketch::Model::Procedure" unless nil == new_procedure or new_procedure.is_a? Dbsketch::Model::Procedure
+				###
+				(nil != old_procedure and nil != new_procedure) and
+					old_procedure.arguments == new_procedure.arguments and
+					old_procedure.algo == new_procedure.algo
+			end
+
+			def compare old_procedure, new_procedure
+				### Preconditions
+				raise ArgumentError, "old_procedure is not a Dbsketch::Model::Procedure" unless nil == old_procedure or old_procedure.is_a? Dbsketch::Model::Procedure
+				raise ArgumentError, "new_procedure is not a Dbsketch::Model::Procedure" unless nil == new_procedure or new_procedure.is_a? Dbsketch::Model::Procedure
+				###
+				ProcedureDiff.new(old_procedure, new_procedure) if not are_equivalent? old_procedure, new_procedure
+			end
+
+		end
+
+	end
+end

data/lib/dbsketch/comparison/table_comparator.rb

@@ -0,0 +1,158 @@
+########################################################################################################################
+# Database differences between two existing columns
+########################################################################################################################
+
+require_relative '../model/table'
+require_relative 'diff'
+require_relative 'check_constraint_comparator'
+require_relative 'column_comparator'
+require_relative 'computed_column_comparator'
+require_relative 'foreign_key_comparator'
+require_relative 'primary_key_comparator'
+require_relative 'unique_constraint_comparator'
+
+module Dbsketch
+	module Comparison
+
+		class TableDiff < Diff
+			def initialize(old_table, new_table, columns, primary_key, check_constraints, foreign_keys, unique_constraints)
+				super old_table, new_table
+				### Preconditions
+				raise ArgumentError, "old_table is not a Dbsketch::Model::Table" unless nil == old_table or old_table.is_a? Dbsketch::Model::Table
+				raise ArgumentError, "new_table is not a Dbsketch::Model::Table" unless nil == new_table or new_table.is_a? Dbsketch::Model::Table
+				check_constraints.each_with_index { |diff, index| raise ArgumentError, "check_constraints[#{index}] is not a Dbsketch::Comparison::CheckConstraintDiff" unless diff.is_a? Dbsketch::Comparison::CheckConstraintDiff }
+				###
+				@columns = columns
+				@primary_key = primary_key
+				@check_constraints = check_constraints
+				@foreign_keys = foreign_keys
+				@unique_constraints = unique_constraints
+			end
+
+			attr_reader :columns, :primary_key, :check_constraints, :foreign_keys, :unique_constraints
+			alias :old_table :old_value
+			alias :new_table :new_value
+		end
+
+		class TableComparator
+			def initialize column_comparator: nil, options: {}
+				### Preconditions
+				raise ArgumentError, "column_comparator is not a Dbsketch::Comparison::ColumnComparator" unless nil == column_comparator or column_comparator.is_a? Dbsketch::Comparison::ColumnComparator
+				###
+				@check_constraint_comparator = CheckConstraintComparator.new
+				@column_comparator = (nil == column_comparator ? ColumnComparator.new(:options => options) : column_comparator)
+				@computed_column_comparator = ComputedColumnComparator.new
+				@foreign_key_comparator = ForeignKeyComparator.new
+				@primary_key_comparator = PrimaryKeyComparator.new
+				@unique_constraint_comparator = UniqueConstraintComparator.new
+			end
+
+			def are_equivalent? old_table, new_table
+				### Preconditions
+				raise ArgumentError, "old_table is not a Dbsketch::Model::Table" unless nil == old_table or old_table.is_a? Dbsketch::Model::Table
+				raise ArgumentError, "new_table is not a Dbsketch::Model::Table" unless nil == new_table or new_table.is_a? Dbsketch::Model::Table
+				###
+				(nil != old_table and nil != new_table) and
+					columns(old_table, new_table).empty? and
+					@primary_key_comparator.are_equivalent?(old_table.primary_key, new_table.primary_key) and
+					check_constraints(old_table, new_table).empty? and
+					foreign_keys(old_table, new_table).empty? and
+					unique_constraints(old_table, new_table).empty?
+			end
+
+			# Returns a TableDiff if tables are different, nil otherwise
+			def compare old_table, new_table
+				### Preconditions
+				raise ArgumentError, "old_table is not a Dbsketch::Model::Table" unless nil == old_table or old_table.is_a? Dbsketch::Model::Table
+				raise ArgumentError, "new_table is not a Dbsketch::Model::Table" unless nil == new_table or new_table.is_a? Dbsketch::Model::Table
+				###
+				if not are_equivalent? old_table, new_table
+					primary_key_diff = @primary_key_comparator.compare(old_table.primary_key, new_table.primary_key) if nil != old_table and nil != new_table
+					TableDiff.new(
+						old_table, new_table,
+						columns(old_table, new_table),
+						primary_key_diff,
+						check_constraints(old_table, new_table),
+						foreign_keys(old_table, new_table),
+						unique_constraints(old_table, new_table)
+					)
+				end
+			end
+
+			private
+
+			def columns old_table, new_table
+				diffs = []
+				if nil != old_table and nil != new_table
+					diffs = old_table.columns.select { |old_c| not new_table.has_column? old_c.name }.map do |old_c|
+						(old_c.is_a? Dbsketch::Model::Column) ? @column_comparator.compare(old_c, nil) : @computed_column_comparator.compare(old_c, nil)
+					end
+					diffs << new_table.columns.select { |new_c| not old_table.has_column? new_c.name }.map do |new_c|
+						(new_c.is_a? Dbsketch::Model::Column) ? @column_comparator.compare(nil, new_c) : @computed_column_comparator.compare(nil, new_c)
+					end
+					diffs << old_table.columns.select { |old_c| new_table.has_column? old_c.name }.map do |old_c|
+						if old_c.class == new_table[old_c.name].class
+							(old_c.is_a? Dbsketch::Model::Column) ? @column_comparator.compare(old_c, new_table[old_c.name]) : @computed_column_comparator.compare(old_c, new_table[old_c.name])
+						else
+							Diff.new old_c, new_table[old_c.name]
+						end
+					end
+				end
+				diffs.flatten.compact
+			end
+
+			def check_constraints old_table, new_table
+				diffs = []
+				if nil != old_table and nil != new_table
+					diffs = old_table.check_constraints.map do |old_c|
+						if new_table.has_check_constraint? old_c.name
+							@check_constraint_comparator.compare(old_c, new_table.check_constraint(old_c.name))
+						else
+							@check_constraint_comparator.compare(old_c, nil)
+						end
+					end
+					diffs << new_table.check_constraints.select { |new_c| not old_table.has_check_constraint? new_c.name }.map do |new_c|
+						@check_constraint_comparator.compare(nil, new_c)
+					end
+				end
+				diffs.flatten.compact
+			end
+
+			def foreign_keys old_table, new_table
+				diffs = []
+				if nil != old_table and nil != new_table
+					diffs = old_table.foreign_keys.map do |old_k|
+						if new_table.has_foreign_key? old_k.name
+							@foreign_key_comparator.compare(old_k, new_table.foreign_key(old_k.name))
+						else
+							@foreign_key_comparator.compare(old_k, nil)
+						end
+					end
+					diffs << new_table.foreign_keys.select { |new_k| not old_table.has_foreign_key? new_k.name }.map do |new_k|
+						@foreign_key_comparator.compare(nil, new_k)
+					end
+				end
+				diffs.flatten.compact
+			end
+
+			def unique_constraints old_table, new_table
+				diffs = []
+				if nil != old_table and nil != new_table
+					diffs = old_table.unique_constraints.map do |old_c|
+						if new_table.has_unique_constraint? old_c.name
+							@unique_constraint_comparator.compare(old_c, new_table.unique_constraint(old_c.name))
+						else
+							@unique_constraint_comparator.compare(old_c, nil)
+						end
+					end
+					diffs << new_table.unique_constraints.select { |new_c| not old_table.has_unique_constraint? new_c.name }.map do |new_c|
+						@unique_constraint_comparator.compare(nil, new_c)
+					end
+				end
+				diffs.flatten.compact
+			end
+
+		end
+
+	end
+end

data/lib/dbsketch/comparison/trigger_comparator.rb

@@ -0,0 +1,53 @@
+########################################################################################################################
+# Compute differences between two triggers
+########################################################################################################################
+
+require_relative '../model/trigger'
+require_relative 'comparison_error'
+require_relative 'diff'
+
+module Dbsketch
+	module Comparison
+
+		class TriggerDiff < Diff
+			def initialize old_trigger, new_trigger
+				super old_trigger, new_trigger
+				if change?
+					@target = Diff.new(old_trigger.target.name, new_trigger.target.name) if old_trigger.target.name != new_trigger.target.name
+					@activation_time = Diff.new(old_trigger.activation_time, new_trigger.activation_time) if old_trigger.activation_time != new_trigger.activation_time
+					@algo = Diff.new(old_trigger.algo, new_trigger.algo) if old_trigger.algo != new_trigger.algo
+				end
+			end
+			attr_reader :target, :activation_time, :algo
+			alias :old_trigger :old_value
+			alias :new_trigger :new_value
+		end
+
+	end
+end
+
+module Dbsketch
+	module Comparison
+
+		class TriggerComparator
+
+			def are_equivalent? old_trigger, new_trigger
+				### Preconditions
+				raise ArgumentError, "old_trigger is not a Dbsketch::Model::Trigger" unless nil == old_trigger or old_trigger.is_a? Dbsketch::Model::Trigger
+				raise ArgumentError, "new_trigger is not a Dbsketch::Model::Trigger" unless nil == new_trigger or new_trigger.is_a? Dbsketch::Model::Trigger
+				###
+				(nil != old_trigger and nil != new_trigger) and (old_trigger.target.name == new_trigger.target.name) and (old_trigger.activation_time == new_trigger.activation_time) and (old_trigger.algo == new_trigger.algo)
+			end
+
+			def compare old_trigger, new_trigger
+				### Preconditions
+				raise ArgumentError, "old_trigger is not a Dbsketch::Model::Trigger" unless nil == old_trigger or old_trigger.is_a? Dbsketch::Model::Trigger
+				raise ArgumentError, "new_trigger is not a Dbsketch::Model::Trigger" unless nil == new_trigger or new_trigger.is_a? Dbsketch::Model::Trigger
+				###
+				TriggerDiff.new(old_trigger, new_trigger) if not are_equivalent? old_trigger, new_trigger
+			end
+
+		end
+
+	end
+end

data/lib/dbsketch/comparison/type_comparator.rb

@@ -0,0 +1,51 @@
+########################################################################################################################
+# Compute differences between two types
+########################################################################################################################
+
+require_relative '../model/type'
+require_relative 'diff'
+
+module Dbsketch
+	module Comparison
+
+		class TypeDiff < Diff
+			def initialize old_type, new_type
+				### Preconditions
+				raise ArgumentError, "old_type is not a Dbsketch::Model::Type" unless old_type.is_a? Dbsketch::Model::Type
+				raise ArgumentError, "new_type is not a Dbsketch::Model::Type" unless new_type.is_a? Dbsketch::Model::Type
+				###
+				super old_type, new_type
+				@sql_type = Diff.new(old_type.sql_type, new_type.sql_type) if (old_type.sql_type != new_type.sql_type)
+				@sizes = Diff.new(old_type.sizes, new_type.sizes) if (old_type.sizes != new_type.sizes)
+			end
+			attr_reader :sql_type, :sizes
+		end
+
+	end
+end
+
+module Dbsketch
+	module Comparison
+
+		class TypeComparator
+
+			def are_equivalent? old_type, new_type
+				### Preconditions
+				raise ArgumentError, "old_type is not a Dbsketch::Model::Type" unless old_type.is_a? Dbsketch::Model::Type
+				raise ArgumentError, "new_type is not a Dbsketch::Model::Type" unless new_type.is_a? Dbsketch::Model::Type
+				###
+				(old_type.sql_type == new_type.sql_type) and (old_type.sizes == new_type.sizes)
+			end
+
+			def compare old_type, new_type
+				### Preconditions
+				raise ArgumentError, "old_type is not a Dbsketch::Model::Type" unless old_type.is_a? Dbsketch::Model::Type
+				raise ArgumentError, "new_type is not a Dbsketch::Model::Type" unless new_type.is_a? Dbsketch::Model::Type
+				###
+				TypeDiff.new(old_type, new_type) if not are_equivalent? old_type, new_type
+			end
+
+		end
+
+	end
+end