sparql 3.1.8 → 3.2.3

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

@@ -3,7 +3,15 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `if` function.
     #
-    # @example
+    # [121] BuiltInCall ::= ... | 'IF' '(' Expression ',' Expression ',' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   BASE <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT ?o (IF(lang(?o) = "ja", true, false) AS ?integer)
+    #   WHERE { ?s ?p ?o }
+    #
+    # @example SSE
     #     (base <http://example.org/>
     #       (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>))
     #         (project (?o ?integer)
@@ -37,8 +45,17 @@ module SPARQL; module Algebra
         operand(0).evaluate(bindings, depth: options[:depth].to_i + 1, **options) == RDF::Literal::TRUE ?
           operand(1).evaluate(bindings, depth: options[:depth].to_i + 1, **options) :
           operand(2).evaluate(bindings, depth: options[:depth].to_i + 1, **options)
-        rescue
-          raise TypeError
+      rescue
+        raise TypeError
+      end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "IF(" + operands.to_sparql(delimiter: ', ', **options) + ")"
       end
     end # If
   end # Operator

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

@@ -3,7 +3,12 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `in` operator.
     #
-    # @example
+    # [114] RelationalExpression    ::= NumericExpression ('IN' ExpressionList)?
+    #
+    # @example SPARQL Grammar
+    #   ASK { FILTER(2 IN (1, 2, 3)) }
+    #
+    # @example SSE
     #   (ask (filter (in 2 1 2 3) (bgp)))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-in
@@ -54,6 +59,18 @@ module SPARQL; module Algebra
         else RDF::Literal::FALSE
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "(" + operands.first.to_sparql(**options) +
+        " IN (" +
+        operands[1..-1].map {|e| e.to_sparql(**options)}.join(", ") +
+        "))"
+      end
     end # In
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,8 +6,19 @@ module SPARQL; module Algebra
     #
     # The INSERT operation is a form of the DELETE/INSERT operation having no DELETE section
     #
-    # @example
-    #   (insert ((triple ?s ?p "q")))
+    # [43]  InsertClause            ::= 'INSERT' QuadPattern
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/> 
+    #   INSERT { ?s ?p "q" }
+    #   WHERE { ?s ?p ?o }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (update
+    #     (modify (bgp (triple ?s ?p ?o))
+    #      (insert ((triple ?s ?p "q"))))))
     #
     # @see https://www.w3.org/TR/sparql11-update/#insert
     class Insert < Operator::Unary
@@ -51,6 +62,17 @@ module SPARQL; module Algebra
         end
         queryable
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this term.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "INSERT {\n" +
+          operands.first.to_sparql(delimiter: " .\n", **options) +
+          "\n}"
+      end
     end # Insert
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,8 +6,18 @@ module SPARQL; module Algebra
     #
     # The INSERT DATA operation adds some triples, given inline in the request, into the Graph Store
     #
-    # @example
-    #   (insertData ((graph <http://example.org/g1> ((triple :s :p :o)))))
+    # [38]  InsertData              ::= 'INSERT DATA' QuadData
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/ns#>
+    #   INSERT DATA { GRAPH <http://example.org/g1> { :s :p :o } }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/ns#>))
+    #    (update
+    #     (insertData (
+    #      (graph <http://example.org/g1> ((triple :s :p :o)))))))
     #
     # @see https://www.w3.org/TR/sparql11-update/#insertData
     class InsertData < 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)
+        "INSERT DATA {\n" +
+          operands.first.to_sparql(top_level: false, delimiter: ". \n", **options) +
+          "\n}"
+      end
     end # InsertData
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,10 +3,18 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `iri` operator.
     #
-    # @example
-    #     (base <http://example.org/> (project (?uri ?iri)
-    #       (extend ((?uri (uri "uri")) (?iri (iri "iri")))
-    #         (bgp))))
+    # [121] BuiltInCall ::= ... | 'IRI' '(' Expression ')' | 'URI' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   BASE <http://example.org/>
+    #   SELECT (URI("uri") AS ?uri) (IRI("iri") AS ?iri)
+    #   WHERE {}
+    #
+    # @example SSE
+    #   (base <http://example.org/>
+    #    (project (?uri ?iri)
+    #     (extend ((?uri (iri "uri")) (?iri (iri "iri")))
+    #      (bgp))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-iri
     class IRI < Operator::Unary
@@ -35,6 +43,15 @@ module SPARQL; module Algebra
         base.join(literal.to_s)
       end
 
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "IRI(" + operands.last.to_sparql(**options) + ")"
+      end
+
       Operator::URI = IRI
     end # IRI
   end # Operator

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

@@ -3,9 +3,17 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `isBlank` operator.
     #
-    # @example
-    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (: <http://example.org/things#>))
+    # [121] BuiltInCall ::= ... | 'isBlank' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX     :    <http://example.org/things#>
+    #   SELECT ?x ?v WHERE {
+    #     ?x :p ?v .
+    #     FILTER isBlank(?v) .
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/things#>))
     #     (project (?x ?v)
     #       (filter (isBlank ?v)
     #         (bgp (triple ?x :p ?v)))))
@@ -30,6 +38,15 @@ module SPARQL; module Algebra
           else raise TypeError, "expected an RDF::Term, but got #{term.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "isBlank(" + operands.first.to_sparql(**options) + ")"
+      end
     end # IsBlank
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,9 +3,17 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `isIRI`/`isURI` operator.
     #
-    # @example
-    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (: <http://example.org/things#>))
+    # [121] BuiltInCall ::= ... | 'isIRI' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX     :    <http://example.org/things#>
+    #   SELECT ?x ?v WHERE {
+    #     ?x :p ?v .
+    #     FILTER isIRI(?v) .
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/things#>))
     #     (project (?x ?v)
     #       (filter (isIRI ?v)
     #         (bgp (triple ?x :p ?v)))))
@@ -32,6 +40,15 @@ module SPARQL; module Algebra
       end
 
       Operator::IsURI = IsIRI
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "isIRI(" + operands.first.to_sparql(**options) + ")"
+      end
     end # IsIRI
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,9 +3,17 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `isLiteral` operator.
     #
-    # @example
-    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (: <http://example.org/things#>))
+    # [121] BuiltInCall ::= ... | 'isLiteral' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX     :    <http://example.org/things#>
+    #   SELECT ?x ?v WHERE {
+    #     ?x :p ?v .
+    #     FILTER isLiteral(?v) .
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/things#>))
     #     (project (?x ?v)
     #       (filter (isLiteral ?v)
     #         (bgp (triple ?x :p ?v)))))
@@ -31,6 +39,15 @@ module SPARQL; module Algebra
           else raise TypeError, "expected an RDF::Term, but got #{term.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "isLiteral(" + operands.first.to_sparql(**options) + ")"
+      end
     end # IsLiteral
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,11 +3,19 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `isNumeric` operator.
     #
-    # Note numeric denotes typed literals with datatypes xsd:integer, xsd:decimal, xsd:float, and xsd:double, not derived types.
+    # Note numeric denotes typed literals with datatypes `xsd:integer`, `xsd:decimal`, `xsd:float`, and `xsd:double`, not derived types.
     #
-    # @example
-    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (: <http://example.org/things#>))
+    # [121] BuiltInCall ::= ... | 'isNumeric' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX     :    <http://example.org/things#>
+    #   SELECT ?x ?v WHERE {
+    #     ?x :p ?v .
+    #     FILTER isNumeric(?v) .
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/things#>))
     #     (project (?x ?v)
     #       (filter (isNumeric ?v)
     #         (bgp (triple ?x :p ?v)))))
@@ -16,7 +24,7 @@ module SPARQL; module Algebra
     class IsNumeric < Operator::Unary
       include Evaluatable
 
-      NAME = :isnumeric
+      NAME = :isNumeric
 
       ##
       # Returns `true` if the operand is an `RDF::Literal::Numeric`, `false`
@@ -36,6 +44,15 @@ module SPARQL; module Algebra
           else raise TypeError, "expected an RDF::Term, but got #{term.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "isNumeric(" + operands.first.to_sparql(**options) + ")"
+      end
     end # IsNumeric
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,6 +5,29 @@ module SPARQL; module Algebra
     #
     # Returns true if term is an RDF-star triple. Returns false otherwise.
     #
+    # [121] BuiltInCall ::= ... | 'isTreiple' '(' 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#istriple
     class IsTriple < Operator::Unary
       include Evaluatable
@@ -25,6 +48,15 @@ module SPARQL; module Algebra
           else raise TypeError, "expected an RDF::Term, but got #{term.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "isTRIPLE(" + operands.first.to_sparql(**options) + ")"
+      end
     end # IsTriple
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,13 +3,38 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `join` operator.
     #
-    # @example
+    # [54]	GroupGraphPatternSub	::=	TriplesBlock? (GraphPatternNotTriples "."? TriplesBlock? )*
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example/> 
+    #   SELECT * { 
+    #      ?s ?p ?o
+    #      GRAPH ?g { ?s ?q ?v }
+    #   }
+    #
+    # @example SSE
     #   (prefix ((: <http://example/>))
     #     (join
     #       (bgp (triple ?s ?p ?o))
     #       (graph ?g
     #         (bgp (triple ?s ?q ?v)))))
     #
+    # @example SPARQL Grammar (inline filter)
+    #   PREFIX : <http://xmlns.com/foaf/0.1/>
+    #   ASK {
+    #     :who :homepage ?homepage 
+    #     FILTER REGEX(?homepage, "^http://example.org/") 
+    #     :who :schoolHomepage ?schoolPage
+    #   }
+    # 
+    # @example SSE (inline filter)
+    #   (prefix ((: <http://xmlns.com/foaf/0.1/>))
+    #    (ask
+    #     (filter (regex ?homepage "^http://example.org/")
+    #      (join
+    #       (bgp (triple :who :homepage ?homepage))
+    #       (bgp (triple :who :schoolHomepage ?schoolPage))))))
+    #
     # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class Join < Operator::Binary
       include Query
@@ -32,8 +57,8 @@ module SPARQL; module Algebra
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
       # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      # @see    https://www.rubydoc.info/github/ruby-rdf/rdf/RDF/Query/Solution#merge-instance_method
-      # @see    https://www.rubydoc.info/github/ruby-rdf/rdf/RDF/Query/Solution#compatible%3F-instance_method
+      # @see    https://ruby-rdf.github.io/rdf/RDF/Query/Solution#merge-instance_method
+      # @see    https://ruby-rdf.github.io/rdf/RDF/Query/Solution#compatible%3F-instance_method
       def execute(queryable, **options, &block)
         # Join(Ω1, Ω2) = { merge(μ1, μ2) | μ1 in Ω1 and μ2 in Ω2, and μ1 and μ2 are compatible }
         # eval(D(G), Join(P1, P2)) = Join(eval(D(G), P1), eval(D(G), P2))
@@ -82,6 +107,36 @@ 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 {}
+      # @param [Hash{String => Operator}] extensions
+      #   Variable bindings
+      # @param [Array<Operator>] filter_ops ([])
+      #   Filter Operations
+      # @return [String]
+      def to_sparql(top_level: true, filter_ops: [], extensions: {}, **options)
+        # If this is top-level, and the last operand is a Table (values), put the values at the outer-level
+        str = "{\n" + operands.first.to_sparql(top_level: false, extensions: {}, **options)
+
+        # Any accrued filters go here.
+        filter_ops.each do |op|
+          str << "\nFILTER (#{op.to_sparql(**options)}) ."
+        end
+
+        if top_level && operands.last.is_a?(Table)
+          str << "\n}"
+          options = options.merge(values_clause: operands.last)
+        else
+          str << "\n{\n" + operands.last.to_sparql(top_level: false, extensions: {}, **options) + "\n}\n}"
+        end
+
+        top_level ? Operator.to_sparql(str, extensions: extensions, **options) : str
+      end
     end # Join
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,6 +3,22 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `lang` operator.
     #
+    # [121] BuiltInCall ::= ... | 'LANG' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example/> 
+    #   
+    #   SELECT ?x
+    #   { ?x :p ?v . 
+    #     FILTER ( lang(?v) != '@NotALangTag@' )
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example/>))
+    #    (project (?x)
+    #     (filter (!= (lang ?v) "@NotALangTag@")
+    #      (bgp (triple ?x :p ?v)))))
+    #
     # @see https://www.w3.org/TR/sparql11-query/#func-lang
     class Lang < Operator::Unary
       include Evaluatable
@@ -24,6 +40,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)
+        "lang(" + operands.first.to_sparql(**options) + ")"
+      end
     end # Lang
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,7 +3,15 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `langMatches` operator.
     #
-    # @example
+    # [121] BuiltInCall ::= ... | 'LANGMATCHES' '(' Expression ',' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/#>
+    #   
+    #   SELECT *
+    #   { :x ?p ?v . FILTER langMatches(lang(?v), "en-GB") . }
+    #
+    # @example SSE
     #   (prefix ((: <http://example.org/#>))
     #     (filter (langMatches (lang ?v) "en-GB")
     #       (bgp (triple :x ?p ?v))))
@@ -48,6 +56,19 @@ module SPARQL; module Algebra
             RDF::Literal(language_tag.start_with?(language_range + '-'))
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "langMatches(" +
+          operands.first.to_sparql(**options) +
+          ", " +
+          operands.last.to_sparql(**options) +
+          ")"
+      end
     end # LangMatches
   end # Operator
 end; end # SPARQL::Algebra

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

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

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

@@ -3,7 +3,19 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `leftjoin` operator.
     #
-    # @example
+    # [57]  OptionalGraphPattern    ::= 'OPTIONAL' GroupGraphPattern
+    #
+    # @example SPARQL Grammar
+    #   PREFIX :    <http://example/>
+    #   SELECT * { 
+    #     ?x :p ?v .
+    #     OPTIONAL { 
+    #       ?y :q ?w .
+    #       FILTER(?v=2)
+    #     }
+    #   }
+    #
+    # @example SSE
     #   (prefix ((: <http://example/>))
     #     (leftjoin
     #       (bgp (triple ?x :p ?v))
@@ -32,8 +44,8 @@ module SPARQL; module Algebra
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
       # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      # @see    https://www.rubydoc.info/github/ruby-rdf/rdf/RDF/Query/Solution#merge-instance_method
-      # @see    https://www.rubydoc.info/github/ruby-rdf/rdf/RDF/Query/Solution#compatible%3F-instance_method
+      # @see    https://ruby-rdf.github.io/rdf/RDF/Query/Solution#merge-instance_method
+      # @see    https://ruby-rdf.github.io/rdf/RDF/Query/Solution#compatible%3F-instance_method
       def execute(queryable, **options, &block)
         filter = operand(2)
 
@@ -112,6 +124,35 @@ module SPARQL; module Algebra
           expr ? LeftJoin.new(ops[0], ops[1], expr) : LeftJoin.new(ops[0], ops[1])
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @param [Boolean] top_level (true)
+      #   Treat this as a top-level, generating SELECT ... WHERE {}
+      # @param [Hash{String => Operator}] extensions
+      #   Variable bindings
+      # @param [Array<Operator>] filter_ops ([])
+      #   Filter Operations
+      # @return [String]
+      def to_sparql(top_level: true, filter_ops: [], extensions: {}, **options)
+        str = "{\n" + operands[0].to_sparql(top_level: false, extensions: {}, **options)
+        str << 
+          "\nOPTIONAL {\n" +
+          operands[1].to_sparql(top_level: false, extensions: {}, **options)
+        case operands[2]
+        when SPARQL::Algebra::Operator::Exprlist
+          operands[2].operands.each do |op|
+            str << "\nFILTER (" + op.to_sparql(**options) + ")"
+          end
+        when nil
+        else
+          str << "\nFILTER (" + operands[2].to_sparql(**options) + ")"
+        end
+        str << "\n}}"
+        top_level ? Operator.to_sparql(str, filter_ops: filter_ops, extensions: extensions, **options) : str
+      end
     end # LeftJoin
   end # Operator
 end; end # SPARQL::Algebra