dbsketch 0.0.1

data/lib/dbsketch/comparison/check_constraint_comparator.rb

@@ -0,0 +1,54 @@
+########################################################################################################################
+# Compute differences between two existing check constraint
+########################################################################################################################
+
+require_relative '../model/check_constraint'
+require_relative 'comparison_error'
+require_relative 'diff'
+
+module Dbsketch
+	module Comparison
+
+		class CheckConstraintDiff < Diff
+			def initialize old_constraint, new_constraint
+				super old_constraint, new_constraint
+			end
+			alias :old_constraint :old_value
+			alias :new_constraint :new_value
+
+			def condition
+				### Preconditions
+				raise ComparisonError, "no change found" if not change?
+				###
+				Diff.new old_constraint.condition, new_constraint.condition
+			end
+		end
+
+	end
+end
+
+module Dbsketch
+	module Comparison
+
+		class CheckConstraintComparator
+
+			def are_equivalent? old_constraint, new_constraint
+				### Preconditions
+				raise ArgumentError, "old_constraint is not a Dbsketch::Model::CheckConstraint" unless nil == old_constraint or old_constraint.is_a? Dbsketch::Model::CheckConstraint
+				raise ArgumentError, "new_constraint is not a Dbsketch::Model::CheckConstraint" unless nil == new_constraint or new_constraint.is_a? Dbsketch::Model::CheckConstraint
+				###
+				(nil != old_constraint and nil != new_constraint) and (old_constraint.condition == new_constraint.condition)
+			end
+
+			def compare old_constraint, new_constraint
+				### Preconditions
+				raise ArgumentError, "old_constraint is not a Dbsketch::Model::CheckConstraint" unless nil == old_constraint or old_constraint.is_a? Dbsketch::Model::CheckConstraint
+				raise ArgumentError, "new_constraint is not a Dbsketch::Model::CheckConstraint" unless nil == new_constraint or new_constraint.is_a? Dbsketch::Model::CheckConstraint
+				###
+				CheckConstraintDiff.new(old_constraint, new_constraint) if not are_equivalent? old_constraint, new_constraint
+			end
+
+		end
+
+	end
+end

data/lib/dbsketch/comparison/column_comparator.rb

@@ -0,0 +1,65 @@
+########################################################################################################################
+# Compute differences between two existing columns
+########################################################################################################################
+
+require_relative '../model/column'
+require_relative 'diff'
+require_relative 'type_comparator'
+
+module Dbsketch
+	module Comparison
+
+		class ColumnDiff < Diff
+			def initialize old_column, new_column, type_comparator, options
+				super old_column, new_column
+				if change?
+					@type = type_comparator.compare(old_column.type, new_column.type)
+					@identity = Diff.new(old_column.identity, new_column.identity) if old_column.identity != new_column.identity
+					@default = Diff.new(old_column.default, new_column.default) if old_column.default != new_column.default
+					@nullable = Diff.new(old_column.nullable, new_column.nullable) if old_column.nullable != new_column.nullable
+					@order = Diff.new(old_column.order, new_column.order) if options[:compare_order] and old_column.order != new_column.order
+				end
+			end
+			
+			attr_reader :type, :identity, :default, :nullable, :order
+			alias :old_column :old_value
+			alias :new_column :new_value
+		end
+
+	end
+end
+
+module Dbsketch
+	module Comparison
+
+		class ColumnComparator
+			def initialize options: {}
+				@options = { :compare_order => true }.merge options
+				@type_comparator = TypeComparator.new
+			end
+
+			def are_equivalent? old_column, new_column
+				### Preconditions
+				raise ArgumentError, "old_column is not a Dbsketch::Model::Column" unless nil == old_column or old_column.is_a? Dbsketch::Model::Column
+				raise ArgumentError, "new_column is not a Dbsketch::Model::Column" unless nil == new_column or new_column.is_a? Dbsketch::Model::Column
+				###
+				(nil != old_column and nil != new_column) and
+					@type_comparator.are_equivalent?(old_column.type, new_column.type) and
+					old_column.identity == new_column.identity and
+					old_column.default == new_column.default and
+					old_column.nullable == new_column.nullable and
+					(not @options[:compare_order] or old_column.order == new_column.order)
+			end
+
+			def compare old_column, new_column
+				### Preconditions
+				raise ArgumentError, "old_column is not a Dbsketch::Model::Column" unless nil == old_column or old_column.is_a? Dbsketch::Model::Column
+				raise ArgumentError, "new_column is not a Dbsketch::Model::Column" unless nil == new_column or new_column.is_a? Dbsketch::Model::Column
+				###
+				ColumnDiff.new(old_column, new_column, @type_comparator, @options) if not are_equivalent? old_column, new_column
+			end
+
+		end
+
+	end
+end

data/lib/dbsketch/comparison/comparison_error.rb

@@ -0,0 +1,15 @@
+########################################################################################################################
+# Represents database comparison error
+########################################################################################################################
+
+module Dbsketch
+	module Comparison
+
+		class ComparisonError < StandardError
+			def initialize message
+				super(message)
+			end
+		end
+
+	end
+end

data/lib/dbsketch/comparison/computed_column_comparator.rb

@@ -0,0 +1,63 @@
+########################################################################################################################
+# Compute differences between two existing computed columns
+########################################################################################################################
+
+require_relative '../model/computed_column'
+require_relative 'diff'
+require_relative 'type_comparator'
+
+module Dbsketch
+	module Comparison
+
+		class ComputedColumnDiff < Diff
+			def initialize old_column, new_column, options
+				super old_column, new_column
+				if change?
+					@query = Diff.new(old_column.query, new_column.query) if old_column.query != new_column.query
+					@nullable = Diff.new(old_column.nullable, new_column.nullable) if old_column.nullable != new_column.nullable
+					@order = Diff.new(old_column.order, new_column.order) if options[:compare_order] and old_column.order != new_column.order
+					@persisted = Diff.new(old_column.persisted, new_column.persisted) if old_column.persisted != new_column.persisted
+				end
+			end
+
+			attr_reader :query, :nullable, :order, :persisted
+			alias :old_column :old_value
+			alias :new_column :new_value
+		end
+
+	end
+end
+
+module Dbsketch
+	module Comparison
+
+		class ComputedColumnComparator
+
+			def initialize options: {}
+				@options = { :compare_order => true }.merge options
+			end
+
+			def are_equivalent? old_column, new_column
+				### Preconditions
+				raise ArgumentError, "old_column is not a Dbsketch::Model::ComputedColumn" unless nil == old_column or old_column.is_a? Dbsketch::Model::ComputedColumn
+				raise ArgumentError, "new_column is not a Dbsketch::Model::ComputedColumn" unless nil == new_column or new_column.is_a? Dbsketch::Model::ComputedColumn
+				###
+				(nil != old_column and nil != new_column) and
+					old_column.query == new_column.query and
+					old_column.nullable == new_column.nullable and
+					old_column.persisted == new_column.persisted and
+					(not @options[:compare_order] or old_column.order == new_column.order)
+			end
+
+			def compare old_column, new_column
+				### Preconditions
+				raise ArgumentError, "old_column is not a Dbsketch::Model::ComputedColumn" unless nil == old_column or old_column.is_a? Dbsketch::Model::ComputedColumn
+				raise ArgumentError, "new_column is not a Dbsketch::Model::ComputedColumn" unless nil == new_column or new_column.is_a? Dbsketch::Model::ComputedColumn
+				###
+				ComputedColumnDiff.new(old_column, new_column, @options) if not are_equivalent? old_column, new_column
+			end
+
+		end
+
+	end
+end

data/lib/dbsketch/comparison/database_comparator.rb

@@ -0,0 +1,115 @@
+########################################################################################################################
+# Database differences between two databases
+########################################################################################################################
+
+require_relative '../model/database'
+require_relative 'diff'
+require_relative 'index_comparator'
+require_relative 'table_comparator'
+require_relative 'trigger_comparator'
+require_relative 'view_comparator'
+
+module Dbsketch
+	module Comparison
+
+		class DatabaseDiff < Diff
+			def initialize(old_database, new_database, indexes, operations, tables, triggers, views)
+				super old_database, new_database
+				### Preconditions
+				raise ArgumentError, "old_database is not a Dbsketch::Model::Database" unless old_database.is_a? Dbsketch::Model::Database
+				raise ArgumentError, "new_database is not a Dbsketch::Model::Database" unless new_database.is_a? Dbsketch::Model::Database
+				###
+				@indexes = indexes
+				@operations = operations
+				@tables = tables
+				@triggers = triggers
+				@views = views
+			end
+			attr_reader :indexes, :operations, :tables, :triggers, :views
+		end
+
+		class DatabaseComparator
+			def initialize options: {}
+				@index_comparator = IndexComparator.new
+				@function_comparator = FunctionComparator.new
+				@procedure_comparator = ProcedureComparator.new
+				@table_comparator = TableComparator.new :options => options
+				@trigger_comparator = TriggerComparator.new
+				@view_comparator = ViewComparator.new
+			end
+
+			def are_equivalent? old_database, new_database
+				### Preconditions
+				raise ArgumentError, "old_database is not a Dbsketch::Model::Database" unless old_database.is_a? Dbsketch::Model::Database
+				raise ArgumentError, "new_database is not a Dbsketch::Model::Database" unless new_database.is_a? Dbsketch::Model::Database
+				###
+				indexes(old_database, new_database).empty? and operations(old_database, new_database).empty? and tables(old_database, new_database).empty? and triggers(old_database, new_database).empty? and views(old_database, new_database).empty?
+			end
+
+			# Returns a DatabaseDiff if tables are different, nil otherwise
+			def compare old_database, new_database
+				### Preconditions
+				raise ArgumentError, "old_database is not a Dbsketch::Model::Database" unless old_database.is_a? Dbsketch::Model::Database
+				raise ArgumentError, "new_database is not a Dbsketch::Model::Database" unless new_database.is_a? Dbsketch::Model::Database
+				###
+				DatabaseDiff.new(
+					old_database, new_database, indexes(old_database, new_database), operations(old_database, new_database), tables(old_database, new_database), triggers(old_database, new_database), views(old_database, new_database)
+				) if not are_equivalent? old_database, new_database
+			end
+
+			private
+
+			def find_diffs old_database, new_database, comparator, collection
+				### Preconditions
+				raise ArgumentError, "collection is not a Symbol" unless collection.is_a? Symbol
+				raise ArgumentError, "collection is not a method of Dbsketch::Model::Database" unless old_database.respond_to? collection
+				###
+				diffs = old_database.method(collection).call.select { |old_item| not new_database.has_item? old_item.name }.map do |old_item|
+					comparator.compare(old_item, nil)
+				end
+				diffs << new_database.method(collection).call.select { |new_item| not old_database.has_item? new_item.name }.map do |new_item|
+					comparator.compare(nil, new_item)
+				end
+				diffs << old_database.method(collection).call.select { |old_item| new_database.has_item? old_item.name }.map do |old_item|
+					comparator.compare(old_item, new_database[old_item.name])
+				end
+				diffs.flatten.compact
+			end
+
+			def indexes old_database, new_database
+				find_diffs old_database, new_database, @index_comparator, :indexes
+			end
+
+			def operations old_database, new_database
+				diffs = old_database.operations.select { |old_op| not new_database.has_item? old_op.name }.map do |old_op|
+					(old_op.is_a? Dbsketch::Model::Function) ? @function_comparator.compare(old_op, nil) : @procedure_comparator.compare(old_op, nil)
+				end
+				diffs << new_database.operations.select { |new_op| not old_database.has_item? new_op.name }.map do |new_op|
+					(new_op.is_a? Dbsketch::Model::Function) ? @function_comparator.compare(nil, new_op) : @procedure_comparator.compare(nil, new_op)
+				end
+				diffs << old_database.operations.select { |old_op| new_database.has_item? old_op.name }.map do |old_op|
+					if old_op.class == new_database[old_op.name].class
+						(old_op.is_a? Dbsketch::Model::Function) ? @function_comparator.compare(old_op, new_database[old_op.name]) : @procedure_comparator.compare(old_op, new_database[old_op.name])
+					else
+						Diff.new old_op, new_database[old_op.name]
+					end
+				end
+				diffs.flatten.compact
+			end
+
+			def tables old_database, new_database
+				find_diffs old_database, new_database, @table_comparator, :tables
+			end
+
+			def triggers old_database, new_database
+				find_diffs old_database, new_database, @trigger_comparator, :triggers
+			end
+
+			def views old_database, new_database
+				find_diffs old_database, new_database, @view_comparator, :views
+			end
+
+		end
+
+	end
+end

data/lib/dbsketch/comparison/diff.rb

@@ -0,0 +1,37 @@
+########################################################################################################################
+# Defines difference between two values
+########################################################################################################################
+
+module Dbsketch
+	module Comparison
+
+		class Diff
+			def initialize old_value, new_value
+				### Preconditions
+				raise ArgumentError, "new_value is not different from old_value" unless new_value != old_value
+				###
+				@old_value = old_value
+				@new_value = new_value
+			end
+
+			attr_reader :old_value, :new_value
+
+			# Returns true if the diff represents the deletion of an old value
+			def deletion?
+				nil != @old_value and nil == @new_value
+			end
+
+			# Returns true if the diff represents a change
+			def change?
+				nil != @old_value and nil != @new_value
+			end
+
+			# Returns true if the diff represents the addition of a new value
+			def addition?
+				nil == @old_value and nil != @new_value
+			end
+
+		end
+
+	end
+end

data/lib/dbsketch/comparison/foreign_key_comparator.rb

@@ -0,0 +1,56 @@
+########################################################################################################################
+# Compute differences between two existing foreign keys
+########################################################################################################################
+
+require_relative '../model/foreign_key'
+require_relative 'diff'
+
+module Dbsketch
+	module Comparison
+
+		class ForeignKeyDiff < Diff
+			def initialize old_key, new_key
+				super old_key, new_key
+				if change?
+					@constricted_column = Diff.new(old_key.constricted_column.name, new_key.constricted_column.name) if old_key.constricted_column.name != new_key.constricted_column.name
+					@referenced_table = Diff.new(old_key.referenced_table.name, new_key.referenced_table.name) if old_key.referenced_table.name != new_key.referenced_table.name
+					@referenced_column = Diff.new(old_key.referenced_column.name, new_key.referenced_column.name) if old_key.referenced_column.name != new_key.referenced_column.name
+				end
+			end
+
+			attr_reader :constricted_column, :referenced_table, :referenced_column
+			alias :old_key :old_value
+			alias :new_key :new_value
+		end
+
+	end
+end
+
+module Dbsketch
+	module Comparison
+
+		class ForeignKeyComparator
+
+			def are_equivalent? old_key, new_key
+				### Preconditions
+				raise ArgumentError, "old_key is not a Dbsketch::Model::ForeignKey" unless nil == old_key or old_key.is_a? Dbsketch::Model::ForeignKey
+				raise ArgumentError, "new_key is not a Dbsketch::Model::ForeignKey" unless nil == new_key or new_key.is_a? Dbsketch::Model::ForeignKey
+				###
+				(nil != old_key and nil != new_key) and
+					old_key.constricted_column.name == new_key.constricted_column.name and
+					old_key.referenced_table.name == new_key.referenced_table.name and
+					old_key.referenced_column.name == new_key.referenced_column.name
+			end
+
+			def compare old_key, new_key
+				### Preconditions
+				raise ArgumentError, "old_key is not a Dbsketch::Model::ForeignKey" unless nil == old_key or old_key.is_a? Dbsketch::Model::ForeignKey
+				raise ArgumentError, "new_key is not a Dbsketch::Model::ForeignKey" unless nil == new_key or new_key.is_a? Dbsketch::Model::ForeignKey
+				###
+				ForeignKeyDiff.new(old_key, new_key) if not are_equivalent? old_key, new_key
+			end
+
+		end
+
+	end
+end

data/lib/dbsketch/comparison/function_comparator.rb

@@ -0,0 +1,56 @@
+########################################################################################################################
+# Compute differences between two functions
+########################################################################################################################
+
+require_relative '../model/function'
+require_relative 'diff'
+
+module Dbsketch
+	module Comparison
+
+		class FunctionDiff < Diff
+			def initialize old_function, new_function
+				super old_function, new_function
+				if change?
+					@arguments = Diff.new(old_function.arguments, new_function.arguments) if old_function.arguments != new_function.arguments
+					@returns = Diff.new(old_function.returns, new_function.returns) if old_function.returns != new_function.returns
+					@algo = Diff.new(old_function.algo, new_function.algo) if old_function.algo != new_function.algo
+				end
+			end
+
+			attr_reader :arguments, :returns, :algo
+			alias :old_function :old_value
+			alias :new_function :new_value
+		end
+
+	end
+end
+
+module Dbsketch
+	module Comparison
+
+		class FunctionComparator
+
+			def are_equivalent? old_function, new_function
+				### Preconditions
+				raise ArgumentError, "old_function is not a Dbsketch::Model::Function" unless nil == old_function or old_function.is_a? Dbsketch::Model::Function
+				raise ArgumentError, "new_function is not a Dbsketch::Model::Function" unless nil == new_function or new_function.is_a? Dbsketch::Model::Function
+				###
+				(nil != old_function and nil != new_function) and
+					old_function.arguments == new_function.arguments and
+					old_function.returns == new_function.returns and
+					old_function.algo == new_function.algo
+			end
+
+			def compare old_function, new_function
+				### Preconditions
+				raise ArgumentError, "old_function is not a Dbsketch::Model::Function" unless nil == old_function or old_function.is_a? Dbsketch::Model::Function
+				raise ArgumentError, "new_function is not a Dbsketch::Model::Function" unless nil == new_function or new_function.is_a? Dbsketch::Model::Function
+				###
+				FunctionDiff.new(old_function, new_function) if not are_equivalent? old_function, new_function
+			end
+
+		end
+
+	end
+end