class Dbsketch::Model::Table

Attributes

check_constraints[R]
columns[R]
foreign_keys[R]
primary_key[R]
unique_constraints[R]

Public Class Methods

new(name, meaning: nil, comment: nil, dependencies: [], columns: [], p_key_columns: []) click to toggle source
Calls superclass method Dbsketch::Model::Database_Object::new
# File lib/dbsketch/model/table.rb, line 18
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

Public Instance Methods

[](column_name) click to toggle source
# File lib/dbsketch/model/table.rb, line 92
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
add(object) click to toggle source
# File lib/dbsketch/model/table.rb, line 42
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
check_constraint(constraint_name) click to toggle source
# File lib/dbsketch/model/table.rb, line 98
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
foreign_key(key_name) click to toggle source
# File lib/dbsketch/model/table.rb, line 104
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
has_check_constraint?(constraint_name) click to toggle source
# File lib/dbsketch/model/table.rb, line 71
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
has_column?(column_name) click to toggle source
# File lib/dbsketch/model/table.rb, line 64
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
has_foreign_key?(key_name) click to toggle source
# File lib/dbsketch/model/table.rb, line 78
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
has_unique_constraint?(constraint_name) click to toggle source
# File lib/dbsketch/model/table.rb, line 85
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
unique_constraint(constraint_name) click to toggle source
# File lib/dbsketch/model/table.rb, line 110
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 Instance Methods

add_check_constraint(constraint) click to toggle source
# File lib/dbsketch/model/table.rb, line 143
def add_check_constraint constraint
        ### Preconditions
        raise ModelError, "constraint #{constraint.name} already exists in table #{@name}" if constraint_exist? constraint
        ###
        @check_constraints << constraint
end
add_column(column) click to toggle source
# File lib/dbsketch/model/table.rb, line 118
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
add_foreign_key(constraint) click to toggle source
# File lib/dbsketch/model/table.rb, line 150
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
add_unique_constraint(constraint) click to toggle source
# File lib/dbsketch/model/table.rb, line 159
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
constraint_exist?(constraint) click to toggle source
# File lib/dbsketch/model/table.rb, line 137
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
set_primary_key(key) click to toggle source
# File lib/dbsketch/model/table.rb, line 127
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