sparql 3.1.5 → 3.2.0

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

@@ -3,7 +3,15 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `order` operator.
     #
-    # @example
+    # [23]  OrderClause             ::= 'ORDER' 'BY' OrderCondition+
+    #
+    # @example SPARQL Grammar
+    #   PREFIX foaf:    <http://xmlns.com/foaf/0.1/>
+    #   SELECT ?name
+    #   WHERE { ?x foaf:name ?name }
+    #   ORDER BY ASC(?name)
+    #
+    # @example SSE
     #   (prefix ((foaf: <http://xmlns.com/foaf/0.1/>))
     #     (project (?name)
     #       (order ((asc ?name))
@@ -40,7 +48,13 @@ module SPARQL; module Algebra
             memo = begin
               a_eval = op.evaluate(a, queryable: queryable, depth: options[:depth].to_i + 1, **options) rescue nil
               b_eval = op.evaluate(b, queryable: queryable, depth: options[:depth].to_i + 1, **options) rescue nil
-              comp = Operator::Compare.evaluate(a_eval, b_eval).to_i
+              comp = begin
+                Operator::Compare.evaluate(a_eval, b_eval, order_by: true).to_s.to_i
+              rescue TypeError
+                # Type sError is effectively zero
+                debug(options) {"(order) rescue(#{$!}): #{a_eval.inspect}, #{b_eval.inspect}"}
+                RDF::Literal(0)
+              end
               comp = -comp if op.is_a?(Operator::Desc)
               comp
             end if memo == 0
@@ -50,6 +64,17 @@ module SPARQL; module Algebra
         @solutions.each(&block) if block_given?
         @solutions
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # Provides order to descendant query.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        operands.last.to_sparql(order_ops: operands.first, **options)
+      end
     end # Order
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,23 @@ module SPARQL; module Algebra
     ##
     # The SPARQL Property Path `path` operator.
     #
-    # @example
-    #   (path :a (path+ :p) ?z)
+    # [88]  Path ::= PathAlternative
+    #
+    # @example SPARQL Grammar
+    #   PREFIX :  <http://www.example.org/>
+    #   SELECT ?t
+    #   WHERE {
+    #     :a :p1|:p2/:p3|:p4 ?t
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://www.example.org/>))
+    #    (project (?t)
+    #     (path :a
+    #      (alt
+    #       (alt :p1 (seq :p2 :p3))
+    #       :p4)
+    #      ?t)))
     #
     # @see https://www.w3.org/TR/sparql11-query/#sparqlTranslatePathExpressions
     class Path < Operator::Ternary
@@ -45,6 +60,18 @@ 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 = operands.to_sparql(top_level: false, **options) + " ."
+        top_level ? Operator.to_sparql(str, **options) : str
+      end
     end # Path
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,18 @@ module SPARQL; module Algebra
     ##
     # The SPARQL Property Path `path?` (ZeroOrOnePath) operator.
     #
-    # @example
-    #   (path? :p)
+    # [91]  PathElt                 ::= PathPrimary PathMod?
+    # [93]  PathMod                 ::= '*' | '?' | '+'
+    
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example/> 
+    #   SELECT * WHERE {
+    #     :a (:p/:p)? ?t
+    #   } 
+    #
+    # @example SSE
+    #   (prefix ((: <http://example/>))
+    #    (path :a (path? (seq :p :p)) ?t))
     #
     # @see https://www.w3.org/TR/sparql11-query/#defn_evalPP_ZeroOrOnePath
     class PathOpt < Operator::Unary
@@ -107,6 +117,15 @@ 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)
+        "(#{operands.first.to_sparql(**options)})?"
+      end
     end # PathOpt
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,18 @@ module SPARQL; module Algebra
     ##
     # The SPARQL Property Path `path+` (OneOrMorePath) operator.
     #
-    # @example
-    #   (path+ :p)
+    # [91]  PathElt                 ::= PathPrimary PathMod?
+    # [93]  PathMod                 ::= '*' | '?' | '+'
+    
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example/> 
+    #   SELECT * WHERE {
+    #     :a :p+ ?z
+    #   } 
+    #
+    # @example SSE
+    #   (prefix ((: <http://example/>))
+    #    (path :a (path+ :p) ?z))
     #
     # @see https://www.w3.org/TR/sparql11-query/#defn_evalPP_OneOrMorePath
     class PathPlus < Operator::Unary
@@ -94,6 +104,15 @@ module SPARQL; module Algebra
         solutions.each(&block) if block_given? # Only at top-level
         solutions
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "(#{operands.first.to_sparql(**options)})+"
+      end
     end # PathPlus
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,18 @@ module SPARQL; module Algebra
     ##
     # The SPARQL Property Path `path*` (ZeroOrMorePath) operator.
     #
-    # @example
-    #   (path* :p)
+    # [91]  PathElt                 ::= PathPrimary PathMod?
+    # [93]  PathMod                 ::= '*' | '?' | '+'
+    
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example/> 
+    #   SELECT * WHERE {
+    #     :a :p* ?z
+    #   } 
+    #
+    # @example SSE
+    #   (prefix ((: <http://example/>))
+    #    (path :a (path* :p) ?z))
     #
     # @see https://www.w3.org/TR/sparql11-query/#defn_evalPP_ZeroOrMorePath
     class PathStar < Operator::Unary
@@ -37,6 +47,14 @@ module SPARQL; module Algebra
         query = PathOpt.new(PathPlus.new(*operands))
         query.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)
+        "(#{operands.first.to_sparql(**options)})*"
+      end
     end # PathStar
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,9 +3,39 @@ module SPARQL; module Algebra
     ##
     # The SPARQL numeric binary/unary `+` operator.
     #
-    # @example
-    #   (+ ?x ?y)
-    #   (plus ?x ?y)
+    # [118] UnaryExpression ::=	... | '+' PrimaryExpression 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s WHERE {
+    #     ?s :p ?o .
+    #     FILTER(-?o = +3) .
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>))
+    #    (project (?s)
+    #     (filter (= (- ?o) +3)
+    #      (bgp (triple ?s :p ?o)))))
+    #
+    # [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-unary-plus
     # @see https://www.w3.org/TR/xpath-functions/#func-numeric-add
@@ -23,7 +53,7 @@ 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 = nil)
+      def apply(left, right = nil, **options)
         case
         when left.is_a?(RDF::Literal::Numeric) && right.is_a?(RDF::Literal::Numeric)
           left + right
@@ -32,6 +62,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 # Plus
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -0,0 +1,59 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `PREDICATE` operator.
+    #
+    # If triple is an RDF-star triple, the function returns the predicate of this triple. Passing anything other than an RDF-star triple is an error.
+    #
+    # [121] BuiltInCall ::= ... | 'PREDICATE' '(' 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#predicate
+    class Predicate < Operator::Unary
+      include Evaluatable
+
+      NAME = :predicate
+
+      ##
+      # Returns the predicate part of arg.
+      #
+      # @param  [RDF::Statement] operand
+      #   the operand
+      # @return [RDF::Literal]
+      # @raise  [TypeError] if the operand is not a statement
+      def apply(operand, **options)
+        raise TypeError, "expected an RDF::Statement, but got #{operand.inspect}" unless operand.is_a?(RDF::Statement)
+        operand.predicate
+      end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "PREDICATE(" + operands.last.to_sparql(**options) + ")"
+      end
+    end # Predicate
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -3,10 +3,15 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `prefix` operator.
     #
-    # @example
+    # [6]   PrefixDecl              ::= 'PREFIX' PNAME_NS IRIREF
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example/>
+    #   SELECT * { :s :p :o }
+    #
+    # @example SSE
     #   (prefix ((: <http://example/>))
-    #     (graph ?g
-    #       (bgp (triple ?s ?p ?o))))
+    #    (bgp (triple :s :p :o)))
     #
     # @see https://www.w3.org/TR/sparql11-query/#QSynIRI
     class Prefix < Binary
@@ -65,6 +70,22 @@ module SPARQL; module Algebra
       def query_yields_statements?
         operands.last.query_yields_statements?
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this term.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        prefixes = {}
+        str = operands.first.map do |(pfx, sfx)|
+          pfx = pfx.to_s.chomp(':').to_sym
+          prefixes[pfx] = sfx
+          "PREFIX #{pfx}: #{sfx.to_sparql}\n"
+        end.join("")
+
+        str << operands.last.to_sparql(prefixes: prefixes, **options)
+      end
     end # Prefix
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,11 +3,36 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `project` operator.
     #
-    # @example
-    #   (select (?v)
-    #     (project (?v)
-    #       (filter (= ?v 2)
-    #         (bgp (triple ?s <http://example/p> ?v)))))
+    # [9] SelectClause ::= 'SELECT' ( 'DISTINCT' | 'REDUCED' )?  ( ( Var | ( '(' Expression 'AS' Var ')' ) )+ | '*' )
+    #
+    # ## Basic Projection
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example/>
+    #   SELECT ?v  { 
+    #     ?s :p ?v . 
+    #     FILTER (?v = 2)
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example/>))
+    #    (project (?v)
+    #     (filter (= ?v 2)
+    #      (bgp (triple ?s :p ?v)))))
+    #
+    # ## Sub select
+    #
+    # @example SPARQL Grammar
+    #   SELECT (1 AS ?X ) {
+    #     SELECT (2 AS ?Y ) {}
+    #   }
+    #
+    # @example SSE
+    #   (project (?X)
+    #    (extend ((?X 1))
+    #     (project (?Y)
+    #      (extend ((?Y 2))
+    #       (bgp)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#modProjection
     class Project < Operator::Binary
@@ -36,6 +61,27 @@ module SPARQL; module Algebra
         @solutions.each(&block) if block_given?
         @solutions
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # Extracts projections
+      #
+      # If there are already extensions or filters, then this is a sub-select.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        vars = operands[0].empty? ? [:*] : operands[0]
+        if options[:extensions] || options[:filter_ops] || options[:project]
+          # Any of these options indicates we're in a sub-select
+          opts = options.dup.delete_if {|k,v| %I{extensions filter_ops project}.include?(k)}
+          content = operands.last.to_sparql(project: vars, **opts)
+          Operator.to_sparql(content, **options)
+        else
+          operands.last.to_sparql(project: vars, **options)
+        end
+      end
     end # Project
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,8 +5,25 @@ module SPARQL; module Algebra
     #
     # Returns a pseudo-random number between 0 (inclusive) and 1.0e0 (exclusive). Different numbers can be produced every time this function is invoked. Numbers should be produced with approximately equal probability.
     #
-    # @example
-    #   (rand)
+    # [121] BuiltInCall ::= ... | 'RAND' NIL 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   ASK {
+    #     BIND(RAND() AS ?r)
+    #     FILTER(DATATYPE(?r) = xsd:double && ?r >= 0.0 && ?r < 1.0)
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (ask
+    #     (filter
+    #      (&&
+    #       (&& (= (datatype ?r) xsd:double) (>= ?r 0.0))
+    #       (< ?r 1.0))
+    #      (extend ((?r (rand)))
+    #       (bgp)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#idp2130040
     class Rand < Operator::Nullary
@@ -18,9 +35,20 @@ module SPARQL; module Algebra
       # Returns a pseudo-random number between 0 (inclusive) and 1.0e0 (exclusive). Different numbers can be produced every time this function is invoked. Numbers should be produced with approximately equal probability.
       #
       # @return [RDF::Literal::Double] random value
-      def apply
+      def apply(**options)
         RDF::Literal::Double.new(Random.rand)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # Extracts projections
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "RAND()"
+      end
     end # Rand
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,7 +3,15 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `reduced` operator.
     #
-    # @example
+    # [9] SelectClause ::= 'SELECT' ( 'DISTINCT' | 'REDUCED' )? ( ( Var | ( '(' Expression 'AS' Var ')' ) )+ | '*' )
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT DISTINCT ?v
+    #   WHERE { ?x ?p ?v }
+    #
+    # @example SSE
     #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
     #            (: <http://example/>))
     #     (reduced
@@ -37,6 +45,15 @@ 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)
+        operands.first.to_sparql(reduced: true, **options)
+      end
     end # Reduced
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,33 +3,31 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `regex` operator.
     #
-    # @example
+    # [122] RegexExpression         ::= 'REGEX' '(' Expression ',' Expression ( ',' Expression )? ')'
+    #
+    # @example SPARQL Grammar
+    #   PREFIX  rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+    #   PREFIX  ex: <http://example.com/#>
+    #   SELECT ?val
+    #   WHERE {
+    #     ex:foo rdf:value ?val .
+    #     FILTER regex(?val, "GHI")
+    #   }
+    #
+    # @example SSE
     #   (prefix ((ex: <http://example.com/#>)
     #            (rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>))
-    #     (project (?val)
-    #       (filter (regex ?val "GHI")
-    #         (bgp (triple ex:foo rdf:value ?val)))))
+    #    (project (?val)
+    #     (filter (regex ?val "GHI")
+    #      (bgp (triple ex:foo rdf:value ?val)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#funcex-regex
     # @see https://www.w3.org/TR/xpath-functions/#func-matches
-    class Regex < Operator::Ternary
+    class Regex < Operator
       include Evaluatable
 
       NAME = :regex
 
-      ##
-      # Initializes a new operator instance.
-      #
-      # @param  [RDF::Term] text
-      # @param  [RDF::Term] pattern
-      # @param  [RDF::Term] flags
-      # @param  [Hash{Symbol => Object}] options
-      #   any additional options (see {Operator#initialize})
-      # @raise  [TypeError] if any operand is invalid
-      def initialize(text, pattern, flags = RDF::Literal(''), **options)
-        super
-      end
-
       ##
       # Matches `text` against a regular expression `pattern`.
       #
@@ -42,7 +40,7 @@ module SPARQL; module Algebra
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if any operand is unbound
       # @raise  [TypeError] if any operand is not a simple literal
-      def apply(text, pattern, flags = RDF::Literal(''))
+      def apply(text, pattern, flags = RDF::Literal(''), **options)
         # @see https://www.w3.org/TR/xpath-functions/#regex-syntax
         raise TypeError, "expected a plain RDF::Literal, but got #{text.inspect}" unless text.is_a?(RDF::Literal) && text.plain?
         text = text.to_s
@@ -65,6 +63,16 @@ module SPARQL; module Algebra
         options |= Regexp::EXTENDED   if flags.include?(?x)
         RDF::Literal(Regexp.new(pattern, options) === text)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        ops = operands.last.to_s.empty? ? operands[0..-2] : operands
+        "regex(" + ops.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # Regex
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,12 +3,22 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `replace` operator.
     #
-    # @example
-    #     (prefix ((: <http://example.org/>)
-    #              (xsd: <http://www.w3.org/2001/XMLSchema#>))
-    #       (project (?s ?new)
-    #         (extend ((?new (replace ?str "[^a-z0-9]" "-")))
-    #           (bgp (triple ?s :str ?str)))))
+    # [124] StrReplaceExpression ::= 'REPLACE' '(' Expression ',' Expression ',' Expression ( ',' Expression )? ')'
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT ?s (REPLACE(?str,"[^a-z0-9]", "-") AS ?new)
+    #   WHERE {
+    #     ?s :str ?str
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>)
+    #            (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #     (project (?s ?new)
+    #       (extend ((?new (replace ?str "[^a-z0-9]" "-")))
+    #         (bgp (triple ?s :str ?str)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#funcex-replace
     # @see https://www.w3.org/TR/xpath-functions/#func-replace
@@ -42,7 +52,7 @@ module SPARQL; module Algebra
       # @return [RDF::Literal] 
       # @raise  [TypeError] if any operand is unbound
       # @raise  [TypeError] if any operand is not a plain literal
-      def apply(text, pattern, replacement, flags = RDF::Literal(''))
+      def apply(text, pattern, replacement, flags = RDF::Literal(''), **options)
         raise TypeError, "expected a plain RDF::Literal, but got #{text.inspect}" unless text.literal? && text.plain?
         # TODO: validate text syntax
 
@@ -76,6 +86,16 @@ 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)
+        ops = operands.last.to_s.empty? ? operands[0..-2] : operands
+        "REPLACE(" + ops.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # Replace
   end # Operator
 end; end # SPARQL::Algebra