\n" +
"
\n" +
"
\n" +
h1("Logical Data Model for " + @composition.name)
end
def generate_definitions
defns =
@composition.
all_composite.
reject {|c| c.mapping.object_type.is_a?(ActiveFacts::Metamodel::ValueType)}.
reject {|c| c.mapping.object_type.is_static}.
reject {|c| c.mapping.object_type.fact_type}.
map {|c| c.mapping.object_type}
@definitions = {}
defns.each do |o|
@definitions[o] = true
end
defns.each do |o|
ftm = relevant_fact_types(o)
trace :ldm, "expanding #{o.name}"
ftm.each do |r, ft|
next if ft.is_a?(ActiveFacts::Metamodel::TypeInheritance)
ft.all_role.each do |ftr|
next if @definitions[ftr.object_type]
next if ftr.object_type.is_a?(ActiveFacts::Metamodel::ValueType)
trace :ldm, "adding #{ftr.object_type.name}"
defns = defns << ftr.object_type
@definitions[ftr.object_type] = true
end
end
end
"
Business Definitions and Relationships
\n" +
defns.sort_by{|o| o.name.gsub(/ /, '').downcase}.map do |o|
entity_type_dump(o, 0)
end * "\n" + "\n"
end
def generate_diagrams
''
end
def generate_details
h2("Logical Data Model Details") +
@composition.
all_composite.
sort_by{|composite| composite.mapping.name}.
map{|composite| generate_table(composite)}*"\n" + "\n"
end
def generate_footer
" \n" +
"
\n" +
"
\n" +
"
\n" +
(supers.size > 0 ?
"#{span('Each', 'keyword')} #{termref(o.name, nil, o)} #{span('is a kind of', 'keyword')} #{supers.map{|s| termref(s.name, nil, s)}*', '}\n" :
''
) +
if pi
"#{span('Each', 'keyword')} #{termref(o.name, nil, o)} #{span('is identified by', 'keyword')} " +
pi.role_sequence.all_role_ref_in_order.map do |rr|
termref(
rr.role.object_type.name,
[ rr.leading_adjective,
rr.role.role_name || rr.role.object_type.name,
rr.trailing_adjective
].compact * '-',
rr.role.object_type
)
end * ", " + "\n"
else
''
end +
fact_types_dump(o, relevant_fact_types(o)) + "\n" +
"
\n" +
"
\n" +
" " * indent + " | #{column_name}\n" +
" " * indent + " | #{component_type(leaf, column_name)}\n" +
" " * indent + " | #{leaf.path_mandatory ? 'Yes' : 'No'}\n" +
" " * indent + " | #{column_comment leaf}\n" +
" " * indent + " |
"
# "-- #{column_comment leaf}\n\t#{column_name}#{padding}#{component_type leaf, column_name}#{identity}"
end
def column_comment component
return '' unless cp = component.parent
prefix = column_comment(cp)
name = component.name
if component.is_a?(MM::Absorption)
reading = component.parent_role.fact_type.reading_preferably_starting_with_role(component.parent_role).expand([], false)
maybe = component.parent_role.is_mandatory ? '' : 'maybe '
cpname = cp.name
if prefix[(-cpname.size-1)..-1] == ' '+cpname && reading[0..cpname.size] == cpname+' '
prefix+' that ' + maybe + reading[cpname.size+1..-1]
else
(prefix.empty? ? '' : prefix+' and ') + maybe + reading
end
else
name
end
end
def boolean_type
'boolean'
end
def surrogate_type
'bigint'
end
def component_type component, column_name
case component
when MM::Indicator
boolean_type
when MM::SurrogateKey
surrogate_type
when MM::ValueField, MM::Absorption
object_type = component.object_type
while object_type.is_a?(MM::EntityType)
rr = object_type.preferred_identifier.role_sequence.all_role_ref.single
raise "Can't produce a column for composite #{component.inspect}" unless rr
object_type = rr.role.object_type
end
raise "A column can only be produced from a ValueType" unless object_type.is_a?(MM::ValueType)
if component.is_a?(MM::Absorption)
value_constraint ||= component.child_role.role_value_constraint
end
supertype = object_type
begin
object_type = supertype
length ||= object_type.length
scale ||= object_type.scale
unless component.parent.parent and component.parent.foreign_key
# No need to enforce value constraints that are already enforced by a foreign key
value_constraint ||= object_type.value_constraint
end
end while supertype = object_type.supertype
type, length = normalise_type(object_type.name, length)
sql_type = "#{type}#{
if !length
''
else
'(' + length.to_s + (scale ? ", #{scale}" : '') + ')'
end
# }#{
# (component.path_mandatory ? '' : ' NOT') + ' NULL'
# }#{
# # REVISIT: This is an SQL Server-ism. Replace with a standard SQL SEQUENCE/
# # Emit IDENTITY for columns auto-assigned on commit (except FKs)
# if a = object_type.is_auto_assigned and a != 'assert' and
# !component.all_foreign_key_field.detect{|fkf| fkf.foreign_key.source_composite == component.root}
# ' IDENTITY'
# else
# ''
# end
}#{
value_constraint ? check_clause(column_name, value_constraint) : ''
}"
when MM::ValidFrom
component.object_type.name
else
raise "Can't make a column from #{component}"
end
end
def generate_index index, delayed_indices, indent
nullable_columns =
index.all_index_field.select do |ixf|
!ixf.component.path_mandatory
end
contains_nullable_columns = nullable_columns.size > 0
primary = index.composite_as_primary_index && !contains_nullable_columns
column_names =
index.all_index_field.map do |ixf|
column_name(ixf.component)
end
clustering =
(index.composite_as_primary_index ? ' CLUSTERED' : ' NONCLUSTERED')
if contains_nullable_columns
table_name = safe_table_name(index.composite)
delayed_indices <<
'CREATE UNIQUE'+clustering+' INDEX '+
escape("#{table_name(index.composite)}By#{column_names*''}", index_name_max) +
" ON #{table_name}("+column_names.map{|n| escape(n, column_name_max)}*', ' +
") WHERE #{
nullable_columns.
map{|ixf| safe_column_name ixf.component}.
map{|column_name| column_name + ' IS NOT NULL'} *
' AND '
}"
nil
else
# '-- '+index.inspect
" " * indent + (primary ? 'PRIMARY KEY' : 'UNIQUE') +
clustering +
"(#{column_names.map{|n| escape(n, column_name_max)}*', '})"
end
end
def generate_foreign_key fk, indent
# '-- '+fk.inspect
" " * indent + "FOREIGN KEY (" +
fk.all_foreign_key_field.map{|fkf| safe_column_name fkf.component}*", " +
") REFERENCES