sparql 3.1.8 → 3.2.0

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,15 @@ 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)
+        "MAX(" + operands.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,9 +3,16 @@ 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))))))
@@ -42,6 +49,15 @@ 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)
+        "MIN(" + operands.to_sparql(**options) + ")"
+      end
     end # Min
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,13 +3,16 @@ 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)))
     #
     # @see https://www.w3.org/TR/xpath-functions/#func-numeric-unary-minus
     # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
@@ -66,6 +69,21 @@ module SPARQL; module Algebra
         @operands = ops
         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)
+        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
+      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
@@ -28,6 +37,15 @@ module SPARQL; module Algebra
         raise TypeError, "expected an RDF::Literal::DateTime, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::DateTime)
         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,23 @@ 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)))
+    # [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
@@ -48,6 +60,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
@@ -28,6 +37,15 @@ module SPARQL; module Algebra
         raise TypeError, "expected an RDF::Literal::DateTime, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::DateTime)
         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

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

@@ -5,12 +5,23 @@ module SPARQL; module Algebra
     #
     # There is a filter operator EXISTS that takes a graph pattern. EXISTS returns `true`/`false` depending on whether the pattern matches the dataset given the bindings in the current group graph pattern, the dataset and the active graph at this point in the query evaluation. No additional binding of variables occurs. The `NOT EXISTS` form translates into `fn:not(EXISTS{...})`.
     #
-    # @example
-    #    (prefix ((ex: <http://www.example.org/>))
-    #      (filter (exists
-    #                 (filter (notexists (bgp (triple ?s ?p ex:o2)))
-    #                   (bgp (triple ?s ?p ex:o1))))
-    #        (bgp (triple ?s ?p ex:o))))
+    # [126] NotExistsFunc           ::= 'NOT' 'EXISTS' GroupGraphPattern
+    #
+    # @example SPARQL Grammar
+    #   PREFIX ex: <http://www.w3.org/2009/sparql/docs/tests/data-sparql11/negation#>
+    #   SELECT ?animal { 
+    #     ?animal a ex:Animal 
+    #     FILTER NOT EXISTS { ?animal a ex:Insect } 
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((ex: <http://www.w3.org/2009/sparql/docs/tests/data-sparql11/negation#>))
+    #    (project (?animal)
+    #     (filter
+    #      (notexists
+    #       (bgp (triple ?animal a ex:Insect)))
+    #      (bgp (triple ?animal a ex:Animal)))) )
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-abs
     # @see https://www.w3.org/TR/xpath-functions/#func-abs
@@ -34,6 +45,19 @@ module SPARQL; module Algebra
         queryable = options[:queryable]
         operand(0).execute(queryable, solutions: solutions, **options).empty?
       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)
+        "NOT EXISTS {\n" +
+          operands.last.to_sparql(top_level: false, **options) +
+          "\n}"
+      end
     end # NotExists
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,8 +5,13 @@ module SPARQL; module Algebra
     #
     # Used for filters with more than one expression.
     #
-    # @example
-    #   (ask (filter (notin ?o 1 2) (bgp)))
+    # [114] RelationalExpression    ::= NumericExpression ('NOT' 'IN' ExpressionList)?
+    #
+    # @example SPARQL Grammar
+    #   ASK { FILTER(2 NOT IN ()) }
+    #
+    # @example SSE
+    #   (ask (filter (notin 2) (bgp)))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-notin
     class NotIn < Operator
@@ -58,6 +63,18 @@ module SPARQL; module Algebra
         else RDF::Literal::TRUE
         end
       end
-    end # Exprlist
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "(" + operands.first.to_sparql(**options) +
+        " NOT IN (" +
+        operands[1..-1].map {|e| e.to_sparql(**options)}.join(", ") +
+        "))"
+      end
+    end # NotIn
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,18 @@ module SPARQL; module Algebra
     ##
     # The SPARQL Property Path `notoneof` (NegatedPropertySet) operator.
     #
-    # @example
-    #   (notoneof ex:p1 ex:p2)
+    # [96]  PathOneInPropertySet ::= iri | 'a' | '^' ( iri | 'a' )
+    #
+    # @example SPARQL Grammar
+    #   PREFIX ex:	<http://www.example.org/schema#>
+    #   PREFIX in:	<http://www.example.org/instance#>
+    #   ASK { in:b ^ex:p in:a }
+    #
+    # @example SSE
+    #   (prefix ((ex: <http://www.example.org/schema#>)
+    #            (in: <http://www.example.org/instance#>))
+    #    (ask
+    #     (path in:b (reverse ex:p) in:a)))
     #
     # @see https://www.w3.org/TR/sparql11-query/#eval_negatedPropertySet
     class NotOneOf < Operator

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

@@ -7,11 +7,21 @@ module SPARQL; module Algebra
     #
     # Returns an XSD dateTime value for the current query execution. All calls to this function in any one query execution must return the same value. The exact moment returned is not specified.
     #
-    # @example
-    #     (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>))
-    #       (ask (filter (= (datatype ?n) xsd:dateTime)
-    #         (extend ((?n (now)))
-    #           (bgp)))))
+    # [121] BuiltInCall ::= ... | 'NOW' NIL 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   ASK {
+    #     BIND(NOW() AS ?n)
+    #     FILTER(DATATYPE(?n) = xsd:dateTime)
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (ask
+    #     (filter (= (datatype ?n) xsd:dateTime)
+    #      (extend ((?n (now)))
+    #       (bgp)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-now
     class Now < Operator::Nullary
@@ -26,6 +36,15 @@ module SPARQL; module Algebra
       def apply(**options)
         RDF::Literal(DateTime.now)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "NOW()"
+      end
     end # Now
   end # Operator
 end; end # SPARQL::Algebra