activefacts 0.8.9 → 0.8.10

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

@@ -2,70 +2,135 @@ module ActiveFacts
   module CQL
     class Compiler < ActiveFacts::CQL::Parser
 
-      class FactType < Concept
-        attr_reader :fact_type
-        attr_writer :name
+      class Query < ObjectType  # A fact type which is objectified (whether derived or not) is also an ObjectType
+        attr_reader :context    # Exposed for testing purposes
+        attr_reader :conditions
 
-        def initialize name, readings, conditions = nil, returning = nil
+        def initialize name, conditions = nil, returning = nil
           super name
-          @readings = readings
           @conditions = conditions
-          @returning = returning
+          @returning = returning || []
+        end
+
+        def prepare_roles clauses = nil
+          debug :binding, "preparing roles" do
+            @context ||= CompilationContext.new(@vocabulary)
+            @context.bind clauses||[], @conditions, @returning
+          end
         end
 
         def compile
-          raise "Queries not yet handled: #{@source}" unless @conditions.empty? and !@returning
+          # Match roles with players, and match clauses with existing fact types
+          prepare_roles unless @context
 
-          #
+          @context.left_contraction_allowed = true
+          match_condition_fact_types
+
+          # Build the join:
+          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
+            end
+          end
+          @context.left_contraction_allowed = false
+          @join
+        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).
+            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
+            end
+          end
+        end
+
+        def detect_projection_by_equality condition
+          return false unless condition.is_a?(Comparison)
+          if is_projected_role(condition.e1)
+            condition.project :left
+          elsif is_projected_role(condition.e2)
+            condition.project :right
+          end
+        end
+
+        def is_projected_role(rr)
+          false
+        end
+      end
+
+      class FactType < ActiveFacts::CQL::Compiler::Query
+        attr_reader :fact_type
+        attr_reader :clauses
+        attr_writer :name
+        attr_writer :pragmas
+
+        def initialize name, clauses, conditions = nil, returning = nil
+          super name, conditions, returning
+          @clauses = clauses
+          if ec = @clauses.detect{|r| r.is_equality_comparison}
+            @clauses.delete(ec)
+            @conditions.unshift(ec)
+          end
+        end
+
+        def compile
           # Process:
-          # * Identify all role players
-          # * Match up the players in all @readings
+          # * Identify all role players (must be done for both clauses and conditions BEFORE matching clauses)
+          # * Match up the players in all @clauses
           #   - Be aware of multiple roles with the same player, and bind tight/loose using subscripts/role_names/adjectives
-          #   - Reject the fact type unless all @readings match
-          # * Find any existing fact type that matches any reading, or make a new one
-          # * Add each reading that doesn't already exist in the fact type
+          #   - Reject the fact type unless all @clauses match
+          # * Find any existing fact type that matches any clause, or make a new one
+          # * Add each clause that doesn't already exist in the fact type
           # * Create any ring constraint(s)
           # * Create embedded presence constraints
           # * If fact type has no identifier, arrange to create the implicit one (before first use?)
           # * Objectify the fact type if @name
           #
 
-          @context = CompilationContext.new(@vocabulary)
-          @readings.each{ |reading| reading.identify_players_with_role_name(@context) }
-          @readings.each{ |reading| reading.identify_other_players(@context) }
-          @readings.each{ |reading| reading.bind_roles @context }  # Create the Compiler::Bindings
+          prepare_roles @clauses
 
-          verify_matching_roles   # All readings of a fact type must have the same roles
+          # REVISIT: Compiling the conditions here make it impossible to define a self-referential (transitive) query.
+          return super if @clauses.empty?  # It's a query
 
-          # Ignore any useless readings:
-          @readings.reject!{|reading| reading.is_existential_type }
-          return true unless @readings.size > 0   # Nothing interesting was said.
+          # Ignore any useless clauses:
+          @clauses.reject!{|clause| clause.is_existential_type }
+          return true unless @clauses.size > 0   # Nothing interesting was said.
 
           # See if any existing fact type is being invoked (presumably to objectify or extend it)
-          @fact_type = check_compatibility_of_matched_readings
+          @fact_type = check_compatibility_of_matched_clauses
+
+          verify_matching_roles   # All clauses of a fact type must have the same roles
 
           if !@fact_type
             # Make a new fact type:
-            first_reading = @readings[0]
-            @fact_type = first_reading.make_fact_type(@vocabulary)
-            first_reading.make_reading(@vocabulary, @fact_type)
-            first_reading.make_embedded_constraints vocabulary
+            first_clause = @clauses[0]
+            @fact_type = first_clause.make_fact_type(@vocabulary)
+            first_clause.make_reading(@vocabulary, @fact_type)
+            first_clause.make_embedded_constraints vocabulary
             @fact_type.create_implicit_fact_type_for_unary if @fact_type.all_role.size == 1 && !@name
-            @existing_readings = [first_reading]
-          elsif (n = @readings.size - @existing_readings.size) > 0
+            @existing_clauses = [first_clause]
+          elsif (n = @clauses.size - @existing_clauses.size) > 0
             debug :binding, "Extending existing fact type with #{n} new readings"
           end
 
           # Now make any new readings:
-          new_readings = @readings - @existing_readings
-          new_readings.each do |reading|
-            reading.make_reading(@vocabulary, @fact_type)
-            reading.make_embedded_constraints vocabulary
+          new_clauses = @clauses - @existing_clauses
+          new_clauses.each do |clause|
+            clause.make_reading(@vocabulary, @fact_type)
+            clause.make_embedded_constraints vocabulary
           end
 
-          # If a reading matched but the match left extra adjectives, we need to make a new RoleSequence for them:
-          @existing_readings.each do |reading|
-            reading.adjust_for_match
+          # If a clause matched but the match left extra adjectives, we need to make a new RoleSequence for them:
+          @existing_clauses.each do |clause|
+            clause.adjust_for_match
+            # Add any new constraints that we found in the match (presence, ring, etc)
+            clause.make_embedded_constraints(vocabulary)
           end
 
           # Objectify the fact type if necessary:
@@ -73,34 +138,72 @@ module ActiveFacts
             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
-            @constellation.EntityType(@vocabulary, @name, :fact_type => @fact_type).create_implicit_fact_types
+            e = @constellation.EntityType(@vocabulary, @name, :fact_type => @fact_type)
+            e.create_implicit_fact_types
+            if @pragmas
+              e.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}"
+            end
+          end
+
+          @clauses.each do |clause|
+            next unless clause.context_note
+            clause.context_note.compile(@constellation, @fact_type)
           end
 
           # REVISIT: This isn't the thing to do long term; it needs to be added later only if we find no other constraint
-          make_default_identifier_for_fact_type
+          make_default_identifier_for_fact_type if @conditions.empty?
 
-          @readings.each do |reading|
-            next unless reading.context_note
-            reading.context_note.compile(@constellation, @fact_type)
+          # Compile the conditions:
+          super
+          unless @conditions.empty?
+            @clauses.each do |clause|
+              project_clause_roles(clause)
+            end
           end
 
           @fact_type
         end
 
-        def check_compatibility_of_matched_readings
-          @existing_readings = @readings.
-            select{ |reading| reading.match_existing_fact_type @context }.
-            sort_by{ |reading| reading.side_effects.cost }
-          fact_types = @existing_readings.map{ |reading| reading.fact_type }.uniq.compact
-          return nil if fact_types.empty? || @existing_readings[0].side_effects.cost != 0
+        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
+          end
+        end
+
+        # A Comparison in the conditions which projects a role is not treated as a comparison, just as projection
+        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|
+            @readings.include?(ref.reading)
+          end
+        end
+
+        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 }.
+            sort_by{ |clause| clause.side_effects.cost }
+          fact_types = @existing_clauses.map{ |clause| clause.fact_type }.uniq.compact
+
+          return nil if fact_types.empty?
+          # If there's only a single clause, the match must be exact:
+          return nil if @clauses.size == 1 && @existing_clauses[0].side_effects.cost != 0
           if (fact_types.size > 1)
             # There must be only one fact type with exact matches:
-            if @existing_readings[0].side_effects.cost != 0 or
-              @existing_readings.detect{|r| r.fact_type != fact_types[0] && r.side_effects.cost == 0 }
+            if @existing_clauses[0].side_effects.cost != 0 or
+              @existing_clauses.detect{|r| r.fact_type != fact_types[0] && r.side_effects.cost == 0 }
               raise "Clauses match different existing fact types '#{fact_types.map{|ft| ft.preferred_reading.expand}*"', '"}'"
             end
-            # Try to make false-matched readings match the chosen one instead
-            @existing_readings.reject!{|r| r.fact_type != fact_types[0] }
+            # Try to make false-matched clauses match the chosen one instead
+            @existing_clauses.reject!{|r| r.fact_type != fact_types[0] }
           end
           fact_types[0]
         end
@@ -125,9 +228,9 @@ module ActiveFacts
               end
 
           # If there's an existing presence constraint that can be converted into a PC, do that:
-          @readings.each do |reading|
-            rr = reading.role_refs[-1] or next
-            epc = rr.embedded_presence_constraint or next
+          @clauses.each do |clause|
+            var_ref = clause.var_refs[-1] or next
+            epc = var_ref.embedded_presence_constraint or next
             epc.max_frequency == 1 or next
             next if epc.enforcement
             epc.is_preferred_identifier = true
@@ -154,27 +257,27 @@ module ActiveFacts
         end
 
         def verify_matching_roles
-          role_refs_by_reading_and_key = {}
-          readings_by_role_refs =
-            @readings.inject({}) do |hash, reading|
-              keys = reading.role_refs.map do |rr|
-                key = rr.key.compact
-                role_refs_by_reading_and_key[[reading, key]] = rr
+          var_refs_by_clause_and_key = {}
+          clauses_by_var_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
                 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
-              (hash[keys] ||= []) << reading
+              (hash[keys] ||= []) << clause
               hash
             end
 
-          if readings_by_role_refs.size != 1
-            # Attempt loose binding here; it might merge some Compiler::RoleRefs to share the same Bindings
-            variants = readings_by_role_refs.keys
-            (readings_by_role_refs.size-1).downto(1) do |m|   # Start with the last one
+          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
               0.upto(m-1) do |l|                              # Try to rebind onto any lower one
                 common = variants[m]&variants[l]
-                readings_l = readings_by_role_refs[variants[l]]
-                readings_m = readings_by_role_refs[variants[m]]
+                clauses_l = clauses_by_var_refs[variants[l]]
+                clauses_m = clauses_by_var_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}"
@@ -184,16 +287,16 @@ module ActiveFacts
                   candidates = []
                   (0...m_keys.size).each do |j|
                     m_key = m_keys[j]
-                    l_role_ref = role_refs_by_reading_and_key[[readings_l[0], l_key]]
-                    m_role_ref = role_refs_by_reading_and_key[[readings_m[0], m_key]]
-                    debug :binding, "Can we match #{l_role_ref.inspect} (#{i}) with #{m_role_ref.inspect} (#{j})?"
-                    next if m_role_ref.player != l_role_ref.player
-                    if has_more_adjectives(m_role_ref, l_role_ref)
-                      debug :binding, "can rebind #{m_role_ref.inspect} to #{l_role_ref.inspect}"
-                      candidates << [m_role_ref, l_role_ref]
-                    elsif has_more_adjectives(l_role_ref, m_role_ref)
-                      debug :binding, "can rebind #{l_role_ref.inspect} to #{m_role_ref.inspect}"
-                      candidates << [l_role_ref, m_role_ref]
+                    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]
                     end
                   end
 
@@ -207,12 +310,12 @@ module ActiveFacts
                 end
                 if (rebindings == l_keys.size)
                   # Successfully rebound this fact type
-                  debug :binding, "Successfully rebound readings #{readings_l.map{|r|r.inspect}*'; '} on to #{readings_m.map{|r|r.inspect}*'; '}"
+                  debug :binding, "Successfully rebound clauses #{clauses_l.map{|r|r.inspect}*'; '} on to #{clauses_m.map{|r|r.inspect}*'; '}"
                   break
                 else
                   # No point continuing, we failed on this one.
                   raise "All readings in a fact type definition must have matching role players, compare (#{
-                      readings_by_role_refs.keys.map do |keys|
+                      clauses_by_var_refs.keys.map do |keys|
                         keys.map{|key| key*'-' }*", "
                       end*") with ("
                     })"
@@ -220,11 +323,25 @@ module ActiveFacts
 
               end
             end
-          # else all readings already matched
+          # else all clauses already matched
           end
         end
-      end
 
+        def to_s
+          if @conditions.size > 0
+            true
+          end
+          "FactType: #{(s = super and !s.empty?) ? "#{s} " : '' }#{@clauses.inspect}" +
+            if @conditions && !@conditions.empty?
+              " where "+@conditions.map{|c| ((j=c.conjunction) ? j+' ' : '') + c.to_s}*' '
+            else
+              ''
+            end +
+            (@pragmas && @pragmas.size > 0 ? ", pragmas [#{@pragmas.sort*','}]" : '')
+
+          # REVISIT: @returning = returning
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,159 @@
+module ActiveFacts
+  module CQL
+    class Compiler < ActiveFacts::CQL::Parser
+      class Definition
+        # Make a JoinNode for every variable present in these clauses
+        def build_join_nodes(clauses_list)
+          debug :join, "Building join nodes" do
+            join = @constellation.Join(:new)
+            all_variables_in_clauses(clauses_list).
+              each do |variable|
+                debug :join, "Creating join node #{join.all_join_node.size} for #{variable.inspect}"
+                variable.join_node = @constellation.JoinNode(join, join.all_join_node.size, :object_type => variable.player)
+                if literal = variable.refs.detect{|r| r.literal}
+                  unit = @constellation.Unit.detect{|k, v| [v.name, v.plural_name].include? literal.unit} if literal.unit
+                  variable.join_node.value = [literal.literal.to_s, literal.is_a?(String), unit]
+                end
+              end
+            join
+          end
+        end
+
+        def build_all_join_steps(clauses_list)
+          roles_by_variable = {}
+          debug :join, "Building join steps" do
+            clauses_list.each do |clause|
+              next if clause.is_naked_object_type
+              build_join_steps(clause, roles_by_variable)
+            end
+          end
+          roles_by_variable
+        end
+
+        def build_join_steps clause, roles_by_variable = {}, objectification_node = nil
+          join_roles = []
+          incidental_roles = []
+          debug :join, "Creating join Role Sequence for #{clause.inspect} with #{clause.var_refs.size} role refs" do
+            objectification_step = nil
+            clause.var_refs.each do |var_ref|
+              # These var_refs are the Compiler::VarRefs, which have associated Metamodel::RoleRefs,
+              # but we need to create JoinRoles for those roles.
+              # REVISIT: JoinRoles may need to save residual_adjectives
+              variable = var_ref.variable
+              role = (var_ref && var_ref.role) || (var_ref.role_ref && var_ref.role_ref.role)
+              join_role = nil
+
+              debugger unless clause.fact_type
+              if (clause.fact_type.entity_type)
+                # This clause is of an objectified fact type.
+                # We need a join step from this role to the phantom role, but not
+                # for a role that has only one var_ref (this one) in their variable.
+                # Create the JoinNode and JoinRole in any case though.
+                refs_count = variable.refs.size
+                objectification_ref_count = 0
+                if var_ref.nested_clauses
+                  var_ref.nested_clauses.each do |ojc|
+                    objectification_ref_count += ojc.var_refs.select{|var_ref| var_ref.variable.refs.size > 1}.size
+                  end
+                end
+                refs_count += objectification_ref_count
+
+                debug :join, "Creating Join Node #{var_ref.inspect} (counts #{refs_count}/#{objectification_ref_count}) and objectification Join Step for #{var_ref.inspect}" do
+
+                  raise "Internal error: Trying to add role of #{role.object_type.name} to join node for #{variable.join_node.object_type.name}" unless variable.join_node.object_type == role.object_type
+                  join_role = @constellation.JoinRole(variable.join_node, role)
+
+                  if (refs_count <= 1)   # Our work here is done if there are no other refs
+                    if objectification_step
+                      join_role.join_step = objectification_step
+                    else
+                      incidental_roles << join_role
+                    end
+                    next
+                  end
+
+                  join_roles << join_role
+                  unless objectification_node
+                    # This is an implicit objectification, just the FT clause, not ET(where ...clause...)
+                    # We need to create a JoinNode for this object, even though it has no VarRefs
+                    join = variable.join_node.join
+                    debug :join, "Creating JN#{join.all_join_node.size} for #{clause.fact_type.entity_type.name} in objectification"
+                    objectification_node = @constellation.JoinNode(join, join.all_join_node.size, :object_type => clause.fact_type.entity_type)
+                  end
+                  raise "Internal error: Trying to add role of #{role.implicit_fact_type.all_role.single.object_type.name} to join node for #{objectification_node.object_type.name}" unless objectification_node.object_type == role.implicit_fact_type.all_role.single.object_type
+
+                  irole = role.implicit_fact_type.all_role.single
+                  raise "Internal error: Trying to add role of #{irole.object_type.name} to join node for #{objectification_node.object_type.name}" unless objectification_node.object_type == irole.object_type
+                  objectification_role = @constellation.JoinRole(objectification_node, role.implicit_fact_type.all_role.single)
+                  objectification_step = @constellation.JoinStep(objectification_role, join_role, :fact_type => role.implicit_fact_type)
+                  debug :join, "New #{objectification_step.describe}"
+                  debug :join, "Associating #{incidental_roles.map(&:describe)*', '} incidental roles with #{objectification_step.describe}" if incidental_roles.size > 0
+                  incidental_roles.each { |jr| jr.join_step = objectification_step }
+                  incidental_roles = []
+                  join_roles = []
+                end
+              else
+                debug :join, "Creating VarRef for #{var_ref.inspect}" do
+                    # REVISIT: If there's an implicit subtyping join 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 join steps.
+                  if variable.join_node.object_type != role.object_type and
+                    0 == (variable.join_node.object_type.supertypes_transitive & role.object_type.supertypes_transitive).size
+                    raise "Internal error: Trying to add role of #{role.object_type.name} to join node #{variable.join_node.ordinal} for #{variable.join_node.object_type.name} in '#{clause.fact_type.default_reading}'"
+                  end
+                  raise "Internal error: Trying to add role of #{role.object_type.name} to join node #{variable.join_node.ordinal} for #{variable.join_node.object_type.name}" unless variable.join_node.object_type == role.object_type
+                  begin
+                    join_role = @constellation.JoinRole(variable.join_node, role)
+                  rescue ArgumentError => e
+                    join_role = @constellation.JoinRole(variable.join_node, role)
+                  end
+                  join_roles << join_role
+                end
+              end
+
+              if var_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 join step.
+                var_ref.nested_clauses.each do |r|
+                  debug :join, "Building objectification join for #{var_ref.nested_clauses.inspect}" do
+                    build_join_steps r, roles_by_variable, variable.join_node
+                  end
+                end
+              end
+              roles_by_variable[variable] = [role, join_role]
+            end
+          end
+
+          if join_roles.size > 0
+            end_node = join_roles[-1].join_node
+            if !clause.fact_type.entity_type and role = clause.fact_type.all_role.single
+              # Don't give the ImplicitBoolean a join_node. We can live without one, for now.
+              # The Join Step will have a duplicate node, and the fact type will tell us what's happening
+              join_roles << join_roles[0]
+            end
+            # We aren't talking about objectification here, so there must be exactly two roles.
+            raise "REVISIT: Internal error constructing join for #{clause.inspect}" if join_roles.size != 2
+            js = @constellation.JoinStep(join_roles[0], join_roles[1], :fact_type => clause.fact_type)
+            debug :join, "New Join Step #{js.describe}"
+            debug :join, "Associating #{incidental_roles.map(&:describe)*', '} incidental roles with #{js.describe}" if incidental_roles.size > 0
+            incidental_roles.each { |jr| jr.join_step = js }
+          end
+          roles_by_variable
+        end
+
+        # Return the unique array of all variables in these clauses, including in objectification joins
+        def all_variables_in_clauses clauses
+          clauses.map do |clause|
+            clause.var_refs.map do |var_ref|
+              raise "Variable reference #{var_ref.inspect} is not bound to a variable" unless var_ref.variable
+              [var_ref.variable] + (var_ref.nested_clauses ? all_variables_in_clauses(var_ref.nested_clauses) : [])
+            end
+          end.
+            flatten.
+            uniq
+        end
+      end
+    end
+  end
+end