sparql 3.2.0 → 3.2.1

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

@@ -0,0 +1,64 @@
+
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `function_call` operator.
+    #
+    # [70]  FunctionCall ::= iri ArgList
+    #
+    # @example SPARQL Grammar
+    #   PREFIX xsd:   <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT *
+    #   WHERE { ?s ?p ?o . FILTER xsd:integer(?o) }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (filter (xsd:integer ?o)
+    #     (bgp (triple ?s ?p ?o))))
+    #
+    # @see https://www.w3.org/TR/sparql11-query/#funcex-regex
+    # @see https://www.w3.org/TR/xpath-functions/#func-matches
+    class FunctionCall < Operator
+      include Evaluatable
+
+      NAME = :function_call
+
+      ##
+      # Invokes the function with the passed arguments.
+      #
+      # @param  [RDF::IRI] iri
+      #   Identifies the function
+      # @param  [Array<RDF::Term>] args
+      # @return [RDF::Term]
+      def apply(iri, *args, **options)
+        args = RDF.nil == args.last ? args[0..-2] : args
+        SPARQL::Algebra::Expression.extension(iri, *args, **options)
+      end
+
+      ##
+      # Returns the SPARQL S-Expression (SSE) representation of this expression.
+      #
+      # Remove the optional argument.
+      #
+      # @return [Array] `self`
+      # @see    https://openjena.org/wiki/SSE
+      def to_sxp_bin
+        @operands.map(&:to_sxp_bin)
+      end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        iri, args = operands
+        iri.to_sparql(**options) +
+          '(' +
+          args.to_sparql(delimiter: ', ', **options) +
+          ')'
+      end
+    end # FunctionCall
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -7,7 +7,7 @@ module SPARQL; module Algebra
     #
     # [58]  GraphGraphPattern       ::= 'GRAPH' VarOrIri GroupGraphPattern
     #
-    # @example SPARQL Grammar
+    # @example SPARQL Grammar (query)
     #   PREFIX : <http://example/> 
     #   SELECT * { 
     #       GRAPH ?g { ?s ?p ?o }
@@ -18,15 +18,50 @@ module SPARQL; module Algebra
     #    (graph ?g
     #     (bgp (triple ?s ?p ?o))))
     #
-    # @example of a query
+    # @example SPARQL Grammar (named set of statements)
+    #   PREFIX : <http://example/> 
+    #   SELECT * { 
+    #       GRAPH :g { :s :p :o }
+    #   }
+    #
+    # @example SSE (named set of statements)
     #   (prefix ((: <http://example/>))
+    #    (graph :g
+    #     (bgp (triple :s :p :o))))
+    #
+    # @example SPARQL Grammar (syntax-graph-05.rq)
+    #   PREFIX : <http://example.org/>
+    #   SELECT *
+    #   WHERE
+    #   {
+    #     :x :p :z
+    #     GRAPH ?g { :x :b ?a . GRAPH ?g2 { :x :p ?x } }
+    #   }
+    #
+    # @example SSE (syntax-graph-05.rq)
+    #   (prefix ((: <http://example.org/>))
+    #    (join
+    #     (bgp (triple :x :p :z))
     #     (graph ?g
-    #       (bgp (triple ?s ?p ?o))))
+    #      (join
+    #       (bgp (triple :x :b ?a))
+    #       (graph ?g2
+    #        (bgp (triple :x :p ?x)))))))
     #
-    # @example named set of statements
-    #   (prefix ((: <http://example/>))
-    #     (graph :g
-    #       ((triple :s :p :o))))
+    # @example SPARQL Grammar (pp06.rq)
+    #   prefix ex:	<http://www.example.org/schema#>
+    #   prefix in:	<http://www.example.org/instance#>
+    #   
+    #   select ?x where {
+    #     graph ?g {in:a ex:p1/ex:p2 ?x}
+    #   }
+    #
+    # @example SSE (syntax-graph-05.rq)
+    #   (prefix ((ex: <http://www.example.org/schema#>)
+    #            (in: <http://www.example.org/instance#>))
+    #    (project (?x)
+    #     (graph ?g
+    #      (path in:a (seq ex:p1 ex:p2) ?x))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class Graph < Operator::Binary
@@ -89,6 +124,21 @@ module SPARQL; module Algebra
       def rewrite(&block)
         self
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @param [Boolean] top_level (true)
+      #   Treat this as a top-level, generating SELECT ... WHERE {}
+      # @return [String]
+      def to_sparql(top_level: true, **options)
+        query = operands.last.to_sparql(top_level: false, **options)
+        # Paths don't automatically get braces.
+        query = "{\n#{query}\n}" unless query.start_with?('{')
+        str = "GRAPH #{operands.first.to_sparql(**options)} " + query
+        top_level ? Operator.to_sparql(str, **options) : str
+      end
     end # Graph
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -25,6 +25,37 @@ module SPARQL; module Algebra
     #      (group (?P) ((??.0 (count ?O)))
     #       (bgp (triple ?S ?P ?O))))))
     #
+    # @example SPARQL Grammar (HAVING aggregate)
+    #   PREFIX : <http://www.example.org/>
+    #   SELECT ?s (AVG(?o) AS ?avg)
+    #   WHERE { ?s ?p ?o }
+    #   GROUP BY ?s
+    #   HAVING (AVG(?o) <= 2.0)
+    #
+    # @example SSE (HAVING aggregate)
+    #   (prefix ((: <http://www.example.org/>))
+    #    (project (?s ?avg)
+    #     (filter (<= ??.0 2.0)
+    #      (extend ((?avg ??.0))
+    #       (group (?s) ((??.0 (avg ?o)))
+    #        (bgp (triple ?s ?p ?o)))))) )
+    #
+    # @example SPARQL Grammar (non-triveal filters)
+    #   PREFIX : <http://example.com/data/#>
+    #   SELECT ?g (AVG(?p) AS ?avg) ((MIN(?p) + MAX(?p)) / 2 AS ?c)
+    #   WHERE { ?g :p ?p . }
+    #   GROUP BY ?g
+    #
+    # @example SSE (non-triveal filters)
+    #   (prefix ((: <http://example.com/data/#>))
+    #    (project (?g ?avg ?c)
+    #     (extend ((?avg ??.0) (?c (/ (+ ??.1 ??.2) 2)))
+    #      (group (?g)
+    #             ((??.0 (avg ?p))
+    #              (??.1 (min ?p))
+    #              (??.2 (max ?p)))
+    #       (bgp (triple ?g :p ?p)))) ))
+    #
     # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class Group < Operator
       include Query
@@ -137,16 +168,56 @@ module SPARQL; module Algebra
       #
       # @param [Hash{Symbol => Operator}] extensions
       #   Variable bindings
+      # @param [Array<Operator>] filter_ops ([])
+      #   Filter Operations
       # @return [String]
-      def to_sparql(extensions: {}, **options)
+      def to_sparql(extensions: {}, filter_ops: [], **options)
+        having_ops = []
         if operands.length > 2
+          temp_bindings = operands[1].inject({}) {|memo, (var, op)| memo.merge(var => op)}
           # Replace extensions from temporary bindings
-          operands[1].each do |var, op|
-            ext_var = extensions.invert.fetch(var)
-            extensions[ext_var] = op
+          temp_bindings.each do |var, op|
+            # Update extensions using a temporarily bound variable with its binding
+            extensions = extensions.inject({}) do |memo, (ext_var, ext_op)|
+              if ext_op.is_a?(Operator)
+                # Try to recursivley replace variable within operator
+                new_op = ext_op.deep_dup.rewrite do |operand|
+                  if operand.is_a?(Variable) && operand.to_sym == var.to_sym
+                    op.dup
+                  else
+                    operand
+                  end
+                end
+                memo.merge(ext_var => new_op)
+              elsif ext_op.is_a?(Variable) && ext_op.to_sym == var.to_sym
+                memo.merge(ext_var => op)
+              else
+                # Doesn't match this variable, so don't change
+                memo.merge(ext_var => ext_op)
+              end
+            end
+
+            # Filter ops using temporary bindinds are used for HAVING clauses
+            filter_ops.each do |fop|
+              having_ops << fop if fop.descendants.include?(var) && !having_ops.include?(fop)
+            end
+          end
+
+          # If used in a HAVING clause, it's not also a filter
+          filter_ops -= having_ops
+
+          # Replace each operand in having using var with it's corresponding operation
+          having_ops = having_ops.map do |op|
+            op.dup.rewrite do |operand|
+              # Rewrite based on temporary bindings
+              temp_bindings.fetch(operand, operand)
+            end
           end
         end
-        operands.last.to_sparql(extensions: extensions, group_ops: operands.first, **options)
+        operands.last.to_sparql(extensions: extensions,
+                                group_ops: operands.first,
+                                having_ops: having_ops,
+                                **options)
       end
     end # Group
   end # Operator

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

@@ -16,6 +16,24 @@ module SPARQL; module Algebra
     #     (group () ((??.0 (group_concat ?x)))
     #      (bgp))))
     #
+    # @example SPARQL Grammar (DISTINCT)
+    #   SELECT (GROUP_CONCAT(DISTINCT ?x) AS ?y) {}
+    #
+    # @example SSE (DISTINCT)
+    #   (project (?y)
+    #    (extend ((?y ??.0))
+    #     (group () ((??.0 (group_concat distinct ?x)))
+    #      (bgp))))
+    #
+    # @example SPARQL Grammar (SEPARATOR)
+    #   SELECT (GROUP_CONCAT(?x; SEPARATOR=';') AS ?y) {}
+    #
+    # @example SSE (SEPARATOR)
+    #   (project (?y)
+    #    (extend ((?y ??.0))
+    #     (group () ((??.0 (group_concat (separator ";") ?x)))
+    #      (bgp))))
+    #
     # @see https://www.w3.org/TR/sparql11-query/#defn_aggGroupConcat
     class GroupConcat < Operator
       include Aggregate
@@ -63,7 +81,13 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        "GROUP_CONCAT(#{operands.to_sparql(delimiter: ', ', **options)})"
+        distinct = operands.first == :distinct
+        args = distinct ? operands[1..-1] : operands
+        separator = args.first.last if args.first.is_a?(Array) && args.first.first == :separator
+        args = args[1..-1] if separator
+        str = "GROUP_CONCAT(#{'DISTINCT ' if distinct}#{args.to_sparql(delimiter: ', ', **options)}"
+        str << "; SEPARATOR=#{separator.to_sparql}" if separator
+        str << ")"
       end
     end # GroupConcat
   end # Operator

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

@@ -48,15 +48,15 @@ module SPARQL; module Algebra
       rescue
         raise TypeError
       end
-    end # If
 
-    ##
-    #
-    # Returns a partial SPARQL grammar for this operator.
-    #
-    # @return [String]
-    def to_sparql(**options)
-      "IF(" + operands.to_sparql(delimiter: ', ', **options) + ")"
-    end
-  end # If
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "IF(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+      end
+    end # If
+  end # Operator
 end; end # SPARQL::Algebra

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

@@ -69,7 +69,9 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        "INSERT {\n" + operands.first.to_sparql(as_statement: true, **options) + "\n}"
+        "INSERT {\n" +
+          operands.first.to_sparql(as_statement: true, delimiter: " .\n", **options) +
+          "\n}"
       end
     end # Insert
   end # Operator

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

@@ -54,7 +54,7 @@ module SPARQL; module Algebra
       # @return [String]
       def to_sparql(**options)
         "INSERT DATA {\n" +
-          operands.first.to_sparql(as_statement: true, top_level: false, delimiter: "\n", **options) +
+          operands.first.to_sparql(as_statement: true, top_level: false, delimiter: ". \n", **options) +
           "\n}"
       end
     end # InsertData

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

@@ -13,8 +13,7 @@ module SPARQL; module Algebra
     #   }
     #
     # @example SSE
-    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (: <http://example.org/things#>))
+    #   (prefix ((: <http://example.org/things#>))
     #     (project (?x ?v)
     #       (filter (isBlank ?v)
     #         (bgp (triple ?x :p ?v)))))

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

@@ -13,8 +13,7 @@ module SPARQL; module Algebra
     #   }
     #
     # @example SSE
-    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (: <http://example.org/things#>))
+    #   (prefix ((: <http://example.org/things#>))
     #     (project (?x ?v)
     #       (filter (isIRI ?v)
     #         (bgp (triple ?x :p ?v)))))

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

@@ -13,8 +13,7 @@ module SPARQL; module Algebra
     #   }
     #
     # @example SSE
-    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (: <http://example.org/things#>))
+    #   (prefix ((: <http://example.org/things#>))
     #     (project (?x ?v)
     #       (filter (isLiteral ?v)
     #         (bgp (triple ?x :p ?v)))))

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

@@ -15,8 +15,7 @@ module SPARQL; module Algebra
     #   }
     #
     # @example SSE
-    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (: <http://example.org/things#>))
+    #   (prefix ((: <http://example.org/things#>))
     #     (project (?x ?v)
     #       (filter (isNumeric ?v)
     #         (bgp (triple ?x :p ?v)))))

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

@@ -19,6 +19,22 @@ module SPARQL; module Algebra
     #       (graph ?g
     #         (bgp (triple ?s ?q ?v)))))
     #
+    # @example SPARQL Grammar (inline filter)
+    #   PREFIX : <http://xmlns.com/foaf/0.1/>
+    #   ASK {
+    #     :who :homepage ?homepage 
+    #     FILTER REGEX(?homepage, "^http://example.org/") 
+    #     :who :schoolHomepage ?schoolPage
+    #   }
+    # 
+    # @example SSE (inline filter)
+    #   (prefix ((: <http://xmlns.com/foaf/0.1/>))
+    #    (ask
+    #     (filter (regex ?homepage "^http://example.org/")
+    #      (join
+    #       (bgp (triple :who :homepage ?homepage))
+    #       (bgp (triple :who :schoolHomepage ?schoolPage))))))
+    #
     # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class Join < Operator::Binary
       include Query
@@ -98,10 +114,28 @@ module SPARQL; module Algebra
       #
       # @param [Boolean] top_level (true)
       #   Treat this as a top-level, generating SELECT ... WHERE {}
+      # @param [Hash{Symbol => Operator}] extensions
+      #   Variable bindings
+      # @param [Array<Operator>] filter_ops ([])
+      #   Filter Operations
       # @return [String]
-      def to_sparql(top_level: true, **options)
-        str = operands.to_sparql(top_level: false, delimiter: "\n", **options)
-        top_level ? Operator.to_sparql(str, **options) : str
+      def to_sparql(top_level: true, filter_ops: [], extensions: {}, **options)
+        # If this is top-level, and the last operand is a Table (values), put the values at the outer-level
+        str = "{\n" + operands.first.to_sparql(top_level: false, extensions: {}, **options)
+
+        # Any accrued filters go here.
+        filter_ops.each do |op|
+          str << "\nFILTER (#{op.to_sparql(**options)}) ."
+        end
+
+        if top_level && operands.last.is_a?(Table)
+          str << "\n}"
+          options = options.merge(values_clause: operands.last)
+        else
+          str << "\n{\n" + operands.last.to_sparql(top_level: false, extensions: {}, **options) + "\n}\n}"
+        end
+
+        top_level ? Operator.to_sparql(str, extensions: extensions, **options) : str
       end
     end # Join
   end # Operator

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

@@ -12,9 +12,8 @@ module SPARQL; module Algebra
     #   }
     #
     # @example SSE
-    #   (prefix
-    #    ((: <http://example.org/>))
-    #    (project (?str ?lstr)
+    #   (prefix ((: <http://example.org/>))
+    #    (project (?s ?lstr)
     #     (extend ((?lstr (lcase ?str)))
     #      (bgp (triple ?s :str ?str)))))
     #

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

@@ -131,14 +131,27 @@ module SPARQL; module Algebra
       #
       # @param [Boolean] top_level (true)
       #   Treat this as a top-level, generating SELECT ... WHERE {}
+      # @param [Hash{Symbol => 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{Symbol => 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/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