sparql 3.1.8 → 3.2.3

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

@@ -3,8 +3,18 @@ module SPARQL; module Algebra
     ##
     # The SPARQL relational `<` (less than) comparison operator.
     #
-    # @example
-    #   (< ?x ?y)
+    # [114] RelationalExpression    ::= NumericExpression ('<' NumericExpression)?
+    #
+    # @example SPARQL Grammar
+    #   PREFIX  xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   PREFIX  : <http://example.org/things#>
+    #   SELECT  ?x
+    #   WHERE { ?x :p ?v . FILTER ( ?v < 1 ) }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((xsd: <http://www.w3.org/2001/XMLSchema#>) (: <http://example.org/things#>))
+    #    (project (?x) (filter (< ?v 1) (bgp (triple ?x :p ?v)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#OperatorMapping
     # @see https://www.w3.org/TR/xpath-functions/#func-compare
@@ -25,7 +35,6 @@ module SPARQL; module Algebra
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is not a literal
       def apply(left, right, **options)
-        #require 'byebug'; byebug if super == RDF::Literal(-1)
         RDF::Literal(super == RDF::Literal(-1))
       end
     end # LessThan

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

@@ -3,8 +3,18 @@ module SPARQL; module Algebra
     ##
     # The SPARQL relational `<=` (less than or equal) comparison operator.
     #
-    # @example
-    #   (<= ?x ?y)
+    # [114] RelationalExpression    ::= NumericExpression ('<=' NumericExpression)?
+    #
+    # @example SPARQL Grammar
+    #   PREFIX  xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   PREFIX  : <http://example.org/things#>
+    #   SELECT  ?x
+    #   WHERE { ?x :p ?v . FILTER ( ?v <= 1 ) }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((xsd: <http://www.w3.org/2001/XMLSchema#>) (: <http://example.org/things#>))
+    #    (project (?x) (filter (<= ?v 1) (bgp (triple ?x :p ?v)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#OperatorMapping
     # @see https://www.w3.org/TR/xpath-functions/#func-compare

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

@@ -6,8 +6,14 @@ module SPARQL; module Algebra
     #
     # The LOAD operation reads an RDF document from a IRI and inserts its triples into the specified graph in the Graph Store. The specified destination graph should be created if required; again, implementations providing an update service over a fixed set of graphs must return with failure for a request that would create a disallowed graph. If the destination graph already exists, then no data in that graph will be removed.
     #
-    # @example
-    #   (load <remote> <g>)
+    #
+    # [31]  Load                    ::= 'LOAD' 'SILENT'? iri ( 'INTO' GraphRef )?
+    #
+    # @example SPARQL Grammar
+    #   LOAD <http://example.org/remote> INTO GRAPH <http://example.org/g> ;
+    #
+    # @example SSE
+    #   (update (load <http://example.org/remote> <http://example.org/g>))
     #
     # @see https://www.w3.org/TR/sparql11-update/#load
     class Load < Operator
@@ -43,6 +49,23 @@ module SPARQL; module Algebra
       ensure
         queryable
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        silent = operands.first == :silent
+        ops = silent ? operands[1..-1] : operands
+        location, name = ops
+
+        str = "LOAD "
+        str << "SILENT " if silent
+        str << location.to_sparql(**options)
+        str << " INTO GRAPH " + name.to_sparql(**options) if name
+        str
+      end
     end # Load
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,7 +3,14 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `max` set function.
     #
-    # @example
+    # [127] Aggregate::= ... | 'MAX' '(' 'DISTINCT'? Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://www.example.org/>
+    #   SELECT (MAX(?o) AS ?max)
+    #   WHERE { ?s ?p ?o }
+    #
+    # @example SSE
     #    (prefix ((: <http://www.example.org/>))
     #      (project (?max)
     #        (extend ((?max ??.0))
@@ -42,6 +49,17 @@ module SPARQL; module Algebra
           raise TypeError, "Maximum of non-literals: #{enum.flatten}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def 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
 end; end # SPARQL::Algebra

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

@@ -7,11 +7,19 @@ module SPARQL; module Algebra
     #
     # Returns the MD5 checksum, as a hex digit string, calculated on the UTF-8 representation of the simple literal or lexical form of the `xsd:string`. Hex digits `SHOULD` be in lower case.
     #
-    # @example
-    #     (prefix ((: <http://example.org/>))
-    #       (project (?hash)
-    #         (extend ((?hash (md5 ?l)))
-    #           (bgp (triple :s1 :str ?l)))))
+    # [121] BuiltInCall ::= ... | 'MD5' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT (MD5(?l) AS ?hash) WHERE {
+    #    :s1 :str ?l
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>))
+    #     (project (?hash)
+    #       (extend ((?hash (md5 ?l)))
+    #         (bgp (triple :s1 :str ?l)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-md5
     class MD5 < Operator::Unary
@@ -31,6 +39,15 @@ module SPARQL; module Algebra
         raise TypeError, "expected simple literal or xsd:string, but got #{operand.inspect}" unless (operand.datatype || RDF::XSD.string) == RDF::XSD.string
         RDF::Literal(Digest::MD5.new.hexdigest(operand.to_s))
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "MD5(" + operands.to_sparql(**options) + ")"
+      end
     end # MD5
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,12 +3,19 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `min` set function.
     #
-    # @example
+    # [127] Aggregate::= ... | 'MIN' '(' 'DISTINCT'? Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://www.example.org/>
+    #   SELECT (MIN(?o) AS ?min)
+    #   WHERE { ?s :dec ?o }
+    #
+    # @example SSE
     #    (prefix ((: <http://www.example.org/>))
-    #      (project (?max)
+    #      (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
@@ -42,6 +49,17 @@ module SPARQL; module Algebra
           raise TypeError, "Minumuim of non-literals: #{enum.flatten}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def 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
 end; end # SPARQL::Algebra

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

@@ -3,13 +3,42 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `minus` operator.
     #
-    # @example
-    #    (prefix ((ex: <http://www.w3.org/2009/sparql/docs/tests/data-sparql11/negation#>))
-    #      (project (?animal)
-    #        (minus
-    #          (bgp (triple ?animal <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ex:Animal))
-    #          (filter (|| (= ?type ex:Reptile) (= ?type ex:Insect))
-    #            (bgp (triple ?animal <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ?type))))))
+    # [66]  MinusGraphPattern       ::= 'MINUS' GroupGraphPattern
+    #
+    # @example SPARQL Grammar
+    #   SELECT * { ?s ?p ?o MINUS { ?s ?q ?v } }
+    #
+    # @example SSE
+    #   (minus
+    #    (bgp
+    #     (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
@@ -66,6 +95,35 @@ module SPARQL; module Algebra
         @operands = ops
         self
       end
+
+      ##
+      #
+      # 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, 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
 end; end # SPARQL::Algebra

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

@@ -5,11 +5,20 @@ module SPARQL; module Algebra
     #
     # Returns the minutes part of the lexical form of `arg`. The value is as given in the lexical form of the XSD dateTime.
     #
-    # @example
-    #     (prefix ((: <http://example.org/>))
-    #       (project (?s ?x)
-    #         (extend ((?x (minutes ?date)))
-    #           (bgp (triple ?s :date ?date)))))
+    # [121] BuiltInCall ::= ... | 'MINUTES' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s (MINUTES(?date) AS ?x) WHERE {
+    #     ?s :date ?date
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?s ?x)
+    #     (extend ((?x (minutes ?date)))
+    #      (bgp (triple ?s :date ?date)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-minutes
     class Minutes < Operator::Unary
@@ -22,12 +31,21 @@ 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
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "MINUTES(#{operands.last.to_sparql(**options)})"
+      end
     end # Minutes
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,11 +6,28 @@ module SPARQL; module Algebra
     #
     # Wraps delete/insert
     #
-    # @example
-    #   (modify
-    #     (bgp (triple ?a foaf:knows ?b))
-    #     (delete ((triple ?a foaf:knows ?b)))
-    #     (insert ((triple ?b foaf:knows ?a)))
+    # 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
+    #   PREFIX     : <http://example.org/> 
+    #   PREFIX foaf: <http://xmlns.com/foaf/0.1/> 
+    #   DELETE  { ?a foaf:knows ?b }
+    #   INSERT { ?b foaf:knows ?a }
+    #   WHERE { ?a foaf:knows ?b }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>)
+    #            (foaf: <http://xmlns.com/foaf/0.1/>))
+    #    (update
+    #     (modify
+    #      (bgp (triple ?a foaf:knows ?b))
+    #      (delete ((triple ?a foaf:knows ?b)))
+    #      (insert ((triple ?b foaf:knows ?a)))) ))
     #
     # @see XXX
     class Modify < Operator
@@ -23,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
@@ -38,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}"}
 
@@ -48,6 +81,30 @@ module SPARQL; module Algebra
         end
         queryable
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        if operands.first.is_a?(With)
+          operands.first.to_sparql(**options)
+        else
+          # The content of the WHERE clause, may be USING
+          content = operands.first.to_sparql(top_level: false, **options)
+
+          # DELETE | INSERT | DELETE INSERT
+          str = operands[1..-1].to_sparql(top_level: false, delimiter: "\n", **options) + "\n"
+
+          # Append the WHERE or USING clause
+          str << if operands.first.is_a?(Using)
+            content
+          else
+            Operator.to_sparql(content, project: nil, **options)
+          end
+        end
+      end
     end # Modify
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,11 +5,20 @@ module SPARQL; module Algebra
     #
     # Returns the month part of `arg` as an integer.
     #
-    # @example
-    #     (prefix ((: <http://example.org/>))
-    #       (project (?s ?x)
-    #         (extend ((?x (month ?date)))
-    #           (bgp (triple ?s :date ?date)))))
+    # [121] BuiltInCall ::= ... | 'MONTH' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s (MONTH(?date) AS ?x) WHERE {
+    #     ?s :date ?date
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?s ?x)
+    #     (extend ((?x (month ?date)))
+    #      (bgp (triple ?s :date ?date)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-month
     class Month < Operator::Unary
@@ -22,12 +31,21 @@ 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
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "MONTH(#{operands.last.to_sparql(**options)})"
+      end
     end # Month
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,8 +6,14 @@ module SPARQL; module Algebra
     #
     # The MOVE operation is a shortcut for moving all data from an input graph into a destination graph. The input graph is removed after insertion and data from the destination graph, if any, is removed before insertion.
     #
-    # @example
-    #   (move silent <iri> to default)
+    # [36]  Move                    ::= 'MOVE' 'SILENT'? GraphOrDefault 'TO' GraphOrDefault
+    #
+    # @example SPARQL Grammar
+    #   MOVE SILENT GRAPH <http://www.example.com/g1> TO DEFAULT
+    #
+    # @example SSE
+    #   (update
+    #    (move silent <http://www.example.com/g1> default))
     #
     # @see https://www.w3.org/TR/sparql11-update/#move
     class Move < Operator
@@ -62,6 +68,18 @@ module SPARQL; module Algebra
         end
         queryable
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        *args, last = operands.dup
+        args += [:TO, last]
+        
+        "MOVE " + args.to_sparql(**options)
+      end
     end # Move
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,9 +3,23 @@ module SPARQL; module Algebra
     ##
     # The SPARQL numeric `multiply` operator.
     #
-    # @example
-    #   (* ?x ?y)
-    #   (multiply ?x ?y)
+    # [117] MultiplicativeExpression::= UnaryExpression ( '*' UnaryExpression | '/' UnaryExpression )*
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s WHERE {
+    #     ?s :p ?o .
+    #     ?s2 :p ?o2 .
+    #     FILTER(?o * ?o2 = 4) .
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>))
+    #    (project (?s)
+    #     (filter (= (* ?o ?o2) 4)
+    #      (bgp
+    #       (triple ?s :p ?o)
+    #       (triple ?s2 :p ?o2)))))
     #
     # @see https://www.w3.org/TR/xpath-functions/#func-numeric-multiply
     class Multiply < Operator::Binary
@@ -29,6 +43,15 @@ module SPARQL; module Algebra
           else raise TypeError, "expected two RDF::Literal::Numeric operands, but got #{left.inspect} and #{right.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "(#{operands.first.to_sparql(**options)} * #{operands.last.to_sparql(**options)})"
+      end
     end # Multiply
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,9 +3,20 @@ module SPARQL; module Algebra
     ##
     # The SPARQL numeric unary `-` (negation) operator.
     #
-    # @example
-    #   (- ?x)
-    #   (negate ?x)
+    # [118] UnaryExpression ::=	... | '-' PrimaryExpression 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s WHERE {
+    #     ?s :p ?o .
+    #     FILTER(-?o = -2) .
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>))
+    #    (project (?s)
+    #     (filter (= (- ?o) -2)
+    #      (bgp (triple ?s :p ?o)))))
     #
     # @see https://www.w3.org/TR/xpath-functions/#func-numeric-unary-minus
     class Negate < Operator::Unary
@@ -26,6 +37,15 @@ module SPARQL; module Algebra
           else raise TypeError, "expected an RDF::Literal::Numeric, but got #{term.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "(-#{operands.to_sparql(**options)})"
+      end
     end # Negate
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,9 +3,21 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `not` operator.
     #
-    # @example
-    #   (! ?x)
-    #   (not ?x)
+    # [118] UnaryExpression ::=	... | '!' PrimaryExpression 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX  : <http://example.org/ns#>
+    #   SELECT  ?a
+    #   WHERE {
+    #     ?a :p ?v . 
+    #     FILTER ( ! ?v ) .
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/ns#>))
+    #    (project (?a)
+    #     (filter (! ?v)
+    #      (bgp (triple ?a :p ?v)))))
     #
     # @see https://www.w3.org/TR/xpath-functions/#func-not
     class Not < Operator::Unary
@@ -30,6 +42,15 @@ module SPARQL; module Algebra
           else super
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "(!" + operands.first.to_sparql(**options) + ")"
+      end
     end # Not
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,6 +3,19 @@ module SPARQL; module Algebra
     ##
     # The SPARQL relational `!=` (not equal) comparison operator.
     #
+    # [114] RelationalExpression    ::= NumericExpression ('!=' NumericExpression)?
+    #
+    # @example SPARQL Grammar
+    #   PREFIX  xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   PREFIX  : <http://example.org/things#>
+    #   SELECT  ?x
+    #   WHERE { ?x :p ?v . FILTER ( ?v != 1 ) }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((xsd: <http://www.w3.org/2001/XMLSchema#>) (: <http://example.org/things#>))
+    #    (project (?x) (filter (!= ?v 1) (bgp (triple ?x :p ?v)))))
+    #
     # @see https://www.w3.org/TR/sparql11-query/#OperatorMapping
     # @see https://www.w3.org/TR/sparql11-query/#func-RDFterm-equal
     class NotEqual < Equal