activefacts 1.6.0 → 1.7.1

data/lib/activefacts/persistence/reference.rb

@@ -1,434 +0,0 @@
-#
-#       ActiveFacts Relational mapping and persistence.
-#       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 Persistence
-
-    # 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::Persistence::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::Persistence::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::Persistence::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::Persistence::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::Persistence::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::Persistence::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|
-              next unless object_type.references_from.size > 0
-              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/persistence/tables.rb

@@ -1,380 +0,0 @@
-#
-#       ActiveFacts Relational mapping and persistence.
-#       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/persistence/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