activefacts 0.6.0 → 0.7.0

data/lib/activefacts/generate/sql/server.rb

@@ -10,6 +10,7 @@ module ActiveFacts
     class SQL
       class SERVER
         include Metamodel
+        ColumnNameMax = 40
 
         RESERVED_WORDS = %w{
           ADD ALL ALTER AND ANY AS ASC AUTHORIZATION BACKUP BEGIN BETWEEN
@@ -38,6 +39,7 @@ module ActiveFacts
           @vocabulary = vocabulary
           @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
           @delay_fks = options.include? "delay_fks"
+          @norma = options.include? "norma"
         end
 
         def puts s
@@ -51,6 +53,7 @@ module ActiveFacts
 
         def escape s
           # Escape SQL keywords and non-identifiers
+          s = s[0...120]
           if s =~ /[^A-Za-z0-9_]/ || RESERVED_WORDS[s.upcase]
             "[#{s}]"
           else
@@ -58,50 +61,41 @@ module ActiveFacts
           end
         end
 
-        # Return a ValueType definition for the passed role reference
-        def sql_type(role_ref)
-          if role_ref.role.fact_type.all_role.size == 1
-            "bit"
-          else
-            vt = role_ref.role.concept
-            length = vt.length
-            scale = vt.scale
-            while vt.supertype
-              length ||= vt.length
-              scale ||= vt.scale
-              vt = vt.supertype
-            end
-            basic_type = case (vt.supertype||vt).name
-              when "AutoCounter"; "int"
-              when "Date"; "datetime"
-              when "UnsignedInteger",
-                "SignedInteger"
-                l = length
-                length = nil
-                case
-                when l <= 8; "tinyint"
-                when l <= 16; "shortint"
-                when l <= 32; "int"
+        # Return SQL type and (modified?) length for the passed NORMA base type
+        def norma_type(type, length)
+          sql_type = case type
+            when "AutoCounter"; "int"
+            when "UnsignedInteger",
+              "SignedInteger",
+              "UnsignedSmallInteger",
+              "SignedSmallInteger",
+              "UnsignedTinyInteger"
+              s = case
+                when length <= 8; "tinyint"
+                when length <= 16; "shortint"
+                when length <= 32; "int"
                 else "bigint"
                 end
-              when "VariableLengthText"; "varchar"
-              when "Decimal"; "decimal"
-              else vt.name
-              end
-            if length && length != 0
-              basic_type + ((scale && scale != 0) ? "(#{length}, #{scale})" : "(#{length})")
-            else
-              basic_type
+              length = nil
+              s
+            when "Decimal"; "decimal"
+
+            when "FixedLengthText"; "char"
+            when "VariableLengthText"; "varchar"
+            when "LargeLengthText"; "text"
+
+            when "DateAndTime"; "datetime"
+            when "Date"; "datetime" # SQLSVR 2K5: "date"
+            when "Time"; "datetime" # SQLSVR 2K5: "time"
+            when "AutoTimestamp"; "timestamp"
+
+            when "Money"; "decimal"
+            when "PictureRawData"; "image"
+            when "VariableLengthRawData"; "varbinary"
+            when "BIT"; "bit"
+            else raise "SQL type unknown for NORMA type #{type}"
             end
-          end +
-          (
-            # Is there any role along the path that lacks a mandatory constraint?
-            role_ref.output_roles.detect { |role| !role.is_mandatory } ? " NULL" : " NOT NULL"
-          )
-        end
-
-        def column_name(role_ref)
-          escape(role_ref.column_name(nil).map{|n| n.sub(/^[a-z]/){|s| s.upcase}}*"")
+          [sql_type, length]
         end
 
         def generate(out = $>)
@@ -112,52 +106,123 @@ module ActiveFacts
           delayed_foreign_keys = []
 
           @vocabulary.tables.sort_by{|table| table.name}.each do |table|
-            tables_emitted[table] = true
             puts "CREATE TABLE #{escape table.name} ("
 
-            pk = table.absorbed_reference_roles.all_role_ref
-            pk_names = pk.map{|rr| column_name(rr) }
+            pk = table.identifier_columns
+            identity_column = pk[0] if pk.size == 1 && pk[0].is_auto_assigned
 
-            columns = table.absorbed_roles.all_role_ref.sort_by do |role_ref|
-                  name = column_name(role_ref)
-                  [pk_names.include?(name) ? 0 : 1, name]
-                end.map do |role_ref|
-                  "\t#{column_name(role_ref)}\t#{sql_type(role_ref)}"
-                end
+            fk_refs = table.references_from.select{|ref| ref.is_simple_reference }
+            fk_columns = table.columns.select do |column|
+              column.references[0].is_simple_reference
+            end
 
-            pk_def =
-                  if pk.detect{ |role_ref| !role_ref.role.is_mandatory }
-                    # Any nullable fields mean this can't be a primary key, just a unique constraint
-                    "\tUNIQUE("
-                  else
-                    "\tPRIMARY KEY("
-                  end +
-                  table.absorbed_reference_roles.all_role_ref.map do |role_ref|
-                    column_name(role_ref)
-                  end*", " + ")"
+            columns = table.columns.map do |column|
+              name = escape column.name("")
+              padding = " "*(name.size >= ColumnNameMax ? 1 : ColumnNameMax-name.size)
+              type, params, restrictions = column.type
+              restrictions = [] if (fk_columns.include?(column))  # Don't enforce VT restrictions on FK columns
+              length = params[:length]
+              length &&= length.to_i
+              scale = params[:scale]
+              scale &&= scale.to_i
+              type, length = norma_type(type, length) if @norma
+              sql_type = "#{type}#{
+                if !length
+                  ""
+                else
+                  "(" + length.to_s + (scale ? ", #{scale}" : "") + ")"
+                end
+                }"
+              identity = column == identity_column ? " IDENTITY" : ""
+              null = (column.is_mandatory ? "NOT " : "") + "NULL"
+              check = check_clause(name, restrictions)
+              comment = column.comment
+              [ "-- #{comment}", "#{name}#{padding}#{sql_type}#{identity} #{null}#{check}" ]
+            end.flatten
+
+            pk_def = (pk.detect{|column| !column.is_mandatory} ? "UNIQUE(" : "PRIMARY KEY(") +
+                pk.map{|column| escape column.name("")}*", " +
+                ")"
 
             inline_fks = []
-            table.absorbed_references.sort_by { |role, other_table, from_columns, to_columns|
-              [ other_table.name, from_columns.map{|c| column_name(c)} ]
-            }.each do |role, other_table, from_columns, to_columns|
-              fk =
-                if tables_emitted[other_table] && !@delay_fks
-                  inline_fks << "\t"
-                else
-                  delayed_foreign_keys << "ALTER TABLE #{escape table.name}\n\tADD "
-                end.last
-              fk << "FOREIGN KEY(#{from_columns.map{|c| column_name(c)}*", "})\n"+
-                "\tREFERENCES #{escape other_table.name}(#{to_columns.map{|c| column_name(c)}*", "})"
+            table.foreign_keys.each do |fk|
+              fk_text = "FOREIGN KEY (" +
+                fk.from_columns.map{|column| column.name}*", " +
+                ") REFERENCES #{escape fk.to.name} (" +
+                fk.to_columns.map{|column| column.name}*", " +
+                ")"
+              if !@delay_fks and              # We don't want to delay all Fks
+                (tables_emitted[fk.to] or     # The target table has been emitted
+                fk.to == table && !fk.to_columns.detect{|column| !column.is_mandatory})   # The reference columns already have the required indexes
+                inline_fks << fk_text
+              else
+                delayed_foreign_keys << ("ALTER TABLE #{escape fk.from.name}\n\tADD " + fk_text)
+              end
+            end
+
+            indices = table.indices
+            inline_indices = []
+            delayed_indices = []
+            indices.each do |index|
+              next if index.over == table && index.is_primary   # Already did the primary keys
+              abbreviated_column_names = index.abbreviated_column_names*""
+              column_names = index.column_names
+              column_name_list = column_names.map{|n| escape(n)}*", "
+              if index.columns.all?{|column| column.is_mandatory}
+                inline_indices << "UNIQUE(#{column_name_list})"
+              else
+                view_name = escape "#{index.view_name}_#{abbreviated_column_names}"
+                delayed_indices <<
+%Q{CREATE VIEW dbo.#{view_name} (#{column_name_list}) WITH SCHEMABINDING AS
+\tSELECT #{column_name_list} FROM dbo.#{escape index.on.name}
+\tWHERE\t#{
+  index.columns.
+    select{|column| !column.is_mandatory }.
+    map{|column|
+      escape(column.name) + " IS NOT NULL"
+    }*"\n\t  AND\t"
+}
+GO
+
+CREATE UNIQUE CLUSTERED INDEX #{escape index.name} ON dbo.#{view_name}(#{index.columns.map{|column| column.name}*", "})
+}
+              end
             end
 
-            puts((columns + [pk_def] + inline_fks)*",\n")
+            tables_emitted[table] = true
+
+            puts("\t" + (columns + [pk_def] + inline_indices + inline_fks)*",\n\t")
             go ")"
+            delayed_indices.each {|index_text|
+              go index_text
+            }
           end
 
           delayed_foreign_keys.each do |fk|
             go fk
           end
         end
+
+        def check_clause(column_name, restrictions)
+          return "" if restrictions.empty?
+          # REVISIT: Merge all restrictions (later; now just use the first)
+          " CHECK(" +
+            restrictions[0].all_allowed_range.map do |ar|
+              vr = ar.value_range
+              min = vr.minimum_bound
+              max = vr.maximum_bound
+              if (min && max && max.value == min.value)
+                "#{column_name} = #{min.value}"
+              else
+                inequalities = [
+                  min && "#{column_name} >#{min.is_inclusive ? "=" : ""} #{min.value}",
+                  max && "#{column_name} <#{max.is_inclusive ? "=" : ""} #{max.value}"
+                ].compact
+                inequalities.size > 1 ? "(" + inequalities*" AND " + ")" : inequalities[0]
+              end
+            end*" OR " +
+          ")"
+        end
       end
     end
   end

data/lib/activefacts/generate/text.rb

@@ -9,7 +9,7 @@ module ActiveFacts
     class TEXT
       def initialize(vocabulary)
         @vocabulary = vocabulary
-        @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::Constellation === @vocabulary
+        @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
       end
 
       def generate(out = $>)

data/lib/activefacts/input/orm.rb

@@ -161,8 +161,18 @@ module ActiveFacts
         min = x_range.attributes['MinValue']
         max = x_range.attributes['MaxValue']
         q = "'"
-        min = min =~ /[^0-9\.]/ ? q+min+q : min.to_i
-        max = max =~ /[^0-9\.]/ ? q+max+q : max.to_i
+        min = case min
+          when ""; nil
+          when /[^0-9\.]/; q+min+q
+          when /\./; Float(min)
+          else Integer(min)
+          end
+        max = case max
+          when ""; nil
+          when /[^0-9\.]/; q+max+q
+          when /\./; Float(max)
+          else Integer(max)
+          end
         # ValueRange takes a minimum and/or a maximum Bound, each takes value and whether inclusive
         @constellation.ValueRange(
             min ? [min.to_s, true] : nil,

data/lib/activefacts/persistence.rb

@@ -1 +1,5 @@
-require 'activefacts/persistence/composition'
+require 'activefacts/persistence/reference'
+require 'activefacts/persistence/tables'
+require 'activefacts/persistence/columns'
+require 'activefacts/persistence/foreignkey'
+require 'activefacts/persistence/index'

data/lib/activefacts/persistence/columns.rb

@@ -0,0 +1,324 @@
+#
+# Each Reference from a Concept creates one or more Columns.
+# A reference to a simple valuetype creates a single column, as
+# does a reference to a table entity identified by a single value.
+#
+# When referring to a concept that doesn't have its own table,
+# all references from that concept are absorbed into this one.
+#
+# When multiple values identify an entity that does have its own
+# table, a reference to that entity creates multiple columns,
+# a multi-part foreign key.
+#
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+
+module ActiveFacts
+  module Metamodel
+
+    class Column
+      attr_reader :references
+
+      def references
+        @references ||= []
+      end
+
+      # All references up to and including the first non-absorbing reference
+      def absorption_references
+        @references.inject([]) do |array, ref|
+          array << ref
+          # puts "Column #{name} spans #{ref}, #{ref.is_absorbing ? "" : "not "} absorbing (#{ref.to.name} absorbs via #{ref.to.absorbed_via.inspect})"
+          break array unless ref.is_absorbing
+          array
+        end
+      end
+
+      def absorption_level
+        l = 0
+        @references.detect do |ref|
+          l += 1 if ref.is_absorbing
+          false
+        end
+        l
+      end
+
+      def initialize(reference = nil)
+        references << reference if reference
+      end
+
+      def prepend reference
+        references.insert 0, reference
+        self
+      end
+
+      def name(joiner = "")
+        last_name = ""
+        names = @references.
+          reject do |ref|
+            # Skip any object after the first which is identified by this reference
+            ref != @references[0] and
+              !ref.fact_type.is_a?(TypeInheritance) and
+              ref.to and
+              ref.to.is_a?(EntityType) and
+              (role_refs = ref.to.preferred_identifier.role_sequence.all_role_ref).size == 1 and
+              role_refs[0].role == ref.from_role
+          end.
+          inject([]) do |a, ref|
+            names = ref.to_names
+
+            # When traversing type inheritances, keep the subtype name, not the supertype names as well:
+            if a.size > 0 && ref.fact_type.is_a?(TypeInheritance)
+              a[-1] = names[0] if ref.to == ref.fact_type.subtype   # Else we already had the subtype
+              next a
+            end
+
+            # When Xyz is followed by XyzID, truncate that to just ID:
+            names[0] = names[0][last_name.size..-1] if last_name == names[0][0...last_name.size] 
+            last_name = names.last
+
+            a += names
+            a
+          end
+
+        # Where the last name is like a reference mode but the preceeding name isn't the identified concept,
+        # strip it down (so turn Driver.PartyID into Driver.ID for example):
+        if names.size > 1 and
+            (et = @references.last.from).is_a?(EntityType) and
+            (role_refs = et.preferred_identifier.role_sequence.all_role_ref).size == 1 and
+            role_refs[0].role == @references.last.to_role and
+            names.last[0...et.name.size].downcase == et.name.downcase
+          names[-1] = names.last[et.name.size..-1]
+          names.pop if names.last == ''
+        end
+
+        name_array = names.map{|n| n.sub(/^[a-z]/){|s| s.upcase}}
+        joiner ? name_array * joiner : name_array
+      end
+
+      def is_mandatory
+        !@references.detect{|ref| !ref.is_mandatory}
+      end
+
+      def is_auto_assigned
+        (to = references[-1].to) && to.is_auto_assigned
+      end
+
+      def type
+        params = {}
+        restrictions = []
+        return ["BIT", params, restrictions] if references[-1].is_unary   # It's a unary
+
+        # Add a role value restriction
+        # REVISIT: Can add join-role-value-restrictions here, if we ever provide a way to define them
+        if references[-1].to_role && references[-1].to_role.role_value_restriction
+          restrictions << references[-1].to_role.role_value_restriction
+        end
+
+        vt = references[-1].is_self_value ? references[-1].from : references[-1].to
+        params[:length] ||= vt.length if vt.length.to_i != 0
+        params[:scale] ||= vt.scale if vt.scale.to_i != 0
+        while vt.supertype
+          params[:length] ||= vt.length if vt.length.to_i != 0
+          params[:scale] ||= vt.scale if vt.scale.to_i != 0
+          restrictions << vt.value_restriction if vt.value_restriction
+          vt = vt.supertype
+        end
+        return [vt.name, params, restrictions]
+      end
+
+      def comment
+        @references.map do |ref|
+          (ref.is_mandatory ? "" : "maybe ") +
+          (ref.fact_type && ref.fact_type.entity_type ? ref.fact_type.entity_type.name+" is where " : "") +
+          ref.reading
+        end * " and "
+      end
+
+      def to_s
+        "#{@references[0].from.name} column #{name('.')}"
+      end
+    end
+
+    class Reference
+      def columns(excluded_supertypes)
+        kind = ""
+        cols = 
+          if is_unary
+            kind = "unary "
+            [Column.new()]
+          elsif is_self_value
+            kind = "self-role "
+            [Column.new()]
+          elsif is_simple_reference
+            @to.reference_columns(excluded_supertypes)
+          else
+            kind = "absorbing "
+            @to.all_columns(excluded_supertypes)
+          end
+
+        cols.each do |c|
+          c.prepend self
+        end
+
+        debug :columns, "Columns from #{kind}#{self}" do
+          cols.each {|c|
+            debug :columns, "#{c}"
+          }
+        end
+      end
+    end
+
+    class Concept
+      attr_accessor :columns
+
+      def populate_columns
+        @columns = all_columns({})
+      end
+    end
+
+    class ValueType
+      def identifier_columns
+        debug :columns, "Identifier Columns for #{name}" do
+          raise "Illegal call to identifier_columns for absorbed ValueType #{name}" unless is_table
+          columns.select{|column| column.references[0] == self_value_reference}
+        end
+      end
+
+      def reference_columns(excluded_supertypes)
+        debug :columns, "Reference Columns for #{name}" do
+          if is_table
+            [Column.new(self_value_reference)]
+          else
+            [Column.new]
+          end
+        end
+      end
+
+      def all_columns(excluded_supertypes)
+        columns = []
+        debug :columns, "All Columns for #{name}" do
+          if is_table
+            self_value_reference
+          else
+            columns << Column.new
+          end
+          references_from.each do |ref|
+            debug :columns, "Columns absorbed via #{ref}" do
+              columns += ref.columns({})
+            end
+          end
+        end
+        columns
+      end
+
+      def self_value_reference
+        # Make a reference for the self-value column
+        @self_value_reference ||= Reference.new(self, nil).tabulate
+      end
+    end
+
+    class EntityType
+      def identifier_columns
+        debug :columns, "Identifier Columns for #{name}" do
+          if absorbed_via and
+            # If this is a subtype that has its own identification, use that.
+            (all_type_inheritance_by_subtype.size == 0 ||
+              all_type_inheritance_by_subtype.detect{|ti| ti.provides_identification })
+            return absorbed_via.from.identifier_columns
+          end
+
+          preferred_identifier.role_sequence.all_role_ref.map do |role_ref|
+            ref = references_from.detect {|ref| ref.to_role == role_ref.role}
+
+            columns.select{|column| column.references[0] == ref}
+          end.flatten
+        end
+      end
+
+      def reference_columns(excluded_supertypes)
+        debug :columns, "Reference Columns for #{name}" do
+
+          if absorbed_via and
+            # If this is a subtype that has its own identification, use that.
+            (all_type_inheritance_by_subtype.size == 0 ||
+              all_type_inheritance_by_subtype.detect{|ti| ti.provides_identification })
+            return absorbed_via.from.reference_columns(excluded_supertypes)
+          end
+
+          # REVISIT: Should have built preferred_identifier_references
+          preferred_identifier.role_sequence.all_role_ref.map do |role_ref|
+            # REVISIT: Should index references by to_role:
+            ref = references_from.detect {|ref| ref.to_role == role_ref.role}
+
+            raise "reference for role #{role.describe} not found on #{name} in #{references_from.size} references:\n\t#{references_from.map(&:to_s)*"\n\t"}" unless ref
+
+            ref.columns({})
+          end.flatten
+        end
+      end
+
+      def all_columns(excluded_supertypes)
+        debug :columns, "All Columns for #{name}" do
+          columns = []
+          sups = supertypes
+          references_from.sort_by do |ref|
+            # Put supertypes first, in order, then non-subtype references, then subtypes, otherwise retaining their order:
+            sups.index(ref.to) ||
+              (!ref.fact_type.is_a?(TypeInheritance) && references_from.size+references_from.index(ref)) ||
+              references_from.size*2+references_from.index(ref)
+          end.each do |ref|
+            debug :columns, "Columns absorbed via #{ref}" do
+              if (ref.role_type == :supertype)
+                if excluded_supertypes[ref.to]
+                  debug :columns, "Exclude #{ref.to.name}, we already inherited it"
+                  next
+                end
+
+                next if (ref.to.absorbed_via != ref)
+                excluded_supertypes[ref.to] = true
+                columns += ref.columns(excluded_supertypes)
+              else
+                columns += ref.columns({})
+              end
+            end
+          end
+          columns
+        end
+      end
+    end
+
+    class Vocabulary
+      # Do things like adding ID fields and ValueType self-value columns
+      def finish_schema
+        all_feature.each do |feature|
+          feature.self_value_reference if feature.is_a?(ValueType) && feature.is_table
+        end
+      end
+
+      def populate_all_columns
+        # REVISIT: Is now a good time to apply schema transforms or should this be more explicit?
+        finish_schema
+
+        debug :columns, "Populating all columns" do
+          all_feature.each do |feature|
+            next if !feature.is_a?(Concept) || !feature.is_table
+            debug :columns, "Populating columns for table #{feature.name}" do
+              feature.populate_columns
+            end
+          end
+        end
+        debug :columns, "Finished columns" do
+          all_feature.each do |feature|
+            next if !feature.is_a?(Concept) || !feature.is_table
+            debug :columns, "Finished columns for table #{feature.name}" do
+              feature.columns.each do |column|
+                debug :columns, "#{column}"
+              end
+            end
+          end
+        end
+      end
+    end
+
+    end
+  end