activefacts-metamodel 1.9.0 → 1.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: afb3d3c2e330c364478dbfa0f3add48f91977a18
-  data.tar.gz: cae27ec48c4f46e2a0827bbddc20cc1560c997e9
+  metadata.gz: 239e2d9123f73a9176d115db67c86c68ed9a6567
+  data.tar.gz: 0fee1c5e78e43da17e3c72732efa7de2ac0d7c94
 SHA512:
-  metadata.gz: 4a4db7310d00e7fea438ab2edbfa536d5ff994ae736ef491ee58173a5affda389e28a0cad2a7ddfad81d4cd175df1c9078df7a35d01286bb02dbe80086764893
-  data.tar.gz: 79de78dfc8c6f0ec08c14a7a23940dc5dbc22e422b21614255472bae3449d49411c1d67c14b19cd0c161afc0bae72148c48d12abba990eb081dfbcd827ca1fee
+  metadata.gz: 1cf4a18f8354ea5d3f68535c8dc0150da9c82434da62d589a0968e131fcae45108a83ee3dfcfd3e2de05065c45f7045738e597f6a75762ecf859e9f3b977b37b
+  data.tar.gz: b7a96af8283b16f3253451b0db7630a13aa51a5a813e24ba97333baa6801a4296198ed5b085a655588335edb26e7a31c63a701880588936e5bc27fd14af2bfa1

data/Gemfile

@@ -2,8 +2,7 @@ source 'https://rubygems.org'
 
 gemspec
 
-if ENV['PWD'] =~ %r{\A#{ENV['HOME']}/work}
+if ENV['PWD'] =~ %r{\A#{ENV['HOME']}/work}i
   $stderr.puts "Using work area gems for #{File.basename(File.dirname(__FILE__))} from activefacts-metamodel"
-  gem 'activefacts-api', path: '/Users/cjh/work/activefacts/api'
-  # gem 'activefacts-api', git: 'git://github.com/cjheath/activefacts-api.git'
+  gem 'activefacts-api', path: '../api'
 end

data/Rakefile

@@ -23,13 +23,17 @@ task :bump do
   end
 end
 
-desc "Generate new CQL from the ORM file"
+desc "Generate new CQL from the ORM file (to verify version similarity)"
 task :cql do
+  # Note: Import from ORM is broken on the implicit derivations in constraints, and the result is unstable.
+  # This means that SOME PATCHES WILL FAIL
   system "afgen --cql orm/Metamodel.orm > Metamodel.cql"
-  system "afgen --cql cql/Metamodel.cql 2>/dev/null | diff -ub - Metamodel.cql | tee Metamodel.cql.diffs"
+  system "patch < orm/Metamodel.cql.diffs"
+  system "afgen --cql cql/Metamodel.cql 2>/dev/null >Metamodel.cql.cql"
+  system "diff -b -C 1 Metamodel.cql Metamodel.cql.cql | tee Metamodel.cql.diffs"
 end
 
-desc "Generate new Ruby from the ORM file"
+desc "Generate new Ruby from the CQL file"
 task :ruby do
   system %q{
     afgen --ruby cql/Metamodel.cql 2>/dev/null |

data/activefacts-metamodel.gemspec

@@ -24,6 +24,6 @@ This gem provides the core representations for the Fact Modeling tools of Active
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.3"
 
-  spec.add_runtime_dependency "activefacts-api", ">= 1.9", "~> 1.9.0"
-  spec.add_development_dependency "activefacts", "~> 1.8", "~> 1.8.0"
+  spec.add_runtime_dependency "activefacts-api", ">= 1.8", "~> 1"
+  spec.add_development_dependency "activefacts", "~> 1.8", "~> 1"
 end

data/cql/Metamodel.cql

@@ -54,18 +54,6 @@ Coefficient is identified by Numerator and Denominator and Coefficient is precis
 	Coefficient has one Denominator,
 	Coefficient is precise;
 
-Component is identified by Guid where
-	Component has one Guid,
-	Guid is of at most one Component;
-Component projects at most one Name;
-Component has at most one Ordinal rank;
-
-Composition is identified by Guid where
-	Composition has one Guid,
-	Guid is of at most one Composition;
-Composition is called one Name,
-	Name is of at most one Composition;
-
 Concept is identified by Guid where
 	Concept has one Guid,
 	Guid is of at most one Concept;
@@ -88,8 +76,6 @@ Context Note has one Discussion,
 Context Note applies to at most one relevant-Concept,
 	Concept has Context Note;
 
-Discriminator is a kind of Component;
-
 Enforcement is identified by Constraint where
 	Constraint requires at most one Enforcement,
 	Enforcement applies to one Constraint;
@@ -107,8 +93,6 @@ Fact is of one Fact Type;
 Implication Rule is identified by its Name;
 Concept is implied by at most one Implication Rule;
 
-Indicator is a kind of Component;
-
 Instance is identified by Concept where
 	Instance is an instance of one Concept;
 Instance objectifies at most one Fact,
@@ -120,10 +104,6 @@ Location is identified by X and Y where
 	Location is at one X,
 	Location is at one Y;
 
-Mapping is a kind of Component;
-Mapping (as Parent) contains Component (as Member) [acyclic, stronglyintransitive],
-	Member belongs to at most one Parent;
-
 Presence Constraint is a kind of Constraint;
 Presence Constraint has at most one max-Frequency restricted to {1..};
 Presence Constraint has at most one min-Frequency restricted to {2..};
@@ -149,7 +129,7 @@ Role is identified by Fact Type and Ordinal where
 	Fact Type contains Role,
 	Role fills one Ordinal,
 	Ordinal applies to Role;
-Indicator indicates one Role played;
+
 Link Fact Type has one implying-Role,
 	implying-Role implies at most one Link Fact Type;
 Ring Constraint has at most one other-Role,
@@ -176,8 +156,6 @@ Role Value is identified by Fact and Role where
 Instance plays Role Value,
 	Role Value is of one Instance;
 
-Scoping is a kind of Mapping;
-
 Set Constraint is a kind of Constraint;
 
 Shape is identified by Guid where
@@ -253,12 +231,6 @@ Vocabulary contains Constraint,
 Vocabulary includes Unit,
 	Unit is in one Vocabulary;
 
-Absorption is a kind of Mapping;
-Absorption traverses to one child-Role;
-Absorption traverses from one parent-Role;
-Absorption is matched by at most one reverse-Absorption;
-Absorption flattens;
-
 Aggregation is where
 	Variable is bound to Aggregate over aggregated-Variable,
 	Aggregate of aggregated-Variable is bound as one Variable;
@@ -274,12 +246,6 @@ Bound is identified by Value and Bound is inclusive where
 	Value is of at least one Bound,
 	Bound is inclusive;
 
-Composite is identified by Mapping where
-	Mapping projects at most one Composite,
-	Composite consists of one Mapping;
-Composition contains Composite,
-	Composite belongs to one Composition;
-
 Constraint Shape is a kind of Shape;
 Constraint Shape is for one Constraint;
 
@@ -302,19 +268,12 @@ Diagram is identified by Vocabulary and Name where
 	Diagram is called one Name,
 	Name is of Diagram;
 
-Discriminated Role is where
-	Discriminator distinguishes Role using one Value,
-	Role is indicated by Value for Discriminator;
-
 Fact Type Shape is a kind of Shape;
 Fact Type Shape has at most one Display Role Names Setting;
 Fact Type Shape is for one Fact Type,
 	Fact Type has Fact Type Shape;
 Fact Type Shape has at most one Rotation Setting;
 
-Injection is a kind of Mapping;
-ValueField is a kind of Injection;
-
 Mirror Role is a kind of Role;
 Mirror Role is for at most one Role (as Base Role),
 	Base Role implies at most one Mirror Role;
@@ -322,16 +281,6 @@ Mirror Role is for at most one Role (as Base Role),
 Model Note Shape is a kind of Shape;
 Model Note Shape is for one Context Note;
 
-Nesting is where
-	Absorption is nested under index-Role in Ordinal position,
-	Absorption in Ordinal position is nested under one Role,
-	Role keys nesting of Absorption at Ordinal priority;
-Absorption uses at most one Nesting Mode;
-Nesting has at most one key-Name;
-Absorption is nested under index Role in Ordinal position
-	if and only if
-	that Absorption uses some Nesting Mode;
-
 ORM Diagram is a kind of Diagram;
 Shape is in one ORM Diagram,
 	ORM Diagram includes Shape;
@@ -340,7 +289,6 @@ Object Type is identified by Vocabulary and Name where
 	Object Type belongs to one Vocabulary,
 	Object Type is called one Name;
 Instance is of one Object Type;
-Mapping represents one Object Type;
 Object Type is an instance of one Concept;
 Object Type uses at most one Pronoun;
 Object Type plays Role,
@@ -457,15 +405,125 @@ Value Type is subtype of at most one super-Value Type (as Supertype) [acyclic, t
 	Supertype is supertype of Value Type;
 
 Value Type Parameter is where
-	Value Type has facet called Name,
-	Name is a facet of Value Type;
-Value Type Parameter requires value of one facet-Value Type;
+	Value Type has parameter called Name,
+	Name identifies parameter of Value Type;
+Value Type Parameter requires value of one parameter-Value Type;
 
 Value Type Parameter Restriction is where
 	Value Type receives Value Type Parameter,
 	Value Type Parameter applies to Value Type;
 Value Type Parameter Restriction has one Value;
 
+/* Compositions */
+Composition is identified by Guid where
+	Composition has one Guid,
+	Guid is of at most one Composition;
+Composition is called one Name,
+	Name is of at most one Composition;
+
+Component is identified by Guid where
+	Component has one Guid,
+	Guid is of at most one Component;
+Component projects at most one Name;
+Component has at most one Ordinal rank;
+
+Indicator is a kind of Component;
+Indicator indicates one Role played;
+
+Discriminator is a kind of Component;
+Discriminated Role is where
+	Discriminator distinguishes Role using one Value,
+	Role is indicated by Value for Discriminator;
+
+Mapping is a kind of Component;
+Mapping represents one Object Type;
+Component (as Member) belongs to at most one Mapping (as Parent),
+	Parent contains Member [acyclic, stronglyintransitive];
+
+Composite is identified by Mapping where
+	Mapping projects at most one Composite,
+	Composite consists of one Mapping;
+Composition contains Composite,
+	Composite belongs to one Composition;
+
+Scoping is a kind of Mapping;
+Injection is a kind of Mapping;
+Value Field is a kind of Injection;
+Surrogate Key is a kind of Injection;
+
+Absorption is a kind of Mapping;
+Absorption traverses to one child-Role;
+Absorption traverses from one parent-Role;
+forward-Absorption is matched by at most one reverse-Absorption,
+	reverse-Absorption is reverse of at most one forward-Absorption;
+Absorption flattens;
+
+some Absorption traverses from some parent- Role(1) and that Role(1) is played by some Object Type
+	only if that Absorption is a kind of Mapping(1) that contains some Component that is a Mapping(2) that represents that Object Type;
+some Absorption traverses to some child- Role(1) and that Role(1) is played by some Object Type
+	only if that Absorption is a kind of Mapping that represents that Object Type;
+
+Full Absorption is where
+	Composition fully absorbs Object Type;
+Full Absorption applies to one Absorption,
+	Absorption creates at most one Full Absorption;
+/*
+some Object Type is involved in some Full Absorption that applies to some Absorption that is a kind of Mapping
+	if and only if
+	that Mapping represents that Object Type;
+*/
+
+/* Access Paths */
+Access Path is identified by Guid where
+	Access Path has one Guid,
+	Guid is of at most one Access Path;
+Access Path is called at most one Name;
+Access Path is to one Composite,
+	Composite is reached through Access Path;
+
+/* Indices */
+Index is a kind of Access Path;
+Index is unique;
+Index derives from one Presence Constraint;
+Composite has at most one primary-Index,
+	Index is primary for at most one Composite;
+Index is primary for Composite
+	only if Index is unique;
+identified Composite has primary Access Path
+	only if Composite is reached through Access Path;
+
+Index Field is where
+	Access Path for Ordinal field uses one Component,
+	Component provides Ordinal field for Access Path;
+Index Field is discriminated by at most one Value;
+each Access Path occurs at least one time in
+	Access Path for Ordinal field uses Component;
+
+/* Foreign keys */
+Foreign Key is a kind of Access Path;
+either Access Path is an Index or Access Path is a Foreign Key but not both;
+Foreign Key traverses from one source-Composite,
+	Composite contains Foreign Key;
+Foreign Key derives from one Absorption;
+
+Foreign Key Field is where
+	Foreign Key for Ordinal field uses one Component,
+	Component provides Ordinal field for Foreign Key;
+each Foreign Key occurs at least one time in
+	Foreign Key for Ordinal field uses Component;
+Foreign Key Field is discriminated by at most one Value;
+
+/* Nesting is a non-first-normal form used for SQL ARRAY and Map (hstore) fields */
+Nesting is where
+	Absorption is nested under index-Role in Ordinal position,
+	Absorption in Ordinal position is nested under one Role,
+	Role keys nesting of Absorption at Ordinal priority;
+Absorption uses at most one Nesting Mode;
+Nesting has at most one key-Name;
+Absorption is nested under index Role in Ordinal position
+	if and only if
+	that Absorption uses some Nesting Mode;
+
 /*
  * Constraints:
  */
@@ -548,8 +606,6 @@ Value Type has Scale
 	only if Value Type has Length;
 Variable matches nesting over Step
 	only if Variable is for Object Type and Step specifies Fact Type;
-each Absorption(1) occurs at most one time in
-	Absorption(2) is matched by reverse Absorption(1);
 either Agreement was reached by Agent or Agreement was on Date;
 // either Component projects Name or Component is some Absorption that flattens;
 each Concept occurs at most one time in

data/lib/activefacts/metamodel/extensions.rb

@@ -303,14 +303,20 @@ module ActiveFacts
           rs = rr.role_sequence
           rs.all_role_ref.size == 1 and
             rs.all_presence_constraint.detect do |pc|
-              pc.max_frequency == 1 and !pc.enforcement   # Alethic uniqueness constraint
+              return pc if pc.max_frequency == 1 and !pc.enforcement   # Alethic uniqueness constraint
             end
         }
+	nil
+      end
+
+      def is_identifying
+	uc = uniqueness_constraint and uc.is_preferred_identifier
       end
 
       # Is there are internal uniqueness constraint on this role only?
       def is_unique
-	return true if fact_type.is_a?(LinkFactType) # Handle objectification roles
+	return true if fact_type.is_a?(LinkFactType) or		# Handle objectification roles
+	  fact_type.all_role.size == 1				# and unary roles
 
 	uniqueness_constraint ? true : false
       end
@@ -350,58 +356,8 @@ module ActiveFacts
 	when 2
 	  (fact_type.all_role.to_a-[self])[0]
 	else
-	  raise "counterpart roles are undefined in n-ary fact types"
-	end
-      end
-
-      def role_type
-	raise "Incorrectly implemented"
-	if fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
-	  return object_type == fact_type.supertype ? :supertype : :subtype
+	  nil # raise "counterpart roles are undefined in n-ary fact types"
 	end
-
-	if fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType)
-	  # Prevent an unnecessary from-1 search:
-	  from_1 = true
-	  # Change the to_1 search to detect a one-to-one:
-	  return fact_type.implying_role.role_type
-	elsif fact_type.all_role.size == 1
-	  return :unary
-	end
-
-	# 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
-
-	# It's to-1 if a UC exists over exactly this role:
-        to_1 =
-          all_uniqueness_constraints.
-            detect do |c|
-                (rr = c.role_sequence.all_role_ref.single) and
-                rr.role == role
-            end 
-
-        if from_1 || fact_type.entity_type
-          # This is a role in an objectified fact type
-          from_1 = true
-        else
-          # It's from-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 == role || 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
 
@@ -494,6 +450,10 @@ module ActiveFacts
       def is_separate
 	is_independent or concept.all_concept_annotation.detect{|ca| ca.mapping_annotation == 'separate'}
       end
+
+      def all_role_transitive
+	supertypes_transitive.flat_map(&:all_role)
+      end
     end
 
     class ValueType
@@ -501,9 +461,10 @@ module ActiveFacts
         [self] + (supertype ? supertype.supertypes_transitive : [])
       end
 
-      def subtypes
+      def all_subtype
         all_value_type_as_supertype
       end
+      alias_method :subtypes, :all_subtype    # REVISIT: Delete legacy name
 
       def subtypes_transitive
         [self] + subtypes.map{|st| st.subtypes_transitive}.flatten
@@ -516,14 +477,14 @@ module ActiveFacts
         nil
       end
 
-      # Is this ValueType auto-assigned either at assert or on first save to the database?
+      # Is this ValueType auto-assigned? Returns either 'assert', 'commit', otherwise nil.
       def is_auto_assigned
         type = self
         while type
-          return true if type.name =~ /^Auto/ || type.transaction_phase
+          return type.transaction_phase || 'commit' if type.name =~ /^Auto/ || type.transaction_phase
           type = type.supertype
         end
-        false
+        nil
       end
     end
 
@@ -534,11 +495,7 @@ module ActiveFacts
       end
 
       def assimilation
-        if rr = identification_is_inherited
-          rr.role.fact_type.assimilation
-        else
-          nil
-        end
+	ti = identifying_type_inheritance and ti.assimilation
       end
 
       def is_separate
@@ -548,6 +505,11 @@ module ActiveFacts
       def preferred_identifier
         return @preferred_identifier if @preferred_identifier
         if fact_type
+	  # Objectified unaries are identified by the ID of the object that plays the role:
+	  if fact_type.all_role.size == 1
+	    return @preferred_identifier = fact_type.all_role.single.object_type.preferred_identifier
+	  end
+
           # When compiling a fact instance, the delayed creation of a preferred identifier might be necessary
           if c = fact_type.check_and_add_spanning_uniqueness_constraint
             fact_type.check_and_add_spanning_uniqueness_constraint = nil
@@ -606,7 +568,8 @@ module ActiveFacts
                   next unless role.is_unique || fact_type
                   ftroles = Array(role.fact_type.all_role)
 
-                  # Skip roles in ternary and higher fact types, they're objectified, and in unaries, they can't identify us.
+                  # Skip roles in ternary and higher fact types, they're objectified
+		  # REVISIT: This next line prevents a unary being used as a preferred_identifier:
                   next if ftroles.size != 2
 
                   trace :pi, "Considering role in #{role.fact_type.describe(role)}"
@@ -691,8 +654,8 @@ module ActiveFacts
                 pi = possible_pi
               end
             else
-              debugger
               trace :pi, "No PI found for #{name}"
+              debugger if respond_to?(:debugger)
             end
           end
           raise "No PI found for #{name}" unless pi
@@ -724,13 +687,18 @@ module ActiveFacts
           }
       end
 
-      # An array all direct supertypes
+      # An array of all direct supertypes
       def supertypes
         all_supertype_inheritance.map{|ti|
             ti.supertype
           }
       end
 
+      # An array of all direct subtypes
+      def all_subtype
+        all_type_inheritance_as_supertype.map(&:subtype)
+      end
+
       # An array of self followed by all supertypes in order:
       def supertypes_transitive
         ([self] + all_type_inheritance_as_subtype.map{|ti|
@@ -738,21 +706,19 @@ module ActiveFacts
           }).flatten.uniq
       end
 
+      def identifying_type_inheritance
+        all_type_inheritance_as_subtype.detect do |ti|
+	  ti.provides_identification
+	end
+      end
+
       # A subtype does not have a identifying_supertype if it defines its own identifier
       def identifying_supertype
-        trace "Looking for identifying_supertype of #{name}"
-        all_type_inheritance_as_subtype.detect{|ti|
-            trace "considering supertype #{ti.supertype.name}"
-            next unless ti.provides_identification
-            trace "found identifying supertype of #{name}, it's #{ti.supertype.name}"
-            return ti.supertype
-          }
-        trace "Failed to find identifying supertype of #{name}"
-        return nil
+	ti = identifying_type_inheritance and ti.supertype
       end
 
       def common_supertype(other)
-        return nil unless other.is_?(ActiveFacts::Metamodel::EntityType)
+        return nil unless other.is_a?(ActiveFacts::Metamodel::EntityType)
         candidates = supertypes_transitive & other.supertypes_transitive
         return candidates[0] if candidates.size <= 1
         candidates[0] # REVISIT: This might not be the closest supertype
@@ -1039,6 +1005,10 @@ module ActiveFacts
         max = max_frequency
         'PresenceConstraint over '+role_sequence.describe + " occurs " + frequency + " time#{(min&&min>1)||(max&&max>1) ? 's' : ''}"
       end
+
+      def covers_role role
+	role_sequence.all_role_ref.map(&:role).include?(role)
+      end
     end
 
     class SubsetConstraint
@@ -1463,6 +1433,112 @@ module ActiveFacts
       end
     end
 
+    class Composite
+      def inspect
+	"Composite #{mapping.inspect}"
+      end
+
+      def show_trace
+	trace :composition, inspect do
+	  trace :composition?, "Columns" do
+	    mapping.show_trace
+	  end
+
+	  indices =
+	    all_access_path.
+	    select{|ap| ap.is_a?(Index)}.
+	    sort_by{|ap| [ap.composite_as_primary_index ? 0 : 1] + Array(ap.name)+ap.all_index_field.map(&:inspect) }  # REVISIT: Fix hack for stable ordering
+	  unless indices.empty?
+	    trace :composition, "Indices" do
+	      indices.each do |ap|
+		ap.show_trace
+	      end
+	    end
+	  end
+
+	  inbound = all_access_path.
+	    select{|ap| ap.is_a?(ForeignKey)}.
+	    sort_by{|fk| [fk.source_composite.mapping.name, fk.absorption.inspect]+fk.all_foreign_key_field.map(&:inspect)+fk.all_index_field.map(&:inspect) }
+	  unless inbound.empty?
+	    trace :composition, "Foreign keys inbound" do
+	      inbound.each do |fk|
+		fk.show_trace
+	      end
+	    end
+	  end
+
+	  outbound =
+	    all_foreign_key_as_source_composite.
+	    sort_by{|fk| [fk.source_composite.mapping.name, fk.absorption.inspect]+fk.all_index_field.map(&:inspect)+fk.all_foreign_key_field.map(&:inspect) }
+	  unless outbound.empty?
+	    trace :composition, "Foreign keys outbound" do
+	      outbound.each do |fk|
+		fk.show_trace
+	      end
+	    end
+	  end
+	end
+      end
+    end
+
+    class AccessPath
+      def show_trace
+	trace :composition, inspect do
+	  if is_a?(ForeignKey)
+	    # First list any fields in a foreign key
+	    all_foreign_key_field.sort_by(&:ordinal).each do |fk|
+	      raise "Internal error: Foreign key not in foreign table!" if fk.component.root != source_composite
+	      trace :composition, fk.inspect
+	    end
+	  end
+	  # Now list the fields in the primary key
+	  all_index_field.sort_by(&:ordinal).each do |ak|
+	    trace :composition, ak.inspect
+	  end
+	end
+      end
+    end
+
+    class Index
+      def inspect
+	case
+	when !is_unique
+	  'Non-unique index'
+	when composite_as_primary_index
+	  'Primary index'
+	else
+	  'Unique index'
+	end +
+	(name ? " #{name.inspect}" : '') +
+	" to #{composite.mapping.name}" +
+	(presence_constraint ? " over #{presence_constraint.describe}" : '')
+      end
+    end
+
+    class ForeignKey
+      def inspect
+	"Foreign Key" +
+	(name ? " #{name.inspect}" : '') +
+	" from #{source_composite.mapping.name} to #{composite.mapping.name}" +
+	(absorption ? " over #{absorption.inspect}" : '')
+      end
+    end
+
+    class IndexField
+      def inspect
+	"IndexField part #{ordinal} in #{component.root.mapping.name} references #{component.inspect}" +
+	(value ? " discriminated by #{value.inspect}" : '')
+      end
+    end
+
+    class ForeignKeyField
+      def inspect
+	operation = value ? "filters by value #{value} of" : "is"
+	"ForeignKeyField part #{ordinal} in #{component.root.mapping.name} #{operation} #{component.inspect}" +
+	(value ? " discriminated by #{value.inspect}" : '')
+      end
+    end
+
     class Mapping
       def inspect
 	"#{self.class.basename} (#{rank_kind})#{parent ? " in #{parent.name}" :''} of #{name && name != '' ? name : '<anonymous>'}"
@@ -1479,6 +1555,7 @@ module ActiveFacts
 
       # Recompute a contiguous member ranking fron zero, based on current membership:
       def re_rank
+        all_member.each(&:uncache_rank_key)
         next_rank = 0
         all_member.
 	sort_by(&:rank_key).
@@ -1488,6 +1565,9 @@ module ActiveFacts
         end
       end
 
+      def root
+	composite || parent && parent.root
+      end
     end
 
     class Nesting
@@ -1504,7 +1584,16 @@ module ActiveFacts
       end
 
       def inspect
-	"#{super} in #{inspect_reading}#{absorption ? ' (forward)' : (reverse_absorption ? ' (reverse)' : '')}"
+	"#{super}#{full_absorption ? ' (full)' : ''
+	} in #{inspect_reading}#{
+	  # If we have a related forward absorption, we're by definition a reverse absorption
+	  if forward_absorption
+	    ' (reverse)'
+	   else
+	      # If we have a related reverse absorption, we're by definition a forward absorption
+	      reverse_absorption ? ' (forward)' : ''
+	  end
+	}"
       end
 
       def show_trace
@@ -1555,7 +1644,9 @@ module ActiveFacts
 	  return cvt if pvt != cvt
 
 	  if !pvt
-	    # REVISIT: Force the decision if one EntityType identifies another
+	    # Force the decision if one EntityType identifies another
+	    return true if child_role.base_role.is_identifying  # Parent is identified by child role, correct
+	    return false if parent_role.base_role.is_identifying # Child is identified by parent role, incorrect
 	  end
 
 	  # Primary absorption absorbs the object playing the mandatory role into the non-mandatory:
@@ -1580,14 +1671,15 @@ module ActiveFacts
       end
 
       def flip!
-	if (other = absorption)
+	raise "REVISIT: Need to flip FullAbsorption on #{inspect}" if full_absorption or reverse_absorption && reverse_absorption.full_absorption or forward_absorption && forward_absorption.full_absorption
+	if (other = forward_absorption)
 	  # We point at them - make them point at us instead
-	  self.absorption = nil
+	  self.forward_absorption = nil
 	  self.reverse_absorption = other
 	elsif (other = reverse_absorption)
 	  # They point at us - make us point at them instead
 	  self.reverse_absorption = nil
-	  self.absorption = other
+	  self.forward_absorption = other
 	else
 	  raise "Absorption cannot be flipped as it has no reverse"
 	end
@@ -1595,6 +1687,12 @@ module ActiveFacts
 
     end
 
+    class FullAbsorption
+      def inspect
+	"Full #{absorption.inspect}"
+      end
+    end
+
     class Indicator
       def inspect
 	"#{self.class.basename} #{role.fact_type.default_reading.inspect}"
@@ -1628,22 +1726,34 @@ module ActiveFacts
     class Component
       # The ranking key of a component indicates its importance to its parent:
       # Ranking assigns a total order, but is computed in groups:
-      RANK_SUPER = 0		# Supertypes, with the identifying supertype first, others alphabetical
-      RANK_IDENT = 1		# Identifying components (absorptions, indicator), in order of the identifier
-      RANK_VALUE = 2		# A ValueField
-      RANK_INJECTION = 3	# Injections, in alphabetical order
-      RANK_DISCRIMINATOR = 4	# Discriminator components, in alphabetical order
-      RANK_FOREIGN = 5		# REVISIT: Foreign key components
-      RANK_INDICATOR = 6	# Indicators in alphabetical order
-      RANK_MANDATORY = 7	# Absorption: unique mandatory
-      RANK_NON_MANDATORY = 8	# Absorption: unique optional
-      RANK_MULTIPLE = 9		# Absorption: manifold
-      RANK_SUBTYPE = 10		# Subtypes in alphabetical order
-      RANK_SCOPING = 11		# Scoping in alphabetical order
+      RANK_SURROGATE = 0
+      RANK_SUPER = 1		# Supertypes, with the identifying supertype first, others alphabetical
+      RANK_IDENT = 2		# Identifying components (absorptions, indicator), in order of the identifier
+      RANK_VALUE = 3		# A ValueField
+      RANK_INJECTION = 4	# Injections, in alphabetical order
+      RANK_DISCRIMINATOR = 5	# Discriminator components, in alphabetical order
+      RANK_FOREIGN = 6		# REVISIT: Foreign key components
+      RANK_INDICATOR = 7	# Indicators in alphabetical order
+      RANK_MANDATORY = 8	# Absorption: unique mandatory
+      RANK_NON_MANDATORY = 9	# Absorption: unique optional
+      RANK_MULTIPLE = 10	# Absorption: manifold
+      RANK_SUBTYPE = 11		# Subtypes in alphabetical order
+      RANK_SCOPING = 12		# Scoping in alphabetical order
+
+      def uncache_rank_key
+	@rank_key = nil
+      end
 
       def rank_key
 	@rank_key ||=
 	  case self
+	  when SurrogateKey
+	    if !parent.parent
+	      [RANK_SURROGATE]	# an injected PK
+	    else
+	      [RANK_MANDATORY, name]	# an FK
+	    end
+
 	  when Indicator
 	    if (p = parent_entity_type) and (position = p.rank_in_preferred_identifier(role.base_role))
 	      [RANK_IDENT, position]     # An identifying unary
@@ -1690,6 +1800,15 @@ module ActiveFacts
 	  end
       end
 
+      def primary_index_components
+	root and
+	ix = root.primary_index and				# Primary index has been decided
+	root.primary_index.all_index_field.size > 0 and		# has been populated and
+	ix = root.primary_index and
+	ixfs = ix.all_index_field.sort_by(&:ordinal) and
+	ixfs.map(&:component)
+      end
+
       def parent_entity_type
 	parent &&
 	  parent.object_type.is_a?(EntityType) &&
@@ -1699,6 +1818,7 @@ module ActiveFacts
       def rank_kind
 	return "top" unless parent  # E.g. a Mapping that is a Composite
 	case rank_key[0]
+	when RANK_SURROGATE;	"surrogate"
 	when RANK_SUPER;	"supertype"
 	when RANK_IDENT;	"existential"
 	when RANK_VALUE;	"self-value"
@@ -1714,6 +1834,14 @@ module ActiveFacts
 	end
       end
 
+      def root
+	parent.root
+      end
+
+      def depth
+	parent ? 1+parent.depth : 0
+      end
+
       def inspect
 	"#{self.class.basename}"
       end