sparql 3.2.0 → 3.2.4

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

@@ -10,14 +10,47 @@ module SPARQL; module Algebra
     # @example SPARQL Grammar
     #   SELECT ?z
     #   { 
-    #     ?x <http://example/p> ?o
-    #     BIND(?o+1 AS ?z)
+    #     ?x <http://example.org/p> ?o
+    #     BIND(?o+10 AS ?z)
     #   }
     #
     # @example SSE
     #   (project (?z)
     #     (extend ((?z (+ ?o 10)))
-    #       (bgp (triple ?s <http://example/p> ?o))))
+    #       (bgp (triple ?x <http://example.org/p> ?o))))
+    #
+    # @example SPARQL Grammar (cast as boolean)
+    #   PREFIX : <http://example.org/>
+    #   PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT ?a ?v (xsd:boolean(?v) AS ?boolean)
+    #   WHERE { ?a :p ?v . }
+    #
+    # @example SSE (cast as boolean)
+    #   (prefix ((: <http://example.org/>)
+    #            (rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>)
+    #            (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (project (?a ?v ?boolean)
+    #     (extend ((?boolean (xsd:boolean ?v)))
+    #      (bgp (triple ?a :p ?v)))))
+    #
+    # @example SPARQL Grammar (inner bind)
+    #   PREFIX : <http://example.org/> 
+    #   
+    #   SELECT ?z ?s1
+    #   {
+    #     ?s ?p ?o .
+    #     BIND(?o+1 AS ?z)
+    #     ?s1 ?p1 ?z
+    #   }
+    #
+    # @example SSE (inner bind)
+    #   (prefix ((: <http://example.org/>))
+    #    (project (?z ?s1)
+    #     (join
+    #      (extend ((?z (+ ?o 1)))
+    #       (bgp (triple ?s ?p ?o)))
+    #     (bgp (triple ?s1 ?p1 ?z)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#evaluation
     class Extend < Operator::Binary
@@ -51,6 +84,11 @@ module SPARQL; module Algebra
         debug(options) {"Extend"}
         @solutions = operand(1).execute(queryable, depth: options[:depth].to_i + 1, **options)
         @solutions.each do |solution|
+          # Re-bind to bindings, if defined, as they might not be found in solution
+          options[:bindings].each_binding do |name, value|
+            solution[name] = value if operands.first.variables.include?(name)
+          end if options[:bindings] && operands.first.respond_to?(:variables)
+
           debug(options) {"===> soln #{solution.to_h.inspect}"}
           operand(0).each do |(var, expr)|
             begin
@@ -71,17 +109,46 @@ module SPARQL; module Algebra
       end
 
       # The variable introduced by the BIND clause must not have been used in the group graph pattern up to the point of use in BIND
+      #
+      # Also, variables used in a binding expression must be projected by the query.
       def validate!
         bind_vars = operand(0).map(&:first).map(&:name)
-        query_vars = operand(1).vars.map(&:name)
+        query_vars = operand(1).variables.keys
         
         unless (bind_vars.compact & query_vars.compact).empty?
           raise ArgumentError,
                "bound variable used in query: #{(bind_vars.compact & query_vars.compact).to_sse}"
         end
+
+        # Special case for group variables
+        if operands.last.is_a?(Group)
+          bind_expr_vars = operand(0).map(&:last).variables.keys
+          group_vars = operands.last.variables.keys
+          group_internal_vars = operands.last.internal_variables.keys
+
+          bind_expr_vars.each do |v|
+            raise ArgumentError,
+                 "extension expression uses variable not in scope: #{v}" if
+                 group_internal_vars.include?(v) &&
+                 !group_vars.include?(v)
+          end
+        end
+
         super
       end
 
+      ##
+      # The variables used in the extension.
+      # Includes extended variables.
+      #
+      # @return [Hash{Symbol => RDF::Query::Variable}]
+      def variables
+        operands.first.
+          map(&:first).
+          map(&:variables).
+          inject(operands.last.variables) {|memo, h| memo.merge(h)}
+      end
+
       ##
       #
       # Returns a partial SPARQL grammar for this operator.
@@ -91,7 +158,8 @@ module SPARQL; module Algebra
       # @return [String]
       def to_sparql(**options)
         extensions = operands.first.inject({}) do |memo, (as, expression)|
-          memo.merge(as => expression)
+          # Use string/name of variable "as" to aid in later matching
+          memo.merge(as.to_s => expression)
         end
 
         # Merge any inherited extensions from options

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

@@ -49,6 +49,11 @@ module SPARQL; module Algebra
         opts = options.merge(queryable: queryable, depth: options[:depth].to_i + 1)
         @solutions = RDF::Query::Solutions()
         queryable.query(operands.last, depth: options[:depth].to_i + 1, **options) do |solution|
+          # Re-bind to bindings, if defined, as they might not be found in solution
+          options[:bindings].each_binding do |name, value|
+            solution[name] ||= value if operands.first.variables.include?(name)
+          end if options[:bindings] && operands.first.respond_to?(:variables)
+
           begin
             pass = boolean(operands.first.evaluate(solution, **opts)).true?
             debug(options) {"(filter) #{pass.inspect} #{solution.to_h.inspect}"}
@@ -89,7 +94,7 @@ module SPARQL; module Algebra
       # @return [String]
       def to_sparql(**options)
         filter_ops = operands.first.is_a?(Operator::Exprlist) ? operands.first.operands : [operands.first]
-        operands.last.to_sparql(filter_ops: filter_ops, **options)
+        str = operands.last.to_sparql(filter_ops: filter_ops, **options)
       end
     end # Filter
   end # Operator

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

@@ -0,0 +1,64 @@
+
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `function_call` operator.
+    #
+    # [70]  FunctionCall ::= iri ArgList
+    #
+    # @example SPARQL Grammar
+    #   PREFIX xsd:   <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT *
+    #   WHERE { ?s ?p ?o . FILTER xsd:integer(?o) }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (filter (xsd:integer ?o)
+    #     (bgp (triple ?s ?p ?o))))
+    #
+    # @see https://www.w3.org/TR/sparql11-query/#funcex-regex
+    # @see https://www.w3.org/TR/xpath-functions/#func-matches
+    class FunctionCall < Operator
+      include Evaluatable
+
+      NAME = :function_call
+
+      ##
+      # Invokes the function with the passed arguments.
+      #
+      # @param  [RDF::IRI] iri
+      #   Identifies the function
+      # @param  [Array<RDF::Term>] args
+      # @return [RDF::Term]
+      def apply(iri, *args, **options)
+        args = RDF.nil == args.last ? args[0..-2] : args
+        SPARQL::Algebra::Expression.extension(iri, *args, **options)
+      end
+
+      ##
+      # Returns the SPARQL S-Expression (SSE) representation of this expression.
+      #
+      # Remove the optional argument.
+      #
+      # @return [Array] `self`
+      # @see    https://openjena.org/wiki/SSE
+      def to_sxp_bin
+        @operands.map(&:to_sxp_bin)
+      end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        iri, args = operands
+        iri.to_sparql(**options) +
+          '(' +
+          args.to_sparql(delimiter: ', ', **options) +
+          ')'
+      end
+    end # FunctionCall
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -7,7 +7,7 @@ module SPARQL; module Algebra
     #
     # [58]  GraphGraphPattern       ::= 'GRAPH' VarOrIri GroupGraphPattern
     #
-    # @example SPARQL Grammar
+    # @example SPARQL Grammar (query)
     #   PREFIX : <http://example/> 
     #   SELECT * { 
     #       GRAPH ?g { ?s ?p ?o }
@@ -18,15 +18,50 @@ module SPARQL; module Algebra
     #    (graph ?g
     #     (bgp (triple ?s ?p ?o))))
     #
-    # @example of a query
+    # @example SPARQL Grammar (named set of statements)
+    #   PREFIX : <http://example/> 
+    #   SELECT * { 
+    #       GRAPH :g { :s :p :o }
+    #   }
+    #
+    # @example SSE (named set of statements)
     #   (prefix ((: <http://example/>))
+    #    (graph :g
+    #     (bgp (triple :s :p :o))))
+    #
+    # @example SPARQL Grammar (syntax-graph-05.rq)
+    #   PREFIX : <http://example.org/>
+    #   SELECT *
+    #   WHERE
+    #   {
+    #     :x :p :z
+    #     GRAPH ?g { :x :b ?a . GRAPH ?g2 { :x :p ?x } }
+    #   }
+    #
+    # @example SSE (syntax-graph-05.rq)
+    #   (prefix ((: <http://example.org/>))
+    #    (join
+    #     (bgp (triple :x :p :z))
     #     (graph ?g
-    #       (bgp (triple ?s ?p ?o))))
+    #      (join
+    #       (bgp (triple :x :b ?a))
+    #       (graph ?g2
+    #        (bgp (triple :x :p ?x)))))))
     #
-    # @example named set of statements
-    #   (prefix ((: <http://example/>))
-    #     (graph :g
-    #       ((triple :s :p :o))))
+    # @example SPARQL Grammar (pp06.rq)
+    #   prefix ex:	<http://www.example.org/schema#>
+    #   prefix in:	<http://www.example.org/instance#>
+    #   
+    #   select ?x where {
+    #     graph ?g {in:a ex:p1/ex:p2 ?x}
+    #   }
+    #
+    # @example SSE (syntax-graph-05.rq)
+    #   (prefix ((ex: <http://www.example.org/schema#>)
+    #            (in: <http://www.example.org/instance#>))
+    #    (project (?x)
+    #     (graph ?g
+    #      (path in:a (seq ex:p1 ex:p2) ?x))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class Graph < Operator::Binary
@@ -89,6 +124,21 @@ module SPARQL; module Algebra
       def rewrite(&block)
         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)
+        query = operands.last.to_sparql(top_level: false, **options)
+        # Paths don't automatically get braces.
+        query = "{\n#{query}\n}" unless query.start_with?('{')
+        str = "GRAPH #{operands.first.to_sparql(**options)} " + query
+        top_level ? Operator.to_sparql(str, **options) : str
+      end
     end # Graph
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -25,6 +25,37 @@ module SPARQL; module Algebra
     #      (group (?P) ((??.0 (count ?O)))
     #       (bgp (triple ?S ?P ?O))))))
     #
+    # @example SPARQL Grammar (HAVING aggregate)
+    #   PREFIX : <http://www.example.org/>
+    #   SELECT ?s (AVG(?o) AS ?avg)
+    #   WHERE { ?s ?p ?o }
+    #   GROUP BY ?s
+    #   HAVING (AVG(?o) <= 2.0)
+    #
+    # @example SSE (HAVING aggregate)
+    #   (prefix ((: <http://www.example.org/>))
+    #    (project (?s ?avg)
+    #     (filter (<= ??.0 2.0)
+    #      (extend ((?avg ??.0))
+    #       (group (?s) ((??.0 (avg ?o)))
+    #        (bgp (triple ?s ?p ?o)))))) )
+    #
+    # @example SPARQL Grammar (non-trivial filters)
+    #   PREFIX : <http://example.com/data/#>
+    #   SELECT ?g (AVG(?p) AS ?avg) ((MIN(?p) + MAX(?p)) / 2 AS ?c)
+    #   WHERE { ?g :p ?p . }
+    #   GROUP BY ?g
+    #
+    # @example SSE (non-trivial filters)
+    #   (prefix ((: <http://example.com/data/#>))
+    #    (project (?g ?avg ?c)
+    #     (extend ((?avg ??.0) (?c (/ (+ ??.1 ??.2) 2)))
+    #      (group (?g)
+    #             ((??.0 (avg ?p))
+    #              (??.1 (min ?p))
+    #              (??.2 (max ?p)))
+    #       (bgp (triple ?g :p ?p)))) ))
+    #
     # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class Group < Operator
       include Query
@@ -131,22 +162,90 @@ module SPARQL; module Algebra
         super
       end
 
+      ##
+      # The variables used in the extension.
+      # Includes grouped variables and temporary, but not those in the query, itself
+      #
+      # @return [Hash{Symbol => RDF::Query::Variable}]
+      def variables
+        group_vars = operands.first
+
+        aggregate_vars = (operands.length == 3 ? operand(1) : [])
+
+        # Extract first element of each and merge it's variables
+        (group_vars + aggregate_vars).
+          map do  |o|
+            v = Array(o).first
+            v if v.is_a?(RDF::Query::Variable)
+          end.compact.
+          map(&:variables).
+          inject({}) {|memo, h| memo.merge(h)}
+      end
+
+      ##
+      # The variables used within the query
+      #
+      # @return [Hash{Symbol => RDF::Query::Variable}]
+      def internal_variables
+        operands.last.variables
+      end
+
       ##
       #
       # Returns a partial SPARQL grammar for this operator.
       #
-      # @param [Hash{Symbol => Operator}] extensions
+      # @param [Hash{String => Operator}] extensions
       #   Variable bindings
+      # @param [Array<Operator>] filter_ops ([])
+      #   Filter Operations
       # @return [String]
-      def to_sparql(extensions: {}, **options)
+      def to_sparql(extensions: {}, filter_ops: [], **options)
+        having_ops = []
         if operands.length > 2
+          temp_bindings = operands[1].inject({}) {|memo, (var, op)| memo.merge(var => op)}
           # Replace extensions from temporary bindings
-          operands[1].each do |var, op|
-            ext_var = extensions.invert.fetch(var)
-            extensions[ext_var] = op
+          temp_bindings.each do |var, op|
+            # Update extensions using a temporarily bound variable with its binding
+            extensions = extensions.inject({}) do |memo, (ext_var, ext_op)|
+              if ext_op.is_a?(Operator)
+                # Try to recursivley replace variable within operator
+                new_op = ext_op.deep_dup.rewrite do |operand|
+                  if operand.is_a?(Variable) && operand.to_sym == var.to_sym
+                    op.dup
+                  else
+                    operand
+                  end
+                end
+                memo.merge(ext_var.to_s => new_op)
+              elsif ext_op.is_a?(Variable) && ext_op.to_sym == var.to_sym
+                memo.merge(ext_var.to_s => op)
+              else
+                # Doesn't match this variable, so don't change
+                memo.merge(ext_var.to_s => ext_op)
+              end
+            end
+
+            # Filter ops using temporary bindinds are used for HAVING clauses
+            filter_ops.each do |fop|
+              having_ops << fop if fop.descendants.include?(var) && !having_ops.include?(fop)
+            end
+          end
+
+          # If used in a HAVING clause, it's not also a filter
+          filter_ops -= having_ops
+
+          # Replace each operand in having using var with it's corresponding operation
+          having_ops = having_ops.map do |op|
+            op.dup.rewrite do |operand|
+              # Rewrite based on temporary bindings
+              temp_bindings.fetch(operand, operand)
+            end
           end
         end
-        operands.last.to_sparql(extensions: extensions, group_ops: operands.first, **options)
+        operands.last.to_sparql(extensions: extensions,
+                                group_ops: operands.first,
+                                having_ops: having_ops,
+                                **options)
       end
     end # Group
   end # Operator

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

@@ -16,6 +16,24 @@ module SPARQL; module Algebra
     #     (group () ((??.0 (group_concat ?x)))
     #      (bgp))))
     #
+    # @example SPARQL Grammar (DISTINCT)
+    #   SELECT (GROUP_CONCAT(DISTINCT ?x) AS ?y) {}
+    #
+    # @example SSE (DISTINCT)
+    #   (project (?y)
+    #    (extend ((?y ??.0))
+    #     (group () ((??.0 (group_concat distinct ?x)))
+    #      (bgp))))
+    #
+    # @example SPARQL Grammar (SEPARATOR)
+    #   SELECT (GROUP_CONCAT(?x; SEPARATOR=';') AS ?y) {}
+    #
+    # @example SSE (SEPARATOR)
+    #   (project (?y)
+    #    (extend ((?y ??.0))
+    #     (group () ((??.0 (group_concat (separator ";") ?x)))
+    #      (bgp))))
+    #
     # @see https://www.w3.org/TR/sparql11-query/#defn_aggGroupConcat
     class GroupConcat < Operator
       include Aggregate
@@ -63,7 +81,13 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        "GROUP_CONCAT(#{operands.to_sparql(delimiter: ', ', **options)})"
+        distinct = operands.first == :distinct
+        args = distinct ? operands[1..-1] : operands
+        separator = args.first.last if args.first.is_a?(Array) && args.first.first == :separator
+        args = args[1..-1] if separator
+        str = "GROUP_CONCAT(#{'DISTINCT ' if distinct}#{args.to_sparql(delimiter: ', ', **options)}"
+        str << "; SEPARATOR=#{separator.to_sparql}" if separator
+        str << ")"
       end
     end # GroupConcat
   end # Operator

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

@@ -29,10 +29,10 @@ module SPARQL; module Algebra
       #
       # @param  [RDF::Literal] operand
       #   the operand
-      # @return [RDF::Literal]
+      # @return [RDF::Literal::Temporal]
       # @raise  [TypeError] if the operand is not a simple literal
       def apply(operand, **options)
-        raise TypeError, "expected an RDF::Literal::DateTime, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::DateTime)
+        raise TypeError, "expected an RDF::Literal::Temporal, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::Temporal)
         RDF::Literal(operand.object.hour)
       end
 

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

@@ -48,15 +48,15 @@ module SPARQL; module Algebra
       rescue
         raise TypeError
       end
-    end # If
 
-    ##
-    #
-    # Returns a partial SPARQL grammar for this operator.
-    #
-    # @return [String]
-    def to_sparql(**options)
-      "IF(" + operands.to_sparql(delimiter: ', ', **options) + ")"
-    end
-  end # If
+      ##
+      #
+      # 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
 end; end # SPARQL::Algebra

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

@@ -69,7 +69,9 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        "INSERT {\n" + operands.first.to_sparql(as_statement: true, **options) + "\n}"
+        "INSERT {\n" +
+          operands.first.to_sparql(delimiter: " .\n", **options) +
+          "\n}"
       end
     end # Insert
   end # Operator

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

@@ -54,7 +54,7 @@ module SPARQL; module Algebra
       # @return [String]
       def to_sparql(**options)
         "INSERT DATA {\n" +
-          operands.first.to_sparql(as_statement: true, top_level: false, delimiter: "\n", **options) +
+          operands.first.to_sparql(top_level: false, delimiter: ". \n", **options) +
           "\n}"
       end
     end # InsertData

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

@@ -13,8 +13,7 @@ module SPARQL; module Algebra
     #   }
     #
     # @example SSE
-    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (: <http://example.org/things#>))
+    #   (prefix ((: <http://example.org/things#>))
     #     (project (?x ?v)
     #       (filter (isBlank ?v)
     #         (bgp (triple ?x :p ?v)))))

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

@@ -13,8 +13,7 @@ module SPARQL; module Algebra
     #   }
     #
     # @example SSE
-    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (: <http://example.org/things#>))
+    #   (prefix ((: <http://example.org/things#>))
     #     (project (?x ?v)
     #       (filter (isIRI ?v)
     #         (bgp (triple ?x :p ?v)))))

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

@@ -13,8 +13,7 @@ module SPARQL; module Algebra
     #   }
     #
     # @example SSE
-    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (: <http://example.org/things#>))
+    #   (prefix ((: <http://example.org/things#>))
     #     (project (?x ?v)
     #       (filter (isLiteral ?v)
     #         (bgp (triple ?x :p ?v)))))

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

@@ -15,8 +15,7 @@ module SPARQL; module Algebra
     #   }
     #
     # @example SSE
-    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (: <http://example.org/things#>))
+    #   (prefix ((: <http://example.org/things#>))
     #     (project (?x ?v)
     #       (filter (isNumeric ?v)
     #         (bgp (triple ?x :p ?v)))))

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

@@ -19,6 +19,22 @@ module SPARQL; module Algebra
     #       (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
@@ -41,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))
@@ -98,10 +114,28 @@ module SPARQL; module Algebra
       #
       # @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, **options)
-        str = operands.to_sparql(top_level: false, delimiter: "\n", **options)
-        top_level ? Operator.to_sparql(str, **options) : str
+      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

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

@@ -12,9 +12,8 @@ module SPARQL; module Algebra
     #   }
     #
     # @example SSE
-    #   (prefix
-    #    ((: <http://example.org/>))
-    #    (project (?str ?lstr)
+    #   (prefix ((: <http://example.org/>))
+    #    (project (?s ?lstr)
     #     (extend ((?lstr (lcase ?str)))
     #      (bgp (triple ?s :str ?str)))))
     #