activefacts-metamodel 1.9.20 → 1.9.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 71dd29d7debbe4133a9425b5582555e6b881b0d5
-  data.tar.gz: ec5e5d777449f81589ffe5f1210680ff44466a32
+  metadata.gz: 8f78f93ff86302b754f0170041f1e5118a08dbbe
+  data.tar.gz: d6ade4f75f9960d866088c9c0fc8d6def107bd4e
 SHA512:
-  metadata.gz: 4914c1693e41cc07db38f6c6b343783e8c60dc684ece547fe72163d107d5bf47bff0764dd89aea6335544db3e99736d52dc08ae683c35debb15bfa57208582e3
-  data.tar.gz: 4fe9146122f4b9ba8067a19f95e71ba06fcbfdceb6cfa86ac897ccbc82738585a97073683a67f7279c4ba96b4b77f70f741fc806fb821fd16d6a461be1d597ba
+  metadata.gz: 423622558e664532cff04bc8fa9f8ef418e7f0d437894336d6715063744980110c87df94b4308a8aac0908f6c69995d249f970f14c460aaa75722348a18def1a
+  data.tar.gz: 837e537f5da6ca45fb8b5590222844e75124a1a80533173773ac3ea7ae05027de4e7b4c193a4a36be4d4f0e08907d445a0a4053f5efae20b88c491b0a25a1933

data/.gitignore

@@ -14,3 +14,4 @@ bin
 *.orig
 *.diff
 Metamodel.old.cql
+.byebug_history

data/cql/Metamodel.cql

@@ -28,6 +28,7 @@ Offset is written as Decimal;
 Ordinal is written as Unsigned Integer(16);
 Pronoun is written as String(20) restricted to {'feminine', 'masculine', 'neuter', 'personal'};
 Regular Expression is written as String;
+Restriction Style is written as String restricted to {'ascending', 'descending', 'fixed'};
 Ring Type is written as String;
 Rotation Setting is written as String restricted to {'left', 'right'};
 Scale is written as Unsigned Integer(32);
@@ -362,12 +363,12 @@ Value Type is subtype of at most one super-Value Type (as Supertype) [acyclic, t
 Value Type Parameter is where
 	Value Type has parameter called Name,
 	Name identifies parameter of Value Type;
+Value Type Parameter has at most one Restriction Style;
 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;
+	Value Type allows Value Type Parameter to have Value Range;
+
 
 /*
  * Compositions
@@ -387,6 +388,7 @@ Component (as Member) belongs to at most one Component (as Parent) [acyclic, str
 Component projects at most one Name;
 Component has at most one Ordinal rank;
 Component has absolute name;
+Component has at most one injection-Annotation;
 
 Indicator is a kind of Component;
 Indicator indicates one Role played;
@@ -398,9 +400,20 @@ Discriminated Role is where
 	Discriminator distinguishes Role using one Value,
 	Role is indicated by Value for Discriminator;
 
+Injection is a kind of Component;
+Surrogate Key is a kind of Injection;
+Computed Value is a kind of Injection;
+Hash Value is a kind of Computed Value;
+Component Hash is where
+	Hash Value covers at least one Component;
+either Injection is a Surrogate Key
+	or Injection is a Computed Value but not both;
+
 Mapping is a kind of Component;
 Mapping represents one Object Type;
 Mapping uses at most one native- type Name;
+forward-Mapping is matched by at most one reverse-Mapping,
+	reverse-Mapping is reverse of at most one forward-Mapping;
 
 Composite is identified by Mapping where
 	Mapping projects at most one Composite,
@@ -411,14 +424,9 @@ Composition contains Composite,
 each Composite Group is identified by Name;
 Composite belongs to at most one Composite Group;
 
-Temporal Mapping is a kind of Mapping;
-Temporal Mapping records time using one Value Type;
-
 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
@@ -429,8 +437,8 @@ some Absorption traverses to some child- Role(1) and that Role(1) is played by s
 
 Full Absorption is where
 	Composition fully absorbs Object Type;
-Full Absorption applies to one Absorption,
-	Absorption creates at most one Full Absorption;
+Full Absorption applies to one Mapping,
+	Mapping 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
@@ -453,10 +461,8 @@ Spanning Constraint is where
 	Constraint spans Composite;
 
 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;
-Valid From is a kind of Injection;
+Value Field is a kind of Mapping;
+Valid From is a kind of Mapping;
 
 /* Access Paths */
 Access Path is identified by Guid where
@@ -469,7 +475,7 @@ Access Path is to one Composite,
 /* Indices */
 Index is a kind of Access Path;
 Index is unique;
-Index derives from one Presence Constraint;
+Index derives from at most one Presence Constraint;
 Composite has at most one natural-Index,
 	Index is natural for at most one Composite;
 Composite has primary-Index;  // Avoid ambiguity; this is a new fact type
@@ -493,8 +499,8 @@ 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,
-        Absorption gives rise to at most one Foreign Key;
+Foreign Key derives from at most one Mapping,
+        Mapping gives rise to at most one Foreign Key;
 
 Foreign Key Field is where
 	Foreign Key for Ordinal field uses one Component,
@@ -660,7 +666,8 @@ either Component(1) belongs to Component(2) or Component(1) is a Mapping that pr
 for each Component exactly one of these holds:
 	Component is a Mapping,
 	Component is an Indicator,
-	Component is a Discriminator;
+	Component is a Discriminator,
+	Component is an Injection;
 for each Concept exactly one of these holds:
 	Object Type is an instance of Concept,
 	Fact Type is an instance of Concept,
@@ -678,11 +685,6 @@ for each Constraint exactly one of these holds:
 	Constraint is a Ring Constraint,
 	Constraint is a Value Constraint;
 either Domain Object Type is a Value Type or Domain Object Type is an Entity Type but not both;
-for each Mapping exactly one of these holds:
-	Mapping is an Absorption,
-	Mapping is an Injection,
-	Mapping is a Scoping,
-	Mapping projects Composite;
 for each Role Sequence exactly one of these holds:
 	Role Sequence is for Reading,
 	Presence Constraint covers Role Sequence,

data/lib/activefacts/metamodel/datatypes.rb

@@ -25,7 +25,7 @@ module ActiveFacts
         TYPE_Boolean =>
           %w{ bit },
         TYPE_Integer =>
-          %w{ auto_counter int tiny_int small_int big_int unsigned unsigned_int unsigned_integer signed_int signed_integer},
+          %w{ auto_counter int tiny_int small_int big_int long_integer unsigned unsigned_int unsigned_integer signed_int signed_integer},
         TYPE_Real =>
           %w{ float double },
         TYPE_Decimal =>
@@ -47,7 +47,7 @@ module ActiveFacts
         TYPE_Timestamp =>
           %w{ time_stamp auto_time_stamp },
         TYPE_Binary =>
-          %w{ guid picture_raw_data variable_length_raw_data },
+          %w{ binary blob guid picture_raw_data variable_length_raw_data },
       }
       TypeParameters = {
         TYPE_Integer => [:length],            # Length is the number of bits
@@ -63,13 +63,17 @@ module ActiveFacts
       # A DataType Context class should refine this class.
       # The default context might work for you.
       class Context
+        def initialize options = {}
+          raise "Unused options in DataType::Context: #{options.inspect}" unless options.empty?
+        end
+
         def integer_ranges
         end
 
         def default_length data_type, type_name
         end
 
-        def choose_integer_type min, max
+        def choose_integer_range min, max
           integer_ranges.
             select{|type_name, vmin, vmax| min >= vmin && max <= vmax}.
             sort_by{|type_name, vmin, vmax| vmax-vmin}[0]   # Choose the smallest range
@@ -103,7 +107,7 @@ module ActiveFacts
             when /([a-z ]|\b)Small([a-z ]|\b)/i,
               /([a-z ]|\b)Short([a-z ]|\b)/i
               16
-            when /([a-z ]|\b)Big([a-z ]|\b)/i
+            when /([a-z ]|\b)(Big|Long)([a-z ]|\b)/i
               64
             else
               32
@@ -122,12 +126,13 @@ module ActiveFacts
         end
       end
 
-      def self.normalise type_name
+      def self.intrinsic_type type_name
         data_type, = type_mapping.detect{|t, names| names.detect{|n| n === type_name}}
         data_type
       end
 
-      def self.normalise_int_length type_name, length = nil, value_constraint = nil, context = DefaultContext.new
+      # Integers are available in multiple sizes. Choose the most appropriate one.
+      def self.choose_integer type_name, length = nil, value_constraint = nil, context = DefaultContext.new
         int_length = length || context.default_length(TYPE_Integer, type_name)
         if int_length
           if value_constraint
@@ -145,14 +150,18 @@ module ActiveFacts
           int_max = unsigned ? 2**(int_length-1) - 1 : 2**(int_length-1)-1
           max = int_max if !max || length && int_max < max
         end
-        best = context.choose_integer_type(min, max)
+        best = context.choose_integer_range(min, max)
         unless best || length
           # Use the largest available integer size
           best = context.integer_ranges.last
         end
 
         # Use a context-defined integer size if one suits, otherwise the requested size:
-        best && [best[0], best[3]] || [ 'int', length ]
+        if best
+          best[0]
+        else
+          nil   # No integer seems suitable
+        end
       end
 
     private
@@ -180,6 +189,11 @@ module ActiveFacts
         primary_index.all_index_field.detect{|ixf| ixf.component == self}
       end
 
+      def in_natural_index
+        natural_index = root.natural_index and
+        natural_index.all_index_field.detect{|ixf| ixf.component == self}
+      end
+
       def in_foreign_key
         all_foreign_key_field.detect{|fkf| fkf.foreign_key.source_composite == root}
       end
@@ -190,17 +204,15 @@ module ActiveFacts
           context.boolean_type
 
         when SurrogateKey
-          [ context.surrogate_type,
-            {
-              auto_assign: ((in_primary_index && !in_foreign_key) ? "commit" : nil),
-              mandatory: path_mandatory
-            }
-          ]
-
-        when ValidFrom
-          object_type.name
+          type_name, options = *context.surrogate_type
+          options ||= {}
+          # Flag but disable auto-assignment for a surrogate that's an FK (assigned elsewhere)
+          options[:auto_assign] ||= 'commit'
+          options[:auto_assign] = nil if in_foreign_key
+          options[:mandatory] = path_mandatory
+          [ type_name, options ]
 
-        when ValueField, Absorption
+        when ValidFrom, ValueField, Mapping
           # Walk up the entity type identifiers (must be single-part) to a value type:
           vt = self.object_type
           while vt.is_a?(EntityType)
@@ -248,8 +260,6 @@ module ActiveFacts
             merge!(value_constraint ? {value_constraint: value_constraint} : {})
           ]
 
-        when Injection
-          object_type.name
         else
           raise "Can't make a column from #{component}"
         end
@@ -265,7 +275,7 @@ end
 
 if $0 == __FILE__
   D = ActiveFacts::Metamodel::DataType
-  D.normalise('Auto Timestamp')
+  D.intrinsic_type('Auto Timestamp')
 
   class ModContext < D::DefaultContext
     def integer_ranges
@@ -277,5 +287,5 @@ if $0 == __FILE__
     end
   end
   puts "Normalising a tiny"
-  p D.normalise_int_length('tiny', nil, nil, ModContext.new)
+  p D.choose_integer('tiny', nil, nil, ModContext.new)
 end

data/lib/activefacts/metamodel/extensions.rb

@@ -1,4 +1,3 @@
-require 'pp'
 #
 #       ActiveFacts Vocabulary Metamodel.
 #       Extensions to the ActiveFacts Vocabulary classes (which are generated from the Metamodel)
@@ -534,6 +533,33 @@ module ActiveFacts
         end
         nil
       end
+
+      def all_value_type_parameter_transitive
+        supertypes_transitive.flat_map{|st| st.all_value_type_parameter.to_a}
+      end
+
+      def applicable_parameter_restrictions parameter_name, include_base_type = false
+        vtp = all_value_type_parameter_transitive.detect{|vtp| vtp.name == parameter_name }
+        return [] if !vtp || vtp.value_type == self
+        vtpr = all_value_type_parameter_restriction.select{|vtpr| vtpr.value_type_parameter == vtp }
+        if vtpr.empty?
+          supertype.applicable_parameter_restrictions parameter_name
+        else
+          vtpr
+        end
+      end
+    end
+
+    class ValueTypeParameter
+      def describe
+        "ValueType '#{value_type.name}' Parameter '#{name}' is of type '#{parameter_value_type.name}'"
+      end
+    end
+
+    class ValueTypeParameterRestriction
+      def inspect
+        value_range.inspect
+      end
     end
 
     class EntityType
@@ -555,101 +581,8 @@ module ActiveFacts
         assimilation == 'partitioned'
       end
 
-      def new_pi
-        trace :newpi, "Looking for New PI for #{name}" do
-          # An objectified fact type is identified by the object which plays it.
-          if fact_type && fact_type.all_role.size == 1
-            # REVISIT: If the OFT is separate (is this even possible?), this probably won't work:
-            return fact_type.all_role.single.object_type.preferred_identifier
-          end
-
-          # All roles in a preferred identifier must be a counterpart
-          # to a role played by this type or any of its supertypes.
-          # Here, a unary role is deemed to be its own counterpart.
-          # If this is an objectified fact type, its roles are deemed
-          # to be counterparts per virtue of the mirror role.
-
-#          if name == 'User'
-#            pp all_role_transitive.map{|a| a.fact_type.describe(a)}
-#            debugger
-#          end
-
-          art = all_role_transitive.map do |role|
-            # No TypeInheritance roles unless we play the subtype
-            if (ti = role.fact_type).is_a?(TypeInheritance) && role != ti.subtype_role
-              nil
-            elsif role.is_a?(MirrorRole)
-              nil
-            elsif role.fact_type.all_role.size == 1
-              role.base_role
-            else
-              x = (c = role.counterpart and c.base_role)
-              # debugger if x && x.object_type == self
-              x
-            end
-          end.compact
-
-          all_role.each do |role|
-            # Is this the subtype role in a supertype that identifies us?
-            if (ti = role.base_role.fact_type).is_a?(TypeInheritance)
-              if role == ti.subtype_role and ti.provides_identification
-                trace :newpi, "#{name} is identified by supertype #{ti.supertype.name}"
-
-                pcs = ti.supertype_role.all_role_ref.to_a.flat_map(&:role_sequence).flat_map(&:all_presence_constraint).to_a
-                debugger if pcs.size > 1
-                return pcs[0]
-
-                return ti.supertype_role.object_type.preferred_identifier
-              end
-              next  # It can't be this TypeInheritance
-            end
-
-            # The fact type must be binary or unary
-            next if role.fact_type.all_role.size > 2
-
-            base_role = role.counterpart.base_role  # Go to the OFT role that implied the link fact type
-            base_role.all_role_ref.each do |rr|
-              if rr.role_sequence.all_presence_constraint.size > 0
-                trace :newpi, "Looking for New PI that includes '#{base_role.fact_type.describe(base_role)}'"
-              end
-              rr.role_sequence.all_presence_constraint.each do |pc|
-                next unless pc.max_frequency == 1 and
-                    pc.is_preferred_identifier and
-                    !pc.enforcement               # Alethic uniqueness constraint
-                # We have a uniqueness constraint that is alethic and preferred.
-                # If all its role are valid counterparts, this is our preferred identifier.
-                next if pc.role_sequence.all_role_ref.to_a.detect do |nrr|
-                    if !art.include?(nrr.role)
-                      trace :newpi, "Rejecting New PI with excluded role '#{nrr.role.fact_type.describe(nrr.role)}'"
-                    end
-                    !art.include?(nrr.role) # Nope, not included in the valid counterparts
-                  end
-                trace :newpi, "Accepting New PI #{pc.describe}"
-                return pc
-              end
-            end
-          end
-
-          debugger
-          trace :newpi, "No New PI found for #{name}"
-          nil
-
-        end
-      end
-
       def preferred_identifier
         return @preferred_identifier if @preferred_identifier
-
-        @old_preferred_identifier = old_preferred_identifier
-#        @new_preferred_identifier = new_pi
-#        if @old_preferred_identifier != @new_preferred_identifier
-##          debugger
-#          new_pi
-#        end
-        return @preferred_identifier = @old_preferred_identifier
-      end
-
-      def old_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
@@ -1101,11 +1034,17 @@ module ActiveFacts
 
     class AllowedRange
       def to_s(infinity = true)
-        min = value_range.minimum_bound
-        max = value_range.maximum_bound
+        value_range.to_s infinity
+      end
+    end
+
+    class ValueRange
+      def to_s(infinity = true)
+        min = minimum_bound
+        max = maximum_bound
         # Open-ended string ranges will fail in Ruby
 
-        if min = value_range.minimum_bound
+        if min = minimum_bound
           min = min.value
           if min.is_literal_string
             min_literal = min.literal.inspect.gsub(/\A"|"\Z/,"'")   # Escape string characters
@@ -1115,7 +1054,7 @@ module ActiveFacts
         else
           min_literal = infinity ? "-Infinity" : ""
         end
-        if max = value_range.maximum_bound
+        if max = maximum_bound
           max = max.value
           if max.is_literal_string
             max_literal = max.literal.inspect.gsub(/\A"|"\Z/,"'")   # Escape string characters
@@ -1129,6 +1068,40 @@ module ActiveFacts
         min_literal +
           (min_literal != (max&&max_literal) ? (".." + max_literal) : "")
       end
+
+      def inspect
+        to_s
+      end
+
+      # Note the mismatched return types here:
+      def effective_maximum
+        maximum_bound ? maximum_bound.value : Infinity
+      end
+
+      def effective_minimum
+        minimum_bound ? minimum_bound.value : -Infinity
+      end
+
+      def includes? range
+        if ValueRange === range
+          range.effective_minimum >= effective_minimum && range.effective_maximum <= effective_maximum
+        # elsif Bound === range   # REVISIT: use self.includes?(range.value) with is_literal_string, etc
+        else
+          range >= effective_minimum && range <= effective_maximum
+        end
+      end
+    end
+
+    class Bound
+      def <=(other)
+        return true if other == Infinity
+        is_inclusive ? value <= other : value < other
+      end
+
+      def >=(other)
+        return true if other == -Infinity
+        is_inclusive ? value >= other : value > other
+      end
     end
 
     class Value
@@ -1149,6 +1122,38 @@ module ActiveFacts
       def inspect
         to_s
       end
+
+      def effective_value
+        is_literal_string ? literal : eval(literal)
+      end
+
+      def ==(other)
+        effective_value == (Value === other ? other.effective_value : other)
+      end
+
+      def !=(other)
+        !(self == other)
+      end
+
+      def <=(other)
+        return true if other == Infinity
+        effective_value <= other.effective_value rescue nil
+      end
+
+      def >=(other)
+        return true if other == -Infinity
+        effective_value >= other.effective_value rescue nil
+      end
+
+      def <(other)
+        v = self >= other
+        v == nil ? v : !v
+      end
+
+      def >(other)
+        v = self >= other
+        v == nil ? v : !v
+      end
     end
 
     class PresenceConstraint
@@ -1671,7 +1676,7 @@ module ActiveFacts
 
           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) }
+            sort_by{|fk| [fk.source_composite.mapping.name, fk.mapping.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|
@@ -1682,7 +1687,7 @@ module ActiveFacts
 
           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) }
+            sort_by{|fk| [fk.source_composite.mapping.name, fk.mapping.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|
@@ -1697,7 +1702,7 @@ module ActiveFacts
       def all_indices_by_rank
         all_access_path.
         reject{|ap| ap.is_a?(ActiveFacts::Metamodel::ForeignKey)}.
-        sort_by{|ap| ap.all_index_field.to_a.flat_map{|ixf| ixf.component.rank_path}.compact }
+        sort_by{|ap| ap.all_index_field.to_a.flat_map{|ixf| (c = ixf.component) ? c.rank_path : 0}.compact }
       end
 
       def all_foreign_key_as_target_composite
@@ -1736,12 +1741,14 @@ module ActiveFacts
           'Non-unique index'
         when composite_as_primary_index
           'Primary index'
+        when composite_as_natural_index
+          'Natural index'
         else
           'Unique index'
         end +
         (name ? " #{name.inspect}" : '') +
         " to #{composite.mapping.name}" +
-        (presence_constraint ? " over #{presence_constraint.describe}" : '')
+        (presence_constraint ? "#{presence_constraint.role_sequence.describe}" : '')
       end
     end
 
@@ -1750,13 +1757,14 @@ module ActiveFacts
         "Foreign Key" +
         (name ? " #{name.inspect}" : '') +
         " from #{(sc = source_composite) ? sc.mapping.name : 'NO-SOURCE'} to #{composite.mapping.name}" +
-        (absorption ? " over #{absorption.inspect}" : '')
+        (mapping ? " over #{mapping.inspect}" : '')
       end
     end
 
     class IndexField
       def inspect
-        "IndexField part #{ordinal} in #{component.root.mapping.name} references #{component.inspect}" +
+        c_name = component ? component.root.mapping.name : "WARNING: IndexField without Component"
+        "IndexField part #{ordinal} in #{c_name} references #{component.inspect}" +
         (value ? " discriminated by #{value.inspect}" : '')
       end
     end
@@ -1770,6 +1778,10 @@ module ActiveFacts
     end
 
     class Mapping
+      def inspect_reason
+        "#{parent.name} contains mapping of #{name}"
+      end
+
       def inspect
         "#{self.class.basename} (#{rank_kind})#{parent ? " in #{parent.name}" :''} of #{name && name != '' ? name : '<anonymous>'}"
       end
@@ -1777,12 +1789,20 @@ module ActiveFacts
       def show_trace
         trace :composition, "#{ordinal ? "#{ordinal}: " : ''}#{inspect}" do
           yield if block_given?
+          if m = all_member.detect{|m| !m.ordinal}
+            trace :composition, "WARNING: show_trace needed to re_rank #{name} because of unranked #{m.inspect}"
+            re_rank
+          end
           all_member.sort_by{|member| [member.ordinal, member.name]}.each do |member|
             member.show_trace
           end
         end
       end
 
+      def is_type_inheritance
+        false
+      end
+
       # Recompute a contiguous member ranking fron zero, based on current membership:
       def re_rank
         all_member.each(&:uncache_rank_key)
@@ -1815,7 +1835,7 @@ module ActiveFacts
       end
 
       def path_mandatory
-        true
+        !parent || parent.path_mandatory
       end
 
       def is_auto_assigned
@@ -1829,6 +1849,10 @@ module ActiveFacts
           nil
         end
       end
+
+      def is_partitioned_here
+        false # Must be an absorption to be partitioned here
+      end
     end
 
     class Nesting
@@ -1840,19 +1864,19 @@ module ActiveFacts
     end
 
     class Absorption
-      def inspect_reading
+      def inspect_reason
         parent_role.fact_type.reading_preferably_starting_with_role(parent_role).expand.inspect
       end
 
       def inspect
         "#{super}#{full_absorption ? ' (full)' : ''
-        } in #{inspect_reading}#{
+        } in #{inspect_reason}#{
           # If we have a related forward absorption, we're by definition a reverse absorption
-          if forward_absorption
+          if forward_mapping
             ' (reverse)'
            else
               # If we have a related reverse absorption, we're by definition a forward absorption
-              reverse_absorption ? ' (forward)' : ''
+              reverse_mapping ? ' (forward)' : ''
           end
         }"
       end
@@ -1879,6 +1903,14 @@ module ActiveFacts
         is_type_inheritance && parent_role.fact_type.supertype == object_type
       end
 
+      def is_partitioned_here
+        (ft = child_role.fact_type).is_a?(TypeInheritance) && ft.assimilation == 'partitioned'
+      end
+
+      def is_one_to_one
+        parent_role.is_unique and child_role.is_unique
+      end
+
       def is_preferred_direction
         return child_role.is_mirror_role if child_role.is_mirror_role != parent_role.is_mirror_role
 
@@ -1932,15 +1964,15 @@ module ActiveFacts
       end
 
       def flip!
-        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)
+        raise "REVISIT: Need to flip FullAbsorption on #{inspect}" if full_absorption or reverse_mapping && reverse_mapping.full_absorption or forward_mapping && forward_mapping.full_absorption
+        if (other = forward_mapping)
           # We point at them - make them point at us instead
-          self.forward_absorption = nil
-          self.reverse_absorption = other
-        elsif (other = reverse_absorption)
+          self.forward_mapping = nil
+          self.reverse_mapping = other
+        elsif (other = reverse_mapping)
           # They point at us - make us point at them instead
-          self.reverse_absorption = nil
-          self.forward_absorption = other
+          self.reverse_mapping = nil
+          self.forward_mapping = other
         else
           raise "Absorption cannot be flipped as it has no reverse"
         end
@@ -2053,8 +2085,10 @@ module ActiveFacts
           when SurrogateKey
             if is_identifying
               [RANK_SURROGATE]  # an injected PK
+            elsif injection_annotation
+              [RANK_INJECTION, name]
             else
-              [RANK_MANDATORY, name]    # an FK
+              [RANK_FOREIGN, name]    # an FK
             end
 
           when Indicator
@@ -2070,10 +2104,11 @@ module ActiveFacts
             [RANK_DISCRIMINATOR, name || child_role.name]
 
           when ValueField
-            [RANK_IDENT]
-
-          when Injection
-            [RANK_INJECTION, name]            # REVISIT: Injection not fully elaborated. A different sub-key for ranking may be needed
+            if injection_annotation
+              [RANK_INJECTION, name]
+            else
+              [RANK_IDENT]
+            end
 
           when Absorption
             if is_type_inheritance
@@ -2089,6 +2124,8 @@ module ActiveFacts
               end
             elsif (p = parent_entity_type) and (position = p.rank_in_preferred_identifier(child_role.base_role))
               [RANK_IDENT, position]
+            elsif injection_annotation
+              [RANK_INJECTION, name]
             else
               if parent_role.is_unique
                 [parent_role.is_mandatory ? RANK_MANDATORY : RANK_NON_MANDATORY, name || child_role.name]
@@ -2100,8 +2137,16 @@ module ActiveFacts
           when Scoping
             [RANK_SCOPING, name || object_type.name]
 
+          when ValidFrom
+            [RANK_INJECTION, name]
+
           when Mapping
-            [ name ]
+            # bare Mappings are always injected
+            if root.mapping.object_type == object_type
+              [RANK_IDENT, 0]
+            else
+              [RANK_INJECTION, name]
+            end
 
           else
             raise "unexpected #{self.class.basename} in Component#rank_key"
@@ -2118,6 +2163,10 @@ module ActiveFacts
         ixfs.map(&:component)
       end
 
+      def is_in_primary
+        !!(root and p = root.primary_index and p.all_index_field.detect{|f| f.component == self})
+      end
+
       def parent_entity_type
         parent &&
           parent.object_type.is_a?(EntityType) &&
@@ -2195,7 +2244,7 @@ module ActiveFacts
       end
 
       def fork_to_new_parent parent
-        @constellation.fork self, guid: :new, parent: parent
+        @constellation.fork self, guid: :new, parent: parent, injection_annotation: nil
       end
     end
 
@@ -2205,12 +2254,6 @@ module ActiveFacts
       end
     end
 
-    class Injection
-      def path_mandatory
-        parent.path_mandatory
-      end
-    end
-
     class ValueField
       def inspect
         "#{self.class.basename} #{object_type.name.inspect}"
@@ -2226,7 +2269,7 @@ module ActiveFacts
 
       def fork_to_new_parent parent
         # When we fork from a ValueField, we want to use the name of the ValueType, not the ValueField name
-        @constellation.fork self, guid: :new, parent: parent, name: object_type.name
+        @constellation.fork self, guid: :new, parent: parent, name: object_type.name, injection_annotation: nil
       end
     end
 
@@ -2254,6 +2297,14 @@ module ActiveFacts
         end
         (parent ? parent.name + ' ' : '') + 'surrogate key'
       end
+
+      def inspect
+        "#{self.class.basename} (#{rank_kind})#{parent ? " in #{parent.name}" :''} of #{name && name != '' ? name : '<anonymous>'}"
+      end
+
+      def show_trace
+        trace :composition, "#{ordinal ? "#{ordinal}: " : ''}#{inspect}"
+      end
     end
 
     #