sparql 3.1.8 → 3.2.0

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

@@ -5,16 +5,30 @@ module SPARQL; module Algebra
     #
     # The BNODE function constructs a blank node that is distinct from all blank nodes in the dataset being queried and distinct from all blank nodes created by calls to this constructor for other query solutions. If the no argument form is used, every call results in a distinct blank node. If the form with a simple literal is used, every call results in distinct blank nodes for different simple literals, and the same blank node for calls with the same simple literal within expressions for one solution mapping.
     #
-    # @example
-    #     (prefix ((: <http://example.org/>)
-    #              (xsd: <http://www.w3.org/2001/XMLSchema#>))
-    #       (project (?s1 ?s2 ?b1 ?b2)
-    #         (extend ((?b1 (bnode ?s1)) (?b2 (bnode ?s2)))
-    #           (filter (exprlist (|| (= ?a :s1) (= ?a :s3)) (|| (= ?b :s1) (= ?b :s3)))
-    #             (bgp
-    #               (triple ?a :str ?s1)
-    #               (triple ?b :str ?s2)
-    #             )))))
+    # [121] BuiltInCall ::= ... | 'BNODE' ( '(' Expression ')' | NIL ) 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT ?s1 ?s2 (BNODE(?s1) AS ?b1) (BNODE(?s2) AS ?b2)
+    #   WHERE {
+    #     ?a :str ?s1 .
+    #     ?b :str ?s2 .
+    #     FILTER (?a = :s1 || ?a = :s3)
+    #     FILTER (?b = :s1 || ?b = :s3)
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>) (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (project (?s1 ?s2 ?b1 ?b2)
+    #     (extend
+    #      ((?b1 (bnode ?s1)) (?b2 (bnode ?s2)))
+    #      (filter
+    #       (exprlist
+    #        (|| (= ?a :s1) (= ?a :s3))
+    #        (|| (= ?b :s1) (= ?b :s3)))
+    #       (bgp (triple ?a :str ?s1) (triple ?b :str ?s2))) )) )
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-bnode
     class BNode < Operator::Unary
@@ -86,6 +100,15 @@ module SPARQL; module Algebra
       def to_sxp_bin
         [NAME] + operands.reject {|o| o == false}
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "BNODE(#{operands.last.to_sparql(**options)})"
+      end
     end # BNode
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,7 +3,19 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `bound` operator.
     #
-    # @example
+    # [121] BuiltInCall ::= ... | 'BOUND' '(' Var ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX  : <http://example.org/ns#>
+    #   SELECT  ?a ?c
+    #   WHERE
+    #       { ?a :b ?c . 
+    #         OPTIONAL
+    #           { ?c :d ?e } . 
+    #         FILTER (! bound(?e)) 
+    #       }
+    #
+    # @example SSE
     #   (prefix ((: <http://example.org/ns#>))
     #     (project (?a ?c)
     #       (filter (! (bound ?e))
@@ -46,6 +58,15 @@ module SPARQL; module Algebra
           else raise TypeError, "expected an RDF::Query::Variable, but got #{var.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "bound(" + operands.first.to_sparql(**options) + ")"
+      end
     end # Bound
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,22 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `ceil` operator.
     #
-    # @example
-    #   (ceil ?x)
+    # [121] BuiltInCall ::= ... 'CEIL' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT ?s ?num (CEIL(?num) AS ?ceil) WHERE {
+    #    ?s :num ?num
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>)
+    #     (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (project (?s ?num ?ceil)
+    #     (extend ((?ceil (ceil ?num)))
+    #      (bgp (triple ?s :num ?num)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-ceil
     # @see https://www.w3.org/TR/xpath-functions/#func-ceil
@@ -26,6 +40,15 @@ module SPARQL; module Algebra
           else raise TypeError, "expected an RDF::Literal::Numeric, but got #{operand.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "CEIL(#{operands.to_sparql(**options)})"
+      end
     end # Ceil
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,8 +6,13 @@ module SPARQL; module Algebra
     #
     # The CLEAR operation removes all the triples in the specified graph(s) in the Graph Store.
     #
-    # @example
-    #   (clear silent default)
+    # [32]  Clear                   ::= 'CLEAR' 'SILENT'? GraphRefAll
+    #
+    # @example SPARQL Grammar
+    #   CLEAR SILENT DEFAULT
+    #
+    # @example SSE
+    #   (update (clear silent default))
     #
     # @see https://www.w3.org/TR/sparql11-update/#clear
     class Clear < Operator
@@ -58,6 +63,15 @@ module SPARQL; module Algebra
 
         queryable
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "CLEAR " + operands.to_sparql(**options)
+      end
     end # Clear
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,17 +3,30 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `coalesce` function.
     #
-    # @example
-    #     (prefix ((: <http://example.org/>)
-    #              (xsd: <http://www.w3.org/2001/XMLSchema#>))
-    #       (project (?cx ?div ?def ?err)
-    #         (extend ((?cx (coalesce ?x -1))
-    #                  (?div (coalesce (/ ?o ?x) -2))
-    #                  (?def (coalesce ?z -3))
-    #                  (?err (coalesce ?z)))
-    #           (leftjoin
-    #             (bgp (triple ?s :p ?o))
-    #             (bgp (triple ?s :q ?x))))))
+    # [121] BuiltInCall ::= ... | 'COALESCE' ExpressionList 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX :        <http://example/>
+    #   PREFIX xsd:     <http://www.w3.org/2001/XMLSchema#>
+    #   
+    #   SELECT ?X (SAMPLE(?v) AS ?S)
+    #   {
+    #     ?s :p ?v .
+    #     OPTIONAL { ?s :q ?w }
+    #   }
+    #   GROUP BY (COALESCE(?w, "1605-11-05"^^xsd:date) AS ?X) 
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example/>) (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (project (?X ?S)
+    #     (extend ((?S ??.0))
+    #      (group
+    #       ((?X (coalesce ?w "1605-11-05"^^xsd:date)))
+    #       ((??.0 (sample ?v)))
+    #       (leftjoin
+    #        (bgp (triple ?s :p ?v))
+    #        (bgp (triple ?s :q ?w)))))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-coalesce
     class Coalesce < Operator
@@ -50,6 +63,15 @@ module SPARQL; module Algebra
         end
         raise TypeError, "None of the operands evaluated"
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "COALESCE(#{operands.to_sparql(delimiter: ', ', **options)})"
+      end
     end # Coalesce
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -35,6 +35,15 @@ module SPARQL; module Algebra
         RDF::Literal(spaceship(left, right, **options))
       end
 
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "(#{operands.first.to_sparql(**options)} #{self.class.const_get(:NAME)} #{operands.last.to_sparql(**options)})"
+      end
+
     private
       # Define <=> as private for recursive statements
       def spaceship(left, right, **options)

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

@@ -5,8 +5,23 @@ module SPARQL; module Algebra
     #
     # The CONCAT function corresponds to the XPath fn:concat function. The function accepts string literals as arguments.
     #
-    # @example
-    #   (concat ?a ?b ...)
+    # [121] BuiltInCall ::= ... 'CONCAT' ExpressionList 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT (CONCAT(?str1,?str2) AS ?str) WHERE {
+    #     :s6 :str ?str1 .
+    #     :s7 :str ?str2 .
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?str)
+    #     (extend ((?str (concat ?str1 ?str2)))
+    #      (bgp
+    #       (triple :s6 :str ?str1)
+    #       (triple :s7 :str ?str2)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-concat
     # @see https://www.w3.org/TR/xpath-functions/#func-concat
@@ -48,6 +63,15 @@ module SPARQL; module Algebra
           end
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "CONCAT(#{operands.to_sparql(delimiter: ', ', **options)})"
+      end
     end # Concat
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,12 +5,22 @@ module SPARQL; module Algebra
     #
     # The CONSTRUCT query form returns a single RDF graph specified by a graph template. The result is an RDF graph formed by taking each query solution in the solution sequence, substituting for the variables in the graph template, and combining the triples into a single RDF graph by set union.
     #
-    # @example
-    #   (prefix ((rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>)
-    #            (foaf: <http://xmlns.com/foaf/0.1/>))
-    #     (construct ((triple ?s ?p ?o))
-    #       (project (?s ?p ?o)
-    #         (bgp (triple ?s ?p ?o)))))
+    # [10]  ConstructQuery          ::= 'CONSTRUCT' ( ConstructTemplate DatasetClause* WhereClause SolutionModifier | DatasetClause* 'WHERE' '{' TriplesTemplate? '}' SolutionModifier ) ValuesClause
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example/> 
+    #   CONSTRUCT { ?x :p2 ?v }
+    #   WHERE {
+    #     ?x :p ?o .
+    #     OPTIONAL {?o :q ?v }
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example/>))
+    #    (construct ((triple ?x :p2 ?v))
+    #     (leftjoin
+    #      (bgp (triple ?x :p ?o))
+    #      (bgp (triple ?o :q ?v)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#construct
     class Construct < Operator::Binary
@@ -81,6 +91,19 @@ module SPARQL; module Algebra
       def query_yields_statements?
         true
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this term.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        str = "CONSTRUCT {\n" +
+        operands[0].map { |e| e.to_sparql(as_statement: true, top_level: false, **options) }.join("\n") +
+        "\n}\n"
+
+        str << operands[1].to_sparql(top_level: true, project: nil, **options)
+      end
     end # Construct
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,21 @@ module SPARQL; module Algebra
     ##
     # A SPARQL `contains` operator.
     #
-    # @example
-    #   (contains ?x ?y)
+    # [121] BuiltInCall ::= ... | 'CONTAINS' '(' Expression ',' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s ?str WHERE {
+    #     ?s :str ?str
+    #     FILTER CONTAINS(?str, "a")
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?s ?str)
+    #     (filter (contains ?str "a")
+    #      (bgp (triple ?s :str ?str)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-contains
     # @see https://www.w3.org/TR/xpath-functions/#func-contains
@@ -39,6 +52,15 @@ module SPARQL; module Algebra
         else RDF::Literal::FALSE
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "contains(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # Contains
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,8 +6,13 @@ module SPARQL; module Algebra
     #
     # The COPY operation is a shortcut for inserting all data from an input graph into a destination graph. Data from the input graph is not affected, but data from the destination graph, if any, is removed before insertion.
     #
-    # @example
-    #   (copy silent <iri> to default)
+    # [37]  Copy                    ::= 'COPY' 'SILENT'? GraphOrDefault 'TO' GraphOrDefault
+    #
+    # @example SPARQL Grammar
+    #   COPY SILENT GRAPH <http://www.example.com/g1> TO DEFAULT
+    #
+    # @example SSE
+    #   (update (copy silent <http://www.example.com/g1> default))
     #
     # @see https://www.w3.org/TR/sparql11-update/#copy
     class Copy < Operator
@@ -59,6 +64,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]
+        
+        "COPY " + args.to_sparql(**options)
+      end
     end # Copy
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,7 +3,14 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `count` set function.
     #
-    # @example
+    # [127] Aggregate::= 'COUNT' '(' 'DISTINCT'? ( '*' | Expression ) ')' ...
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://www.example.org/>
+    #   SELECT (COUNT(?O) AS ?C)
+    #   WHERE { ?S ?P ?O }
+    #
+    # @example SSE
     #    (prefix ((: <http://www.example.org>))
     #      (project (?C)
     #        (extend ((?C ??.0))
@@ -25,6 +32,15 @@ module SPARQL; module Algebra
       def apply(enum, **options)
         RDF::Literal(enum.length)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "COUNT(#{operands.to_sparql(**options)})"
+      end
     end # Count
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -8,8 +8,13 @@ module SPARQL; module Algebra
     #
     # This is a no-op for RDF.rb implementations, unless the graph exists
     #
-    # @example
-    #   (create silent <graph>)
+    # [34]  Create                  ::= 'CREATE' 'SILENT'? GraphRef
+    #
+    # @example SPARQL Grammar
+    #   CREATE SILENT GRAPH <http://example.org/g1>
+    #
+    # @example SSE
+    #   (update (create silent <http://example.org/g1>))
     #
     # @see https://www.w3.org/TR/sparql11-update/#create
     class Create < Operator
@@ -43,6 +48,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 += [:GRAPH, last]
+
+        "CREATE " + args.to_sparql(**options)
+      end
     end # Create
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -158,6 +158,23 @@ module SPARQL; module Algebra
         aggregate.default(*default_datasets.select {|name| queryable.has_graph?(name)})
         aggregate.query(operands.last, depth: options[:depth].to_i + 1, **options, &base)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        operands[0].each_with_object('') do |graph, str|
+          str << if graph.is_a?(Array)
+            "FROM #{graph[0].upcase} #{graph[1].to_sparql(**options)}\n"
+          else
+            "FROM #{graph.to_sparql(**options)}\n"
+          end
+        end.tap do |str|
+          str << operands[1].to_sparql(**options)
+        end
+      end
     end # Dataset
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,13 +3,23 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `datatype` operator.
     #
-    # @example
+    # [121] BuiltInCall ::= ... | 'DATATYPE' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX  xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   PREFIX  : <http://example.org/things#>
+    #   SELECT  ?x ?v
+    #   WHERE
+    #       { ?x :p ?v . 
+    #         FILTER ( datatype(?v) = xsd:double ) .
+    #       }
+    #
+    # @example SSE
     #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>)
-    #            (: <http://example.org/>))
-    #     (project (?s)
-    #       (filter (= (datatype (xsd:double ?v)) xsd:double)
-    #         (bgp (triple ?s :p ?v)))))
+    #            (: <http://example.org/things#>))
+    #    (project (?x ?v)
+    #     (filter (= (datatype ?v) xsd:double)
+    #      (bgp (triple ?x :p ?v)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-datatype
     class Datatype < Operator::Unary
@@ -33,6 +43,15 @@ module SPARQL; module Algebra
           else raise TypeError, "expected an RDF::Literal, but got #{literal.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "DATATYPE(#{operands.last.to_sparql(**options)})"
+      end
     end # Datatype
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,11 +3,20 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `day` operator.
     #
-    # @example
-    #     (prefix ((: <http://example.org/>))
-    #       (project (?s ?x)
-    #         (extend ((?x (day ?date)))
-    #           (bgp (triple ?s :date ?date)))))
+    # [121] BuiltInCall ::= ... | 'DAY' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s (DAY(?date) AS ?x) WHERE {
+    #     ?s :date ?date
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?s ?x)
+    #     (extend ((?x (day ?date)))
+    #      (bgp (triple ?s :date ?date)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-day
     class Day < Operator::Unary
@@ -26,6 +35,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.day)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "DAY(#{operands.last.to_sparql(**options)})"
+      end
     end # Day
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,8 +6,24 @@ module SPARQL; module Algebra
     #
     # The DELETE operation is a form of the DELETE/INSERT operation having no INSERT section
     #
-    # @example
-    #   (delete ((triple ?s ?p ?o))))
+    # [42]  DeleteClause            ::= 'DELETE' QuadPattern
+    #
+    # @example SPARQL Grammar
+    #   PREFIX     : <http://example.org/> 
+    #   PREFIX foaf: <http://xmlns.com/foaf/0.1/> 
+    #   
+    #   DELETE { ?s ?p ?o }
+    #   WHERE  { :a foaf:knows ?s . ?s ?p ?o }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>)
+    #            (foaf: <http://xmlns.com/foaf/0.1/>))
+    #    (update
+    #     (modify
+    #      (bgp
+    #       (triple :a foaf:knows ?s)
+    #       (triple ?s ?p ?o))
+    #      (delete ((triple ?s ?p ?o))))))
     #
     # @see https://www.w3.org/TR/sparql11-update/#delete
     class Delete < Operator::Unary
@@ -52,6 +68,15 @@ module SPARQL; module Algebra
         end
         queryable
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this term.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "DELETE {\n" + operands.first.to_sparql(as_statement: true, **options) + "\n}"
+      end
     end # Delete
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,8 +6,18 @@ module SPARQL; module Algebra
     #
     # The DELETE DATA operation removes some triples, given inline in the request, if the respective graphs in the Graph Store contain those
     #
-    # @example
-    #   (deleteData ((triple :a foaf:knows :c)))
+    # [39]  DeleteData              ::= 'DELETE DATA' QuadData
+    #
+    # @example SPARQL Grammar
+    #   PREFIX     : <http://example.org/> 
+    #   PREFIX foaf: <http://xmlns.com/foaf/0.1/> 
+    #   DELETE DATA {
+    #     :a foaf:knows :b .
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>) (foaf: <http://xmlns.com/foaf/0.1/>))
+    #    (update (deleteData ((triple :a foaf:knows :b)))))
     #
     # @see https://www.w3.org/TR/sparql11-update/#deleteData
     class DeleteData < Operator::Unary
@@ -36,6 +46,17 @@ module SPARQL; module Algebra
         end
         queryable
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this term.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "DELETE DATA {\n" +
+          operands.first.to_sparql(as_statement: true, top_level: false, delimiter: "\n", **options) +
+          "\n}"
+      end
     end # DeleteData
   end # Operator
 end; end # SPARQL::Algebra