sparql 3.1.6 → 3.2.1

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
@@ -25,10 +37,19 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal::Integer] length of string
       # @raise  [TypeError] if the operand is not a numeric value
-      def apply(operand)
+      def apply(operand, **options)
         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
@@ -33,7 +47,7 @@ module SPARQL; module Algebra
       #   a literal
       # @return [RDF::Literal::Boolean]
       # @raise  [TypeError] if operands are not compatible
-      def apply(left, right)
+      def apply(left, right, **options)
         case
         when !left.compatible?(right)
           raise TypeError, "expected two RDF::Literal operands, but got #{left.inspect} and #{right.inspect}"
@@ -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
@@ -24,9 +35,18 @@ module SPARQL; module Algebra
       # Return a string that is the scheme specific part of UUID. That is, as a simple literal, the result of generating a UUID, converting to a simple literal and removing the initial urn:uuid:.
       #
       # @return [RDF::URI]
-      def apply
+      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
@@ -20,10 +43,19 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal]
       # @raise  [TypeError] if the operand is not a statement
-      def apply(operand)
+      def apply(operand, **options)
         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
@@ -49,7 +61,7 @@ module SPARQL; module Algebra
       #   an optional length of the substring.
       # @return [RDF::Literal]
       # @raise  [TypeError] if operands are not compatible
-      def apply(source, startingLoc, length)
+      def apply(source, startingLoc, length, **options)
         raise TypeError, "expected a plain RDF::Literal, but got #{source.inspect}" unless source.literal? && source.plain?
         text = text.to_s
 
@@ -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
@@ -20,13 +37,22 @@ module SPARQL; module Algebra
       #   a numeric literal
       # @return [RDF::Literal::Numeric]
       # @raise  [TypeError] if either operand is not a numeric literal
-      def apply(left, right)
+      def apply(left, right, **options)
         case
           when left.is_a?(RDF::Literal::Numeric) && right.is_a?(RDF::Literal::Numeric)
             left - right
           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,12 +3,19 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `sum` set function.
     #
-    # @example
-    #    (prefix ((: <http://www.example.org/>))
-    #      (project (?sum)
-    #        (extend ((?sum ??.0))
-    #          (group () ((??.0 (sum ?o)))
-    #            (bgp (triple ?s :dec ?o))))))
+    # [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))
+    #         (group () ((??.0 (sum ?o)))
+    #           (bgp (triple ?s :dec ?o))))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#defn_aggSum
     class Sum < Operator
@@ -22,7 +29,7 @@ module SPARQL; module Algebra
       # @param  [Enumerable<Array<RDF::Term>>] enum
       #   enum of evaluated operand
       # @return [RDF::Literal::Numeric] The sum of the terms
-      def apply(enum)
+      def apply(enum, **options)
         # FIXME: we don't actually do anything with distinct
         operands.shift if distinct = (operands.first == :distinct)
         if enum.empty?
@@ -33,6 +40,17 @@ 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)
+        distinct = operands.first == :distinct
+        args = distinct ? operands[1..-1] : operands
+        "SUM(#{'DISTINCT ' if distinct}#{args.to_sparql(**options)})"
+      end
     end # Sum
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,13 +6,59 @@ 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 (ValuesClause)
+    #   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 (ValuesClause)
+    #   (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 SPARQL Grammar (empty query no values)
+    #    SELECT * { } VALUES () { }
+    #
+    # @example SSE (empty query no values)
+    #    (join (bgp) (table empty))
+    #
+    # [61]  InlineData              ::= 'VALUES' DataBlock
+    #
+    # @example SPARQL Grammar (InlineData)
+    #   PREFIX dc:   <http://purl.org/dc/elements/1.1/> 
+    #   PREFIX :     <http://example.org/book/> 
+    #   PREFIX ns:   <http://example.org/ns#> 
+    #   
+    #   SELECT ?book ?title ?price
+    #   {
+    #      VALUES ?book { :book1 }
+    #      ?book dc:title ?title ;
+    #            ns:price ?price .
+    #   }
+    #
+    # @example SSE (InlineData)
+    #   (prefix ((dc: <http://purl.org/dc/elements/1.1/>)
+    #            (: <http://example.org/book/>)
+    #            (ns: <http://example.org/ns#>))
+    #    (project (?book ?title ?price)
+    #     (join
+    #      (table (vars ?book) (row (?book :book1)))
+    #      (bgp (triple ?book dc:title ?title) (triple ?book ns:price ?price))) ))
     #
     # @example empty table
     #     (table unit)
+    #
     # @see https://www.w3.org/TR/2013/REC-sparql11-query-20130321/#inline-data
     class Table < Operator
       include Query
@@ -46,6 +92,32 @@ module SPARQL; module Algebra
         @solutions.each(&block) if block_given?
         @solutions
       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 = "VALUES (#{Array(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|
+            v = col[1].to_sparql(as_statement: true, **options)
+            v = "<< #{v} >>" if col[1].is_a?(RDF::Statement)
+            line << v + ' '
+          end
+          line = line.chomp(' ')
+          line << ")\n"
+
+          str << line
+        end
+
+        str << "}\n"
+        top_level ? Operator.to_sparql(str, **options) : 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
@@ -26,11 +35,20 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal]
       # @raise  [TypeError] if the operand is not a simple literal
-      def apply(operand)
+      def apply(operand, **options)
         raise TypeError, "expected an RDF::Literal::DateTime, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::DateTime)
         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
@@ -24,10 +33,18 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal]
       # @raise  [TypeError] if the operand is not a simple literal
-      def apply(operand)
+      def apply(operand, **options)
         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 (?s ?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
@@ -20,12 +32,21 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal] literal of same type
       # @raise  [TypeError] if the operand is not a literal value
-      def apply(operand)
+      def apply(operand, **options)
         case operand
           when RDF::Literal then RDF::Literal(operand.to_s.upcase, datatype: operand.datatype, language: operand.language)
           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