sparql 3.1.8 → 3.2.0

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

@@ -3,12 +3,22 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `strlang` operator.
     #
-    # @example
-    #     (prefix ((: <http://example.org/>))
-    #       (project (?s ?s2)
-    #         (extend ((?s2 (strlang ?str "en-US")))
-    #           (filter (langMatches (lang ?str) "en")
-    #             (bgp (triple ?s :str ?str))))))
+    # [121] BuiltInCall ::= ... | 'STRLANG' '(' Expression ',' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s (STRLANG(?str,"en-US") AS ?s2) WHERE {
+    #     ?s :str ?str
+    #     FILTER(LANGMATCHES(LANG(?str), "en"))
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>) (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #     (project (?s ?s2)
+    #       (extend ((?s2 (strlang ?str "en-US")))
+    #         (filter (langMatches (lang ?str) "en")
+    #           (bgp (triple ?s :str ?str))))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-strlang
     class StrLang < Operator::Binary
@@ -29,6 +39,15 @@ module SPARQL; module Algebra
         raise TypeError, "Literal #{value.inspect} is not simple" unless value.simple?
         RDF::Literal.new(value.to_s, language: langTag.to_s)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "STRLANG(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # StrLang
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,20 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `strlen` operator.
     #
-    # @example
-    #   (strlen ?x)
+    # [121] BuiltInCall ::= ... 'STRLEN' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?str (STRLEN(?str) AS ?len) WHERE {
+    #     ?s :str ?str
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?str ?len)
+    #     (extend ((?len (strlen ?str)))
+    #      (bgp (triple ?s :str ?str)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-strlen
     # @see https://www.w3.org/TR/xpath-functions/#func-string-length
@@ -29,6 +41,15 @@ module SPARQL; module Algebra
         raise TypeError, "expected a plain RDF::Literal, but got #{operand.inspect}" unless operand.literal? && operand.plain?
         RDF::Literal(operand.to_s.length)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "STRLEN(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # StrLen
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,22 @@ module SPARQL; module Algebra
     ##
     # A SPARQL `strstarts` operator.
     #
-    # @example
-    #   (strstarts ?x ?y)
+    # [121] BuiltInCall ::= ... | 'STRSTARTS' '(' Expression ',' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+
+    #   SELECT ?s ?str WHERE {
+    #     ?s :str ?str
+    #     FILTER STRSTARTS(?str, "a")
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?s ?str)
+    #     (filter (strstarts ?str "a")
+    #      (bgp (triple ?s :str ?str)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-strstarts
     # @see https://www.w3.org/TR/xpath-functions/#func-starts-with
@@ -41,6 +55,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)
+        "STRSTARTS(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # StrStarts
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,16 +3,27 @@ require 'securerandom'
 module SPARQL; module Algebra
   class Operator
     ##
-    # The SPARQL `uuid` function.
+    # [121] BuiltInCall ::= ... | 'STRUUID' NIL 
     #
-    # @example
-    #     (prefix ((: <http://example.org/>)
-    #              (xsd: <http://www.w3.org/2001/XMLSchema#>))
-    #       (project (?length)
-    #         (extend ((?length (strlen ?uuid)))
-    #           (filter (&& (isLiteral ?uuid) (regex ?uuid "^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$" "i"))
-    #             (extend ((?uuid (struuid)))
-    #               (bgp))))))
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT (STRLEN(?uuid) AS ?length)
+    #   WHERE {
+    #     BIND(STRUUID() AS ?uuid)
+    #     FILTER(ISLITERAL(?uuid) && REGEX(?uuid, "^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$", "i"))
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>) (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (project (?length)
+    #     (extend ((?length (strlen ?uuid)))
+    #      (filter
+    #       (&&
+    #        (isLiteral ?uuid)
+    #        (regex ?uuid "^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$" "i"))
+    #       (extend ((?uuid (struuid)))
+    #        (bgp))))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-struuid
     class StrUUID < Operator::Nullary
@@ -27,6 +38,15 @@ module SPARQL; module Algebra
       def apply(**options)
         RDF::Literal(SecureRandom.uuid)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "STRUUID(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # StrUUID
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -7,6 +7,29 @@ module SPARQL; module Algebra
     #
     # If triple is an RDF-star triple, the function returns the subject of this triple. Passing anything other than an RDF-star triple is an error.
     #
+    # [121] BuiltInCall ::= ... | 'SUBJECT' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.com/ns#>
+    #   SELECT * {
+    #     ?t :source :g
+    #     FILTER(isTriple(?t))
+    #     FILTER(SUBJECT(?t) = :s)
+    #     FILTER(PREDICATE(?t) = :p)
+    #     FILTER(OBJECT(?t) = :o)
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.com/ns#>))
+    #    (filter
+    #     (exprlist
+    #      (isTRIPLE ?t)
+    #      (= (subject ?t) :s)
+    #      (= (predicate ?t) :p)
+    #      (= (object ?t) :o))
+    #     (bgp (triple ?t :source :g))) )
+    #
     # @see https://w3c.github.io/rdf-star/rdf-star-cg-spec.html#subject
     class Subject < Operator::Unary
       include Evaluatable
@@ -24,6 +47,15 @@ module SPARQL; module Algebra
         raise TypeError, "expected an RDF::Statement, but got #{operand.inspect}" unless operand.is_a?(RDF::Statement)
         operand.subject
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "SUBJECT(" + operands.last.to_sparql(**options) + ")"
+      end
     end # Subject
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,20 @@ module SPARQL; module Algebra
     ##
     # A SPARQL `substr` operator.
     #
-    # @example
-    #   (substr ?x ?y)
+    # [123] SubstringExpression ::= 'SUBSTR' '(' Expression ',' Expression ( ',' Expression )? ')'
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s ?str (SUBSTR(?str,1,1) AS ?substr)
+    #   WHERE {
+    #     ?s :str ?str
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>))
+    #    (project (?s ?str ?substr)
+    #     (extend ((?substr (substr ?str 1 1)))
+    #      (bgp (triple ?s :str ?str)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-substr
     # @see https://www.w3.org/TR/xpath-functions/#func-substring
@@ -75,6 +87,15 @@ module SPARQL; module Algebra
       def to_sxp_bin
         [NAME] + operands.reject {|o| o.to_s == ""}
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "SUBSTR(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # SubStr
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -2,8 +2,25 @@ module SPARQL; module Algebra
   class Operator
     ##
     # The SPARQL numeric `subtract` operator.
-    #   (- ?x ?y)
-    #   (subtract ?x ?y)
+    #
+    # [116] AdditiveExpression ::=	MultiplicativeExpression ( '-' MultiplicativeExpression )?
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s WHERE {
+    #     ?s :p ?o .
+    #     ?s2 :p ?o2 .
+    #     FILTER(?o - ?o2 = 3) .
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?s)
+    #     (filter (= (- ?o ?o2) 3)
+    #      (bgp
+    #       (triple ?s :p ?o)
+    #       (triple ?s2 :p ?o2)))))
     #
     # @see https://www.w3.org/TR/xpath-functions/#func-numeric-subtract
     class Subtract < Operator::Binary
@@ -27,6 +44,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 # Subtract
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,7 +3,14 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `sum` set function.
     #
-    # @example
+    # [127] Aggregate::= ... | 'SUM' '(' 'DISTINCT'? Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://www.example.org/>
+    #   SELECT (SUM(?O) AS ?sum)
+    #   WHERE { ?s :dec ?o }
+    #
+    # @example SSE
     #    (prefix ((: <http://www.example.org/>))
     #      (project (?sum)
     #        (extend ((?sum ??.0))
@@ -33,6 +40,15 @@ module SPARQL; module Algebra
           raise TypeError, "Averaging non-numeric types: #{enum.flatten}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "SUM(" + operands.to_sparql(**options) + ")"
+      end
     end # Sum
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,10 +6,26 @@ module SPARQL; module Algebra
     # This is used to provide inline values. Each row becomes
     # a solution.
     #
-    # @example
-    #    (table (vars ?book ?title)
-    #      (row (?title "SPARQL Tutorial"))
-    #      (row (?book :book2)))
+    # [28]  ValuesClause            ::= ( 'VALUES' DataBlock )?
+    #
+    # @example SPARQL Grammar
+    #   PREFIX dc:   <http://purl.org/dc/elements/1.1/> 
+    #   PREFIX :     <http://example.org/book/> 
+    #   PREFIX ns:   <http://example.org/ns#> 
+    #   SELECT ?book ?title ?price {
+    #      ?book dc:title ?title ;
+    #            ns:price ?price .
+    #   }
+    #   VALUES ?book { :book1 }
+    #
+    # @example SSE
+    #   (prefix ((dc: <http://purl.org/dc/elements/1.1/>)
+    #            (: <http://example.org/book/>)
+    #            (ns: <http://example.org/ns#>))
+    #    (project (?book ?title ?price)
+    #     (join
+    #      (bgp (triple ?book dc:title ?title) (triple ?book ns:price ?price))
+    #      (table (vars ?book) (row (?book :book1)))) ))
     #
     # @example empty table
     #     (table unit)
@@ -46,6 +62,28 @@ module SPARQL; module Algebra
         @solutions.each(&block) if block_given?
         @solutions
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        str = "VALUES (#{operands.first[1..-1].map { |e| e.to_sparql(**options) }.join(' ')}) {\n"
+        operands[1..-1].each do |row|
+          line = '('
+          row[1..-1].each do |col|
+            line << "#{col[1].to_sparql(**options)} "
+          end
+          line = line.chop
+          line << ")\n"
+
+          str << line
+        end
+
+        str << "}\n"
+        str
+      end
     end # Table
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,11 +5,20 @@ module SPARQL; module Algebra
     #
     # Returns the timezone part of `arg` as an xsd:dayTimeDuration. Raises an error if there is no timezone.
     #
-    # @example
-    #     (prefix ((: <http://example.org/>))
-    #       (project (?s ?x)
-    #         (extend ((?x (timezone ?date)))
-    #           (bgp (triple ?s :date ?date)))))
+    # [121] BuiltInCall ::= ... | 'TIMEZONE' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s (TIMEZONE(?date) AS ?x) WHERE {
+    #     ?s :date ?date
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?s ?x)
+    #     (extend ((?x (timezone ?date)))
+    #      (bgp (triple ?s :date ?date)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-timezone
     class Timezone < Operator::Unary
@@ -31,6 +40,15 @@ module SPARQL; module Algebra
         raise TypeError, "literal has no timezone" unless res = operand.timezone
         res
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "TIMEZONE(" + operands.to_sparql(**options) + ")"
+      end
     end # Timezone
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,11 +5,20 @@ module SPARQL; module Algebra
     #
     # Returns the timezone part of `arg` as a simple literal. Returns the empty string if there is no timezone.
     #
-    # @example
-    #     (prefix ((: <http://example.org/>))
-    #       (project (?s ?x)
-    #         (extend ((?x (tz ?date)))
-    #           (bgp (triple ?s :date ?date)))))
+    # [121] BuiltInCall ::= ... | 'TZ' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s (TZ(?date) AS ?x) WHERE {
+    #     ?s :date ?date
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?s ?x)
+    #     (extend ((?x (tz ?date)))
+    #      (bgp (triple ?s :date ?date)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-tz
     class TZ < Operator::Unary
@@ -28,6 +37,14 @@ module SPARQL; module Algebra
         raise TypeError, "expected an RDF::Literal::DateTime, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::DateTime)
         operand.tz
       end
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "TZ(" + operands.to_sparql(**options) + ")"
+      end
     end # TZ
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,20 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `ucase` operator.
     #
-    # @example
-    #   (ucase ?x)
+    # [121] BuiltInCall ::= ... | 'UCASE' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s (UCASE(?str) AS ?ustr) WHERE {
+    #     ?s :str ?str
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?str ?ustr)
+    #     (extend ((?ustr (ucase ?str)))
+    #      (bgp (triple ?s :str ?str)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-ucase
     # @see https://www.w3.org/TR/xpath-functions/#func-ucase
@@ -26,6 +38,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)
+        "UCASE(" + operands.last.to_sparql(**options) + ")"
+      end
     end # UCase
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,12 +3,19 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `union` operator.
     #
-    # @example
-    #   (prefix ((: <http://example/>))
-    #     (union
-    #       (bgp (triple ?s ?p ?o))
-    #       (graph ?g
-    #         (bgp (triple ?s ?p ?o)))))
+    # [67]  GroupOrUnionGraphPattern::= GroupGraphPattern ( 'UNION' GroupGraphPattern )*
+    #
+    # @example SPARQL Grammar
+    #   SELECT * {
+    #     { ?s ?p ?o }
+    #     UNION
+    #     { GRAPH ?g { ?s ?p ?o } }}
+    #
+    # @example SSE
+    #   (union
+    #    (bgp (triple ?s ?p ?o))
+    #    (graph ?g
+    #     (bgp (triple ?s ?p ?o))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class Union < Operator::Binary
@@ -66,6 +73,22 @@ 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 = "{\n"
+        str << operands[0].to_sparql(top_level: false, **options)
+        str << "\n} UNION {\n"
+        str << operands[1].to_sparql(top_level: false, **options)
+        str << "\n}"
+        top_level ? Operator.to_sparql(str, **options) : str
+      end
     end # Union
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,11 +3,23 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `prefix` operator.
     #
-    # @example
-    #   (update
+    # [29]  Update                  ::= Prologue ( Update1 ( ';' Update )? )?
+    #
+    # @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 ?s ?p ?o))
-    #       (insert ((triple ?s ?p "q")))))
+    #      (bgp (triple ?a foaf:knows ?b))
+    #      (delete ((triple ?a foaf:knows ?b)))
+    #      (insert ((triple ?b foaf:knows ?a)))) ))
     #
     # @see https://www.w3.org/TR/sparql11-update/#graphUpdate
     class Update < Operator
@@ -39,6 +51,15 @@ module SPARQL; module Algebra
         end
         queryable
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        str = operands.map { |e| e.to_sparql(**options) }.join("\n")
+      end
     end # Update
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,8 +6,27 @@ module SPARQL; module Algebra
     #
     # The USING and USING NAMED clauses affect the RDF Dataset used while evaluating the WHERE clause. This describes a dataset in the same way as FROM and FROM NAMED clauses describe RDF Datasets in the SPARQL 1.1 Query Language
     #
-    # @example
-    #   (using (:g1) (bgp (triple ?s ?p ?o)))
+    # [44]  UsingClause             ::= 'USING' ( iri | 'NAMED' iri )
+    #
+    # @example SPARQL Grammar
+    #   PREFIX     : <http://example.org/> 
+    #   PREFIX foaf: <http://xmlns.com/foaf/0.1/> 
+    #   
+    #   DELETE { ?s ?p ?o }
+    #   USING <http://example.org/g2>
+    #   WHERE {
+    #     :a foaf:knows ?s .
+    #     ?s ?p ?o 
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>) (foaf: <http://xmlns.com/foaf/0.1/>))
+    #    (update
+    #     (modify
+    #      (using (:g2)
+    #       (bgp (triple :a foaf:knows ?s) (triple ?s ?p ?o)))
+    #      (delete ((triple ?s ?p ?o)))) ))
     #
     # @see https://www.w3.org/TR/sparql11-update/#add
     class Using < Operator
@@ -35,6 +54,17 @@ module SPARQL; module Algebra
         debug(options) {"Using"}
         Dataset.new(*operands).execute(queryable, depth: options[:depth].to_i + 1, **options, &block)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        str = "USING #{operands.first.to_sparql(**options)}\n"
+        content = operands.last.to_sparql(top_level: false, **options)
+        str << Operator.to_sparql(content, project: nil, **options)
+      end
     end # Using
   end # Operator
 end; end # SPARQL::Algebra