sparql 3.2.0 → 3.2.4

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

@@ -44,8 +44,8 @@ module SPARQL; module Algebra
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
       # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      # @see    https://www.rubydoc.info/github/ruby-rdf/rdf/RDF/Query/Solution#merge-instance_method
-      # @see    https://www.rubydoc.info/github/ruby-rdf/rdf/RDF/Query/Solution#compatible%3F-instance_method
+      # @see    https://ruby-rdf.github.io/rdf/RDF/Query/Solution#merge-instance_method
+      # @see    https://ruby-rdf.github.io/rdf/RDF/Query/Solution#compatible%3F-instance_method
       def execute(queryable, **options, &block)
         filter = operand(2)
 
@@ -66,6 +66,11 @@ module SPARQL; module Algebra
           load_left = true
           right.each do |s2|
             s = s2.merge(s1)
+            # Re-bind to bindings, if defined, as they might not be found in solution
+            options[:bindings].each_binding do |name, value|
+              s[name] = value if filter.variables.include?(name)
+            end if options[:bindings] && filter.respond_to?(:variables)
+
             expr = filter ? boolean(filter.evaluate(s)).true? : true rescue false
             debug(options) {"===>(evaluate) #{s.inspect}"} if filter
 
@@ -131,14 +136,27 @@ module SPARQL; module Algebra
       #
       # @param [Boolean] top_level (true)
       #   Treat this as a top-level, generating SELECT ... WHERE {}
+      # @param [Hash{String => Operator}] extensions
+      #   Variable bindings
+      # @param [Array<Operator>] filter_ops ([])
+      #   Filter Operations
       # @return [String]
-      def to_sparql(top_level: true, **options)
-        str = operands[0].to_sparql(top_level: false, **options) +
-          "\nOPTIONAL { \n" +
-          operands[1].to_sparql(top_level: false, **options) + "\n"
-        str << 'FILTER (' + operands[2].to_sparql(**options) + ") \n" if operands[2]
-        str << '}'
-        top_level ? Operator.to_sparql(str, **options) : str
+      def to_sparql(top_level: true, filter_ops: [], extensions: {}, **options)
+        str = "{\n" + operands[0].to_sparql(top_level: false, extensions: {}, **options)
+        str << 
+          "\nOPTIONAL {\n" +
+          operands[1].to_sparql(top_level: false, extensions: {}, **options)
+        case operands[2]
+        when SPARQL::Algebra::Operator::Exprlist
+          operands[2].operands.each do |op|
+            str << "\nFILTER (" + op.to_sparql(**options) + ")"
+          end
+        when nil
+        else
+          str << "\nFILTER (" + operands[2].to_sparql(**options) + ")"
+        end
+        str << "\n}}"
+        top_level ? Operator.to_sparql(str, filter_ops: filter_ops, extensions: extensions, **options) : str
       end
     end # LeftJoin
   end # Operator

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

@@ -56,7 +56,9 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        "MAX(" + operands.to_sparql(**options) + ")"
+        distinct = operands.first == :distinct
+        args = distinct ? operands[1..-1] : operands
+        "MAX(#{'DISTINCT ' if distinct}#{args.to_sparql(**options)})"
       end
     end # Max
   end # Operator

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

@@ -15,7 +15,7 @@ module SPARQL; module Algebra
     #      (project (?min)
     #        (extend ((?min ??.0))
     #          (group () ((??.0 (min ?o)))
-    #            (bgp (triple ?s ?p ?o))))))
+    #            (bgp (triple ?s :dec ?o))))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#defn_aggMin
     class Min < Operator
@@ -56,7 +56,9 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        "MIN(" + operands.to_sparql(**options) + ")"
+        distinct = operands.first == :distinct
+        args = distinct ? operands[1..-1] : operands
+        "MIN(#{'DISTINCT ' if distinct}#{args.to_sparql(**options)})"
       end
     end # Min
   end # Operator

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

@@ -14,6 +14,32 @@ module SPARQL; module Algebra
     #     (triple ?s ?p ?o))
     #    (bgp (triple ?s ?q ?v)))
     #
+    # @example SPARQL Grammar (inline filter)
+    #   PREFIX :    <http://example/>
+    #   SELECT (?s1 AS ?subset) (?s2 AS ?superset)
+    #   WHERE {
+    #       ?s2 a :Set .
+    #       ?s1 a :Set .
+    #       FILTER(?s1 != ?s2)
+    #       MINUS {
+    #           ?s1 a :Set .
+    #           ?s2 a :Set .
+    #           FILTER(?s1 != ?s2)
+    #       }
+    #   }
+    # 
+    # @example SSE (inline filter)
+    #   (prefix ((: <http://example/>))
+    #    (project (?subset ?superset)
+    #     (extend ((?subset ?s1) (?superset ?s2))
+    #      (filter (!= ?s1 ?s2)
+    #       (minus
+    #        (bgp (triple ?s2 a :Set) (triple ?s1 a :Set))
+    #        (filter (!= ?s1 ?s2)
+    #         (bgp
+    #          (triple ?s1 a :Set)
+    #          (triple ?s2 a :Set))))))))
+    #
     # @see https://www.w3.org/TR/xpath-functions/#func-numeric-unary-minus
     # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class Minus < Operator::Binary
@@ -74,15 +100,29 @@ module SPARQL; module Algebra
       #
       # Returns a partial SPARQL grammar for this operator.
       #
+      # @param [Hash{String => Operator}] extensions
+      #   Variable bindings
+      # @param [Array<Operator>] filter_ops ([])
+      #   Filter Operations
       # @param [Boolean] top_level (true)
       #   Treat this as a top-level, generating SELECT ... WHERE {}
       # @return [String]
-      def to_sparql(top_level: true, **options)
-        str = operands.first.to_sparql(top_level: false, **options) + "\n"
-        str << "MINUS {\n"
-        str << operands.last.to_sparql(top_level: false, **options)
-        str << "\n}"
-        top_level ? Operator.to_sparql(str, **options) : str
+      def to_sparql(top_level: true, filter_ops: [], extensions: {}, **options)
+        lhs, *rhs = operands
+        str = "{\n" + lhs.to_sparql(top_level: false, extensions: {}, **options)
+
+        # Any accrued filters go here.
+        filter_ops.each do |op|
+          str << "\nFILTER (#{op.to_sparql(**options)}) ."
+        end
+
+        rhs.each do |minus|
+          str << "\nMINUS {\n"
+          str << minus.to_sparql(top_level: false, extensions: {}, **options)
+          str << "\n}"
+        end
+        str << "}"
+        top_level ? Operator.to_sparql(str, extensions: extensions, **options) : str
       end
     end # Minus
   end # Operator

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

@@ -31,10 +31,10 @@ module SPARQL; module Algebra
       #
       # @param  [RDF::Literal] operand
       #   the operand
-      # @return [RDF::Literal]
+      # @return [RDF::Literal::Temporal]
       # @raise  [TypeError] if the operand is not a simple literal
       def apply(operand, **options)
-        raise TypeError, "expected an RDF::Literal::DateTime, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::DateTime)
+        raise TypeError, "expected an RDF::Literal::Temporal, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::Temporal)
         RDF::Literal(operand.object.minute)
       end
 

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

@@ -6,6 +6,11 @@ module SPARQL; module Algebra
     #
     # Wraps delete/insert
     #
+    # If `options` contains any of the Protocol attributes, it is treated as if there is a USING or USING NAMED clause inserted.
+    #
+    # * `using-graph-uri`
+    # * `using-named-graph-uri`
+    #
     # [41]  Modify ::= ( 'WITH' iri )? ( DeleteClause InsertClause? | InsertClause ) UsingClause* 'WHERE' GroupGraphPattern
     #
     # @example SPARQL Grammar
@@ -35,6 +40,10 @@ module SPARQL; module Algebra
       #
       # Execute the first operand to get solutions, and apply those solutions to the subsequent operators.
       #
+      # If `options` contains any of the Protocol attributes, any `using` clause is removed and a new `using` clause is added with entries taken from the `using-graph-uri` and `using-named-graph-uri`.
+      #
+      # It is an error to supply the using-graph-uri or using-named-graph-uri parameters when using this protocol to convey a SPARQL 1.1 Update request that contains an operation that uses the USING, USING NAMED, or WITH clause.
+      #
       # @param  [RDF::Queryable] queryable
       #   the graph or repository to write
       # @param  [Hash{Symbol => Object}] options
@@ -50,6 +59,18 @@ module SPARQL; module Algebra
         debug(options) {"Modify"}
         query = operands.shift
 
+        if %i(using-graph-uri using-named-graph-uri).any? {|k| options.key?(k)}
+          raise ArgumentError,
+            "query contains USING/WITH clause, which is incompatible with using-graph-uri or using-named-graph-uri query parameters" if
+            query.is_a?(Operator::Using) || query.is_a?(Operator::With)
+
+          debug("=> Insert USING clause", options)
+          defaults = Array(options.delete(:'using-graph-uri')).map {|uri| RDF::URI(uri)}
+          named = Array(options.delete(:'using-named-graph-uri')).map {|uri| [:named, RDF::URI(uri)]}
+          
+          query = Operator::Using.new((defaults + named), query, **options)
+        end
+
         queryable.query(query, depth: options[:depth].to_i + 1, **options) do |solution|
           debug(options) {"(solution)=>#{solution.inspect}"}
 

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

@@ -31,10 +31,10 @@ module SPARQL; module Algebra
       #
       # @param  [RDF::Literal] operand
       #   the operand
-      # @return [RDF::Literal]
+      # @return [RDF::Literal::Temporal]
       # @raise  [TypeError] if the operand is not a simple literal
       def apply(operand, **options)
-        raise TypeError, "expected an RDF::Literal::DateTime, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::DateTime)
+        raise TypeError, "expected an RDF::Literal::Temporal, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::Temporal)
         RDF::Literal(operand.object.month)
       end
 

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

@@ -50,7 +50,7 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        "#{operands.first.to_sparql(**options)} * #{operands.last.to_sparql(**options)}"
+        "(#{operands.first.to_sparql(**options)} * #{operands.last.to_sparql(**options)})"
       end
     end # Multiply
   end # Operator

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

@@ -8,13 +8,13 @@ module SPARQL; module Algebra
     # @example SPARQL Grammar
     #   PREFIX ex:	<http://www.example.org/schema#>
     #   PREFIX in:	<http://www.example.org/instance#>
-    #   ASK { in:b ^ex:p in:a }
+    #   ASK { in:a !(ex:p1|ex:p2) ?x }
     #
     # @example SSE
     #   (prefix ((ex: <http://www.example.org/schema#>)
-    #            (in: <http://www.example.org/instance#>))
+    #           (in: <http://www.example.org/instance#>))
     #    (ask
-    #     (path in:b (reverse ex:p) in:a)))
+    #     (path in:a (notoneof ex:p1 ex:p2) ?x)))
     #
     # @see https://www.w3.org/TR/sparql11-query/#eval_negatedPropertySet
     class NotOneOf < Operator
@@ -56,6 +56,15 @@ module SPARQL; module Algebra
           block.call(solution)
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "!(" + operands.to_sparql(delimiter: ' | ', **options) + ')'
+      end
     end # NotOneOf
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -17,6 +17,50 @@ module SPARQL; module Algebra
     #       (order ((asc ?name))
     #         (bgp (triple ?x foaf:name ?name)))))
     #
+    # @example SPARQL Grammar (with builtin)
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s WHERE {
+    #     ?s :p ?o .
+    #   }
+    #   ORDER BY str(?o)
+    #
+    # @example SSE (with builtin)
+    #   (prefix ((: <http://example.org/>))
+    #    (project (?s)
+    #     (order ((str ?o))
+    #      (bgp (triple ?s :p ?o)))))
+    #
+    # @example SPARQL Grammar (with bracketed expression)
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s WHERE {
+    #     ?s :p ?o1 ; :q ?o2 .
+    #   } ORDER BY (?o1 + ?o2)
+    #
+    # @example SSE (with bracketed expression)
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?s)
+    #     (order ((+ ?o1 ?o2))
+    #      (bgp
+    #       (triple ?s :p ?o1)
+    #       (triple ?s :q ?o2)))))
+    #
+    # @example SPARQL Grammar (with function call)
+    #   PREFIX :      <http://example.org/ns#>
+    #   PREFIX xsd:   <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT *
+    #   { ?s ?p ?o }
+    #   ORDER BY 
+    #     DESC(?o+57) xsd:string(?o) ASC(?s)
+    #
+    # @example SSE (with function call)
+    #   (prefix ((: <http://example.org/ns#>)
+    #            (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (order ((desc (+ ?o 57))
+    #            (xsd:string ?o)
+    #            (asc ?s))
+    #     (bgp (triple ?s ?p ?o))))
+    #
     # @see https://www.w3.org/TR/sparql11-query/#modOrderBy
     class Order < Operator::Binary
       include Query

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

@@ -3,8 +3,8 @@ module SPARQL; module Algebra
     ##
     # The SPARQL Property Path `path?` (ZeroOrOnePath) operator.
     #
-    # [91]  PathElt                 ::= PathPrimary PathMod?
-    # [93]  PathMod                 ::= '*' | '?' | '+'
+    # [91]  PathElt ::= PathPrimary PathMod?
+    # [93]  PathMod ::= '*' | '?' | '+' | '{' INTEGER? (',' INTEGER?)? '}'
     
     # @example SPARQL Grammar
     #   PREFIX : <http://example/> 
@@ -23,11 +23,10 @@ module SPARQL; module Algebra
       NAME = :path?
 
       ##
-      # Equivalent to:
+      # Optional path:
       #
       #    (path x (path? :p) y)
-      #     => (union (bgp ((x :p y))) (filter (x = x) (solution x y)))
-      #        
+      #     => (union (bgp ((x :p y))) (filter (x = y) (solution x y)))
       #
       # @param  [RDF::Queryable] queryable
       #   the graph or repository to query
@@ -44,76 +43,21 @@ module SPARQL; module Algebra
         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_h.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_h.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_h.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_h.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_h.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_h.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
+        query = PathZero.new(operand)
+        solutions = query.execute(queryable, **options.merge(depth: options[:depth].to_i + 1))
 
         # Solutions where predicate exists
         query = if operand.is_a?(RDF::Term)
           RDF::Query.new do |q|
             q.pattern [subject, operand, object]
           end
-        else
+        else # path
           operand
         end
 
         # Recurse into query
-        solutions += 
-        queryable.query(query, depth: options[:depth].to_i + 1, **options)
+        solutions += query.execute(queryable, **options.merge(depth: options[:depth].to_i + 1))
+        debug(options) {"(path?)=> #{solutions.to_sxp}"}
         solutions.each(&block) if block_given?
         solutions
       end

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

@@ -3,8 +3,8 @@ module SPARQL; module Algebra
     ##
     # The SPARQL Property Path `path+` (OneOrMorePath) operator.
     #
-    # [91]  PathElt                 ::= PathPrimary PathMod?
-    # [93]  PathMod                 ::= '*' | '?' | '+'
+    # [91]  PathElt ::= PathPrimary PathMod?
+    # [93]  PathMod ::= '*' | '?' | '+' | '{' INTEGER? (',' INTEGER?)? '}'
     
     # @example SPARQL Grammar
     #   PREFIX : <http://example/> 
@@ -25,6 +25,16 @@ module SPARQL; module Algebra
       ##
       # Match on simple relation of subject to object, and then recurse on solutions
       #
+      # Path including at least one:
+      #
+      #    (path :a (path+ :p) :b)
+      #
+      # into
+      #
+      #    (union
+      #     (bgp (triple :a :p :b))
+      #     (path :a (path* :p) :b))
+      #
       # @param  [RDF::Queryable] queryable
       #   the graph or repository to query
       # @param  [Hash{Symbol => Object}] options
@@ -62,10 +72,8 @@ module SPARQL; module Algebra
 
         # Keep track of solutions
         # Recurse into query
-        immediate_solutions = []
-        queryable.query(query, depth: options[:depth].to_i + 1, **options) do |solution|
-          immediate_solutions << solution
-        end
+        immediate_solutions = 
+          query.execute(queryable, depth: options[:depth].to_i + 1, **options)
 
         # For all solutions, if they are not in the accumulator, add them and recurse, otherwise skip
         recursive_solutions = RDF::Query::Solutions.new
@@ -76,23 +84,23 @@ module SPARQL; module Algebra
           case
           when subject.variable? && object.variable?
             # Query starting with bound object as subject, but replace result with subject
-            rs = queryable.query(self, **options.merge(
+            rs = self.execute(queryable, **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(
+            ro = self.execute(queryable, **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(
+            recursive_solutions += self.execute(queryable, **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(
+            recursive_solutions += self.execute(queryable, **options.merge(
               subject: solution[object],
               accumulator: (cumulative_solutions + immediate_solutions),
               depth: options[:depth].to_i + 1)).uniq