activefacts-cql 1.8.1 → 1.8.2

data/lib/activefacts/cql/compiler/entity_type.rb

@@ -25,12 +25,12 @@ module ActiveFacts
           @identification = identification
           @pragmas = pragmas
           @clauses = clauses || []
-	  @context_note = context_note
+          @context_note = context_note
         end
 
         def compile
           @entity_type = @vocabulary.valid_entity_type_name(@name) ||
-	    @constellation.EntityType(@vocabulary, @name, :concept => :new)
+            @constellation.EntityType(@vocabulary, @name, :concept => :new)
           @entity_type.is_independent = true if @pragmas.delete('independent')
 
           # REVISIT: CQL needs a way to indicate whether subtype migration can occur.
@@ -38,9 +38,9 @@ module ActiveFacts
           @supertypes.each_with_index do |supertype_name, i|
             add_supertype(supertype_name, @identification || i > 0)
           end
-	  @pragmas.each do |p|
-	    @constellation.ConceptAnnotation(:concept => @entity_type.concept, :mapping_annotation => p)
-	  end if @pragmas
+          @pragmas.each do |p|
+            @constellation.ConceptAnnotation(:concept => @entity_type.concept, :mapping_annotation => p)
+          end if @pragmas
 
           context = CompilationContext.new(@vocabulary)
 
@@ -61,9 +61,9 @@ module ActiveFacts
 
           make_preferred_identifier_over_roles identifying_roles
 
-	  if @context_note
-	    @context_note.compile(@constellation, @entity_type)
-	  end
+          if @context_note
+            @context_note.compile(@constellation, @entity_type)
+          end
 
           @clauses.each do |clause|
             next unless clause.context_note
@@ -138,7 +138,7 @@ module ActiveFacts
                 #:is_mandatory => true,
                 #:min_frequency => 1,
               )
-	    trace :constraint, "Made new preferred PC GUID=#{pc.concept.guid} min=nil max=1 over #{role_sequence.describe}"
+            trace :constraint, "Made new preferred PC GUID=#{pc.concept.guid} min=nil max=1 over #{role_sequence.describe}"
           end
         end
 
@@ -165,9 +165,9 @@ module ActiveFacts
 
             fact_type = create_identifying_fact_type(context, clauses)
             fact_types << fact_type if fact_type
-	    unless fact_type.all_role.detect{|r| r.object_type == @entity_type}
-	      objectify_existing_fact_type(fact_type)
-	    end
+            unless fact_type.all_role.detect{|r| r.object_type == @entity_type}
+              objectify_existing_fact_type(fact_type)
+            end
           end
           fact_types
         end
@@ -175,9 +175,9 @@ module ActiveFacts
         def create_identifying_fact_type context, clauses
           # See if any fact type already exists (this ET cannot be a player, but might objectify it)
           existing_clauses = clauses.select{ |clause| clause.match_existing_fact_type context }
-	  if negation = existing_clauses.detect{|c| c.certainty == false }
-	    raise "#{@name} cannot be identified by negated fact type #{negation.inspect}"
-	  end
+          if negation = existing_clauses.detect{|c| c.certainty == false }
+            raise "#{@name} cannot be identified by negated fact type #{negation.inspect}"
+          end
           any_matched = existing_clauses.size > 0
 
           operation = any_matched ? 'Objectifying' : 'Creating'
@@ -205,9 +205,9 @@ module ActiveFacts
 
         def objectify_existing_fact_type fact_type
           raise "#{@name} cannot objectify fact type '#{fact_type.entity_type.name}' that's already objectified" if fact_type.entity_type
-	  if @fact_type
-	    raise "#{@name} cannot objectify '#{fact_type.default_reading}', it already objectifies '#{@fact_type.default_reading}'"
-	  end
+          if @fact_type
+            raise "#{@name} cannot objectify '#{fact_type.default_reading}', it already objectifies '#{@fact_type.default_reading}'"
+          end
 
           if fact_type.internal_presence_constraints.select{|pc| pc.max_frequency == 1}.size == 0
             # If there's no existing uniqueness constraint over this fact type, make a spanning one.
@@ -219,7 +219,7 @@ module ActiveFacts
               :is_preferred_identifier => false,  # We only get here when there is a reference mode on the entity type
               :max_frequency => 1
             )
-	    trace :constraint, "Made new objectification PC GUID=#{pc.concept.guid} min=nil max=1 over #{fact_type.preferred_reading.role_sequence.describe}"
+            trace :constraint, "Made new objectification PC GUID=#{pc.concept.guid} min=nil max=1 over #{fact_type.preferred_reading.role_sequence.describe}"
           end
 
           @fact_type = @entity_type.fact_type = fact_type
@@ -230,7 +230,7 @@ module ActiveFacts
         def add_supertype(supertype_name, not_identifying)
           trace :supertype, "Adding #{not_identifying ? '' : 'identifying '}supertype #{supertype_name} to #{@entity_type.name}" do
             supertype = @vocabulary.valid_entity_type_name(supertype_name) ||
-	      @constellation.EntityType(@vocabulary, supertype_name, :concept => :new) # Should always already exist
+              @constellation.EntityType(@vocabulary, supertype_name, :concept => :new) # Should always already exist
 
             # Did we already know about this supertyping?
             return if @entity_type.all_type_inheritance_as_subtype.detect{|ti| ti.supertype == supertype}
@@ -238,12 +238,12 @@ module ActiveFacts
             # By default, the first supertype identifies this entity type
             is_identifying_supertype = !not_identifying && @entity_type.all_type_inheritance_as_subtype.size == 0
 
-	    assimilation_pragmas = ['absorbed', 'separate', 'partitioned']
+            assimilation_pragmas = ['absorbed', 'separate', 'partitioned']
             assimilations = @pragmas.select { |p| assimilation_pragmas.include? p}
-	    @pragmas -= assimilation_pragmas
+            @pragmas -= assimilation_pragmas
             raise "Conflicting assimilation pragmas #{assimilations*', '}" if assimilations.size > 1
 
-	    @entity_type.add_supertype(supertype, is_identifying_supertype, assimilations[0])
+            @entity_type.add_supertype(supertype, is_identifying_supertype, assimilations[0])
           end
         end
 
@@ -252,11 +252,11 @@ module ActiveFacts
           vt = nil
           trace :entity, "Preparing value type #{vt_name} for reference mode" do
             # Find an existing ValueType called 'vt_name' or 'name vtname'
-	    # or find/create the supertype '#{mode}' and the subtype
+            # or find/create the supertype '#{mode}' and the subtype
             unless vt = @vocabulary.valid_object_type_name(vt_name) or
-		   vt = @vocabulary.valid_object_type_name(vt_name = "#{name} #{mode}")
+                   vt = @vocabulary.valid_object_type_name(vt_name = "#{name} #{mode}")
               base_vt = @vocabulary.valid_value_type_name(mode) ||
-		  @constellation.ValueType(@vocabulary, mode, :concept => :new)
+                  @constellation.ValueType(@vocabulary, mode, :concept => :new)
               vt = @constellation.ValueType(@vocabulary, vt_name, :supertype => base_vt, :concept => :new)
               if parameters
                 length, scale = *parameters
@@ -358,7 +358,7 @@ module ActiveFacts
               :is_preferred_identifier => false,
               :is_mandatory => true
             )
-	    trace :constraint, "Made new refmode PC GUID=#{constraint.concept.guid} min=1 max=1 over #{rs0.describe}"
+            trace :constraint, "Made new refmode PC GUID=#{constraint.concept.guid} min=1 max=1 over #{rs0.describe}"
           else
             trace :mode, "Using existing EntityType PresenceConstraint"
           end
@@ -386,7 +386,7 @@ module ActiveFacts
               :is_preferred_identifier => true,
               :is_mandatory => false
             )
-	    trace :constraint, "Made new refmode ValueType PC GUID=#{constraint.concept.guid} min=0 max=1 over #{rs1.describe}"
+            trace :constraint, "Made new refmode ValueType PC GUID=#{constraint.concept.guid} min=0 max=1 over #{rs1.describe}"
           else
             trace :mode, "Marking existing ValueType PresenceConstraint as preferred"
             rs1.all_presence_constraint.single.is_preferred_identifier = true

data/lib/activefacts/cql/compiler/expression.rb

@@ -28,7 +28,7 @@ module ActiveFacts
         def trailing_adjective; nil; end
         def value_constraint; nil; end
         def literal; nil; end
-	def side_effects; nil; end
+        def side_effects; nil; end
         attr_accessor :player     # What ObjectType does the Binding denote
         attr_accessor :binding    # What Binding for that ObjectType
         attr_accessor :clause     # What clause does the result participate in?
@@ -48,9 +48,9 @@ module ActiveFacts
         attr_reader :fact_type
         def objectified_as; self; end   # The Reference which objectified this fact type
 
-	def initialize
-	  @certainty = true	  # Assume it's definite
-	end
+        def initialize
+          @certainty = true       # Assume it's definite
+        end
 
         def operands context = nil
           raise "REVISIT: Implement operand enumeration in the operator subclass #{self.class.name}"
@@ -92,8 +92,8 @@ module ActiveFacts
         def result_value_type(context, name)
           vocabulary = context.vocabulary
           constellation = vocabulary.constellation
-	  vocabulary.valid_value_type_name(name) ||
-	    constellation.ValueType(vocabulary, name, :concept => :new)
+          vocabulary.valid_value_type_name(name) ||
+            constellation.ValueType(vocabulary, name, :concept => :new)
         end
 
         def is_naked_object_type
@@ -117,9 +117,9 @@ module ActiveFacts
           # REVISIT: We should auto-create steps from Entity Types to an identifying ValueType
           # REVISIT: We should traverse up the supertype of ValueTypes to find a DataType
           @fact_type = clause_ast.match_existing_fact_type(context, :exact_type => true)
-	  if clause.certainty == false
-	    raise "Negated fact types in expressions are not yet supported: #{clause.inspect}"
-	  end
+          if clause.certainty == false
+            raise "Negated fact types in expressions are not yet supported: #{clause.inspect}"
+          end
           return @fact_type if @fact_type
 
           @fact_type = clause_ast.make_fact_type context.vocabulary
@@ -130,9 +130,9 @@ module ActiveFacts
           opnds.each do |opnd|
             next unless opnd.is_a?(Operation)
             opnd.match_existing_fact_type context
-	    if opnd.certainty == false
-	      raise "Negated fact types in expressions are not yet supported: #{opnd.inspect}"
-	    end
+            if opnd.certainty == false
+              raise "Negated fact types in expressions are not yet supported: #{opnd.inspect}"
+            end
           end
           @fact_type
         end
@@ -189,8 +189,8 @@ module ActiveFacts
             end
             v = context.vocabulary
             @boolean ||=
-	      v.constellation.ValueType[[[v.name], 'Boolean']] ||
-	      v.constellation.ValueType(v, 'Boolean', :concept => :new)
+              v.constellation.ValueType[[[v.name], 'Boolean']] ||
+              v.constellation.ValueType(v, 'Boolean', :concept => :new)
             @player = @boolean
           end
         end
@@ -207,20 +207,20 @@ module ActiveFacts
 
         def to_s
           "COMPARE#{
-	    operator
-	  }(#{
-	    case @certainty
-	    when nil; 'maybe '
-	    when false; 'negated '
-	    # else 'definitely '
-	    end
+            operator
+          }(#{
+            case @certainty
+            when nil; 'maybe '
+            when false; 'negated '
+            # else 'definitely '
+            end
+          }#{
+            e1.to_s
+          } WITH #{
+            e2.to_s
           }#{
-	    e1.to_s
-	  } WITH #{
-	    e2.to_s
-	  }#{
-	    @qualifiers.empty? ? '' : ', ['+@qualifiers*', '+']'
-	  })"
+            @qualifiers.empty? ? '' : ', ['+@qualifiers*', '+']'
+          })"
         end
       end
 

data/lib/activefacts/cql/compiler/fact.rb

@@ -10,17 +10,17 @@ module ActiveFacts
 
         def compile
           @population = @constellation.Population[[@vocabulary.identifying_role_values, @population_name]] ||
-	      @constellation.Population(@vocabulary, @population_name, :concept => :new)
+              @constellation.Population(@vocabulary, @population_name, :concept => :new)
 
           @context = CompilationContext.new(@vocabulary)
           @context.bind @clauses
           @context.left_contraction_allowed = true
           @clauses.each do |clause|
-	    ft = clause.match_existing_fact_type @context
-	    if clause.certainty == false
-	      raise "Negated fact #{clause.inspect} is not supported"
-	    end
-	  end
+            ft = clause.match_existing_fact_type @context
+            if clause.certainty == false
+              raise "Negated fact #{clause.inspect} is not supported"
+            end
+          end
 
           # Figure out the simple existential facts and find fact types:
           @bound_facts = []
@@ -84,16 +84,16 @@ module ActiveFacts
           # Find the roles of this clause that do not yet have an instance
           bare_roles = clause.refs.
             select do |ref|
-	      if !ref.binding.instance and ref.literal
+              if !ref.binding.instance and ref.literal
                 ref.binding.instance = instance_identified_by_literal(ref.binding.player, ref.literal)
-	      end
+              end
 
               next false if ref.binding.instance
               true
             end
 
-	  trace :instance_detail, "Considering '#{clause.display}' with "+
-	    (bare_roles.empty? ? "no bare roles" : "bare roles: #{bare_roles.map{|ref| ref.player.name}*", "}") do
+          trace :instance_detail, "Considering '#{clause.display}' with "+
+            (bare_roles.empty? ? "no bare roles" : "bare roles: #{bare_roles.map{|ref| ref.player.name}*", "}") do
 
             # If all the roles are in place, we can bind the rest of this clause:
             return true if bare_roles.size == 0 && bind_complete_fact(clause)
@@ -149,7 +149,7 @@ module ActiveFacts
             fact = clause.refs[0].binding.instance.fact
           else
             # Check that this fact doesn't already exist
-	    trace :instance_detail, "Searching for existing fact instance"
+            trace :instance_detail, "Searching for existing fact instance"
 
             fact = clause.fact_type.all_fact.detect do |f|
 
@@ -207,7 +207,7 @@ module ActiveFacts
           return false unless identifying_binding # This happens when we have a bare objectification
           identifying_instance = identifying_binding.instance
           preferred_identifier = entity_type.preferred_identifier
-	  role_count = preferred_identifier.role_sequence.all_role_ref.size 
+          role_count = preferred_identifier.role_sequence.all_role_ref.size 
 
           trace :instance, "A #{binding.player.name} is #{role_count > 1 ? 'partly ':''}identified in #{clause.inspect}"
 
@@ -251,21 +251,21 @@ module ActiveFacts
             return false
           end
 
-	  instance = @constellation.Instance(:new, :object_type => entity_type, :population => @population)
-	  binding.instance = instance
-	  @bound_facts << instance
-	  identifiers.each do |rr, identifying_clause, identifying_binding, identifying_instance|
-	    # This clause provides the identifying literal for the entity_type
-	    id_fact =
-	      identifying_clause.fact =
-	      @constellation.Fact(:new, :fact_type => rr.role.fact_type, :population => @population)
-	    @bound_facts << id_fact
-	    role = (rr.role.fact_type.all_role.to_a-[rr.role])[0]
-	    @constellation.RoleValue(:instance => instance, :fact => id_fact, :population => @population, :role => role)
-	    @constellation.RoleValue(:instance => identifying_instance, :fact => id_fact, :role => rr.role, :population => @population)
-	    trace :instance, "Assert #{id_fact.verbalise.inspect} (existential) #{@population.name.size>0 ? " in "+@population.name.inspect : ''}"
-	  end
-	  trace :instance, "Assert #{instance.verbalise.inspect} #{@population.name.size>0 ? " in "+@population.name.inspect : ''}"
+          instance = @constellation.Instance(:new, :object_type => entity_type, :population => @population)
+          binding.instance = instance
+          @bound_facts << instance
+          identifiers.each do |rr, identifying_clause, identifying_binding, identifying_instance|
+            # This clause provides the identifying literal for the entity_type
+            id_fact =
+              identifying_clause.fact =
+              @constellation.Fact(:new, :fact_type => rr.role.fact_type, :population => @population)
+            @bound_facts << id_fact
+            role = (rr.role.fact_type.all_role.to_a-[rr.role])[0]
+            @constellation.RoleValue(:instance => instance, :fact => id_fact, :population => @population, :role => role)
+            @constellation.RoleValue(:instance => identifying_instance, :fact => id_fact, :role => rr.role, :population => @population)
+            trace :instance, "Assert #{id_fact.verbalise.inspect} (existential) #{@population.name.size>0 ? " in "+@population.name.inspect : ''}"
+          end
+          trace :instance, "Assert #{instance.verbalise.inspect} #{@population.name.size>0 ? " in "+@population.name.inspect : ''}"
 
           true  # Done with this clause
         end
@@ -276,11 +276,11 @@ module ActiveFacts
           else
             trace :instance_detail, "Assert Value #{object_type.name} #{literal.inspect}" do
               is_literal_string = literal.literal.is_a?(String)
-	      # REVISIT: Check for subtypes and supertypes also, and promote type if necessary
-	      instance = object_type.all_instance.detect do |i|
+              # REVISIT: Check for subtypes and supertypes also, and promote type if necessary
+              instance = object_type.all_instance.detect do |i|
               #instance = @constellation.Instance.detect do |key, i|
                   # REVISIT: And same unit
-		  trace :instance_detail2, "Comparing #{i.value.literal.inspect} to #{literal.literal.to_s.inspect}"
+                  trace :instance_detail2, "Comparing #{i.value.literal.inspect} to #{literal.literal.to_s.inspect}"
                   i.population == @population &&
                     i.value &&
                     i.value.literal.inspect == literal.literal.to_s.inspect &&
@@ -289,14 +289,14 @@ module ActiveFacts
               #instance = object_type.all_instance.detect { |instance|
               #  instance.population == @population && instance.value == literal
               #}
-	      if instance
-		trace :instance, "Instance already known: #{instance.verbalise.inspect}"
+              if instance
+                trace :instance, "Instance already known: #{instance.verbalise.inspect}"
               else
                 instance = @constellation.Instance(:new)
                 instance.object_type = object_type
                 instance.population = @population
                 instance.value = [literal.to_s, is_literal_string, nil]
-		trace :instance, "Assert #{instance.verbalise.inspect} #{@population.name.size>0 ? " in "+@population.name.inspect : ''}"
+                trace :instance, "Assert #{instance.verbalise.inspect} #{@population.name.size>0 ? " in "+@population.name.inspect : ''}"
                 @bound_facts << instance
               end
               instance
@@ -323,20 +323,20 @@ module ActiveFacts
             }
             if instance_rv
               instance = existing_instance
-	      trace :instance, "Already known: #{instance.verbalise.inspect}"
+              trace :instance, "Already known: #{instance.verbalise.inspect}"
             else
               # This fact has no clause.
-	      trace :instance_detail, "Creating implicit existential fact #{role.fact_type.default_reading}"
+              trace :instance_detail, "Creating implicit existential fact #{role.fact_type.default_reading}"
               fact = @constellation.Fact(:new, :fact_type => role.fact_type, :population => @population)
               @bound_facts << fact
               # This instance will be associated with its binding by our caller
               instance = @constellation.Instance(:new, :object_type => object_type, :population => @population)
-	      trace :instance_detail, "Creating Entity #{object_type.name} identified by '#{literal}' #{@population.name.size>0 ? " in "+@population.name.inspect : ''}"
+              trace :instance_detail, "Creating Entity #{object_type.name} identified by '#{literal}' #{@population.name.size>0 ? " in "+@population.name.inspect : ''}"
               @bound_facts << instance
               # The identifying fact type has two roles; create both role instances:
               @constellation.RoleValue(:instance => identifying_instance, :fact => fact, :population => @population, :role => role)
               @constellation.RoleValue(:instance => instance, :fact => fact, :population => @population, :role => (role.fact_type.all_role-[role])[0])
-	      trace :instance, "Assert #{instance.verbalise.inspect}"
+              trace :instance, "Assert #{instance.verbalise.inspect}"
             end
             instance
           end

data/lib/activefacts/cql/compiler/fact_type.rb

@@ -12,17 +12,17 @@ module ActiveFacts
           @returning = returning || []
         end
 
-	def to_s
-	  inspect
-	end
+        def to_s
+          inspect
+        end
 
         def inspect
           "Query: " +
-	    if @conditions.empty?
-	      ''
-	    else
-	      'where ' + @conditions.map{|c| ((j=c.conjunction) ? j+' ' : '') + c.inspect}*' '
-	    end
+            if @conditions.empty?
+              ''
+            else
+              'where ' + @conditions.map{|c| ((j=c.conjunction) ? j+' ' : '') + c.inspect}*' '
+            end
           # REVISIT: @returning = returning
         end
 
@@ -55,10 +55,10 @@ module ActiveFacts
 
         def match_condition_fact_types
           @conditions.each do |condition|
-	    trace :projection, "matching condition fact_type #{condition.inspect}" do
-	      fact_type = condition.match_existing_fact_type @context
-	      raise "Unrecognised fact type #{condition.inspect} in #{self.class}" unless fact_type
-	    end
+            trace :projection, "matching condition fact_type #{condition.inspect}" do
+              fact_type = condition.match_existing_fact_type @context
+              raise "Unrecognised fact type #{condition.inspect} in #{self.class}" unless fact_type
+            end
           end
         end
 
@@ -105,12 +105,12 @@ module ActiveFacts
           # * Objectify the fact type if @name
           #
 
-	  # Prepare to objectify the fact type (so readings for link fact types can be created)
+          # Prepare to objectify the fact type (so readings for link fact types can be created)
           if @name
-	    entity_type = @vocabulary.valid_entity_type_name(@name)
+            entity_type = @vocabulary.valid_entity_type_name(@name)
             raise "You can't objectify #{@name}, it already exists" if entity_type
             @entity_type = @constellation.EntityType(@vocabulary, @name, :fact_type => @fact_type, :concept => :new)
-	  end
+          end
 
           prepare_roles @clauses
 
@@ -119,13 +119,13 @@ module ActiveFacts
 
           return true unless @clauses.size > 0   # Nothing interesting was said.
 
-	  if @entity_type
-	    # Extract readings for link fact types
-	    @link_fact_type_clauses, @clauses =
-	      @clauses.partition do |clause|
-		clause.refs.size == 2 and clause.refs.detect{|ref| ref.player == @entity_type}
-	      end
-	  end
+          if @entity_type
+            # Extract readings for link fact types
+            @link_fact_type_clauses, @clauses =
+              @clauses.partition do |clause|
+                clause.refs.size == 2 and clause.refs.detect{|ref| ref.player == @entity_type}
+              end
+          end
 
           # See if any existing fact type is being invoked (presumably to objectify or extend it)
           @fact_type = check_compatibility_of_matched_clauses
@@ -139,7 +139,7 @@ module ActiveFacts
             first_clause.make_embedded_constraints vocabulary
             @existing_clauses = [first_clause]
           elsif (n = @clauses.size - @existing_clauses.size) > 0
-	    raise "Cannot extend a negated fact type" if @existing_clauses.detect {|clause| clause.certainty == false }
+            raise "Cannot extend a negated fact type" if @existing_clauses.detect {|clause| clause.certainty == false }
             trace :binding, "Extending existing fact type with #{n} new readings"
           end
 
@@ -158,20 +158,20 @@ module ActiveFacts
           end
 
           if @name
-	    # Objectify the fact type:
+            # Objectify the fact type:
             @entity_type.fact_type = @fact_type
             if @fact_type.entity_type and @name != @fact_type.entity_type.name
               raise "Cannot objectify fact type as #{@name} and as #{@fact_type.entity_type.name}"
             end
             ifts = @entity_type.create_link_fact_types
-	    create_link_fact_type_readings(ifts)
+            create_link_fact_type_readings(ifts)
             if @pragmas
               @entity_type.is_independent = true if @pragmas.delete('independent')
             end
           end
-	  @pragmas.each do |p|
-	    @constellation.ConceptAnnotation(:concept => (@entity_type||@fact_type).concept, :mapping_annotation => p)
-	  end if @pragmas
+          @pragmas.each do |p|
+            @constellation.ConceptAnnotation(:concept => (@entity_type||@fact_type).concept, :mapping_annotation => p)
+          end if @pragmas
 
           @clauses.each do |clause|
             next unless clause.context_note
@@ -182,36 +182,40 @@ module ActiveFacts
           make_default_identifier_for_fact_type if @conditions.empty?
 
           # Compile the conditions:
-          super
+          query = super
           unless @conditions.empty?
             @clauses.each do |clause|
               project_clause_roles(clause)
             end
+
+            # Add the head to complete the derived fact type
+            query.derived_fact_type = @fact_type unless query.nil?
+
           end
 
           @fact_type
         end
 
-	def create_link_fact_type_readings(ifts)
-	  @link_fact_type_clauses.each do |clause|
-	    #next false unless clause.refs.size == 2 and clause.refs.detect{|r| r.role.object_type == @entity_type }
-	    other_ref = clause.refs.detect{|ref| ref.player != @entity_type}
-	    ift = ifts.detect do |ift|
-	      other_ref.binding.refs.map{|r| r.role}.include?(ift.implying_role)
-	    end
-	    unless ift
-	      raise "Clause #{clause} in unmatched in definition of objectified fact type #{@name}"
-	      next
-	    end
-	    # This clause is a reading for the LinkFactType ift
-	    i = 0
-	    reading_text = clause.phrases.map do |phrase|
-		next phrase if String === phrase
-		"{#{(i += 1)-1}}"
-	      end*' '
-	    clause.make_reading(@vocabulary, ift)
-	  end
-	end
+        def create_link_fact_type_readings(ifts)
+          @link_fact_type_clauses.each do |clause|
+            #next false unless clause.refs.size == 2 and clause.refs.detect{|r| r.role.object_type == @entity_type }
+            other_ref = clause.refs.detect{|ref| ref.player != @entity_type}
+            ift = ifts.detect do |ift|
+              other_ref.binding.refs.map{|r| r.role}.include?(ift.implying_role)
+            end
+            unless ift
+              raise "Clause #{clause} in unmatched in definition of objectified fact type #{@name}"
+              next
+            end
+            # This clause is a reading for the LinkFactType ift
+            i = 0
+            reading_text = clause.phrases.map do |phrase|
+                next phrase if String === phrase
+                "{#{(i += 1)-1}}"
+              end*' '
+            clause.make_reading(@vocabulary, ift)
+          end
+        end
 
         def project_clause_roles(clause)
           # Attach the clause's role references to the projected roles of the query
@@ -235,7 +239,7 @@ module ActiveFacts
         def check_compatibility_of_matched_clauses
           # REVISIT: If we have conditions, we must match all given clauses exactly (no side-effects)
           @existing_clauses = @clauses.
-            select{ |clause| clause.match_existing_fact_type @context }.
+            select{ |clause| clause.match_existing_fact_type(@context, exact_type: true) }.
             # subtyping match is not allowed for fact type extension:
             reject{ |clause| clause.side_effects.role_side_effects.detect{|se| se.common_supertype } }.
             sort_by{ |clause| clause.side_effects.cost }
@@ -292,41 +296,43 @@ module ActiveFacts
 
           # We need to check uniqueness constraints after processing the whole vocabulary
           # raise "Fact type must be named as it has no identifying uniqueness constraint" unless @name || @fact_type.all_role.size == 1
-	  trace :constraint, "Need to check #{@fact_type.default_reading.inspect} for a uniqueness constraint"
-          fact_type.check_and_add_spanning_uniqueness_constraint = proc do
-	    trace :constraint, "Checking #{@fact_type.default_reading.inspect} for a uniqueness constraint"
-	    existing_pc = nil
-            found = @fact_type.all_role.
-		detect do |role|
-                  role.all_role_ref.detect do |rr|
-                    # This RoleSequence, to be relevant, must only reference roles of this fact type
-                    rr.role_sequence.all_role_ref.all? {|rr2| rr2.role.fact_type == @fact_type} and
-                    # The RoleSequence must have at least one uniqueness constraint
-                    rr.role_sequence.all_presence_constraint.detect do |pc|
-		      if pc.max_frequency == 1
-			existing_pc = pc
-		      end
-		    end
-		  end
-                end
-	    true  # A place for a breakpoint
-
-            if !found
-	      # There's no existing uniqueness constraint over the roles of this fact type. Add one
-	      pc = @constellation.PresenceConstraint(
-		:new,
-		:vocabulary => @vocabulary,
-		:name => @fact_type.entity_type ? @fact_type.entity_type.name+"PK" : '',
-		:role_sequence => (rs = @fact_type.preferred_reading.role_sequence),
-		:max_frequency => 1,
-		:is_preferred_identifier => true # (prefer || !!@fact_type.entity_type)
-	      )
-	      pc.concept.topic = @fact_type.concept.topic
-	      trace :constraint, "Made new fact type implicit PC GUID=#{pc.concept.guid} #{pc.name} min=nil max=1 over #{rs.describe}"
-	    elsif pc
-	      trace :constraint, "Will rely on existing UC GUID=#{pc.concept.guid} #{pc.name} to be used as PI over #{rs.describe}"
+          unless @fact_type.all_role.size == 1
+            trace :constraint, "Need to check #{@fact_type.default_reading.inspect} for a uniqueness constraint"
+            fact_type.check_and_add_spanning_uniqueness_constraint = proc do
+              trace :constraint, "Checking #{@fact_type.default_reading.inspect} for a uniqueness constraint"
+              existing_pc = nil
+              found = @fact_type.all_role.
+                  detect do |role|
+                    role.all_role_ref.detect do |rr|
+                      # This RoleSequence, to be relevant, must only reference roles of this fact type
+                      rr.role_sequence.all_role_ref.all? {|rr2| rr2.role.fact_type == @fact_type} and
+                      # The RoleSequence must have at least one uniqueness constraint
+                      rr.role_sequence.all_presence_constraint.detect do |pc|
+                        if pc.max_frequency == 1
+                          existing_pc = pc
+                        end
+                      end
+                    end
+                  end
+              true  # A place for a breakpoint
+
+              if !found
+                # There's no existing uniqueness constraint over the roles of this fact type. Add one
+                pc = @constellation.PresenceConstraint(
+                  :concept => [:new, {:implication_rule => "spanning"}],
+                  :vocabulary => @vocabulary,
+                  :name => @fact_type.entity_type ? @fact_type.entity_type.name+"PK" : '',
+                  :role_sequence => (rs = @fact_type.preferred_reading.role_sequence),
+                  :max_frequency => 1,
+                  :is_preferred_identifier => true # (prefer || !!@fact_type.entity_type)
+                )
+                pc.concept.topic = @fact_type.concept.topic
+                trace :constraint, "Made new fact type implicit PC GUID=#{pc.concept.guid} #{pc.name} min=nil max=1 over #{rs.describe}"
+              elsif pc
+                trace :constraint, "Will rely on existing UC GUID=#{pc.concept.guid} #{pc.name} to be used as PI over #{rs.describe}"
+              end
             end
-	  end
+          end
         end
 
         def has_more_adjectives(less, more)
@@ -407,7 +413,7 @@ module ActiveFacts
         end
 
         def inspect
-	  s = super
+          s = super
           "FactType: #{@conditions.size > 0 ? super+' ' : '' }#{@clauses.inspect}" +
             (@pragmas && @pragmas.size > 0 ? ", pragmas [#{@pragmas.flatten.sort*','}]" : '')