activefacts-rmap 1.7.1

data/lib/activefacts/rmap/reference.rb

@@ -0,0 +1,433 @@
+#
+#       ActiveFacts Relational mapping
+#       Reference from one ObjectType to another, used to decide the relational mapping.
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+# A Reference from one ObjectType to another is created for each many-1 or 1-1 relationship
+# (including subtyping), and also for a unary role (implicitly to Boolean object_type).
+# A 1-1 or subtyping reference should be created in only one direction, and may be flipped
+# if needed.
+#
+# A reference to a object_type that's a table or is fully absorbed into a table will
+# become a foreign key, otherwise it will absorb all that object_type's references.
+#
+# Reference objects update each object_type's list of the references *to* and *from* that object_type.
+#
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+
+module ActiveFacts
+  module RMap
+
+    # This class contains the core data structure used in composing a relational schema.
+    #
+    # A Reference is *from* one ObjectType *to* another ObjectType, and relates to the *from_role* and the *to_role*.
+    # When either ObjectType is an objectified fact type, the corresponding role is nil.
+    # When the Reference from_role is of a unary fact type, there's no to_role or to ObjectType.
+    # The final kind of Reference is a self-reference which is added to a ValueType that becomes a table.
+    #
+    # When the underlying fact type is a one-to-one (including an inheritance fact type), the Reference may be flipped.
+    #
+    # Each Reference has a name; an array of names in fact, in case of adjectives, etc.
+    # Each Refererence can produce the reading of the underlying fact type.
+    #
+    # A Reference is indexed in the player's *references_from* and *references_to*, and flipping updates those.
+    # Finally, a Reference may be marked as absorbing the whole referenced object, and that can flip too.
+    #
+    class Reference
+      attr_reader :from, :to            # A "from" instance is related to one "to" instance
+      attr_reader :from_role, :to_role  # For objectified facts, one role will be nil (a phantom)
+      attr_reader :fact_type
+      attr_accessor :fk_jump            # True if this reference links a table to another in an FK (between absorbed references)
+
+      # A Reference is created from a object_type in regard to a role it plays
+      def initialize(from, role)
+        @fk_jump = false
+        @from = from
+        return unless role              # All done if it's a self-value reference for a ValueType
+        @fact_type = role.fact_type
+        if @fact_type.all_role.size == 1
+          # @from_role is nil for a unary
+          @to_role = role
+          @to = role.fact_type.entity_type      # nil unless the unary is objectified
+        elsif (role.fact_type.entity_type == @from)  # role is in "from", an objectified fact type
+          @from_role = nil                      # Phantom role
+          @to_role = role
+          @to = @to_role.object_type
+        else
+          @from_role = role
+          @to = role.fact_type.entity_type      # If set, to_role is a phantom
+          unless @to
+            raise "Illegal reference through >binary fact type" if @fact_type.all_role.size >2
+            @to_role = (role.fact_type.all_role-[role])[0]
+            @to = @to_role.object_type
+          end
+        end
+      end
+
+      # What type of Role did this Reference arise from?
+      def role_type
+        role = @from_role||@to_role
+        role && role.role_type
+      end
+
+      # Is this Reference covered by a mandatory constraint (implicitly or explicitly)
+      def is_mandatory
+	!is_unary &&
+	  (!@from_role ||        # All phantom roles of fact types are mandatory
+	    @from_role.is_mandatory)
+      end
+
+      # Is this Reference from a unary Role?
+      def is_unary
+        @to_role && @to_role.fact_type.all_role.size == 1
+      end
+
+      # If this Reference is to an objectified FactType, there is no *to_role*
+      def is_to_objectified_fact
+        # This case is the only one that cannot be used in the preferred identifier of @from
+        @to && !@to_role && @from_role
+      end
+
+      # If this Reference is from an objectified FactType, there is no *from_role*
+      def is_from_objectified_fact
+        @to && !@from_role && @to_role
+      end
+
+      # Is this reference an injected role as a result a ValueType being a table?
+      def is_self_value
+        !@to && !@to_role
+      end
+
+      # Is the *to* object_type fully absorbed through this reference?
+      def is_absorbing
+        @to && @to.absorbed_via == self
+      end
+
+      # Is this a simple reference?
+      def is_simple_reference
+        # It's a simple reference to a thing if that thing is a table,
+        # or is fully absorbed into another table but not via this reference.
+        @to && (@to.is_table or @to.absorbed_via && !is_absorbing)
+      end
+
+      # Return the array of names for the (perhaps implicit) *to_role* of this Reference
+      def to_names(is_prefix = true)
+        case
+        when is_unary
+          if @to && @to.fact_type && is_prefix
+            @to.name.camelwords
+          else
+            @to_role.fact_type.preferred_reading.text.gsub(/\{[0-9]\}/,'').strip.camelwords
+          end
+        when @to && !@to_role           # @to is an objectified fact type so @to_role is a phantom
+          @to.name.camelwords
+        when !@to_role                  # Self-value role of an independent ValueType
+          @from.name.camelwords + ["Value"]
+        when @to_role.role_name         # Named role
+          @to_role.role_name.camelwords
+        else                            # Use the name from the preferred reading
+          role_ref = @to_role.preferred_reference
+          [role_ref.leading_adjective, @to_role.object_type.name, role_ref.trailing_adjective].compact.map{|w| w.camelwords}.flatten.reject{|s| s == ''}
+        end
+      end
+
+      # Return the array of names for the (perhaps implicit) *from_role* of this Reference
+      def from_names
+        case
+        when @from && !@from_role           # @from is an objectified fact type so @from_role is a phantom
+          @from.name.camelwords
+        when is_unary
+          if @from && @from.fact_type
+            @from.name.camelwords
+          else
+            @from_role.fact_type.preferred_reading.text.gsub(/\{[0-9]\}/,'').strip.camelwords
+          end
+        when !@from_role                  # Self-value role of an independent ValueType
+          @from.name.camelwords + ["Value"]
+        when @from_role.role_name         # Named role
+          @from_role.role_name.camelwords
+        else                            # Use the name from the preferred reading
+          role_ref = @from_role.preferred_reference
+          [role_ref.leading_adjective, @from_role.object_type.name, role_ref.trailing_adjective].compact.map{|w| w.camelwords}.flatten.reject{|s| s == ''}
+        end
+      end
+
+      def is_one_to_one
+        [:one_one, :subtype, :supertype].include?(role_type)
+      end
+
+      # For a one-to-one (or a subtyping fact type), reverse the direction.
+      def flip                          #:nodoc:
+        raise "Illegal flip of #{self}" unless @to and is_one_to_one
+
+        detabulate
+        mirror
+        tabulate
+      end
+
+      # Create a (non-tabulated) flipped version of this Reference. Careful not to tabulate it!
+      def mirror
+        if @to.absorbed_via == self
+          @to.absorbed_via = nil
+          @from.absorbed_via = self
+        end
+
+        # Flip the reference
+        @to, @from = @from, @to
+        @to_role, @from_role = @from_role, @to_role
+        self
+      end
+
+      def reversed
+        clone.mirror
+      end
+
+      def tabulate        #:nodoc:
+        # Add to @to and @from's reference lists
+        @from.references_from << self
+        @to.references_to << self if @to        # Guard against self-values
+
+        trace :references, "Adding #{to_s}"
+        self
+      end
+
+      def detabulate        #:nodoc:
+        # Remove from @to and @from's reference lists if present
+        return unless @from.references_from.delete(self)
+        @to.references_to.delete self if @to    # Guard against self-values
+        trace :references, "Dropping #{to_s}"
+        self
+      end
+
+      def to_s              #:nodoc:
+        ref_type = fk_jump ? "jumping to" : (is_absorbing ? "absorbing" : "to")
+        "reference from #{@from.name}#{@to ? " #{ref_type} #{@to.name}" : ""}" + (@fact_type ? " in '#{@fact_type.default_reading}'" : "")
+      end
+
+      # The reading for the fact type underlying this Reference
+      def reading
+        is_self_value ? "#{from.name} has value" : @fact_type.reading_preferably_starting_with_role(@from_role).expand
+      end
+
+      def verbalised_path reverse = false
+	return "#{from.name} Value" if is_self_value
+	objectified = fact_type.entity_type 
+	f =	# Switch to the Link Fact Type if we're traversing an objectification
+	  (to_role && to_role.link_fact_type) ||
+	  (from_role && from_role.link_fact_type) ||
+	  fact_type
+
+	start_role =
+	  if objectified
+	    target = reverse ? to : from
+	    [to_role, from_role, f.all_role[0]].compact.detect{|role| role.object_type == target}
+	  else
+	    reverse ? to_role : from_role
+	  end
+	reading = f.reading_preferably_starting_with_role(start_role)
+	(is_mandatory || is_unary ? '' : 'maybe ') +
+	  reading.expand
+      end
+
+      def inspect #:nodoc:
+        to_s
+      end
+    end
+  end
+
+  module Metamodel          #:nodoc:
+    class ObjectType
+      # Say whether the independence of this object is still under consideration
+      # This is used in detecting dependency cycles, such as occurs in the Metamodel
+      attr_accessor :tentative          #:nodoc:
+      attr_writer :is_table             # The two ObjectType subclasses provide the attr_reader method
+
+      def show_tabular                  #:nodoc:
+        (tentative ? "tentatively " : "") +
+        (is_table ? "" : "not ")+"a table"
+      end
+
+      def definitely_table              #:nodoc:
+        @is_table = true
+        @tentative = false
+      end
+
+      def definitely_not_table          #:nodoc:
+        @is_table = false
+        @tentative = false
+      end
+
+      def probably_table                #:nodoc:
+        @is_table = true
+        @tentative = true
+      end
+
+      def probably_not_table            #:nodoc:
+        @is_table = false
+        @tentative = true
+      end
+
+      # References from this ObjectType
+      def references_from
+        @references_from ||= []
+      end
+
+      # References to this ObjectType
+      def references_to
+        @references_to ||= []
+      end
+
+      # True if this ObjectType has any References (to or from)
+      def has_references                #:nodoc:
+        @references_from || @references_to
+      end
+
+      def clear_references              #:nodoc:
+        # Clear any previous references:
+        @references_to = nil
+        @references_from = nil
+      end
+
+      def populate_references           #:nodoc:
+        all_role.each do |role|
+          # It's possible that this role is in an implicit or derived fact type. Skip it if so.
+          next if role.fact_type.is_a?(LinkFactType) or
+	    # REVISIT: dafuq? Is this looking for a constraint over a derivation? This looks wrong.
+            role.fact_type.preferred_reading.role_sequence.all_role_ref.to_a[0].play or
+	    # This is not yet actually set, and wouldn't handle constraint derivations anyhow:
+	    role.variable_as_projection
+          
+          populate_reference role
+        end
+      end
+
+      def populate_reference role       #:nodoc:
+        role_type = role.role_type
+        trace :references, "#{name} has #{role_type} role in '#{role.fact_type.describe}'"
+        case role_type
+        when :many_one
+          ActiveFacts::RMap::Reference.new(self, role).tabulate      # A simple reference
+
+        when :one_many
+          if role.fact_type.entity_type == self   # A Role of this objectified FactType
+            ActiveFacts::RMap::Reference.new(self, role).tabulate    # A simple reference; check that
+          else
+            # Can't absorb many of these into one of those
+            #trace :references, "Ignoring #{role_type} reference from #{name} to #{Reference.new(self, role).to.name}"
+          end
+
+        when :unary
+          ActiveFacts::RMap::Reference.new(self, role).tabulate      # A simple reference
+
+        when :supertype   # A subtype absorbs a reference to its supertype when separate, or all when partitioned
+          # REVISIT: Or when partitioned
+          raise "Internal error, expected TypeInheritance" unless role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+	  counterpart_role = (role.fact_type.all_role.to_a-[role])[0]
+          if role.fact_type.assimilation or counterpart_role.object_type.is_separate
+            trace :references, "supertype #{name} doesn't absorb a reference to separate subtype #{role.fact_type.subtype.name}"
+          else
+            r = ActiveFacts::RMap::Reference.new(self, role)
+            r.to.absorbed_via = r
+            trace :references, "supertype #{name} absorbs subtype #{r.to.name}"
+            r.tabulate
+          end
+
+        when :subtype    # This object is a supertype, which can absorb the subtype unless that's independent
+          if role.fact_type.assimilation or is_separate
+            ActiveFacts::RMap::Reference.new(self, role).tabulate
+            # If partitioned, the supertype is absorbed into *each* subtype; a reference to the supertype needs to know which
+          else
+            # trace :references, "subtype #{name} is absorbed into #{role.fact_type.supertype.name}"
+          end
+
+        when :one_one
+          r = ActiveFacts::RMap::Reference.new(self, role)
+
+          # Decide which way the one-to-one is likely to go; it will be flipped later if necessary.
+          # Force the decision if just one is independent:
+          # REVISIT: Decide whether supertype assimilation can affect this
+          r.tabulate and return if is_separate and !r.to.is_separate
+          return if !is_separate and r.to.is_separate
+
+          if is_a?(ValueType)
+            # Never absorb an entity type into a value type
+            return if r.to.is_a?(EntityType)  # Don't tabulate it
+          else
+            if r.to.is_a?(ValueType)
+              r.tabulate  # Always absorb a value type into an entity type
+              return 
+            end
+
+            # Force the decision if one EntityType identifies another:
+            if preferred_identifier.role_sequence.all_role_ref.detect{|rr| rr.role == r.to_role}
+              trace :references, "EntityType #{name} is identified by EntityType #{r.to.name}, so gets absorbed elsewhere"
+              return
+            end
+            if r.to.preferred_identifier.role_sequence.all_role_ref.detect{|rr| rr.role == role}
+              trace :references, "EntityType #{name} identifies EntityType #{r.to.name}, so absorbs it"
+              r.to.absorbed_via = r
+              # We can't be absorbed into our supertype!
+              # REVISIT: We might need to flip all one-to-ones as well
+              r.to.references_to.clone.map{|q|q.flip if q.to_role.role_type == :subtype }
+              r.tabulate
+              return
+            end
+          end
+
+          # Either both EntityTypes, or both ValueTypes.
+          # Make an arbitrary (but stable) decision which way to go. We might flip it later,
+          # but not frivolously; the Ruby API column name generation duplicates this logic.
+          unless r.from.name.downcase < r.to.name.downcase or
+            (r.from == r.to && references_to.detect{|ref| ref.to_role == role}) # one-to-one self reference, done already
+            r.tabulate
+          end
+        else
+	  # REVISIT: Should we implicitly objectify this fact type here and add a spanning UC?
+          raise "Role #{role.object_type.name} in '#{role.fact_type.default_reading}' lacks a uniqueness constraint"
+        end
+      end
+    end
+
+    class EntityType < DomainObjectType
+      def populate_references          #:nodoc:
+        if fact_type && fact_type.all_role.size > 1
+          # NOT: fact_type.all_role.each do |role|  # Place roles in the preferred order instead:
+          fact_type.preferred_reading.role_sequence.all_role_ref.map(&:role).each do |role|
+            populate_reference role     # Objectified fact role, handled specially
+          end
+        end
+        super
+      end
+    end
+
+    class Vocabulary
+      def populate_all_references #:nodoc:
+        trace :references, "Populating all object_type references" do
+          all_object_type.each do |object_type|
+            trace :references, "Populating references for #{object_type.name}" do
+              object_type.populate_references
+            end
+          end
+        end
+        show_all_references
+      end
+
+      def show_all_references
+        if trace :references
+          trace :references, "Finished object_type references" do
+            all_object_type.each do |object_type|
+              trace :references?, "#{object_type.name}:" do
+                object_type.references_from.each do |ref|
+                  trace :references, "#{ref}"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/activefacts/rmap/tables.rb

@@ -0,0 +1,380 @@
+#
+#       ActiveFacts Relational mapping
+#       Tables; Calculate the relational composition of a given Vocabulary.
+#       The composition consists of decisions about which ObjectTypes are tables,
+#       and what columns (absorbed roled) those tables will have.
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+# This module has the following known problems:
+#
+# * When a subtype has no mandatory roles, we should support an optional schema transformation step
+#   that introduces a boolean (is_subtype) to indicate it's that subtype.
+#
+
+require 'activefacts/rmap/reference'
+
+module ActiveFacts
+  module Metamodel
+
+    class ValueType < DomainObjectType
+      def absorbed_via  #:nodoc:
+        # ValueTypes aren't absorbed in the way EntityTypes are
+        nil
+      end
+
+      # Returns true if this ValueType is a table
+      def is_table
+        return @is_table if @is_table != nil
+
+        # Always a table if marked so:
+        if is_separate
+          trace :absorption, "ValueType #{name} is declared independent or separate"
+          @tentative = false
+          return @is_table = true
+        end
+
+        # Only a table if it has references (to another ValueType)
+        if !references_from.empty? && !is_auto_assigned
+          trace :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
+
+      # Is this ValueType auto-assigned either at assert or on first save to the database?
+      def is_auto_assigned
+        type = self
+	while type
+	  return true if type.name =~ /^Auto/ || type.transaction_phase
+	  type = type.supertype
+	end
+      end
+      false
+    end
+
+    class EntityType < DomainObjectType
+      # A Reference from an entity type that fully absorbs this one
+      attr_accessor :absorbed_via #:nodoc:
+      attr_accessor :absorbed_mirror #:nodoc:
+
+      def is_auto_assigned  #:nodoc:
+        false
+      end
+
+      # Returns true if this EntityType is a table
+      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_separate
+          trace :absorption, "EntityType #{name} is declared independent or separate"
+          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 }
+          trace :absorption, "EntityType #{name} is presumed independent as it has nowhere to go"
+          return @is_table = true
+        end
+
+        # Subtypes may be partitioned or separate, in which case they're definitely tables.
+        # Otherwise, if their identification is inherited from a supertype, they're definitely absorbed.
+        # If theey have separate identification, it might absorb them.
+        if (!supertypes.empty?)
+          as_ti = all_supertype_inheritance.detect{|ti| ti.assimilation}
+          @is_table = as_ti != nil
+          if @is_table
+            trace :absorption, "EntityType #{name} is #{as_ti.assimilation} from supertype #{as_ti.supertype}"
+          else
+            identifying_fact_type = preferred_identifier.role_sequence.all_role_ref.to_a[0].role.fact_type
+            if identifying_fact_type.is_a?(TypeInheritance)
+              trace :absorption, "EntityType #{name} is absorbed into supertype #{supertypes[0].name}"
+              @is_table = false
+            else
+              # Possibly absorbed, we'll have to see how that pans out
+              @tentative = true
+            end
+          end
+          return @is_table
+        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.object_type.is_a? ValueType
+            rr.role.object_type.is_auto_assigned
+          }
+          trace :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    #:nodoc:
+      def role_type
+        # TypeInheritance roles are always 1:1
+        if TypeInheritance === fact_type
+          return object_type == 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|
+                (rr = c.role_sequence.all_role_ref.single) and
+                rr.role == self
+            end
+	# REVISIT: check mapping pragmas, e.g. by to_1.concept.all_concept_annotation.detect{|ca| ca.mapping_annotation == 'separate'}
+
+        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
+      @@relational_transforms = []
+
+      # return an Array of ObjectTypes that will have their own tables
+      def tables
+        decide_tables if !@tables
+        @@relational_transforms.each{|tr| tr.call(self)}
+        @tables
+      end
+
+      def self.relational_transform &block
+        # Add this block to the additional transformations which will be applied
+        # to the relational schema after the initial absorption.
+        # For example, to perform injection of surrogate keys to replace composite keys...
+        @@relational_transforms << block
+      end
+
+      def wipe_existing_mapping
+        all_object_type.each do |object_type|
+          object_type.clear_references
+          object_type.wipe_columns
+          object_type.is_table = nil      # Undecided; force an attempt to decide
+          object_type.tentative = true    # Uncertain
+        end
+      end
+
+      def decide_tables #:nodoc:
+        # Strategy:
+        # 1) Populate references for all ObjectTypes
+        # 2) Decide which ObjectTypes must be and must not be tables
+        #  a. ObjectTypes labelled is_independent/separate 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 with assimilation = separate or partitioned
+        #  d. ValueTypes are never tables unless they independent or 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
+
+        wipe_existing_mapping
+
+        populate_all_references
+
+        trace :absorption, "Calculating relational composition" do
+          # Evaluate the possible independence of each object_type, building an array of object_types of indeterminate status:
+          undecided =
+            all_object_type.select do |object_type|
+              object_type.is_table          # Ask it whether it thinks it should be a table
+              object_type.tentative         # Selection criterion
+            end
+
+          if trace :absorption, "Generating tables, #{undecided.size} undecided, already decided ones are"
+            (all_object_type-undecided).each {|object_type|
+              next if ValueType === object_type && !object_type.is_table  # Skip unremarkable cases
+              trace :absorption do
+                trace :absorption, "#{object_type.name} is #{object_type.is_table ? "" : "not "}a table#{object_type.tentative ? ", tentatively" : ""}"
+              end
+            }
+          end
+
+          pass = 0
+          begin                         # Loop while we continue to make progress
+            pass += 1
+            trace :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 |object_type|
+                trace :absorption, "Considering #{object_type.name}:" do
+                  trace :absorption, "refs to #{object_type.name} are from #{object_type.references_to.map{|ref| ref.from.name}*", "}" if object_type.references_to.size > 0
+                  trace :absorption, "refs from #{object_type.name} are to #{object_type.references_from.map{|ref| ref.to ? ref.to.name : ref.fact_type.default_reading}*", "}" if object_type.references_from.size > 0
+
+                  # Always absorb an objectified unary into its role player:
+                  if object_type.fact_type && object_type.fact_type.all_role.size == 1
+                    trace :absorption, "Absorb objectified unary #{object_type.name} into #{object_type.fact_type.entity_type.name}"
+                    object_type.definitely_not_table
+                    next object_type
+                  end
+
+                  # If the PI contains one role only, played by an entity type that can absorb us, do that.
+                  pi_roles = object_type.preferred_identifier.role_sequence.all_role_ref.map(&:role)
+                  trace :absorption, "pi_roles are played by #{pi_roles.map{|role| role.object_type.name}*", "}"
+                  first_pi_role = pi_roles[0]
+                  pi_ref = nil
+                  if pi_roles.size == 1 and
+                    object_type.references_to.detect do |ref|
+		      if ref.from_role == first_pi_role and ref.from.is_a?(EntityType) # and ref.is_mandatory # REVISIT
+			pi_ref = ref
+		      end
+		    end
+
+                    trace :absorption, "#{object_type.name} is fully absorbed along its sole reference path into entity type #{pi_ref.from.name}"
+                    object_type.definitely_not_table
+                    next object_type
+                  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 =
+                    object_type.references_from.reject{|ref|
+                      pi_roles.include?(ref.to_role)
+                    }
+                  trace :absorption, "#{object_type.name} has #{non_identifying_refs_from.size} non-identifying functional roles"
+
+=begin
+                  # This is kinda arbitrary. We need a policy for evaluating optional flips, so we can decide if they "improve" things.
+                  # The flipping that occurs below always eliminates a table by absorption, but this doesn't.
+
+                  # If all non-identifying functional roles are one-to-ones that can be flipped, do that:
+                  if non_identifying_refs_from.all? { |ref| ref.role_type == :one_one && (ref.to.is_table || ref.to.tentative) }
+                    trace :absorption, "Flipping references from #{object_type.name}" do
+                      non_identifying_refs_from.each do |ref|
+                        trace :absorption, "Flipping #{ref}"
+                        ref.flip
+                      end
+                    end
+                    non_identifying_refs_from = []
+                  end
+=end
+
+                  if object_type.references_to.size > 1 and
+                      non_identifying_refs_from.size > 0
+                    trace :absorption, "#{object_type.name} has non-identifying functional dependencies so 3NF requires it be a table"
+                    object_type.definitely_table
+                    next object_type
+                  end
+
+                  absorption_paths =
+                    (
+                      non_identifying_refs_from.reject do |ref|
+                        !ref.to or ref.to.absorbed_via == ref
+                      end+object_type.references_to
+                    ).reject do |ref|
+                      next true if !ref.to.is_table or !ref.is_one_to_one
+
+                      # Don't absorb an object along a non-mandatory role (otherwise if it doesn't play that role, it can't exist either)
+                      from_is_mandatory = !!ref.is_mandatory
+                      to_is_mandatory = !ref.to_role || !!ref.to_role.is_mandatory
+
+                      bad = !(ref.from == object_type ? from_is_mandatory : to_is_mandatory)
+                      trace :absorption, "Not absorbing #{object_type.name} through non-mandatory #{ref}" if bad
+                      bad
+                    end
+
+                  # If this object can be fully absorbed, do that (might require flipping some references)
+                  if absorption_paths.size > 0
+                    trace :absorption, "#{object_type.name} is fully absorbed through #{absorption_paths.inspect}"
+                    absorption_paths.each do |ref|
+                      trace :absorption, "Flipping #{ref} so #{object_type.name} can be absorbed"
+                      ref.flip if object_type == ref.from
+                    end
+                    object_type.definitely_not_table
+                    next object_type
+                  end
+
+                  if non_identifying_refs_from.size == 0
+		    # REVISIT: This allows absorption along a non-mandatory role of a objectified fact type
+		    # and object_type.references_to.all?{|ref| ref.is_mandatory }
+#                    and (!object_type.is_a?(EntityType) ||
+#                      # REVISIT: The roles may be collectively but not individually mandatory.
+#                      object_type.references_to.detect { |ref| !ref.from_role || ref.from_role.is_mandatory })
+                    trace :absorption, "#{object_type.name} is fully absorbed in #{object_type.references_to.size} places: #{object_type.references_to.map{|ref| ref.from.name}*", "}"
+                    object_type.definitely_not_table
+                    next object_type
+                  end
+
+                  false   # Failed to decide about this entity_type this time around
+                end
+              end
+
+            undecided -= finalised
+            trace :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_object_type.each do |object_type|
+            if (!object_type.is_table and object_type.references_to.size == 0 and object_type.references_from.size > 0)
+              if !object_type.references_from.detect{|r| !r.is_one_to_one || !r.to.is_table}
+                trace :absorption, "Flipping references from #{object_type.name}; they're all to tables"
+                object_type.references_from.map(&:flip)
+              else
+                trace :absorption, "Making #{object_type.name} a table; it has nowhere else to go and needs to absorb things"
+                object_type.probably_table
+              end
+            end
+          end
+
+          # Now, evaluate all possibilities of the tentative assignments
+          # Incomplete. Apparently unnecessary as well... so far. We'll see.
+          if trace :absorption
+            undecided.each do |object_type|
+              trace :absorption, "Unable to decide independence of #{object_type.name}, going with #{object_type.show_tabular}"
+            end
+          end
+        end
+
+        @tables =
+          all_object_type.
+          select { |f| f.is_table }.
+          sort_by { |table| table.name }
+      end
+    end
+
+  end
+end