activefacts 0.6.0 → 0.7.0

data/lib/activefacts/persistence/tables.rb

@@ -0,0 +1,307 @@
+#
+# Calculate the relational composition of a given Vocabulary
+# The composition consists of decisiona about which Concepts are tables,
+# and what columns (absorbed roled) those tables will have.
+#
+# This module has the following known problems:
+#
+# * Some one-to-ones absorb in both directions (ET<->FT in Metamodel, Blog model)
+#
+# * When a subtype has no mandatory roles, we should introduce
+#   a binary (is_subtype) to indicate it's that subtype.
+#
+
+require 'activefacts/persistence/reference'
+
+module ActiveFacts
+  module Metamodel
+
+    class ValueType
+      def absorbed_via; nil; end  # ValueTypes aren't absorbed in the way EntityTypes are
+
+      # Say whether this object is currently considered a table or not:
+      def is_table
+        return @is_table if @is_table != nil
+
+        # Always a table if marked so:
+        if is_independent
+          debug :absorption, "ValueType #{name} is declared independent"
+          @tentative = false
+          return @is_table = true
+        end
+
+        # Only a table if it has references (to another ValueType)
+        if !references_from.empty?
+          debug :absorption, "#{name} is a table because it has #{references_from.size} references to it"
+          @is_table = true
+        else
+          @is_table = false
+        end
+        @tentative = false
+
+        @is_table
+      end
+
+      # REVISIT: Find a better way to determine AutoCounters (ValueType unary role?)
+      def is_auto_assigned
+        type = self;
+        type = type.supertype while type.supertype
+        type.name =~ /^Auto/
+      end
+    end
+
+    class EntityType
+      attr_accessor :absorbed_via   # A reference from an entity type that fully absorbs this one
+
+      def is_auto_assigned; false; end
+
+      # Decide whether this object is currently considered a table or not:
+      def is_table
+        return @is_table if @is_table != nil  # We already make a guess or decision
+
+        @tentative = false
+
+        # Always a table if marked so
+        if is_independent
+          debug :absorption, "EntityType #{name} is declared independent"
+          return @is_table = true
+        end
+
+        # Always a table if nowhere else to go, and has no one-to-ones that might flip:
+        if references_to.empty? and
+            !references_from.detect{|ref| ref.role_type == :one_one }
+          debug :absorption, "EntityType #{name} is independent as it has nowhere to go"
+          return @is_table = true
+        end
+
+        # Subtypes are not a table unless partitioned or separate
+        # REVISIT: Support partitioned subtypes here
+        if (!supertypes.empty?)
+          av = all_supertype_inheritance[0]
+          return @is_table = false
+        end
+
+        # If the preferred_identifier includes an auto_assigned ValueType
+        # and this object is absorbed in more than one place, we need a table
+        # to manage the auto-assignment.
+        if references_to.size > 1 and
+          preferred_identifier.role_sequence.all_role_ref.detect {|rr|
+            next false unless rr.role.concept.is_a? ValueType
+            rr.role.concept.is_auto_assigned
+          }
+          debug :absorption, "#{name} has an auto-assigned counter in its ID, so must be a table"
+          @tentative = false
+          return @is_table = true
+        end
+
+        @tentative = true
+        @is_table = true
+      end
+    end # EntityType class
+
+    class Role
+      def role_type
+        # TypeInheritance roles are always 1:1
+        if TypeInheritance === fact_type
+          return concept == fact_type.supertype ? :supertype : :subtype
+        end
+
+        # Always N:1 if unary:
+        return :unary if fact_type.all_role.size == 1
+
+        # List the UCs on this fact type:
+        all_uniqueness_constraints =
+          fact_type.all_role.map do |fact_role|
+            fact_role.all_role_ref.map do |rr|
+              rr.role_sequence.all_presence_constraint.select do |pc|
+                pc.max_frequency == 1
+              end
+            end
+          end.flatten.uniq
+
+        to_1 =
+          all_uniqueness_constraints.
+            detect do |c|
+                c.role_sequence.all_role_ref.size == 1 and
+                c.role_sequence.all_role_ref[0].role == self
+            end
+
+        if fact_type.entity_type
+          # This is a role in an objectified fact type
+          from_1 = true
+        else
+          # It's to-1 if a UC exists over roles of this FT that doesn't cover this role:
+          from_1 = all_uniqueness_constraints.detect{|uc|
+            !uc.role_sequence.all_role_ref.detect{|rr| rr.role == self || rr.role.fact_type != fact_type}
+          }
+        end
+
+        if from_1
+          return to_1 ? :one_one : :one_many
+        else
+          return to_1 ? :many_one : :many_many
+        end
+      end
+
+    end
+
+    class Vocabulary
+      # return an Array of Concepts that will have their own tables
+      def tables
+        decide_tables if !@tables
+        @tables
+      end
+
+      def decide_tables
+        # Strategy:
+        # 1) Populate references for all Concepts
+        # 2) Decide which Concepts must be and must not be tables
+        #  a. Concepts labelled is_independent are tables (See the is_table methods above)
+        #  b. Entity types having no references to them must be tables
+        #  c. subtypes are not tables unless marked is_independent (separate) or partitioned (not yet impl)
+        #  d. ValueTypes are never tables unless they can have references (to other ValueTypes)
+        #  e. An EntityType having an identifying AutoInc field must be a table unless it has exactly one reference
+        #  f. An EntityType whose only reference is through its single preferred_identifier role gets absorbed
+        #  g. An EntityType that must has references other than its PI must be a table (unless it has exactly one reference to it)
+        #  h. supertypes are elided if all roles are absorbed into subtypes:
+        #    - partitioned subtype exhaustion
+        #    - subtype extension where supertype has only PI roles and no AutoInc
+        # 3) any ValueType that has references from it must become a table if not already
+
+        populate_all_references
+
+        debug :absorption, "Calculating relational composition" do
+          # Evaluate the possible independence of each concept, building an array of features of indeterminate status:
+          undecided =
+            all_feature.select do |feature|
+              next unless feature.is_a? Concept
+              feature.is_table          # Ask it whether it thinks it should be a table
+              feature.tentative         # Selection criterion
+            end
+
+          if debug :absorption, "Generating tables, #{undecided.size} undecided"
+            (all_feature-undecided).each {|feature|
+              next if ValueType === feature && !feature.is_table  # Skip unremarkable cases
+              debug :absorption do
+                debug :absorption, "#{feature.name} is #{feature.is_table ? "" : "not "}a table#{feature.tentative ? ", tentatively" : ""}"
+              end
+            }
+          end
+
+          pass = 0
+          begin                         # Loop while we continue to make progress
+            pass += 1
+            debug :absorption, "Starting composition pass #{pass} with #{undecided.size} undecided tables"
+            possible_flips = {}         # A hash by table containing an array of references that can be flipped
+            finalised =                 # Make an array of things we finalised during this pass
+              undecided.select do |feature|
+                debug :absorption, "Considering #{feature.name}:" do
+                  debug :absorption, "refs to #{feature.name} are from #{feature.references_to.map{|ref| ref.from.name}*", "}" if feature.references_to.size > 0
+                  debug :absorption, "refs from #{feature.name} are to #{feature.references_from.map{|ref| ref.to.name rescue ref.fact_type.default_reading}*", "}" if feature.references_from.size > 0
+
+                  # Always absorb an objectified unary into its role player:
+                  if feature.fact_type && feature.fact_type.all_role.size == 1
+                    debug :absorption, "Absorb objectified unary #{feature.name} into #{feature.fact_type.entity_type.name}"
+                    feature.definitely_not_table
+                    next feature
+                  end
+
+                  # If the PI contains one role only, played by an entity type that can absorb us, do that.
+                  pi_roles = feature.preferred_identifier.role_sequence.all_role_ref.map(&:role)
+                  debug :absorption, "pi_roles are played by #{pi_roles.map{|role| role.concept.name}*", "}"
+                  first_pi_role = pi_roles[0]
+                  pi_ref = nil
+                  if pi_roles.size == 1 and
+                    feature.references_to.detect{|ref| pi_ref = ref if ref.from_role == first_pi_role && ref.from.is_a?(EntityType)}
+
+                    debug :absorption, "#{feature.name} is fully absorbed along its sole reference path into entity type #{pi_ref.from.name}"
+                    feature.definitely_not_table
+                    next feature
+                  end
+
+                  # If there's more than one absorption path and any functional dependencies that can't absorb us, it's a table
+                  non_identifying_refs_from =
+                    feature.references_from.reject{|ref|
+                      pi_roles.include?(ref.to_role)
+                    }
+                  debug :absorption, "#{feature.name} has #{non_identifying_refs_from.size} non-identifying functional roles"
+
+                  if feature.references_to.size > 1 and
+                      non_identifying_refs_from.size > 0
+                    debug :absorption, "#{feature.name} has non-identifying functional dependencies so 3NF requires it be a table"
+                    feature.definitely_table
+                    next feature
+                  end
+
+                  absorption_paths =
+                    (
+                      non_identifying_refs_from.reject do |ref|
+                        !ref.to or ref.to.absorbed_via == ref
+                      end+feature.references_to
+                    ).reject do |ref|
+                      next true if !ref.to.is_table or
+                        ![:one_one, :supertype, :subtype].include?(ref.role_type)
+
+                      # If one side is mandatory but not the other, don't absorb the mandatory side into the non-mandatory one
+                      from_is_mandatory = !!ref.is_mandatory
+                      to_is_mandatory = !ref.to_role || !!ref.to_role.is_mandatory
+                      bad = (to_is_mandatory != from_is_mandatory and (ref.from == feature ? from_is_mandatory : to_is_mandatory))
+                      debug :absorption, "Not absorbing mandatory #{feature.name} through #{ref}" if bad
+                      bad
+                    end
+
+                  # If this object can be fully absorbed, do that (might require flipping some references)
+                  if absorption_paths.size > 0
+                    debug :absorption, "#{feature.name} is fully absorbed through #{absorption_paths.inspect}"
+                    absorption_paths.each do |ref|
+                      debug :absorption, "flip #{ref} so #{feature.name} can be absorbed"
+                      ref.flip if feature == ref.from
+                    end
+                    feature.definitely_not_table
+                    next feature
+                  end
+
+                  if non_identifying_refs_from.size == 0
+#                    and (!feature.is_a?(EntityType) ||
+#                      # REVISIT: The roles may be collectively but not individually mandatory.
+#                      feature.references_to.detect { |ref| !ref.from_role || ref.from_role.is_mandatory })
+                    debug :absorption, "#{feature.name} is fully absorbed in #{feature.references_to.size} places: #{feature.references_to.map{|ref| ref.from.name}*", "}"
+                    feature.definitely_not_table
+                    next feature
+                  end
+
+                  false   # Failed to decide about this entity_type this time around
+                end
+              end
+
+            undecided -= finalised
+            debug :absorption, "Finalised #{finalised.size} this pass: #{finalised.map{|f| f.name}*", "}"
+          end while !finalised.empty?
+
+          # A ValueType that isn't explicitly a table and isn't needed anywhere doesn't matter,
+          # unless it should absorb something else (another ValueType is all it could be):
+          all_feature.each do |feature|
+            if (!feature.is_table and feature.references_to.size == 0 and feature.references_from.size > 0)
+              debug :absorption, "Making #{feature.name} a table; it has nowhere else to go and needs to absorb things"
+              feature.probably_table
+            end
+          end
+
+          # Now, evaluate all possibilities of the tentative assignments
+          # Incomplete. Apparently unnecessary as well... so far. We'll see.
+          if debug :absorption
+            undecided.each do |feature|
+              debug :absorption, "Unable to decide independence of #{feature.name}, going with #{feature.show_tabular}"
+            end
+          end
+        end
+
+        populate_all_columns
+        populate_all_indices
+
+        @tables = all_feature.select { |f| f.is_table }
+      end
+    end
+
+  end
+end

data/lib/activefacts/support.rb

@@ -8,7 +8,7 @@
       $debug_indent = 0
       $debug_keys = {}
       if (e = ENV["DEBUG"])
-        e.split(/[^a-z]/).each{|k| $debug_keys[k.to_sym] = true }
+        e.split(/[^a-zA-Z0-9]/).each{|k| $debug_keys[k.to_sym] = true }
       end
     end
 

data/lib/activefacts/version.rb

@@ -1,3 +1,3 @@
 module ActiveFacts
-  VERSION = '0.6.0'
+  VERSION = '0.7.0'
 end

data/lib/activefacts/vocabulary/extensions.rb

@@ -40,6 +40,16 @@ module ActiveFacts
         }
       end
 
+      def is_mandatory
+        all_role_ref.detect{|rr|
+          rs = rr.role_sequence
+          rs.all_role_ref.size == 1 and
+          rs.all_presence_constraint.detect{|pc|
+            pc.min_frequency and pc.min_frequency >= 1 and pc.is_mandatory
+          }
+        }
+      end
+
       # Return the RoleRef to this role from its fact type's preferred_reading
       def preferred_reference
         fact_type.preferred_reading.role_sequence.all_role_ref.detect{|rr| rr.role == self }
@@ -73,6 +83,19 @@ module ActiveFacts
           end
         return joiner ? Array(name_array)*joiner : Array(name_array)
       end
+
+      # Two RoleRefs are equal if they have the same role and JoinPaths with matching roles
+      def ==(role_ref)
+        RoleRef === role_ref &&
+        role_ref.role == role &&
+        all_join_path.size == role_ref.all_join_path.size &&
+        !all_join_path.sort_by{|j|j.join_step}.
+          zip(role_ref.all_join_path.sort_by{|j|j.join_step}).
+          detect{|j1,j2|
+            j1.input_role != j2.input_role ||
+            j1.output_role != j2.output_role
+          }
+      end
     end
 
     class RoleSequence
@@ -107,9 +130,23 @@ module ActiveFacts
                         role_sequence = rr.role_sequence
 
                         # The role sequence is only interesting if it cover only this fact's roles
+                        # or roles of the objectification
                         next if role_sequence.all_role_ref.size < fact_roles.size-1 # Not enough roles
                         next if role_sequence.all_role_ref.size > fact_roles.size   # Too many roles
-                        next if role_sequence.all_role_ref.detect{|rsr| ft = rsr.role.fact_type; ft != fact_type }
+                        next if role_sequence.all_role_ref.detect do |rsr|
+                            if (of = rsr.role.fact_type) != fact_type
+                              case of.all_role.size
+                              when 1    # A unary FT must be played by the objectification of this fact type
+                                next rsr.role.concept != fact_type.entity_type
+                              when 2    # A binary FT must have the objectification of this FT as the other player
+                                other_role = (of.all_role-[rsr.role])[0]
+                                next other_role.concept != fact_type.entity_type
+                              else
+                                next true # A role in a ternary (or higher) cannot be usd in our identifier
+                              end
+                            end
+                            rsr.role.fact_type != fact_type
+                          end
 
                         # This role sequence is a candidate
                         pc = role_sequence.all_presence_constraint.detect{|c|
@@ -243,10 +280,10 @@ module ActiveFacts
 
       # An array of self followed by all supertypes in order:
       def supertypes_transitive
-          ([self] + all_type_inheritance_by_subtype.map{|ti|
-              # debug ti.class.roles.verbalise; exit
-              ti.supertype.supertypes_transitive
-            }).flatten.uniq
+        ([self] + all_type_inheritance_by_subtype.map{|ti|
+            # debug ti.class.roles.verbalise; exit
+            ti.supertype.supertypes_transitive
+          }).flatten.uniq
       end
 
       # A subtype does not have a identifying_supertype if it defines its own identifier

data/spec/absorption_spec.rb

@@ -43,7 +43,7 @@ describe "Absorption" do
         #{Prologue}
         Month is in exactly one Season;
       },
-      :tables => { "Month" => [ %w{Month Value}, "Season" ] }
+      :tables => { "Month" => [ "MonthValue", "Season" ] }
     },
 
     { :should => "absorb a one-to-one along the identification path",
@@ -64,7 +64,7 @@ describe "Absorption" do
       },
       :tables => {
         "Claim" => ["ClaimID", %w{Lodgement DateTime}, %w{Lodgement Person ID}],
-        "Party" => ["PartyID", %w{Person birth Date}]
+        "Party" => ["PartyID", %w{Person Birth Date}]
       }
     },
 
@@ -81,13 +81,15 @@ describe "Absorption" do
       @compiler = ActiveFacts::Input::CQL.new(cql, should)
       @vocabulary = @compiler.read
 
+      # puts cql
+
       # Ensure that the same tables were generated:
-      tables = @vocabulary.tables
-      tables.map(&:name).sort.should == expected_tables.keys.sort
+      tables = @vocabulary.tables.sort_by(&:name)
+      tables.map(&:name).should == expected_tables.keys.sort
 
       # Ensure that the same column descriptions were generated:
-      tables.sort_by(&:name).each do |table|
-        column_descriptions = table.absorbed_roles.all_role_ref.map{|rr| rr.column_name(nil) }.sort
+      tables.each do |table|
+        column_descriptions = table.columns.map{|col| col.name(nil) }.sort
         column_descriptions.should == expected_tables[table.name].map{|c| Array(c) }.sort
       end
     end

data/spec/cql_cql_spec.rb

@@ -23,6 +23,7 @@ describe "CQL Loader" do
     Airline
     CompanyQuery
     Insurance
+    OddIdentifier
     OrienteeringER
     ServiceDirector
   }

data/spec/cql_sql_spec.rb

@@ -17,6 +17,7 @@ describe "CQL Loader with SQL output" do
     Airline
     CompanyQuery
     Insurance
+    Marriage
     OrienteeringER
     ServiceDirector
     SimplestUnary
@@ -25,7 +26,7 @@ describe "CQL Loader with SQL output" do
   # Generate and return the SQL for the given vocabulary
   def sql(vocabulary)
     output = StringIO.new
-    @dumper = ActiveFacts::Generate::SQL::SERVER.new(vocabulary.constellation)
+    @dumper = ActiveFacts::Generate::SQL::SERVER.new(vocabulary.constellation, "norma")
     @dumper.generate(output)
     output.rewind
     output.read