activefacts 0.8.16 → 0.8.18

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

@@ -26,23 +26,23 @@ module ActiveFacts
           @context.left_contraction_allowed = true
           match_condition_fact_types
 
-          # Build the join:
+          # Build the query:
           unless @conditions.empty? and !@returning
-            debug :join, "building fact_type join" do
-              @join = build_join_nodes(@conditions.flatten)
-              @roles_by_variable = build_all_join_steps(@conditions)
-              @join.validate
-              @join
+            debug :query, "building query for derived fact type" do
+              @query = build_variables(@conditions.flatten)
+              @roles_by_binding = build_all_steps(@conditions)
+              @query.validate
+              @query
             end
           end
           @context.left_contraction_allowed = false
-          @join
+          @query
         end
 
         def match_condition_fact_types
           @conditions.each do |condition|
             next if condition.is_naked_object_type
-            # REVISIT: Many conditions will imply a number of different join steps, which need to be handled (similar to nested_clauses).
+            # REVISIT: Many conditions will imply a number of different steps, which need to be handled (similar to nested_clauses).
             debug :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
@@ -93,6 +93,13 @@ module ActiveFacts
           # * Objectify the fact type if @name
           #
 
+	  # Prepare to objectify the fact type (so readings for implicit fact types can be created)
+          if @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, :guid => :new)
+	  end
+
           prepare_roles @clauses
 
           # REVISIT: Compiling the conditions here make it impossible to define a self-referential (transitive) query.
@@ -102,9 +109,16 @@ module ActiveFacts
           @clauses.reject!{|clause| clause.is_existential_type }
           return true unless @clauses.size > 0   # Nothing interesting was said.
 
+	  if @entity_type
+	    # Extract readings for implicit fact types
+	    @implicit_readings, @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
-
           verify_matching_roles   # All clauses of a fact type must have the same roles
 
           if !@fact_type
@@ -116,6 +130,7 @@ module ActiveFacts
             @fact_type.create_implicit_fact_type_for_unary if @fact_type.all_role.size == 1 && !@name
             @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 }
             debug :binding, "Extending existing fact type with #{n} new readings"
           end
 
@@ -133,17 +148,16 @@ module ActiveFacts
             clause.make_embedded_constraints(vocabulary)
           end
 
-          # Objectify the fact type if necessary:
           if @name
+	    # 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
-            e = @constellation.EntityType[[@vocabulary, @name]]
-            raise "You can't objectify #{@name}, it already exists" if e
-            e = @constellation.EntityType(@vocabulary, @name, :fact_type => @fact_type, :guid => :new)
-            e.create_implicit_fact_types
+            ifts = @entity_type.create_implicit_fact_types
+	    create_implicit_readings(ifts)
             if @pragmas
-              e.is_independent = true if @pragmas.delete('independent')
+              @entity_type.is_independent = true if @pragmas.delete('independent')
             end
             if @pragmas && @pragmas.size > 0
               $stderr.puts "Mapping pragmas #{@pragmas.inspect} are ignored for objectified fact type #{@name}"
@@ -169,13 +183,35 @@ module ActiveFacts
           @fact_type
         end
 
+	def create_implicit_readings(ifts)
+	  @implicit_readings.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
+	    next unless ift
+	    # This clause is a reading for the implicit LinkFactType ift
+	    i = 0
+	    reading_text = clause.phrases.map do |phrase|
+		next phrase if String === phrase
+		"{#{(i += 1)-1}}"
+	      end*' '
+	    ir = ActiveFacts::Metamodel::LinkFactType::ImplicitReading
+	    irrs = ir::ImplicitReadingRoleSequence
+	    irrf = irrs::ImplicitReadingRoleRef
+	    reading = ir.new(ift, reading_text)
+	    ift.add_reading reading
+	  end
+	end
+
         def project_clause_roles(clause)
-          # Attach the clause's role references to the projected roles of the join
-          clause.var_refs.each_with_index do |var_ref, i|
-            role, join_role = @roles_by_variable[var_ref.variable]
-            raise "#{var_ref} must be a role projected from the conditions" unless role
-            raise "#{var_ref} has already-projected join role!" if join_role.role_ref
-            var_ref.role_ref.join_role = join_role
+          # Attach the clause's role references to the projected roles of the query
+          clause.refs.each_with_index do |ref, i|
+            role, play = @roles_by_binding[ref.binding]
+            raise "#{ref} must be a role projected from the conditions" unless role
+            raise "#{ref} has already-projected play!" if play.role_ref
+            ref.role_ref.play = play
           end
         end
 
@@ -183,7 +219,7 @@ module ActiveFacts
         def is_projected_role(rr)
           # rr is a RoleRef on one side of the comparison.
           # If its binding contains a reference from our readings, it's projected.
-          rr.variable.refs.detect do |ref|
+          rr.binding.refs.detect do |ref|
             @readings.include?(ref.reading)
           end
         end
@@ -237,25 +273,40 @@ module ActiveFacts
 
           # If there's an existing presence constraint that can be converted into a PC, do that:
           @clauses.each do |clause|
-            var_ref = clause.var_refs[-1] or next
-            epc = var_ref.embedded_presence_constraint or next
+            ref = clause.refs[-1] or next
+            epc = ref.embedded_presence_constraint or next
             epc.max_frequency == 1 or next
             next if epc.enforcement
             epc.is_preferred_identifier = true
             return
           end
 
-          # REVISIT: We need to check uniqueness constraints after processing the whole vocabulary
+          # 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
-
-          @constellation.PresenceConstraint(
-            :new,
-            :vocabulary => @vocabulary,
-            :name => @fact_type.entity_type ? @fact_type.entity_type.name+"PK" : '',
-            :role_sequence => @fact_type.preferred_reading.role_sequence,
-            :max_frequency => 1,
-            :is_preferred_identifier => prefer
-          )
+	  debug :constraint, "Need to check #{@fact_type.default_reading.inspect} for a uniqueness constraint"
+          fact_type.check_and_add_spanning_uniqueness_constraint = proc do
+	    debug :constraint, "Checking #{@fact_type.default_reading.inspect} for a uniqueness constraint"
+            if !@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{|pc| pc.max_frequency == 1}
+		  end
+                end
+	      # 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)
+	      )
+	      debug :constraint, "Made new fact type implicit PC GUID=#{pc.guid} #{pc.name} min=nil max=1 over #{rs.describe}"
+            end
+	  end
         end
 
         def has_more_adjectives(less, more)
@@ -265,12 +316,12 @@ module ActiveFacts
         end
 
         def verify_matching_roles
-          var_refs_by_clause_and_key = {}
-          clauses_by_var_refs =
+          refs_by_clause_and_key = {}
+          clauses_by_refs =
             @clauses.inject({}) do |hash, clause|
-              keys = clause.var_refs.map do |var_ref|
-                key = var_ref.key.compact
-                var_refs_by_clause_and_key[[clause, key]] = var_ref
+              keys = clause.refs.map do |ref|
+                key = ref.key.compact
+                refs_by_clause_and_key[[clause, key]] = ref
                 key
               end.sort_by{|a| a.map{|k|k.to_s}}
               raise "Fact types may not have duplicate roles" if keys.uniq.size < keys.size
@@ -278,14 +329,14 @@ module ActiveFacts
               hash
             end
 
-          if clauses_by_var_refs.size != 1 and @conditions.empty?
-            # Attempt loose binding here; it might merge some Compiler::VarRefs to share the same Variables
-            variants = clauses_by_var_refs.keys
-            (clauses_by_var_refs.size-1).downto(1) do |m|   # Start with the last one
+          if clauses_by_refs.size != 1 and @conditions.empty?
+            # Attempt loose binding here; it might merge some Compiler::References to share the same Variables
+            variants = clauses_by_refs.keys
+            (clauses_by_refs.size-1).downto(1) do |m|   # Start with the last one
               0.upto(m-1) do |l|                              # Try to rebind onto any lower one
                 common = variants[m]&variants[l]
-                clauses_l = clauses_by_var_refs[variants[l]]
-                clauses_m = clauses_by_var_refs[variants[m]]
+                clauses_l = clauses_by_refs[variants[l]]
+                clauses_m = clauses_by_refs[variants[m]]
                 l_keys = variants[l]-common
                 m_keys = variants[m]-common
                 debug :binding, "Try to collapse variant #{m} onto #{l}; diffs are #{l_keys.inspect} -> #{m_keys.inspect}"
@@ -295,16 +346,16 @@ module ActiveFacts
                   candidates = []
                   (0...m_keys.size).each do |j|
                     m_key = m_keys[j]
-                    l_var_ref = var_refs_by_clause_and_key[[clauses_l[0], l_key]]
-                    m_var_ref = var_refs_by_clause_and_key[[clauses_m[0], m_key]]
-                    debug :binding, "Can we match #{l_var_ref.inspect} (#{i}) with #{m_var_ref.inspect} (#{j})?"
-                    next if m_var_ref.player != l_var_ref.player
-                    if has_more_adjectives(m_var_ref, l_var_ref)
-                      debug :binding, "can rebind #{m_var_ref.inspect} to #{l_var_ref.inspect}"
-                      candidates << [m_var_ref, l_var_ref]
-                    elsif has_more_adjectives(l_var_ref, m_var_ref)
-                      debug :binding, "can rebind #{l_var_ref.inspect} to #{m_var_ref.inspect}"
-                      candidates << [l_var_ref, m_var_ref]
+                    l_ref = refs_by_clause_and_key[[clauses_l[0], l_key]]
+                    m_ref = refs_by_clause_and_key[[clauses_m[0], m_key]]
+                    debug :binding, "Can we match #{l_ref.inspect} (#{i}) with #{m_ref.inspect} (#{j})?"
+                    next if m_ref.player != l_ref.player
+                    if has_more_adjectives(m_ref, l_ref)
+                      debug :binding, "can rebind #{m_ref.inspect} to #{l_ref.inspect}"
+                      candidates << [m_ref, l_ref]
+                    elsif has_more_adjectives(l_ref, m_ref)
+                      debug :binding, "can rebind #{l_ref.inspect} to #{m_ref.inspect}"
+                      candidates << [l_ref, m_ref]
                     end
                   end
 
@@ -323,7 +374,7 @@ module ActiveFacts
                 else
                   # No point continuing, we failed on this one.
                   raise "All readings in a fact type definition must have matching role players, compare (#{
-                      clauses_by_var_refs.keys.map do |keys|
+                      clauses_by_refs.keys.map do |keys|
                         keys.map{|key| key*'-' }*", "
                       end*") with ("
                     })"
@@ -345,7 +396,7 @@ module ActiveFacts
             else
               ''
             end +
-            (@pragmas && @pragmas.size > 0 ? ", pragmas [#{@pragmas.sort*','}]" : '')
+            (@pragmas && @pragmas.size > 0 ? ", pragmas [#{@pragmas.flatten.sort*','}]" : '')
 
           # REVISIT: @returning = returning
         end

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

@@ -0,0 +1,178 @@
+module ActiveFacts
+  module CQL
+    class Compiler < ActiveFacts::CQL::Parser
+      class Definition
+        # Make a Variable for every binding present in these clauses
+        def build_variables(clauses_list)
+          debug :query, "Building variables" do
+            query = @constellation.Query(:new)
+            all_bindings_in_clauses(clauses_list).
+              each do |binding|
+                debug :query, "Creating variable #{query.all_variable.size} for #{binding.inspect}"
+                binding.variable = @constellation.Variable(query, query.all_variable.size, :object_type => binding.player)
+		if literal = binding.refs.detect{|r| r.literal}
+		  if literal.kind_of?(ActiveFacts::CQL::Compiler::Reference)
+		    # REVISIT: Fix this crappy ad-hoc polymorphism hack
+		    literal = literal.literal
+		  end
+                  unit = @constellation.Unit.detect{|k, v| [v.name, v.plural_name].include? literal.unit} if literal.unit
+                  binding.variable.value = [literal.literal.to_s, literal.literal.is_a?(String), unit]
+                end
+              end
+            query
+          end
+        end
+
+        def build_all_steps(clauses_list)
+          roles_by_binding = {}
+          debug :query, "Building steps" do
+            clauses_list.each do |clause|
+              next if clause.is_naked_object_type
+              build_steps(clause, roles_by_binding)
+            end
+          end
+          roles_by_binding
+        end
+
+        def build_steps clause, roles_by_binding = {}, objectification_node = nil
+          plays = []
+          incidental_roles = []
+          debug :query, "Creating Role Sequence for #{clause.inspect} with #{clause.refs.size} role refs" do
+            objectification_step = nil
+            clause.refs.each do |ref|
+              # These refs are the Compiler::References, which have associated Metamodel::RoleRefs,
+              # but we need to create Plays for those roles.
+              # REVISIT: Plays may need to save residual_adjectives
+              binding = ref.binding
+              role = (ref && ref.role) || (ref.role_ref && ref.role_ref.role)
+              play = nil
+
+              debugger unless clause.fact_type
+              if (clause.fact_type.entity_type)
+                # This clause is of an objectified fact type.
+                # We need a step from this role to the phantom role, but not
+                # for a role that has only one ref (this one) in their binding.
+                # Create the Variable and Play in any case though.
+                refs_count = binding.refs.size
+                objectification_ref_count = 0
+                if ref.nested_clauses
+                  ref.nested_clauses.each do |ojc|
+                    objectification_ref_count += ojc.refs.select{|ref| ref.binding.refs.size > 1}.size
+                  end
+                end
+                refs_count += objectification_ref_count
+
+                debug :query, "Creating Variable #{ref.inspect} (counts #{refs_count}/#{objectification_ref_count}) and objectification Step for #{ref.inspect}" do
+
+                  raise "Internal error: Trying to add role of #{role.object_type.name} to variable for #{binding.variable.object_type.name}" unless binding.variable.object_type == role.object_type
+                  play = @constellation.Play(binding.variable, role)
+
+                  if (refs_count <= 1)   # Our work here is done if there are no other refs
+                    if objectification_step
+                      play.step = objectification_step
+                    else
+                      incidental_roles << play
+                    end
+                    next
+                  end
+
+                  plays << play
+                  unless objectification_node
+                    # This is an implicit objectification, just the FT clause, not ET(where ...clause...)
+                    # We need to create a Variable for this object, even though it has no References
+                    query = binding.variable.query
+                    debug :query, "Creating JN#{query.all_variable.size} for #{clause.fact_type.entity_type.name} in objectification"
+                    objectification_node = @constellation.Variable(query, query.all_variable.size, :object_type => clause.fact_type.entity_type)
+                  end
+                  raise "Internal error: Trying to add role of #{role.link_fact_type.all_role.single.object_type.name} to variable for #{objectification_node.object_type.name}" unless objectification_node.object_type == role.link_fact_type.all_role.single.object_type
+
+                  irole = role.link_fact_type.all_role.single
+                  raise "Internal error: Trying to add role of #{irole.object_type.name} to variable for #{objectification_node.object_type.name}" unless objectification_node.object_type == irole.object_type
+                  objectification_role = @constellation.Play(objectification_node, role.link_fact_type.all_role.single)
+                  objectification_step = @constellation.Step(
+		      objectification_role,
+		      play,
+		      :fact_type => role.link_fact_type,
+		      :is_optional => false,
+		      :is_disallowed => clause.certainty == false
+		    )
+		  if clause.certainty == nil
+		    objectification_step.is_optional = true
+		  end
+                  debug :query, "New #{objectification_step.describe}"
+                  debug :query, "Associating #{incidental_roles.map(&:describe)*', '} incidental roles with #{objectification_step.describe}" if incidental_roles.size > 0
+                  incidental_roles.each { |jr| jr.step = objectification_step }
+                  incidental_roles = []
+                  plays = []
+                end
+              else
+                debug :query, "Creating Reference for #{ref.inspect}" do
+                    # REVISIT: If there's an implicit subtyping step here, create it; then always raise the error here.
+                    # I don't want to do this for now because the verbaliser will always verbalise all steps.
+                  if binding.variable.object_type != role.object_type and
+                    0 == (binding.variable.object_type.supertypes_transitive & role.object_type.supertypes_transitive).size
+                    raise "Internal error: Trying to add role of #{role.object_type.name} to variable #{binding.variable.ordinal} for #{binding.variable.object_type.name} in '#{clause.fact_type.default_reading}'"
+                  end
+                  raise "Internal error: Trying to add role of #{role.object_type.name} to variable #{binding.variable.ordinal} for #{binding.variable.object_type.name}" unless binding.variable.object_type == role.object_type
+                  begin
+                    play = @constellation.Play(binding.variable, role)
+                  rescue ArgumentError => e
+                    play = @constellation.Play(binding.variable, role)
+                  end
+                  plays << play
+                end
+              end
+
+              if ref.nested_clauses
+                # We are looking at a role whose player is an objectification of a fact type,
+                # which will have ImplicitFactTypes for each role.
+                # Each of these ImplicitFactTypes has a single phantom role played by the objectifying entity type
+                # One of these phantom roles is likely to be the subject of an objectification step.
+                ref.nested_clauses.each do |r|
+                  debug :query, "Building objectification step for #{ref.nested_clauses.inspect}" do
+                    build_steps r, roles_by_binding, binding.variable
+                  end
+                end
+              end
+              roles_by_binding[binding] = [role, play]
+            end
+          end
+
+          if plays.size > 0
+            end_node = plays[-1].variable
+            if !clause.fact_type.entity_type and role = clause.fact_type.all_role.single
+              # Don't give the ImplicitBoolean a variable. We can live without one, for now.
+              # The Step will have a duplicate node, and the fact type will tell us what's happening
+              plays << plays[0]
+            end
+            # We aren't talking about objectification here, so there must be exactly two roles.
+            raise "REVISIT: Internal error constructing step for #{clause.inspect}" if plays.size != 2
+            js = @constellation.Step(
+		plays[0],
+		plays[1],
+		:fact_type => clause.fact_type,
+		:is_disallowed => clause.certainty == false,
+		:is_optional => clause.certainty == nil
+	      )
+            debug :query, "New #{js.describe}"
+            debug :query, "Associating #{incidental_roles.map(&:describe)*', '} incidental roles with #{js.describe}" if incidental_roles.size > 0
+            incidental_roles.each { |jr| jr.step = js }
+          end
+          roles_by_binding
+        end
+
+        # Return the unique array of all bindings in these clauses, including in objectification steps
+        def all_bindings_in_clauses clauses
+          clauses.map do |clause|
+            clause.refs.map do |ref|
+              raise "Binding reference #{ref.inspect} is not bound to a binding" unless ref.binding
+              [ref.binding] + (ref.nested_clauses ? all_bindings_in_clauses(ref.nested_clauses) : [])
+            end
+          end.
+            flatten.
+            uniq
+        end
+      end
+    end
+  end
+end