dbsketch 0.0.1

data/lib/dbsketch/model/function.rb

@@ -0,0 +1,23 @@
+########################################################################################################################
+# Defines database function
+########################################################################################################################
+
+require_relative 'operation'
+
+module Dbsketch
+	module Model
+
+		class Function < Operation
+			def initialize name, meaning: nil, comment: nil, dependencies: [], arguments: [], returns:, algo:
+				super name, :meaning => meaning, :comment => comment, :dependencies => dependencies, :arguments => arguments, :algo => algo
+				### Preconditions
+				raise ArgumentError, "returns is not a String" unless returns.is_a? String
+				###
+				@returns = returns
+			end
+
+			attr_reader :returns
+		end
+
+	end
+end

data/lib/dbsketch/model/index.rb

@@ -0,0 +1,40 @@
+########################################################################################################################
+# Defines database column
+########################################################################################################################
+
+require_relative 'abstract_column'
+require_relative 'computed_column'
+require_relative 'database_object'
+require_relative 'table'
+require_relative 'model_error'
+require_relative 'view'
+
+module Dbsketch
+	module Model
+
+		class Index < Database_Object
+			def initialize name, target, columns, meaning: nil, comment: nil, dependencies: []
+				super name, :meaning => meaning, :comment => comment, :dependencies => dependencies
+				@columns = columns.is_a?(Array) ? columns : [columns]
+				### Preconditions
+				raise ArgumentError, "target is not a Dbsketch::Model::Table or a View" unless target.is_a? Table or target.is_a? View
+				@columns.each_with_index do |column, index|
+					raise ArgumentError, "columns[#{index}] is not a Dbsketch::Model::AbstractColumn" unless column.is_a? AbstractColumn
+					raise ModelError, "computed column #{column.name} is not persisted" if column.is_a? ComputedColumn and not column.persisted
+				end
+				###
+				@target = target
+			end
+
+			attr_reader :target, :columns
+
+			def has_column? column_name
+				### Preconditions
+				raise ArgumentError, "column_name is not a String" unless column_name.is_a? String
+				###
+				nil != @columns.find { |c| c.name.downcase == column_name.downcase }
+			end
+		end
+
+	end
+end

data/lib/dbsketch/model/model_error.rb

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

data/lib/dbsketch/model/operation.rb

@@ -0,0 +1,28 @@
+########################################################################################################################
+# Defines database operation (function and procedure common stuff)
+########################################################################################################################
+
+require_relative 'database_object'
+
+module Dbsketch
+	module Model
+
+		class Operation < Database_Object
+			def initialize name, meaning: nil, comment: nil, dependencies: [], arguments: [], algo:
+				super name, :meaning => meaning, :comment => comment, :dependencies => dependencies
+				arguments = arguments.is_a?(Array) ? arguments : [arguments]
+				### Preconditions
+				arguments.each_with_index do |arg, index|
+					raise ArgumentError, "arguments[#{index}] is not a String" unless arg.is_a? String
+				end
+				raise ArgumentError, "algo is not a String" unless algo.is_a? String
+				###
+				@arguments = arguments
+				@algo = algo
+			end
+
+			attr_reader :algo, :arguments
+		end
+
+	end
+end

data/lib/dbsketch/model/primary_key.rb

@@ -0,0 +1,33 @@
+########################################################################################################################
+# Primary Key
+########################################################################################################################
+
+require_relative 'column'
+require_relative 'database_object'
+
+module Dbsketch
+	module Model
+
+		class PrimaryKey < Database_Object
+			def initialize name, columns, meaning: nil, comment: nil
+				super name, :meaning => meaning, :comment => comment
+				@columns = columns.is_a?(Array) ? columns : [columns]
+				### Preconditions
+				@columns.each_with_index do |column, index|
+					raise ArgumentError, "columns[#{index}] is not a Dbsketch::Model::Column" unless column.is_a? Column
+				end
+				###
+			end
+
+			attr_reader :columns
+
+			def has_column? column_name
+				### Preconditions
+				raise ArgumentError, "column_name is not a String" unless column_name.is_a? String
+				###
+				nil != @columns.find { |c| c.name.downcase == column_name.downcase }
+			end
+		end
+
+	end
+end

data/lib/dbsketch/model/procedure.rb

@@ -0,0 +1,18 @@
+########################################################################################################################
+# Defines database stored procedure
+########################################################################################################################
+
+require_relative 'operation'
+
+module Dbsketch
+	module Model
+
+		class Procedure < Operation
+			def initialize name, meaning: nil, comment: nil, dependencies: [], arguments: [], algo:
+				super name, :meaning => meaning, :comment => comment, :dependencies => dependencies, :arguments => arguments, :algo => algo
+				# TODO check arguments are one of [out, output, readonly]
+			end
+		end
+
+	end
+end

data/lib/dbsketch/model/table.rb

@@ -0,0 +1,171 @@
+########################################################################################################################
+# Defines database table structure
+########################################################################################################################
+
+require_relative 'abstract_column'
+require_relative 'check_constraint'
+require_relative 'column'
+require_relative 'database_object'
+require_relative 'foreign_key'
+require_relative 'model_error'
+require_relative 'primary_key'
+require_relative 'unique_constraint'
+
+module Dbsketch
+	module Model
+
+		class Table < Database_Object
+			def initialize name, meaning: nil, comment: nil, dependencies: [], columns: [], p_key_columns: []
+				super name, :meaning => meaning, :comment => comment, :dependencies => dependencies
+				columns = columns.is_a?(Array) ? columns.flatten : [columns]
+				p_key_columns = p_key_columns.is_a?(Array) ? p_key_columns : [p_key_columns]
+				### Preconditions
+				columns.each_with_index do |column, index|
+					raise ArgumentError, "columns[#{index}] is not a Dbsketch::Model::AbstractColumn" unless column.is_a? AbstractColumn
+				end
+				p_key_columns.each_with_index do |column, index|
+					raise ArgumentError, "p_key_columns[#{index}] is not a String nor a Dbsketch::Model::AbstractColumn" unless column.is_a? String or column.is_a? AbstractColumn
+				end
+				###
+				@columns = []
+				columns.each { |c| add_column c }
+				@primary_key = nil
+				primary_key_columns = p_key_columns.map { |c| (c.is_a? AbstractColumn) ? c : self[c] }
+				set_primary_key PrimaryKey.new "PK_#{@name}", primary_key_columns if not primary_key_columns.empty?
+				@check_constraints = []
+				@foreign_keys = []
+				@unique_constraints = []
+			end
+
+			attr_reader :columns, :primary_key, :check_constraints, :foreign_keys, :unique_constraints
+
+			def add object
+				objects = object.is_a?(Array) ? object : [object]
+				### Preconditions
+				objects.each_with_index do |o, index|
+					raise ArgumentError, "object n°#{index + 1} is not a valid Dbsketch::Model object" unless o.is_a? AbstractColumn or o.is_a? PrimaryKey or o.is_a? CheckConstraint or o.is_a? ForeignKey or o.is_a? UniqueConstraint
+				end
+				###
+				objects.each do |o|
+					if o.is_a? AbstractColumn
+						add_column o
+					elsif o.is_a? PrimaryKey
+						set_primary_key o
+					elsif o.is_a? CheckConstraint
+						add_check_constraint o
+					elsif o.is_a? ForeignKey
+						add_foreign_key o
+					elsif o.is_a? UniqueConstraint
+						add_unique_constraint o
+					end
+				end
+			end
+
+			def has_column? column_name
+				### Preconditions
+				raise ArgumentError, "column_name is not a String" unless column_name.is_a? String
+				###
+				nil != @columns.find { |c| c.name.downcase == column_name.downcase }
+			end
+
+			def has_check_constraint? constraint_name
+				### Preconditions
+				raise ArgumentError, "constraint_name is not a String" unless constraint_name.is_a? String
+				###
+				nil != @check_constraints.find { |c| c.name.downcase == constraint_name.downcase }
+			end
+
+			def has_foreign_key? key_name
+				### Preconditions
+				raise ArgumentError, "key_name is not a String" unless key_name.is_a? String
+				###
+				nil != @foreign_keys.find { |c| c.name.downcase == key_name.downcase }
+			end
+
+			def has_unique_constraint? constraint_name
+				### Preconditions
+				raise ArgumentError, "constraint_name is not a String" unless constraint_name.is_a? String
+				###
+				nil != @unique_constraints.find { |c| c.name.downcase == constraint_name.downcase }
+			end
+
+			def [] column_name
+				column = @columns.find { |c| c.name.downcase == column_name.downcase }
+				raise ArgumentError, "column #{column_name} not found in table #{@name}" if nil == column
+				column
+			end
+
+			def check_constraint constraint_name
+				constraint = @check_constraints.find { |c| c.name.downcase == constraint_name.downcase }
+				raise ArgumentError, "check constraint #{constraint_name} not found in table #{@name}" if nil == constraint
+				constraint
+			end
+
+			def foreign_key key_name
+				key = @foreign_keys.find { |c| c.name.downcase == key_name.downcase }
+				raise ArgumentError, "foreign key #{key_name} not found in table #{@name}" if nil == key
+				key
+			end
+
+			def unique_constraint constraint_name
+				constraint = @unique_constraints.find { |c| c.name.downcase == constraint_name.downcase }
+				raise ArgumentError, "unique constraint #{constraint_name} not found in table #{@name}" if nil == constraint
+				constraint
+			end
+
+			private
+
+			def add_column column
+				### Preconditions
+				raise ModelError, "column #{column.name} already exists in table #{@name}" if nil != (@columns.find { |c| c.name.downcase == column.name.downcase })
+				raise ModelError, "column #{column.name} has an order but column without order exists in table #{@name}" if nil != column.order and nil != (@columns.find { |c| nil == c.order })
+				raise ModelError, "a column of order #{column.order} already exists in table #{@name}" if nil != (@columns.find { |c| nil != c.order and c.order == column.order })
+				###
+				@columns << column
+			end
+
+			def set_primary_key key
+				### Preconditions
+				raise ModelError, "a primary key already exists in table #{@name}" if nil != @primary_key
+				key.columns.each do |pk_c|
+					raise ModelError, "primary key column #{pk_c.name} does not exists in table #{@name}" if nil == (@columns.find { |c| c.name.downcase == pk_c.name.downcase })
+				end
+				###
+				@primary_key = key
+			end
+
+			def constraint_exist? constraint
+				(nil != (@check_constraints.find { |c| c.name.downcase == constraint.name.downcase }) or
+				nil != (@foreign_keys.find { |k| k.name.downcase == constraint.name.downcase }) or
+				nil != (@unique_constraints.find { |c| c.name.downcase == constraint.name.downcase }))
+			end
+
+			def add_check_constraint constraint
+				### Preconditions
+				raise ModelError, "constraint #{constraint.name} already exists in table #{@name}" if constraint_exist? constraint
+				###
+				@check_constraints << constraint
+			end
+
+			def add_foreign_key constraint
+				### Preconditions
+				raise ModelError, "constraint #{constraint.name} already exists in table #{@name}" if constraint_exist? constraint
+				raise ModelError, "constraint #{constraint.name} column #{constraint.constricted_column.name} does not exists in table #{@name}" if nil == (@columns.find { |c| c.name.downcase == constraint.constricted_column.name.downcase })
+				###
+				@foreign_keys << constraint
+				add_dependencies constraint.referenced_table
+			end
+
+			def add_unique_constraint constraint
+				### Preconditions
+				raise ModelError, "constraint #{constraint.name} already exists in table #{@name}" if constraint_exist? constraint
+				constraint.columns.each do |uc_c|
+					raise ModelError, "constraint column #{uc_c.name} does not exists in table #{@name}" if nil == (@columns.find { |c| c.name.downcase == uc_c.name.downcase })
+				end
+				###
+				@unique_constraints << constraint
+			end
+		end
+
+	end
+end

data/lib/dbsketch/model/trigger.rb

@@ -0,0 +1,32 @@
+########################################################################################################################
+# Defines database trigger
+########################################################################################################################
+
+require_relative 'database_object'
+require_relative 'model_error'
+require_relative 'table'
+require_relative 'view'
+
+module Dbsketch
+	module Model
+
+		class Trigger < Database_Object
+			def initialize name, target, activation_time, algo:, meaning: nil, comment: nil, dependencies: []
+				super name, :meaning => meaning, :comment => comment, :dependencies => dependencies
+				### Preconditions
+				raise ArgumentError, "target is not a Dbsketch::Model::Table or View" unless target.is_a? Table or target.is_a? View
+				raise ArgumentError, "activation_time is not a String" unless activation_time.is_a? String
+				raise ModelError, "activation_time does not begins 'for', 'after' or 'instead of' (#{activation_time})" if nil == activation_time.downcase.match(/^(for)|(after)|(instead of)/)
+				raise ArgumentError, "algo is not a String" unless algo.is_a? String
+				###
+				@target = target
+				@activation_time = activation_time
+				@algo = algo
+				add_dependencies target
+			end
+
+			attr_reader :target, :activation_time, :algo
+		end
+
+	end
+end

data/lib/dbsketch/model/type.rb

@@ -0,0 +1,92 @@
+########################################################################################################################
+# Represents database type, allow to check compatibility
+########################################################################################################################
+
+module Dbsketch
+	module Model
+
+		class Type
+			def initialize(sql_type, sizes = [])
+				@sizes = sizes.is_a?(Array) ? sizes : [sizes]
+				### Preconditions
+				raise ArgumentError, "sql_type is not a String" unless sql_type.is_a? String
+				@sizes.each do |size|
+					if 'max' == size
+						if not ['varchar', 'nvarchar'].include? sql_type
+							raise ArgumentError, "size 'max' allowed only for [n]varchar"
+						end
+					elsif not size.is_a? Fixnum and not size.is_a? Integer
+						raise ArgumentError, "size #{size} of sql type #{sql_type} is not a number"
+					end
+				end
+				raise ArgumentError, "#{sql_type} do not allow defining sizes" if ['datetime', 'datetime2', 'int'].include? sql_type and @sizes.count > 0
+				raise ArgumentError, "#{sql_type} do not allow more than one size" if sql_type.match(/(n){0,1}(var){0,1}char/) and @sizes.count > 1
+				raise ArgumentError, "#{sql_type} need at least a precision, but no sizes were given" if ['decimal', 'numeric'].include? sql_type and @sizes.count == 0
+				raise ArgumentError, "defining more than 2 sizes for #{sql_type}" if @sizes.count > 2
+				###
+				@sql_type = sql_type
+			end
+
+			attr_reader :sql_type, :sizes
+
+			# Return true if current type can be stored in other_type without error nor information loss
+			def compatible_with? other_type
+				### Preconditions
+				raise ArgumentError, "other_type is not a Dbsketch::Model::Type" unless other_type.is_a? Dbsketch::Model::Type
+				###
+				# TODO enhance this function (numeric and int may be compatible with particular sizes)
+				compatible = false
+
+				if :numeric == get_category(@sql_type)
+					if :numeric == get_category(other_type.sql_type)
+						compatible = size_compatibile_with? other_type.sizes
+					end
+				elsif :datetime == get_category(@sql_type)
+					compatible = (:datetime == get_category(other_type.sql_type))
+				elsif :string == get_category(@sql_type)
+					compatible = false
+					if :string == get_category(other_type.sql_type)
+						if (@sql_type.match(/^(var){0,1}char$/) and other_type.sql_type.match(/^(var){0,1}char$/)) or
+							(@sql_type.match(/^n(var){0,1}char$/) and other_type.sql_type.match(/^n(var){0,1}char$/))
+							compatible = size_compatibile_with? other_type.sizes
+						end
+					end
+				elsif :boolean == get_category(@sql_type)
+					compatible = (:boolean == get_category(other_type.sql_type))
+				end
+				compatible
+			end
+
+			def category
+				get_category(@sql_type)
+			end
+
+			private
+
+			def get_category sql_type
+				if ['decimal', 'int', 'numeric'].include? sql_type
+					:numeric
+				elsif ['datetime', 'datetime2'].include? sql_type
+					:datetime
+				elsif sql_type.match(/(n){0,1}(var){0,1}char/)
+					:string
+				elsif 'bit' == sql_type
+					:boolean
+				else
+					:unknown
+				end
+			end
+
+			def size_compatibile_with? other_sizes
+				compatible = false
+				if @sizes.empty? and other_sizes.empty?
+					compatible = true
+				elsif not @sizes.empty? and not other_sizes.empty?
+					compatible = (@sizes.first <= other_sizes.first)
+				end
+				compatible
+			end
+		end
+
+	end
+end