activefacts 1.6.0 → 1.7.1

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

@@ -1,421 +0,0 @@
-module ActiveFacts
-  module CQL
-    class Compiler < ActiveFacts::CQL::Parser
-
-      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, conditions = nil, returning = nil
-          super name
-          @conditions = conditions
-          @returning = returning || []
-        end
-
-	def to_s
-	  inspect
-	end
-
-        def inspect
-          "Query: " +
-	    if @conditions.empty?
-	      ''
-	    else
-	      'where ' + @conditions.map{|c| ((j=c.conjunction) ? j+' ' : '') + c.inspect}*' '
-	    end
-          # REVISIT: @returning = returning
-        end
-
-        def prepare_roles clauses = nil
-          trace :binding, "preparing roles" do
-            @context ||= CompilationContext.new(@vocabulary)
-            @context.bind clauses||[], @conditions, @returning
-          end
-        end
-
-        def compile
-          # 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 query:
-          unless @conditions.empty? and @returning.empty?
-            trace :query, "building query for derived fact type (returning #{@returning}) with #{@conditions.size} conditions: (#{@conditions.map{|c|c.inspect}*', '})" do
-              @query = build_variables(@conditions.flatten)
-              @roles_by_binding = build_all_steps(@conditions)
-              @query.validate
-              @query
-            end
-          end
-          @context.left_contraction_allowed = false
-          @query
-        end
-
-        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
-          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 (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 @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
-          #
-
-	  # 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, :concept => :new)
-	  end
-
-          prepare_roles @clauses
-
-          # REVISIT: Compiling the conditions here make it impossible to define a self-referential (transitive) query.
-          return super if @clauses.empty?  # It's a query
-
-          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
-            # Make a new fact type:
-            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_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 }
-            trace :binding, "Extending existing fact type with #{n} new readings"
-          end
-
-          # Now make any new readings:
-          new_clauses = @clauses - @existing_clauses
-          new_clauses.each do |clause|
-            clause.make_reading(@vocabulary, @fact_type)
-            clause.make_embedded_constraints vocabulary
-          end
-
-          # 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
-
-          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
-            ifts = @entity_type.create_implicit_fact_types
-	    create_implicit_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
-
-          @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 if @conditions.empty?
-
-          # Compile the conditions:
-          super
-          unless @conditions.empty?
-            @clauses.each do |clause|
-              project_clause_roles(clause)
-            end
-          end
-
-          @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 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
-
-        # 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.binding.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 }.
-            # 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 }
-          fact_types = @existing_clauses.map{ |clause| clause.fact_type }.uniq.compact
-
-          return nil if fact_types.empty?   # There are no matched fact types
-
-          if @clauses.size == 1 && @existing_clauses[0].side_effects.cost != 0
-            trace :matching, "There's only a single clause, but it's not an exact match"
-            return nil
-          end
-
-          if (fact_types.size > 1)
-            # There must be only one fact type with exact matches:
-            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 clauses match the chosen one instead
-            @existing_clauses.reject!{|r| r.fact_type != fact_types[0] }
-          end
-          fact_types[0]
-        end
-
-        def make_default_identifier_for_fact_type(prefer = true)
-          # Non-objectified unaries don't need a PI:
-          return if @fact_type.all_role.size == 1 && !@fact_type.entity_type
-
-          # It's possible that this fact type is objectified and inherits identification through a supertype.
-          return if @fact_type.entity_type and @fact_type.entity_type.all_type_inheritance_as_subtype.detect{|ti| ti.provides_identification}
-
-          # If it's a non-objectified binary and there's an alethic uniqueness constraint over the fact type already, we're done
-          return if !@fact_type.entity_type &&
-            @fact_type.all_role.size == 2 &&
-            @fact_type.all_role.
-              detect do |r|
-                r.all_role_ref.detect do |rr|
-                  rr.role_sequence.all_presence_constraint.detect do |pc|
-                    pc.max_frequency == 1 && !pc.enforcement
-                  end
-                end
-              end
-
-          # If there's an existing presence constraint that can be converted into a PC, do that:
-          @clauses.each do |clause|
-            ref = clause.refs[-1] or next
-            epc = ref.embedded_presence_constraint or next
-            epc.max_frequency == 1 or next
-            next if epc.enforcement
-            trace :constraint, "Converting UC into PI for #{@fact_type.entity_type.name}"
-            epc.is_preferred_identifier = true
-            return
-          end
-
-          # 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}"
-            end
-	  end
-        end
-
-        def has_more_adjectives(less, more)
-          return false if less.leading_adjective && less.leading_adjective != more.leading_adjective
-          return false if less.trailing_adjective && less.trailing_adjective != more.trailing_adjective
-          return true
-        end
-
-        def verify_matching_roles
-          refs_by_clause_and_key = {}
-          clauses_by_refs =
-            @clauses.inject({}) do |hash, clause|
-              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
-              (hash[keys] ||= []) << clause
-              hash
-            end
-
-          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_refs[variants[l]]
-                clauses_m = clauses_by_refs[variants[m]]
-                l_keys = variants[l]-common
-                m_keys = variants[m]-common
-                trace :binding, "Try to collapse variant #{m} onto #{l}; diffs are #{l_keys.inspect} -> #{m_keys.inspect}"
-                rebindings = 0
-                l_keys.each_with_index do |l_key, i|
-                  # Find possible rebinding candidates; there must be exactly one.
-                  candidates = []
-                  (0...m_keys.size).each do |j|
-                    m_key = m_keys[j]
-                    l_ref = refs_by_clause_and_key[[clauses_l[0], l_key]]
-                    m_ref = refs_by_clause_and_key[[clauses_m[0], m_key]]
-                    trace :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)
-                      trace :binding, "can rebind #{m_ref.inspect} to #{l_ref.inspect}"
-                      candidates << [m_ref, l_ref]
-                    elsif has_more_adjectives(l_ref, m_ref)
-                      trace :binding, "can rebind #{l_ref.inspect} to #{m_ref.inspect}"
-                      candidates << [l_ref, m_ref]
-                    end
-                  end
-
-                  # trace :binding, "found #{candidates.size} rebinding candidates for this role"
-                  trace :binding, "rebinding is ambiguous so not attempted" if candidates.size > 1
-                  if (candidates.size == 1)
-                    candidates[0][0].rebind_to(@context, candidates[0][1])
-                    rebindings += 1
-                  end
-
-                end
-                if (rebindings == l_keys.size)
-                  # Successfully rebound this fact type
-                  trace :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 (#{
-                      clauses_by_refs.keys.map do |keys|
-                        keys.map{|key| key*'-' }*", "
-                      end*") with ("
-                    })"
-                end
-
-              end
-            end
-          # else all clauses already matched
-          end
-        end
-
-        def inspect
-	  s = super
-          "FactType: #{@conditions.size > 0 ? super+' ' : '' }#{@clauses.inspect}" +
-            (@pragmas && @pragmas.size > 0 ? ", pragmas [#{@pragmas.flatten.sort*','}]" : '')
-
-          # REVISIT: @returning = returning
-        end
-      end
-    end
-  end
-end

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

@@ -1,106 +0,0 @@
-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)
-          trace :query, "Building variables" do
-            query = @constellation.Query(:new)
-            all_bindings_in_clauses(clauses_list).
-              each do |binding|
-                trace :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 = {}
-          trace :query, "Building steps" do
-            clauses_list.each do |clause|
-              build_step(clause, roles_by_binding)
-            end
-          end
-          roles_by_binding
-        end
-
-        def build_step clause, roles_by_binding = {}, parent_variable = nil
-	  return unless clause.refs.size > 0  # Empty clause... really?
-
-	  step = @constellation.Step(
-	      :guid => :new,
-	      :fact_type => clause.fact_type,
-	      :alternative_set => nil,
-	      :is_disallowed => clause.certainty == false,
-	      :is_optional => clause.certainty == nil
-	    )
-
-	  trace :query, "Creating Plays for #{clause.inspect} with #{clause.refs.size} refs" do
-	    is_input = true
-	    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)
-
-	      objectification_step = nil
-	      if ref.nested_clauses
-		ref.nested_clauses.each do |nested_clause|
-		  objectification_step = build_step nested_clause, roles_by_binding
-		  if ref.binding.player.is_a?(ActiveFacts::Metamodel::EntityType) and
-		      ref.binding.player.fact_type == nested_clause.fact_type
-		    objectification_step.objectification_variable = binding.variable
-		  end
-		end
-	      end
-	      if clause.is_naked_object_type
-		raise "#{self} lacks a proper objectification" if clause.refs[0].nested_clauses and !objectification_step
-		return objectification_step
-	      end
-
-	      if binding.variable.object_type != role.object_type	  # Type mismatch
-		if binding.variable.object_type.common_supertype(role.object_type)
-		  # REVISIT: 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.
-		  raise "Disallowing implicit subtyping step from #{role.object_type.name} to #{binding.variable.object_type.name} in #{clause.fact_type.default_reading.inspect}"
-		end
-		raise "A #{role.object_type.name} cannot satisfy #{binding.variable.object_type.name} in #{clause.fact_type.default_reading.inspect}"
-	      end
-
-	      trace :query, "Creating Play for #{ref.inspect}"
-	      play = @constellation.Play(:step => step, :role => role, :variable => binding.variable)
-	      play.is_input = is_input
-	      is_input = false
-
-	      roles_by_binding[binding] = [role, play]
-	    end
-	  end
-
-	  step
-	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