sparql 1.1.6 → 1.1.7

data/lib/sparql/algebra/operator/group.rb

@@ -91,7 +91,28 @@ module SPARQL; module Algebra
         @solutions.each(&block) if block_given?
         @solutions
       end
-      
+
+      # It is an error for aggregates to project variables with a name already used in other aggregate projections, or in the WHERE clause.
+      #
+      # It is also an error to project ungrouped variables
+      def validate!
+        group_vars = operand(0).map {|v| Array(v).first}
+        ext = first_ancestor(Extend)
+        extend_vars = ext ? ext.operand(0).map(&:first).select {|v| v.is_a?(RDF::Query::Variable)} : []
+        project = first_ancestor(Project)
+        # If not projecting, were are effectively projecting all variables in the query
+        project_vars = project ? project.operand(0) : operands.last.vars
+
+        available_vars = (extend_vars + group_vars).compact
+
+        # All variables must either be grouped or extended
+        unless (project_vars - available_vars).empty?
+          raise ArgumentError,
+               "projecting ungrouped/extended variables: #{(project_vars.compact - available_vars.compact).to_sse}"
+        end
+        super
+      end
+
       ##
       # Returns an optimized version of this query.
       #

data/lib/sparql/algebra/operator/join.rb

@@ -39,22 +39,33 @@ module SPARQL; module Algebra
         # eval(D(G), Join(P1, P2)) = Join(eval(D(G), P1), eval(D(G), P2))
         #
         # Generate solutions independently, merge based on solution compatibility
-        debug(options) {"Join"}
+        debug(options) {"Join #{operands.to_sse}"}
  
         left = queryable.query(operand(0), options.merge(depth: options[:depth].to_i + 1))
-        debug(options) {"(join)=>(left) #{left.inspect}"}
+        debug(options) {"(join)=>(left) #{left.map(&:to_hash).to_sse}"}
 
         right = queryable.query(operand(1), options.merge(depth: options[:depth].to_i + 1))
-        debug(options) {"(join)=>(right) #{right.inspect}"}
+        debug(options) {"(join)=>(right) #{right.map(&:to_hash).to_sse}"}
 
         @solutions = RDF::Query::Solutions(left.map do |s1|
           right.map { |s2| s2.merge(s1) if s2.compatible?(s1) }
         end.flatten.compact)
-        debug(options) {"=> #{@solutions.inspect}"}
+        debug(options) {"(join)=> #{@solutions.map(&:to_hash).to_sse}"}
         @solutions.each(&block) if block_given?
         @solutions
       end
-      
+
+      # The same blank node label cannot be used in two different basic graph patterns in the same query
+      def validate!
+        left_nodes, right_nodes = operand(0).ndvars, operand(1).ndvars
+
+        unless (left_nodes.compact & right_nodes.compact).empty?
+          raise ArgumentError,
+               "sub-operands share non-distinguished variables: #{(left_nodes.compact & right_nodes.compact).to_sse}"
+        end
+        super
+      end
+
       ##
       # Returns an optimized version of this query.
       #

data/lib/sparql/algebra/operator/left_join.rb

@@ -70,7 +70,18 @@ module SPARQL; module Algebra
         @solutions.each(&block) if block_given?
         @solutions
       end
-      
+
+      # The same blank node label cannot be used in two different basic graph patterns in the same query
+      def validate!
+        left_nodes, right_nodes = operand(0).ndvars, operand(1).ndvars
+
+        unless (left_nodes.compact & right_nodes.compact).empty?
+          raise ArgumentError,
+               "sub-operands share non-distinguished variables: #{(left_nodes.compact & right_nodes.compact).to_sse}"
+        end
+        super
+      end
+
       ##
       # Returns an optimized version of this query.
       #

data/lib/sparql/algebra/operator/notin.rb

@@ -6,7 +6,7 @@ module SPARQL; module Algebra
     # Used for filters with more than one expression.
     #
     # @example
-    #   (ask (filter (notin 2) (bgp)))
+    #   (ask (filter (notin ?o 1 2) (bgp)))
     #
     # @see http://www.w3.org/TR/sparql11-query/#func-notin
     class NotIn < Operator

data/lib/sparql/algebra/operator/notoneof.rb

@@ -0,0 +1,52 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL Property Path `notoneof` (NegatedPropertySet) operator.
+    #
+    # @example
+    #   (notoneof ex:p1 ex:p2)
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#eval_negatedPropertySet
+    class NotOneOf < Operator
+      include Query
+      
+      NAME = :notoneof
+
+      ##
+      # Equivalant to:
+      #
+      #   (path (:x (noteoneof :p :q) :y))
+      #   => (filter (notin ??p :p :q) (bgp (:x ??p :y)))
+      #
+      # @note all operands are terms, and not operators, so this can be done by filtering results usin
+      #
+      # @param  [RDF::Queryable] queryable
+      #   the graph or repository to query
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional keyword options
+      # @option options [RDF::Term, RDF::Variable] :subject
+      # @option options [RDF::Term, RDF::Variable] :object
+      # @yield  [solution]
+      #   each matching solution
+      # @yieldparam  [RDF::Query::Solution] solution
+      # @yieldreturn [void] ignored
+      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      def execute(queryable, options = {}, &block)
+        debug(options) {"NotOneOf #{operands.to_sse}"}
+        subject, object = options[:subject], options[:object]
+
+        v = RDF::Query::Variable.new
+        v.distinguished = false
+        bgp = RDF::Query.new do |q|
+          q.pattern [subject, v, object]
+        end
+        query = Filter.new(NotIn.new(v, *operands), bgp)
+        queryable.query(query, options.merge(depth: options[:depth].to_i + 1)) do |solution|
+          solution.bindings.delete(v.to_sym)
+          debug(options) {"(solution)-> #{solution.to_hash.to_sse}"}
+          block.call(solution)
+        end
+      end
+    end # NotOneOf
+  end # Operator
+end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/path.rb

@@ -0,0 +1,49 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL Property Path `path` operator.
+    #
+    # @example
+    #   (path :a (path+ :p) ?z)
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#sparqlTranslatePathExpressions
+    class Path < Operator::Ternary
+      include Query
+      
+      NAME = :path
+
+      ##
+      # Finds solutions from `queryable` matching the path.
+      #
+      # @param  [RDF::Queryable] queryable
+      #   the graph or repository to query
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional keyword options
+      # @yield  [solution]
+      #   each matching solution
+      # @yieldparam  [RDF::Query::Solution] solution
+      # @yieldreturn [void] ignored
+      # @return [RDF::Query::Solutions]
+      #   the resulting solution sequence
+      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      def execute(queryable, options = {}, &block)
+        debug(options) {"Path #{operands.to_sse}"}
+        subject, path_op, object = operands
+
+        @solutions = RDF::Query::Solutions.new
+        path_op.execute(queryable, options.merge(
+          subject: subject,
+          object: object,
+          context: options.fetch(:context, false),
+          depth: options[:depth].to_i + 1)
+        ) do |solution|
+          @solutions << solution
+        end
+        debug(options) {"=> #{@solutions.inspect}"}
+        @solutions.uniq!
+        @solutions.each(&block) if block_given?
+        @solutions
+      end
+    end # Path
+  end # Operator
+end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/path_opt.rb

@@ -0,0 +1,112 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL Property Path `path?` (ZeroOrOnePath) operator.
+    #
+    # @example
+    #   (path? :p)
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#defn_evalPP_ZeroOrOnePath
+    class PathOpt < Operator::Unary
+      include Query
+      
+      NAME = :path?
+
+      ##
+      # Equivalent to:
+      #
+      #    (path x (path? :p) y)
+      #     => (union (bgp ((x :p y))) (filter (x = x) (solution x y)))
+      #        
+      #
+      # @param  [RDF::Queryable] queryable
+      #   the graph or repository to query
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional keyword options
+      # @option options [RDF::Term, RDF::Variable] :subject
+      # @option options [RDF::Term, RDF::Variable] :object
+      # @yield  [solution]
+      #   each matching solution
+      # @yieldparam  [RDF::Query::Solution] solution
+      # @yieldreturn [void] ignored
+      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      def execute(queryable, options = {}, &block)
+        subject, object = options[:subject], options[:object]
+        debug(options) {"Path? #{[subject, operands, object].to_sse}"}
+
+        solutions = RDF::Query::Solutions.new
+        # Solutions where subject == object with no predicate
+        case
+        when subject.variable? && object.variable?
+          # Nodes is the set of all subjects and objects in queryable
+          # FIXME: should this be Queryable#enum_nodes?
+          # All subjects which are `object`
+          query = RDF::Query.new {|q| q.pattern(subject: subject)}
+          queryable.query(query, options) do |solution|
+            solution.merge!(object.to_sym => solution[subject])
+            debug(options) {"(solution-s0)-> #{solution.to_hash.to_sse}"}
+            solutions << solution
+          end if query.valid?
+
+          # All objects which are `object`
+          query = RDF::Query.new {|q| q.pattern(object: object)}
+          queryable.query(query, options) do |solution|
+            solution.merge!(subject.to_sym => solution[object])
+            debug(options) {"(solution-o0)-> #{solution.to_hash.to_sse}"}
+            solutions << solution
+          end if query.valid?
+        when subject.variable?
+          # All subjects which are `object`
+          query = RDF::Query.new {|q| q.pattern(subject: object)}
+          queryable.query(query, options) do |solution|
+            solution.merge!(subject.to_sym => object)
+            debug(options) {"(solution-s0)-> #{solution.to_hash.to_sse}"}
+            solutions << solution
+          end if query.valid?
+
+          # All objects which are `object`
+          query = RDF::Query.new {|q| q.pattern(object: object)}
+          queryable.query(query, options) do |solution|
+            solution.merge!(subject.to_sym => object)
+            debug(options) {"(solution-o0)-> #{solution.to_hash.to_sse}"}
+            solutions << solution
+          end if query.valid?
+        when object.variable?
+          # All subjects which are `subject`
+          query = RDF::Query.new {|q| q.pattern(subject: subject)}
+          queryable.query(query, options) do |solution|
+            solution.merge!(object.to_sym => subject)
+            debug(options) {"(solution-s0)-> #{solution.to_hash.to_sse}"}
+            solutions << solution
+          end if query.valid?
+
+          # All objects which are `subject
+          query = RDF::Query.new {|q| q.pattern(object: subject)}
+          queryable.query(query, options) do |solution|
+            solution.merge!(object.to_sym => subject)
+            debug(options) {"(solution-o0)-> #{solution.to_hash.to_sse}"}
+            solutions << solution
+          end if query.valid?
+        else
+          # Otherwise, if subject == object, an empty solution
+          solutions << RDF::Query::Solution.new if subject == object
+        end
+
+        # Solutions where predicate exists
+        query = if operand.is_a?(RDF::Term)
+          RDF::Query.new do |q|
+            q.pattern [subject, operand, object]
+          end
+        else
+          operand
+        end
+
+        # Recurse into query
+        solutions += 
+        queryable.query(query, options.merge(depth: options[:depth].to_i + 1))
+        solutions.each(&block) if block_given?
+        solutions
+      end
+    end # PathOpt
+  end # Operator
+end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/path_plus.rb

@@ -0,0 +1,99 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL Property Path `path+` (OneOrMorePath) operator.
+    #
+    # @example
+    #   (path+ :p)
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#defn_evalPP_OneOrMorePath
+    class PathPlus < Operator::Unary
+      include Query
+      
+      NAME = :"path+"
+
+      ##
+      # Match on simple relation of subject to object, and then recurse on solutions
+      #
+      # @param  [RDF::Queryable] queryable
+      #   the graph or repository to query
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional keyword options
+      # @option options [RDF::Term, RDF::Variable] :subject
+      # @option options [RDF::Term, RDF::Variable] :object
+      # @yield  [solution]
+      #   each matching solution
+      # @yieldparam  [RDF::Query::Solution] solution
+      # @yieldreturn [void] ignored
+      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      def execute(queryable, options = {}, &block)
+        subject, object = options[:subject], options[:object]
+        debug(options) {"Path+ #{[subject, operands, object].to_sse}"}
+
+        # This turns from
+        # (:x :p+ ?y)
+        # into
+        # (:x :p ?y) UNION solutions(:x :p ?y) do |soln|
+        #   if :x.variable?
+        #     (soln[:x] :p+ soln[:y])
+        # end
+
+        # Solutions where predicate exists
+        query = if operand.is_a?(RDF::Term)
+          RDF::Query.new do |q|
+            q.pattern [subject, operand, object]
+          end
+        else
+          operand
+        end
+
+        # Block is given on the first invocation, otherwise, results are returned. This is necessary to stop when an existing solution has already been found
+        cumulative_solutions = options.fetch(:accumulator, RDF::Query::Solutions.new)
+
+        # Keep track of solutions
+        # Recurse into query
+        immediate_solutions = []
+        queryable.query(query, options.merge(depth: options[:depth].to_i + 1)) do |solution|
+          immediate_solutions << solution
+        end
+
+        # For all solutions, if they are not in the accumulator, add them and recurse, otherwise skip
+        recursive_solutions = RDF::Query::Solutions.new
+        immediate_solutions.reject {|s| cumulative_solutions.include?(s)}.each do |solution|
+          debug(options) {"(immediate solution)-> #{solution.to_hash.to_sse}"}
+
+          # Recurse on subject, if is a variable
+          case
+          when subject.variable? && object.variable?
+            # Query starting with bound object as subject, but replace result with subject
+            rs = queryable.query(self, options.merge(
+              subject: solution[object],
+              accumulator: (cumulative_solutions + immediate_solutions),
+              depth: options[:depth].to_i + 1)).map {|s| s.merge(subject.to_sym => solution[subject])}
+            # Query starting with bound subject as object, but replace result with subject
+            ro = queryable.query(self, options.merge(
+              object: solution[subject],
+              accumulator: (cumulative_solutions + immediate_solutions),
+              depth: options[:depth].to_i + 1)).map {|s| s.merge(object.to_sym => solution[object])}
+            recursive_solutions += (rs + ro).uniq
+          when subject.variable?
+            recursive_solutions += queryable.query(self, options.merge(
+              object: solution[subject],
+              accumulator: (cumulative_solutions + immediate_solutions),
+              depth: options[:depth].to_i + 1)).uniq
+          when object.variable?
+            recursive_solutions += queryable.query(self, options.merge(
+              subject: solution[object],
+              accumulator: (cumulative_solutions + immediate_solutions),
+              depth: options[:depth].to_i + 1)).uniq
+          end
+        end
+        debug(options) {"(recursive solutions)-> #{recursive_solutions.map(&:to_hash).to_sse}"} unless recursive_solutions.empty?
+
+        solutions = (immediate_solutions + recursive_solutions).uniq
+        solutions.each(&block) if block_given? # Only at top-level
+        solutions
+      end
+    end # PathPlus
+  end # Operator
+end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/path_star.rb

@@ -0,0 +1,42 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL Property Path `path*` (ZeroOrMorePath) operator.
+    #
+    # @example
+    #   (path* :p)
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#defn_evalPP_ZeroOrMorePath
+    class PathStar < Operator::Unary
+      include Query
+      
+      NAME = :"path*"
+
+      ##
+      # Path including zero length:
+      #
+      #    (path :a (path* :p) :b)
+      #    => (path :a (path? (path+ :p)) :b)
+      #
+      # @param  [RDF::Queryable] queryable
+      #   the graph or repository to query
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional keyword options
+      # @option options [RDF::Term, RDF::Variable] :subject
+      # @option options [RDF::Term, RDF::Variable] :object
+      # @yield  [solution]
+      #   each matching solution
+      # @yieldparam  [RDF::Query::Solution] solution
+      # @yieldreturn [void] ignored
+      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      def execute(queryable, options = {}, &block)
+        subject, object = options[:subject], options[:object]
+        debug(options) {"Path* #{[subject, operands, object].to_sse}"}
+
+        # (:x :p* :y) => (:x (:p+)? :y)
+        query = PathOpt.new(PathPlus.new(*operands))
+        query.execute(queryable, options.merge(depth: options[:depth].to_i + 1), &block)
+      end
+    end # PathStar
+  end # Operator
+end; end # SPARQL::Algebra