dbsketch 0.0.1

data/README.md

@@ -0,0 +1 @@
+# dbsketch

data/lib/dbsketch.rb

@@ -0,0 +1,64 @@
+require_relative 'dbsketch/model/abstract_column'
+require_relative 'dbsketch/model/check_constraint'
+require_relative 'dbsketch/model/column'
+require_relative 'dbsketch/model/computed_column'
+require_relative 'dbsketch/model/custom_code'
+require_relative 'dbsketch/model/database'
+require_relative 'dbsketch/model/database_object'
+require_relative 'dbsketch/model/foreign_key'
+require_relative 'dbsketch/model/function'
+require_relative 'dbsketch/model/index'
+require_relative 'dbsketch/model/model_error'
+require_relative 'dbsketch/model/operation'
+require_relative 'dbsketch/model/primary_key'
+require_relative 'dbsketch/model/procedure'
+require_relative 'dbsketch/model/table'
+require_relative 'dbsketch/model/trigger'
+require_relative 'dbsketch/model/type'
+require_relative 'dbsketch/model/unique_constraint'
+require_relative 'dbsketch/model/view'
+
+require_relative 'dbsketch/automation/automation_error'
+require_relative 'dbsketch/automation/database_connection_details'
+require_relative 'dbsketch/automation/database_importer'
+require_relative 'dbsketch/automation/database_proxy'
+require_relative 'dbsketch/automation/table_importer'
+
+require_relative 'dbsketch/comparison/check_constraint_comparator'
+require_relative 'dbsketch/comparison/column_comparator'
+require_relative 'dbsketch/comparison/computed_column_comparator'
+require_relative 'dbsketch/comparison/database_comparator'
+require_relative 'dbsketch/comparison/diff'
+require_relative 'dbsketch/comparison/foreign_key_comparator'
+require_relative 'dbsketch/comparison/function_comparator'
+require_relative 'dbsketch/comparison/primary_key_comparator'
+require_relative 'dbsketch/comparison/procedure_comparator'
+require_relative 'dbsketch/comparison/table_comparator'
+require_relative 'dbsketch/comparison/trigger_comparator'
+require_relative 'dbsketch/comparison/type_comparator'
+require_relative 'dbsketch/comparison/unique_constraint_comparator'
+require_relative 'dbsketch/comparison/view_comparator'
+
+require_relative 'dbsketch/rendering/meta/column_renderer'
+require_relative 'dbsketch/rendering/meta/database_renderer'
+require_relative 'dbsketch/rendering/meta/foreign_key_renderer'
+require_relative 'dbsketch/rendering/meta/index_renderer'
+require_relative 'dbsketch/rendering/meta/operation_renderer'
+require_relative 'dbsketch/rendering/meta/table_renderer'
+require_relative 'dbsketch/rendering/meta/trigger_renderer'
+require_relative 'dbsketch/rendering/meta/type_renderer'
+require_relative 'dbsketch/rendering/meta/view_renderer'
+
+require_relative 'dbsketch/rendering/sql/column_renderer'
+require_relative 'dbsketch/rendering/sql/database_renderer'
+require_relative 'dbsketch/rendering/sql/foreign_key_renderer'
+require_relative 'dbsketch/rendering/sql/index_renderer'
+require_relative 'dbsketch/rendering/sql/operation_renderer'
+require_relative 'dbsketch/rendering/sql/table_renderer'
+require_relative 'dbsketch/rendering/sql/trigger_renderer'
+require_relative 'dbsketch/rendering/sql/type_renderer'
+require_relative 'dbsketch/rendering/sql/view_renderer'
+
+module Dbsketch
+
+end

data/lib/dbsketch/automation/automation_error.rb

@@ -0,0 +1,15 @@
+########################################################################################################################
+# Represents database model error (for example, two columns with a same name in a table)
+########################################################################################################################
+
+module Dbsketch
+	module Automation
+
+		class AutomationError < StandardError
+			def initialize message
+				super(message)
+			end
+		end
+
+	end
+end

data/lib/dbsketch/automation/database_connection_details.rb

@@ -0,0 +1,32 @@
+########################################################################################################################
+# Connection details to database on server
+########################################################################################################################
+
+module Dbsketch
+	module Automation
+
+		class DatabaseConnectionDetails
+			def initialize host:, instance: nil, database:, user: nil, password: nil
+				### Preconditions
+				raise ArgumentError, "host is not a String" unless host.is_a? String
+				raise ArgumentError, "instance is not a String" unless nil == instance or instance.is_a? String
+				raise ArgumentError, "database is not a String" unless database.is_a? String
+				raise ArgumentError, "user is not a String" unless nil == user or user.is_a? String
+				raise ArgumentError, "password is not a String" unless nil == password or password.is_a? String
+				###
+				@host = host
+				@instance = instance
+				@database = database
+				@user = user
+				@password = password
+			end
+
+			attr_reader :host, :instance, :database, :user, :password
+
+			def full_host
+				(nil == @instance) ? @host : "#{@host}\\#{@instance}"
+			end
+		end
+
+	end
+end

data/lib/dbsketch/automation/database_importer.rb

@@ -0,0 +1,184 @@
+########################################################################################################################
+# Import database into memory (Dbsketch::Model structure)
+########################################################################################################################
+
+require_relative '../model/database'
+require_relative 'automation_error'
+require_relative 'database_proxy'
+require_relative 'table_importer'
+
+module Dbsketch
+	module Automation
+
+		class DatabaseImporter
+
+			def initialize db
+				### Preconditions
+				raise ArgumentError, "database is not a Dbsketch::Automation::DatabaseProxy" unless db.is_a? DatabaseProxy
+				###
+				@db = db
+				@table_importer = TableImporter.new @db
+			end
+
+			def import options: {}
+				options = {
+					:index_white_list => [], :index_black_list => [],
+					:operation_white_list => [], :operation_black_list => [],
+					:table_white_list => [], :table_black_list => [],
+					:view_white_list => [], :view_black_list => []
+				}.merge options
+				options[:index_white_list] = (options[:index_white_list].is_a? Array) ? options[:index_white_list] : [options[:index_white_list]]
+				options[:index_black_list] = (options[:index_black_list].is_a? Array) ? options[:index_black_list] : [options[:index_black_list]]
+				options[:operation_white_list] = (options[:operation_white_list].is_a? Array) ? options[:operation_white_list] : [options[:operation_white_list]]
+				options[:operation_black_list] = (options[:operation_black_list].is_a? Array) ? options[:operation_black_list] : [options[:operation_black_list]]
+				options[:table_white_list] = (options[:table_white_list].is_a? Array) ? options[:table_white_list] : [options[:table_white_list]]
+				options[:table_black_list] = (options[:table_black_list].is_a? Array) ? options[:table_black_list] : [options[:table_black_list]]
+				options[:view_white_list] = (options[:view_white_list].is_a? Array) ? options[:view_white_list] : [options[:view_white_list]]
+				options[:view_black_list] = (options[:view_black_list].is_a? Array) ? options[:view_black_list] : [options[:view_black_list]]
+				### Preconditions
+				raise ArgumentError, "options[:operation_white_list] and options[:operation_black_list] are exclusive." if not options[:operation_white_list].empty? and not options[:operation_black_list].empty?
+				raise ArgumentError, "options[:table_white_list] and options[:table_black_list] are exclusive." if not options[:table_white_list].empty? and not options[:table_black_list].empty?
+				raise ArgumentError, "options[:view_white_list] and options[:view_black_list] are exclusive." if not options[:view_white_list].empty? and not options[:view_black_list].empty?
+				###
+
+				imported_database = Dbsketch::Model::Database.new
+
+				@db.fetch("select * from sys.tables").all.each do |db_table|
+					if (options[:table_white_list].empty? or name_included_in_list? db_table[:name], options[:table_white_list]) and not name_included_in_list? db_table[:name], options[:table_black_list]
+						table = import_table(db_table[:name])
+						imported_database.add table
+						import_indexes imported_database, table, db_table, options
+						import_triggers imported_database, table, db_table
+					end
+				end
+
+				imported_database.tables.each do |table|
+					import_foreign_keys imported_database, table
+				end
+
+				import_views imported_database, options
+
+				import_functions imported_database, options
+				import_procedures imported_database, options
+
+				imported_database
+			end
+
+			def import_table table_name
+				@table_importer.import table_name
+			end
+
+			private
+
+			def name_included_in_list? name, list
+				included = nil != list.find { |element| (element.is_a? Regexp and name.match(element)) or element == name }
+				included
+			end
+
+			def import_foreign_keys database, table
+				db_table = @db.fetch("select object_id from sys.tables where name = '#{table.name}'").all.first
+				@db.fetch("select object_id, name from sys.foreign_keys where parent_object_id = #{db_table[:object_id]}").all.each do |db_key|
+					db_key_column = @db.fetch("select constraint_column_id, referenced_object_id, referenced_column_id from sys.foreign_key_columns where constraint_object_id = #{db_key[:object_id]}").all.first
+					db_constricted_column = @db.fetch("select name from sys.columns where object_id = #{db_table[:object_id]} and column_id = #{db_key_column[:constraint_column_id]}").all.first
+					db_referenced_table = @db.fetch("select object_id, name from sys.tables where object_id = #{db_key_column[:referenced_object_id]}").all.first
+					db_referenced_column = @db.fetch("select name from sys.columns where object_id = #{db_referenced_table[:object_id]} and column_id =  #{db_key_column[:referenced_column_id]}").all.first
+
+					name = db_key[:name]
+					constricted_column = table[db_constricted_column[:name]]
+					referenced_table = database[db_referenced_table[:name]]
+					referenced_column = referenced_table[db_referenced_column[:name]]
+					table.add Dbsketch::Model::ForeignKey.new name, constricted_column, referenced_table, referenced_column
+				end
+			end
+
+			def import_functions database, options
+				@db.fetch("select name, object_definition(object_id) as definition from sys.objects where type in ('FN', 'FT')").all.each do |db_function|
+					if (options[:operation_white_list].empty? or name_included_in_list? db_function[:name], options[:operation_white_list]) and not name_included_in_list? db_function[:name], options[:operation_black_list]
+						name = db_function[:name]
+						definition = db_function[:definition].strip
+
+						begin_index = definition.index("begin")
+						raw_arguments_line = definition[0..begin_index - 1].sub(/^create function [\[\w\.\]]+\s*\(/, '').sub(/\s*as\s*$/, '')
+						returns_index = raw_arguments_line.index("returns")
+						raw_arguments = raw_arguments_line[0..returns_index - 1].strip
+
+						returns = raw_arguments_line[returns_index, (raw_arguments_line.length - raw_arguments.length)].sub(/^returns\s*/, '')
+
+						raw_arguments = raw_arguments.sub(/\)$/, '').strip.split(/,\s?@/)
+						arguments = raw_arguments.map { |arg| arg.start_with?('@') ? arg : "@#{arg}" }
+
+						matches = definition.match /begin(.*)end/m
+						algo = matches[1].strip.gsub(/\r\n/m, "\n")
+
+						database.add Dbsketch::Model::Function.new(name, :arguments => arguments, :returns => returns, :algo => algo)
+					end
+				end
+			end
+
+			def import_indexes database, table, db_table, options
+				@db.fetch("select index_id, name from sys.indexes where object_id = #{db_table[:object_id]} and is_primary_key = 0 and is_unique_constraint = 0").all.each do |db_index|
+					if (options[:index_white_list].empty? or name_included_in_list? db_index[:name], options[:index_white_list]) and not name_included_in_list? db_index[:name], options[:index_black_list]
+						name = db_index[:name]
+						columns = []
+						if nil != name
+							@db.fetch("select column_id from sys.index_columns where object_id = #{db_table[:object_id]} and index_id = #{db_index[:index_id]}").all.each do |db_index_col|
+								db_column = @db.fetch("select name from sys.columns where object_id = #{db_table[:object_id]} and column_id = #{db_index_col[:column_id]}").all.first
+								columns << table[db_column[:name]]
+							end
+							database.add Dbsketch::Model::Index.new name, table, columns
+						end
+					end
+				end
+			end
+
+			def import_procedures database, options
+				@db.fetch("select name, object_definition(object_id) as definition from sys.procedures").all.each do |db_proc|
+					if (options[:operation_white_list].empty? or name_included_in_list? db_proc[:name], options[:operation_white_list]) and not name_included_in_list? db_proc[:name], options[:operation_black_list]
+						name = db_proc[:name]
+						definition = db_proc[:definition].strip.gsub(/\r\n/m, "\n")
+
+						begin_index = definition.index("begin")
+						raw_arguments = definition[0..begin_index - 1].sub(/^create procedure [\[\w\.\]]+/, '').sub(/\s*as\s*$/, '')
+						raw_arguments = raw_arguments.strip.split(/,\s?@/)
+						arguments = raw_arguments.map { |arg| arg.start_with?('@') ? arg : "@#{arg}" }
+
+						matches = definition.match /begin(.*)end/m
+						algo = matches[1].strip
+
+						database.add Dbsketch::Model::Procedure.new(name, :arguments => arguments, :algo => algo)
+					end
+				end
+			end
+
+			def import_triggers database, table, db_table
+				@db.fetch("select name, object_definition(object_id) as definition from sys.triggers where parent_id = #{db_table[:object_id]}").all.each do |db_trigger|
+					name = db_trigger[:name]
+					definition = db_trigger[:definition].strip
+					matches = definition.match /^create trigger (\[?[\w.]*\]?) on (\[?[\w.]*\]?) (for|after|instead of) (insert)?,? ?(update)?,? ?(delete)?/
+					if nil != matches and matches.captures.count > 5
+						activation_time = matches[3] + " " + matches[4..6].compact.join(", ")
+					else
+						activation_time = "for ???"
+					end
+					matches = definition.match /begin(.*)end/m
+					if nil != matches and matches.captures.count > 0
+						algo = matches[1].strip.gsub(/\r\n/m, "\n")
+					else
+						algo = "???"
+					end
+					database.add Dbsketch::Model::Trigger.new name, table, activation_time, :algo => algo, :dependencies => table
+				end
+			end
+
+			def import_views database, options
+				@db.fetch("select table_name, view_definition from information_schema.views").all.each do |db_view|
+					if (options[:view_white_list].empty? or name_included_in_list? db_view[:table_name], options[:view_white_list]) and not name_included_in_list? db_view[:table_name], options[:view_black_list]
+						database.add Dbsketch::Model::View.new db_view[:table_name], db_view[:view_definition].strip.sub(/^create view \w* as (.*);$/, '\1')
+					end
+				end
+			end
+
+		end
+
+	end
+end

data/lib/dbsketch/automation/database_proxy.rb

@@ -0,0 +1,78 @@
+########################################################################################################################
+# Provide connection facilities to database on server
+########################################################################################################################
+
+require 'sequel'
+
+require_relative 'automation_error'
+require_relative 'database_connection_details'
+
+module Dbsketch
+	module Automation
+
+		class DatabaseProxy
+			def initialize connection_details, output_pathame = nil
+				### Preconditions
+				raise ArgumentError, "connection_details is not a Dbsketch::Automation::DatabaseConnectionDetails" unless connection_details.is_a? DatabaseConnectionDetails
+				###
+				@connection_details = connection_details
+				@db = nil
+				@execution_output_pathname = output_pathame + "execution_result.txt" if nil != output_pathame
+			end
+
+			def establish_connection
+				@db = Sequel.connect(
+					:adapter	=> 'ado',  #mssql
+					:host		=> @connection_details.full_host,
+					:database	=> @connection_details.database,
+					:user		=> @connection_details.user,		#not needed via SSO
+					:password	=> @connection_details.password		#not needed via SSO
+					#:encoding	=> Encoding::UTF_8,	#only MySQL
+				)
+				@db.test_connection	#force exception if problem occured
+			end
+
+			def call_procedure procedure, args = {}
+				@db.call_mssql_sproc procedure, :args => args
+			end
+
+			def [](table_name)
+				### Preconditions
+				raise ArgumentError, "table_name is not a Symbol. If you want to use a qualified name (schema.name), please use the fetch function." unless table_name.is_a? Symbol
+				# @db[object] returns all records if object is a string, regardless of further filter or where statements (in: @db['name'].where(condition), where(condition) is ignored)
+				###
+				@db[table_name]
+			end
+
+			def fetch query
+				### Preconditions
+				raise ArgumentError, "query is not a String" unless query.is_a? String
+				###
+				@db.fetch query
+			end
+
+			def run query
+				### Preconditions
+				raise ArgumentError, "query is not a String" unless query.is_a? String
+				###
+				@db.run query # raise an error if something goes wrong, otherwise returns nil
+				true
+			end
+
+			def execute_file file_pathname
+				cmd =
+					"sqlcmd -d #{@connection_details.database} -S #{@connection_details.full_host} -i #{file_pathname.to_s.gsub(/\//, '\\')}" +
+					" -P #{@connection_details.password} -U #{@connection_details.user} -o #{@execution_output_pathname.to_s.gsub(/\//, '\\')}"
+
+				status = system cmd
+				output = File.readlines(@execution_output_pathname)
+
+				if not status or output.find { |o| o.match(/Msg \d+, Level \d+, State \d+/) } then
+					raise AutomationError, "Error while executing file #{file_pathname}! Extract from #{@execution_output_pathname}:\n #{output[0].strip}\n #{output[1].strip}"
+				end
+				status
+			end
+		end
+
+	end
+end

data/lib/dbsketch/automation/table_importer.rb

@@ -0,0 +1,114 @@
+########################################################################################################################
+# Import table into memory (Dbsketch::Model structure)
+########################################################################################################################
+
+require_relative '../model/table'
+require_relative 'automation_error'
+require_relative 'database_proxy'
+
+module Dbsketch
+	module Automation
+
+		class TableImporter
+			def initialize db
+				### Preconditions
+				raise ArgumentError, "database is not a Dbsketch::Automation::DatabaseProxy" unless db.is_a? DatabaseProxy
+				###
+				@db = db
+			end
+
+			def import table_name
+				### Preconditions
+				raise ArgumentError, "table_name '#{table_name}' is not a Symbol or a String" unless table_name.is_a? String or table_name.is_a? Symbol
+				###
+				db_table = @db.fetch("select object_id, name from sys.tables where name = '#{table_name.to_s}'").all.first
+				### Preconditions
+				raise AutomationError, "table '#{table_symbol}' not found in database" if nil == db_table
+				###
+				table = Dbsketch::Model::Table.new db_table[:name]
+				@db.fetch("select * from information_schema.columns where table_name = '#{db_table[:name]}'").all.each do |db_column|
+					table.add(parse_column db_table, db_column)
+				end
+
+				primary_key = import_primary_key db_table, table
+				table.add primary_key if nil != primary_key
+
+				@db.fetch("select name, definition from sys.check_constraints where parent_object_id = '#{db_table[:object_id]}'").all.each do |db_constraint|
+					table.add(Dbsketch::Model::CheckConstraint.new db_constraint[:name], db_constraint[:definition])
+				end
+
+				@db.fetch("select name from sys.key_constraints where parent_object_id = #{db_table[:object_id]} and type = 'UQ'").all.each do |db_constraint|
+					table.add(import_unique_constraint db_table, table, db_constraint[:name])
+				end
+
+				table
+			end
+
+			private
+
+			def parse_type db_column
+				sizes = []
+				if nil != db_column[:character_maximum_length]
+					sizes << db_column[:character_maximum_length]
+				else
+					sizes << db_column[:numeric_precision] if 'int' != db_column[:data_type] and nil != db_column[:numeric_precision]
+					sizes << db_column[:numeric_scale] if 'int' != db_column[:data_type] and nil != db_column[:numeric_scale] and 0 != db_column[:numeric_scale]
+				end
+				Dbsketch::Model::Type.new db_column[:data_type], sizes
+			end
+
+			def parse_column_default db_default, type
+				default = db_default
+				if nil != default
+					if :numeric == type.category or (:boolean == type.category and default.match(/\(\([01]\)\)/))
+						default = default.gsub(/[\D]*/, '').to_i
+					elsif default.is_a? String
+						default = "'#{default.gsub(/^\('(.*)'\)$/, '\1')}'"
+					end
+				end
+				default
+			end
+
+			def parse_column db_table, db_column
+				column_name = db_column[:column_name].to_s.strip
+				db_sys_column = @db.fetch("select is_nullable, is_computed, is_identity from sys.columns where object_id = #{db_table[:object_id]} and name = '#{column_name}'").all.first
+				nullable = db_sys_column[:is_nullable]
+				order = db_column[:ordinal_position]
+				computed = db_sys_column[:is_computed]
+				if computed
+					db_sys_computed_column = @db.fetch("select definition, is_persisted from sys.computed_columns where object_id = #{db_table[:object_id]} and name = '#{column_name}'").all.first
+					query = db_sys_computed_column[:definition]
+					Dbsketch::Model::ComputedColumn.new column_name, query, :nullable => nullable, :order => order, :persisted => db_sys_computed_column[:is_persisted]
+				else
+					type = parse_type db_column
+					identity = db_sys_column[:is_identity]
+					default = parse_column_default db_column[:column_default], type
+					Dbsketch::Model::Column.new column_name, type, :nullable => nullable, :order => order, :identity => identity, :default => default
+				end
+			end
+
+			def import_primary_key db_table, table
+				primary_key = nil
+				db_sys_key = @db.fetch("select name from sys.key_constraints where parent_object_id = #{db_table[:object_id]} and type = 'PK'").all.first
+				if nil != db_sys_key
+					name = db_sys_key[:name]
+					pkey_columns = []
+					@db.fetch("select column_name from information_schema.constraint_column_usage where constraint_name = '#{name}'").all.each do |db_col|
+						pkey_columns << table[db_col[:column_name]]
+					end
+					primary_key = Dbsketch::Model::PrimaryKey.new name, pkey_columns
+				end
+				primary_key
+			end
+
+			def import_unique_constraint db_table, table, constraint_name
+				columns = []
+				@db.fetch("select column_name from information_schema.constraint_column_usage where constraint_name = '#{constraint_name}'").all.each do |db_col|
+					columns << table[db_col[:column_name]]
+				end
+				Dbsketch::Model::UniqueConstraint.new constraint_name, columns
+			end
+		end
+
+	end
+end