activefacts 0.8.16 → 0.8.18

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

@@ -4,7 +4,7 @@ module ActiveFacts
 
       # An Operation is a binary or ternary fact type involving an operator,
       # a result, and one or two operands.
-      # Viewed as a result, it behaves like a VarRef with a nested Clause.
+      # Viewed as a result, it behaves like a Reference with a nested Clause.
       # Viewed as a fact type, it behaves like a Clause.
       #
       # The only exception here is an equality comparison, where it may
@@ -12,11 +12,11 @@ module ActiveFacts
       # the Operation is dropped from the clauses and is replaced by the
       # projected operand.
       #
-      # Each operand may be a Literal, a VarRef, or another Operation,
-      # so we need to recurse down the tree to build the join.
+      # Each operand may be a Literal, a Reference, or another Operation,
+      # so we need to recurse down the tree to build the query.
       #
       class Operation
-        # VarRef (in)compatibility:
+        # Reference (in)compatibility:
         [ :term, :leading_adjective, :trailing_adjective, :role_name, :quantifier,
           :value_constraint, :embedded_presence_constraint, :literal
         ].each do |s|
@@ -28,15 +28,16 @@ module ActiveFacts
         def trailing_adjective; nil; end
         def value_constraint; nil; end
         def literal; nil; end
-        attr_accessor :player     # What ObjectType does the Variable denote
-        attr_accessor :variable   # What Variable for that ObjectType
+	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?
         attr_accessor :role       # Which Role of this ObjectType
         attr_accessor :role_ref   # Which RoleRef to that Role
+        attr_accessor :certainty  # nil, true, false -> maybe, definitely, not
         def nested_clauses; @nested_clauses ||= [self]; end
         def clause; self; end
         def objectification_of; @fact_type; end
-
         # Clause (in)compatibility:
         [ :phrases, :qualifiers, :context_note, :reading, :role_sequence, :fact
         ].each do |s|
@@ -45,7 +46,11 @@ module ActiveFacts
         end
         def conjunction; nil; end
         attr_reader :fact_type
-        def objectified_as; self; end   # The VarRef which objectified this fact type
+        def objectified_as; self; end   # The Reference which objectified this fact type
+
+	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}"
@@ -53,7 +58,7 @@ module ActiveFacts
 
         def identify_players_with_role_name context
           # Just recurse, there's no way (yet: REVISIT?) to add a role name to the result of an expression
-          var_refs.each { |o|
+          refs.each { |o|
             o.identify_players_with_role_name(context)
           }
           # As yet, an operation cannot have a role name:
@@ -62,22 +67,22 @@ module ActiveFacts
 
         def identify_other_players context
           # Just recurse, there's no way (yet: REVISIT?) to add a role name to the result of an expression
-          var_refs.each { |o|
+          refs.each { |o|
             o.identify_other_players(context)
           }
           identify_player context
         end
 
         def bind context
-          var_refs.each do |o|
+          refs.each do |o|
             o.bind context
           end
           name = result_type_name(context)
           @player = result_value_type(context, name)
-          key = "#{name} #{object_id}"  # Every Operation result is a unique Variable
-          @variable = (context.variables[key] ||= Variable.new(@player))
-          @variable.refs << self
-          @variable
+          key = "#{name} #{object_id}"  # Every Operation result is a unique Binding
+          @binding = (context.bindings[key] ||= Binding.new(@player))
+          @binding.refs << self
+          @binding
         end
 
         def result_type_name(context)
@@ -87,7 +92,8 @@ module ActiveFacts
         def result_value_type(context, name)
           vocabulary = context.vocabulary
           constellation = vocabulary.constellation
-          constellation.ValueType(vocabulary, name, :guid => :new)
+	  vocabulary.valid_value_type_name(name) ||
+	    constellation.ValueType(vocabulary, name, :guid => :new)
         end
 
         def is_naked_object_type
@@ -95,22 +101,25 @@ module ActiveFacts
         end
 
         def match_existing_fact_type context
-          opnds = var_refs
-          result_var_ref = VarRef.new(@variable.player.name)
-          result_var_ref.player = @variable.player
-          result_var_ref.variable = @variable
-          @variable.refs << result_var_ref
+          opnds = refs
+          result_ref = Reference.new(@binding.player.name)
+          result_ref.player = @binding.player
+          result_ref.binding = @binding
+          @binding.refs << result_ref
           clause_ast = Clause.new(
-            [result_var_ref, '='] +
+            [result_ref, '='] +
               (opnds.size > 1 ? [opnds[0]] : []) +
               [operator, opnds[-1]]
           )
 
           # REVISIT: All operands must be value-types or simply-identified Entity Types.
 
-          # REVISIT: We should auto-create joins from Entity Types to an identifying ValueType
+          # 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
           return @fact_type if @fact_type
 
           @fact_type = clause_ast.make_fact_type context.vocabulary
@@ -121,6 +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
           end
           @fact_type
         end
@@ -142,16 +154,16 @@ module ActiveFacts
       class Comparison < Operation
         attr_accessor :operator, :e1, :e2, :qualifiers, :conjunction
 
-        def initialize operator, e1, e2, qualifiers = []
-          @operator, @e1, @e2, @qualifiers = operator, e1, e2, qualifiers
+        def initialize operator, e1, e2, certainty = true
+          @operator, @e1, @e2, @certainty, @qualifiers = operator, e1, e2, certainty, []
         end
 
-        def var_refs
+        def refs
           [@e1, @e2]
         end
 
         def bind context
-          var_refs.each do |o|
+          refs.each do |o|
             o.bind context
           end
 
@@ -160,10 +172,10 @@ module ActiveFacts
 
           name = 'Boolean'
           @player = result_value_type(context, name)
-          key = "#{name} #{object_id}"  # Every Comparison result is a unique Variable
-          @variable = (context.variables[key] ||= Variable.new(@player))
-          @variable.refs << self
-          @variable
+          key = "#{name} #{object_id}"  # Every Comparison result is a unique Binding
+          @binding = (context.bindings[key] ||= Binding.new(@player))
+          @binding.refs << self
+          @binding
         end
 
         def result_type_name(context)
@@ -180,7 +192,10 @@ module ActiveFacts
               raise "REVISIT: The player is the projected expression"
             end
             v = context.vocabulary
-            @player = v.constellation.ValueType(v, 'Boolean', :guid => :new)
+            @boolean ||=
+	      v.constellation.ValueType[[[v.name], 'Boolean']] ||
+	      v.constellation.ValueType(v, 'Boolean', :guid => :new)
+            @player = @boolean
           end
         end
 
@@ -195,7 +210,21 @@ module ActiveFacts
         def inspect; to_s; end
 
         def to_s
-          "compare#{operator}(#{e1.to_s} #{e2.to_s}#{@qualifiers.empty? ? '' : ', ['+@qualifiers*', '+']'})"
+          "compare#{
+	    operator
+	  }(#{
+	    case @certainty
+	    when nil; 'maybe '
+	    when false; 'negated '
+	    # else 'definitely '
+	    end
+          }#{
+	    e1.to_s
+	  } #{
+	    e2.to_s
+	  }#{
+	    @qualifiers.empty? ? '' : ', ['+@qualifiers*', '+']'
+	  })"
         end
       end
 
@@ -205,7 +234,7 @@ module ActiveFacts
           @terms = terms
         end
 
-        def var_refs
+        def refs
           @terms
         end
 
@@ -250,7 +279,7 @@ module ActiveFacts
           @factors = factors
         end
 
-        def var_refs
+        def refs
           @factors
         end
 
@@ -298,7 +327,7 @@ module ActiveFacts
           '1/'
         end
 
-        def var_refs
+        def refs
           [@divisor]
         end
 
@@ -396,20 +425,20 @@ module ActiveFacts
               when TrueClass, FalseClass; 'Boolean'
               end
             v = context.vocabulary
-            @player = v.constellation.ValueType(v, player_name, :guid => :new)
+            @player = v.constellation.ValueType(v, player_name)
           end
         end
 
         def bind context
-          @variable || begin
+          @binding || begin
             key = "#{@player.name} #{@literal}"
-            @variable = (context.variables[key] ||= Variable.new(@player))
-            @variable.refs << self
+            @binding = (context.bindings[key] ||= Binding.new(@player))
+            @binding.refs << self
           end
         end
 
-        def variable
-          @variable
+        def binding
+          @binding
         end
       end
 

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

@@ -9,12 +9,18 @@ module ActiveFacts
         end
 
         def compile
-          @population = @constellation.Population(@vocabulary, @population_name, :guid => :new)
+          @population = @constellation.Population[[@vocabulary.identifying_role_values, @population_name]] ||
+	      @constellation.Population(@vocabulary, @population_name, :guid => :new)
 
           @context = CompilationContext.new(@vocabulary)
           @context.bind @clauses
           @context.left_contraction_allowed = true
-          @clauses.each{ |clause| clause.match_existing_fact_type @context }
+          @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
 
           # Figure out the simple existential facts and find fact types:
           @bound_facts = []
@@ -39,24 +45,24 @@ module ActiveFacts
           # Every bound word (term) in the phrases must have a literal
           # OR be bound to an entity type identified by the phrases
 
-          # Any clause that has one variable and no other word is
+          # Any clause that has one binding and no other word is
           # either a value instance or a simply-identified entity.
-          clause.var_refs.each do |var_ref|
-            next unless l = var_ref.literal    # No literal
-            next if var_ref.variable.instance   # Already bound
-            player = var_ref.variable.player
-            # raise "A literal may not be an objectification" if var_ref.role_ref.nested_clauses
-            # raise "Not processing facts involving nested clauses yet" if var_ref.role_ref
+          clause.refs.each do |ref|
+            next unless l = ref.literal    # No literal
+            next if ref.binding.instance   # Already bound
+            player = ref.binding.player
+            # raise "A literal may not be an objectification" if ref.role_ref.nested_clauses
+            # raise "Not processing facts involving nested clauses yet" if ref.role_ref
             debug :instance, "Making #{player.class.basename} #{player.name} using #{l.inspect}" do
-              var_ref.variable.instance = instance_identified_by_literal(player, l)
+              ref.binding.instance = instance_identified_by_literal(player, l)
             end
-            var_ref
+            ref
           end
 
-          if clause.phrases.size == 1 and (var_ref = clause.phrases[0]).is_a?(Compiler::VarRef)
-            if var_ref.nested_clauses
+          if clause.phrases.size == 1 and (ref = clause.phrases[0]).is_a?(Compiler::Reference)
+            if ref.nested_clauses
               # Assign the objectified fact type as this clause's fact type?
-              clause.fact_type = var_ref.player.fact_type
+              clause.fact_type = ref.player.fact_type
               clause
             else
               # This is an existential fact (like "Name 'foo'", or "Company 'Microsoft'")
@@ -64,7 +70,7 @@ module ActiveFacts
             end
           else
             raise "Fact Type not found: '#{clause.display}'" unless clause.fact_type
-            # This instance will be associated with its variable by our caller
+            # This instance will be associated with its binding by our caller
             clause
           end
         end
@@ -76,26 +82,26 @@ module ActiveFacts
           return true if clause.fact
 
           # Find the roles of this clause that do not yet have an instance
-          bare_roles = clause.var_refs.
-            select do |var_ref|
-              next false if var_ref.variable.instance
-              next false if var_ref.literal and
-                var_ref.variable.instance = instance_identified_by_literal(var_ref.variable.player, var_ref.literal)
+          bare_roles = clause.refs.
+            select do |ref|
+              next false if ref.binding.instance
+              next false if ref.literal and
+                ref.binding.instance = instance_identified_by_literal(ref.binding.player, ref.literal)
               true
             end
 
           debug :instance, "Considering '#{clause.display}' with "+
-            (bare_roles.empty? ? "no bare roles" : "bare roles: #{bare_roles.map{|var_ref| var_ref.player.name}*", "}") do
+            (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)
 
             progress = false
             if bare_roles.size == 1 &&
-                (variable = bare_roles[0].variable) &&
-                (et = variable.player).is_a?(ActiveFacts::Metamodel::EntityType)
+                (binding = bare_roles[0].binding) &&
+                (et = binding.player).is_a?(ActiveFacts::Metamodel::EntityType)
               if et.preferred_identifier.role_sequence.all_role_ref.detect{|rr| rr.role.fact_type == clause.fact_type} &&
-                bind_entity_if_identifier_ready(clause, et, variable)
+                bind_entity_if_identifier_ready(clause, et, binding)
                 progress = true
               end
             end
@@ -127,19 +133,19 @@ module ActiveFacts
         # Occasionally we need to search through all the clauses:
         def all_clauses
           @clauses.map do |clause|
-            [clause] + clause.var_refs.map{|vr| vr.nested_clauses}
+            [clause] + clause.refs.map{|vr| vr.nested_clauses}
           end.flatten.compact
         end
 
         def bind_complete_fact clause
           return true unless clause.fact_type  # An bare objectification
-          debug :instance, "All variables in '#{clause.display}' contain instances; create the fact type"
-          instances = clause.var_refs.map{|vr| vr.variable.instance}
+          debug :instance, "All bindings in '#{clause.display}' contain instances; create the fact type"
+          instances = clause.refs.map{|vr| vr.binding.instance}
           debug :instance, "Instances are #{instances.map{|i| "#{i.object_type.name} #{i.value.inspect}"}*", "}"
 
           if e = clause.fact_type.entity_type and
-            clause.var_refs[0].variable.instance.object_type == e
-            fact = clause.var_refs[0].variable.instance.fact
+            clause.refs[0].binding.instance.object_type == e
+            fact = clause.refs[0].binding.instance.fact
           else
             # Check that this fact doesn't already exist
             fact = clause.fact_type.all_fact.detect do |f|
@@ -169,7 +175,7 @@ module ActiveFacts
 
           if !fact.instance && clause.fact_type.entity_type
             # Objectified fact type; create the instance
-            # Create the instance that objectifies this fact. We don't have the variable to assign it to though; that'll happen in our caller
+            # Create the instance that objectifies this fact. We don't have the binding to assign it to though; that'll happen in our caller
             debug :instance, "Objectifying fact as #{clause.fact_type.entity_type.name}"
             instance =
               @constellation.Instance(:new, :object_type => clause.fact_type.entity_type, :fact => fact, :population => @population)
@@ -179,8 +185,8 @@ module ActiveFacts
           if clause.fact and
             clause.objectified_as and
             instance = clause.fact.instance and
-            instance.object_type == clause.objectified_as.variable.player
-            clause.objectified_as.variable.instance = instance
+            instance.object_type == clause.objectified_as.binding.player
+            clause.objectified_as.binding.instance = instance
           end
 
           true
@@ -189,20 +195,20 @@ module ActiveFacts
         # If we have one bare role (no literal or instance) played by an entity type,
         # and the bound fact type participates in the identifier, we might now be able
         # to create the entity instance.
-        def bind_entity_if_identifier_ready clause, entity_type, variable
+        def bind_entity_if_identifier_ready clause, entity_type, binding
           # Check this instance doesn't already exist already:
-          identifying_variable = (clause.var_refs.map{|vr| vr.variable}-[variable])[0]
-          return false unless identifying_variable # This happens when we have a bare objectification
-          identifying_instance = identifying_variable.instance
+          identifying_binding = (clause.refs.map{|vr| vr.binding}-[binding])[0]
+          return false unless identifying_binding # This happens when we have a bare objectification
+          identifying_instance = identifying_binding.instance
           preferred_identifier = entity_type.preferred_identifier
 
-          debug :instance, "This clause associates a new #{variable.player.name} with a #{identifying_variable.player.name}#{identifying_instance ? " which exists" : ""}"
+          debug :instance, "This clause associates a new #{binding.player.name} with a #{identifying_binding.player.name}#{identifying_instance ? " which exists" : ""}"
 
           identifying_role_ref = preferred_identifier.role_sequence.all_role_ref.detect { |rr|
-              rr.role.fact_type == clause.fact_type && rr.role.object_type == identifying_variable.player
+              rr.role.fact_type == clause.fact_type && rr.role.object_type == identifying_binding.player
             }
           unless identifying_role_ref
-            # This shold never happen; we already bound all var_refs
+            # This shold never happen; we already bound all refs
             debug :instance, "Failed to find a #{identifying_instance.object_type.name}"
             return false # We can't do this yet
           end
@@ -212,37 +218,37 @@ module ActiveFacts
           if role_value
             instance = (role_value.fact.all_role_value.to_a-[role_value])[0].instance
             debug :instance, "Found an existing instance (of #{instance.object_type.name}) from a previous definition"
-            variable.instance = instance
+            binding.instance = instance
             return true  # Done with this clause
           end
 
           pi_role_refs = preferred_identifier.role_sequence.all_role_ref
-          # For each pi role, we have to find the fact clause, which contains the variable we need.
+          # For each pi role, we have to find the fact clause, which contains the binding we need.
           # Then we have to create an instance of each fact
           identifiers =
             pi_role_refs.map do |rr|
-              # Find a clause that provides the identifying_var_ref for this player:
+              # Find a clause that provides the identifying_ref for this player:
               identifying_clause = all_clauses.detect do |clause|
                 rr.role.fact_type == clause.fact_type &&
-                  clause.var_refs.detect{|vr| vr.variable == variable}
+                  clause.refs.detect{|vr| vr.binding == binding}
               end
               return false unless identifying_clause
-              identifying_var_ref = identifying_clause.var_refs.select{|var_ref| var_ref.variable != variable}[0]
-              identifying_variable = identifying_var_ref ? identifying_var_ref.variable : nil
-              identifying_instance = identifying_variable.instance
+              identifying_ref = identifying_clause.refs.select{|ref| ref.binding != binding}[0]
+              identifying_binding = identifying_ref ? identifying_ref.binding : nil
+              identifying_instance = identifying_binding.instance
 
-              [rr, identifying_clause, identifying_variable, identifying_instance]
+              [rr, identifying_clause, identifying_binding, identifying_instance]
             end
           if identifiers.detect{ |i| !i[3] }  # Not all required facts are bound yet
-            debug :instance, "Can't go through with creating #{variable.player.name}; not all the identifying facts are in"
+            debug :instance, "Can't go through with creating #{binding.player.name}; not all the identifying facts are in"
             return false
           end
 
-          debug :instance, "Going ahead with creating #{variable.player.name} using #{identifiers.size} roles" do
+          debug :instance, "Going ahead with creating #{binding.player.name} using #{identifiers.size} roles" do
             instance = @constellation.Instance(:new, :object_type => entity_type, :population => @population)
-            variable.instance = instance
+            binding.instance = instance
             @bound_facts << instance
-            identifiers.each do |rr, identifying_clause, identifying_variable, identifying_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 =
@@ -263,13 +269,13 @@ module ActiveFacts
           else
             debug :instance, "Making ValueType #{object_type.name} #{literal.inspect} #{@population.name.size>0 ? " in "+@population.name.inspect : ''}" do
 
-              is_a_string = String === literal
+              is_literal_string = literal.literal.is_a?(String)
               instance = @constellation.Instance.detect do |key, i|
                   # REVISIT: And same unit
                   i.population == @population &&
                     i.value &&
                     i.value.literal == literal &&
-                    i.value.is_a_string == is_a_string
+                    i.value.is_literal_string == is_literal_string
                 end
               #instance = object_type.all_instance.detect { |instance|
               #  instance.population == @population && instance.value == literal
@@ -279,7 +285,7 @@ module ActiveFacts
                 instance = @constellation.Instance(:new)
                 instance.object_type = object_type
                 instance.population = @population
-                instance.value = [literal.to_s, is_a_string, nil]
+                instance.value = [literal.to_s, is_literal_string, nil]
                 @bound_facts << instance
               end
               instance
@@ -294,7 +300,7 @@ module ActiveFacts
             identifying_role_refs = object_type.preferred_identifier.role_sequence.all_role_ref
             raise "Single literal cannot satisfy multiple identifying roles for #{object_type.name}" if identifying_role_refs.size > 1
             role = identifying_role_refs.single.role
-            # This instance has no variable; the variable is of the entity type not the identifying value type
+            # This instance has no binding; the binding is of the entity type not the identifying value type
             identifying_instance = instance_identified_by_literal role.object_type, literal
             existing_instance = nil
             instance_rv = identifying_instance.all_role_value.detect { |rv|
@@ -311,7 +317,7 @@ module ActiveFacts
               # This fact has no clause.
               fact = @constellation.Fact(:new, :fact_type => role.fact_type, :population => @population)
               @bound_facts << fact
-              # This instance will be associated with its variable by our caller
+              # This instance will be associated with its binding by our caller
               instance = @constellation.Instance(:new, :object_type => object_type, :population => @population)
               @bound_facts << instance
               # The identifying fact type has two roles; create both role instances:
@@ -324,22 +330,22 @@ module ActiveFacts
 
         def complain_incomplete
           if @unbound_clauses.size > 0
-            # Provide a readable description of the problem here, by showing each variable with no instance
-            missing_variables = @unbound_clauses.
+            # Provide a readable description of the problem here, by showing each binding with no instance
+            missing_bindings = @unbound_clauses.
               map do |clause|
-                clause.var_refs.
-                  select do |var_refs|
-                    !var_refs.variable.instance
+                clause.refs.
+                  select do |refs|
+                    !refs.binding.instance
                   end.
-                  map do |var_ref|
-                    var_ref.variable
+                  map do |ref|
+                    ref.binding
                   end
               end.
               flatten.
               uniq
 
             raise "Not enough facts are given to identify #{
-                missing_variables.
+                missing_bindings.
                   sort_by{|b| b.key}.
                   map do |b|
                     player_identifier =