sparql 3.2.0 → 3.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ecbe9289bf43f7fa28940a82545ec08b19c54d8bdf64693934405e83ddb4cc53
-  data.tar.gz: 24ab0942be18a9d9d281452ba9a7195dcad2a31755bda6d84afe4f49fe7c34c1
+  metadata.gz: e9bcab10eb6706316b68b44a0fd917d7b735b18a8353b51e49ef124fc966176d
+  data.tar.gz: 6da59b4e90fd1b7a7d80c42d941f7c27f6bf95892d17302caf16a13809b03afa
 SHA512:
-  metadata.gz: 89a77c749eb99b0fe83f27d5f413556ac2f6cf22af7e06b8e0588155bbf5a50eb053b1f87ffe11a13b5fd873d5fcaaee1166cdf336aacd3029380898a82da382
-  data.tar.gz: 13be95c405b9fdf7e678bc9bbaf6dcc45075a692a08e1762deacc0779948996fdc992376f3a564644f50270282c76a759023d7393e28db07ec7828a73324a948
+  metadata.gz: d2f99aee7d5b9482bbd653333eeefd215da872291993a2ba138ed9bcfc3f92812672cd1508dfbd11a729d527c9724f0a80ec816c5c84fd2df9933b4b91b5a296
+  data.tar.gz: 41a11caf8e85ca4bd01213bb0c0c236314560338dbd2825bd2437afbf4fd9855b994150737dbcad00838dc5ac50e368d72e5bfe2e516566a6319f824bdcacc56

data/README.md

@@ -281,6 +281,8 @@ a full set of RDF formats.
 
 ### Parsing a SSE to SPARQL query or update string to SPARQL
 
+    # Note: if the SSE uses extension functions, they either must be XSD casting functions, or custom functions which are registered extensions. (See [SPARQL Extension Functions](#sparql-extension-functions))
+
     query = SPARQL::Algebra.parse(%{(bgp (triple ?s ?p ?o))})
     sparql = query.to_sparql #=> "SELECT * WHERE { ?s ?p ?o }"
 

data/VERSION

@@ -1 +1 @@
-3.2.0
+3.2.1

data/lib/sparql/algebra/expression.rb

@@ -66,9 +66,11 @@ module SPARQL; module Algebra
     #
     # @param  [Array] sse
     #   a SPARQL S-Expression (SSE) form
+    # @param  [Hash{Symbol => Object}] options
+    #   any additional options (see {Operator#initialize})
     # @return [Expression]
-    def self.for(*sse)
-      self.new(sse)
+    def self.for(*sse, **options)
+      self.new(sse, **options)
     end
     class << self; alias_method :[], :for; end
 
@@ -86,6 +88,13 @@ module SPARQL; module Algebra
       raise ArgumentError, "invalid SPARQL::Algebra::Expression form: #{sse.inspect}" unless sse.is_a?(Array)
 
       operator = Operator.for(sse.first, sse.length - 1)
+
+      # If we don't find an operator, and sse.first is an extension IRI, use a function call
+      if !operator && sse.first.is_a?(RDF::URI) && self.extension?(sse.first)
+        operator = Operator.for(:function_call, sse.length)
+        sse.unshift(:function_call)
+      end
+
       unless operator
         return case sse.first
         when Array
@@ -115,11 +124,16 @@ module SPARQL; module Algebra
       end
 
       debug(options) {"#{operator.inspect}(#{operands.map(&:inspect).join(',')})"}
+      logger = options[:logger]
       options.delete_if {|k, v| [:debug, :logger, :depth, :prefixes, :base_uri, :update, :validate].include?(k) }
       begin
         operator.new(*operands, **options)
       rescue ArgumentError => e
-        error(options) {"Operator=#{operator.inspect}: #{e}"}
+        if logger
+          logger.error("Operator=#{operator.inspect}: #{e}")
+        else
+          raise "Operator=#{operator.inspect}: #{e}"
+        end
       end
     end
 
@@ -163,6 +177,17 @@ module SPARQL; module Algebra
       @extensions ||= {}
     end
 
+    ##
+    # Is an extension function available?
+    #
+    # It's either a registered extension, or an XSD casting function
+    #
+    # @param [RDF::URI] function
+    # @return [Boolean]
+    def self.extension?(function)
+      function.to_s.start_with?(RDF::XSD.to_s) || self.extensions[function]
+    end
+
     ##
     # Invoke an extension function.
     #

data/lib/sparql/algebra/extensions.rb

@@ -70,28 +70,12 @@ class Array
   # Returns a partial SPARQL grammar for this array.
   #
   # @param [String] delimiter (" ")
+  #   If the first element is an IRI, treat it as an extension function
   # @return [String]
-  def to_sparql(delimiter: " ", **options)
+  def to_sparql(delimiter: " ",  **options)
     map {|e| e.to_sparql(**options)}.join(delimiter)
   end
 
-  ##
-  # Evaluates the array using the given variable `bindings`.
-  #
-  # In this case, the Array has two elements, the first of which is
-  # an XSD datatype, and the second is the expression to be evaluated.
-  # The result is cast as a literal of the appropriate type
-  #
-  # @param  [RDF::Query::Solution] bindings
-  #   a query solution containing zero or more variable bindings
-  # @param [Hash{Symbol => Object}] options ({})
-  #   options passed from query
-  # @return [RDF::Term]
-  # @see SPARQL::Algebra::Expression.evaluate
-  def evaluate(bindings, **options)
-    SPARQL::Algebra::Expression.extension(*self.map {|o| o.evaluate(bindings, **options)})
-  end
-
   ##
   # If `#execute` is invoked, it implies that a non-implemented Algebra operator
   # is being invoked
@@ -302,7 +286,6 @@ module RDF::Term
   end
 end # RDF::Term
 
-
 # Override RDF::Queryable to execute against SPARQL::Algebra::Query elements as well as RDF::Query and RDF::Pattern
 module RDF::Queryable
   alias_method :query_without_sparql, :query
@@ -390,15 +373,17 @@ class RDF::Statement
   # @param [Boolean] as_statement (false) serialize as < ... >, otherwise TRIPLE(...)
   # @return [String]
   def to_sparql(as_statement: false, **options)
-    return "TRIPLE(#{to_triple.to_sparql(as_statement: true, **options)})" unless as_statement
-
-    to_triple.map do |term|
-      if term.is_a?(::RDF::Statement)
-        "<<" + term.to_sparql(**options) + ">>"
-      else
-        term.to_sparql(**options)
-      end
-    end.join(" ") + " ."
+    if as_statement
+      to_triple.map do |term|
+        if term.is_a?(::RDF::Statement)
+          "<<" + term.to_sparql(as_statement: true, **options) + ">>"
+        else
+          term.to_sparql(**options)
+        end
+      end.join(" ")
+    else
+      "TRIPLE(#{to_triple.to_sparql(as_statement: true, **options)})"
+    end
   end
 
   ##
@@ -448,15 +433,34 @@ class RDF::Query
 
   ##
   #
-  # Returns a partial SPARQL grammar for this term.
+  # Returns a partial SPARQL grammar for this query.
   #
   # @param [Boolean] top_level (true)
   #   Treat this as a top-level, generating SELECT ... WHERE {}
+  # @param [Array<Operator>] filter_ops ([])
+  #   Filter Operations
   # @return [String]
-  def to_sparql(top_level: true, **options)
-    str = @patterns.map { |e| e.to_sparql(as_statement: true, top_level: false, **options) }.join("\n")
+  def to_sparql(top_level: true, filter_ops: [], **options)
+    str = @patterns.map { |e| e.to_sparql(as_statement: true, top_level: false, **options) }.join(". \n")
     str = "GRAPH #{graph_name.to_sparql(**options)} {\n#{str}\n}\n" if graph_name
-    top_level ? SPARQL::Algebra::Operator.to_sparql(str, **options) : str
+    if top_level
+      SPARQL::Algebra::Operator.to_sparql(str, filter_ops: filter_ops, **options)
+    else
+      # Filters
+      filter_ops.each do |op|
+        str << "\nFILTER (#{op.to_sparql(**options)}) ."
+      end
+
+      # Extensons
+      extensions = options.fetch(:extensions, [])
+      extensions.each do |as, expression|
+        v = expression.to_sparql(as_statement: true, **options)
+        v = "<< #{v} >>" if expression.is_a?(RDF::Statement)
+        str << "\nBIND (" << v << " AS " << as.to_sparql(**options) << ") ."
+      end
+      str = "{#{str}}" unless filter_ops.empty? && extensions.empty?
+      str
+    end
   end
 
   ##

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

@@ -5,7 +5,7 @@ module SPARQL; module Algebra
     #
     # [121] BuiltInCall ::= ... | 'ABS' '(' Expression ')'
     #
-    # @example SPARQL Query
+    # @example SPARQL Grammar
     #   PREFIX : <http://example.org/>
     #   SELECT * WHERE {
     #     ?s :num ?num

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

@@ -79,7 +79,7 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        "#{operands.first.to_sparql(**options)}|#{operands.last.to_sparql(**options)}"
+        "(#{operands.first.to_sparql(**options)}|#{operands.last.to_sparql(**options)})"
       end
     end # Alt
   end # Operator

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

@@ -54,7 +54,9 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        "AVG(#{operands.to_sparql(**options)})"
+        distinct = operands.first == :distinct
+        args = distinct ? operands[1..-1] : operands
+        "AVG(#{'DISTINCT ' if distinct}#{args.to_sparql(**options)})"
       end
     end # Avg
   end # Operator

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

@@ -7,12 +7,20 @@ module SPARQL; module Algebra
     #
     # @example SPARQL Grammar
     #   PREFIX : <http://example/>
-    #   SELECT * { :s :p :o }
+    #   SELECT * { ?s ?p ?o }
     #
     # @example SSE
     #   (prefix ((: <http://example/>))
     #     (bgp (triple ?s ?p ?o)))
     #
+    # @example SPARQL Grammar (sparql-star)
+    #   PREFIX : <http://example.com/ns#>
+    #   SELECT * {<< :a :b :c >> :p1 :o1.}
+    #
+    # @example SSE (sparql-star)
+    #   (prefix ((: <http://example.com/ns#>))
+    #    (bgp (triple (triple :a :b :c) :p1 :o1)))
+    #
     # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class BGP < Operator
       NAME = [:bgp]

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

@@ -8,12 +8,18 @@ module SPARQL; module Algebra
     #
     # [32]  Clear                   ::= 'CLEAR' 'SILENT'? GraphRefAll
     #
-    # @example SPARQL Grammar
+    # @example SPARQL Grammar (SILENT DEFAULT)
     #   CLEAR SILENT DEFAULT
     #
-    # @example SSE
+    # @example SSE (SILENT DEFAULT)
     #   (update (clear silent default))
     #
+    # @example SPARQL Grammar (IRI)
+    #   CLEAR GRAPH <http://example.com/>
+    #
+    # @example SSE (IRI)
+    #   (update (clear <http://example.com/>))
+    #
     # @see https://www.w3.org/TR/sparql11-update/#clear
     class Clear < Operator
       include SPARQL::Algebra::Update
@@ -70,7 +76,11 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        "CLEAR " + operands.to_sparql(**options)
+        silent = operands.first == :silent
+        str = "CLEAR "
+        str << "SILENT " if operands.first == :silent
+        str << "GRAPH " if operands.last.is_a?(RDF::URI)
+        str << operands.last.to_sparql(**options)
       end
     end # Clear
   end # Operator

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

@@ -99,7 +99,7 @@ module SPARQL; module Algebra
       # @return [String]
       def to_sparql(**options)
         str = "CONSTRUCT {\n" +
-        operands[0].map { |e| e.to_sparql(as_statement: true, top_level: false, **options) }.join("\n") +
+        operands[0].map { |e| e.to_sparql(as_statement: true, top_level: false, **options) }.join(". \n") +
         "\n}\n"
 
         str << operands[1].to_sparql(top_level: true, project: nil, **options)

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

@@ -11,11 +11,39 @@ module SPARQL; module Algebra
     #   WHERE { ?S ?P ?O }
     #
     # @example SSE
-    #    (prefix ((: <http://www.example.org>))
-    #      (project (?C)
-    #        (extend ((?C ??.0))
-    #          (group () ((??.0 (count ?O)))
-    #            (bgp (triple ?S ?P ?O))))))
+    #   (prefix ((: <http://www.example.org/>))
+    #     (project (?C)
+    #       (extend ((?C ??.0))
+    #         (group () ((??.0 (count ?O)))
+    #           (bgp (triple ?S ?P ?O))))))
+    #
+    # @example SPARQL Grammar (count(*))
+    #   PREFIX : <http://www.example.org>
+    #   
+    #   SELECT (COUNT(*) AS ?C)
+    #   WHERE { ?S ?P ?O }
+    #
+    # @example SSE (count(*))
+    #   (prefix
+    #    ((: <http://www.example.org>))
+    #    (project (?C)
+    #     (extend ((?C ??.0))
+    #      (group () ((??.0 (count)))
+    #       (bgp (triple ?S ?P ?O))))))
+    #
+    # @example SPARQL Grammar (count(distinct *))
+    #   PREFIX : <http://www.example.org>
+    #   
+    #   SELECT (COUNT(DISTINCT *) AS ?C)
+    #   WHERE { ?S ?P ?O }
+    #
+    # @example SSE (count(distinct *))
+    #   (prefix
+    #    ((: <http://www.example.org>))
+    #    (project (?C)
+    #     (extend ((?C ??.0))
+    #      (group () ((??.0 (count distinct)))
+    #       (bgp (triple ?S ?P ?O))))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#defn_aggCount
     class Count < Operator
@@ -39,7 +67,9 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        "COUNT(#{operands.to_sparql(**options)})"
+        distinct = operands.first == :distinct
+        args = distinct ? operands[1..-1] : operands
+        "COUNT(#{'DISTINCT ' if distinct}#{args.empty? ? '*' : args.to_sparql(**options)})"
       end
     end # Count
   end # Operator

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

@@ -55,10 +55,11 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        *args, last = operands.dup
-        args += [:GRAPH, last]
-
-        "CREATE " + args.to_sparql(**options)
+        silent = operands.first == :silent
+        str = "CREATE "
+        str << "SILENT " if operands.first == :silent
+        str << "GRAPH " if operands.last.is_a?(RDF::URI)
+        str << operands.last.to_sparql(**options)
       end
     end # Create
   end # Operator

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

@@ -73,7 +73,7 @@ module SPARQL; module Algebra
     # @example Dataset with two default data sources
     #
     #     (prefix ((: <http://example/>))
-    #       (dataset (<data-g1.ttl> <data-g1.ttl)
+    #       (dataset (<data-g1.ttl> <data-g2.ttl)
     #         (bgp (triple ?s ?p ?o))))
     #
     #     is effectively re-written to the following:
@@ -101,7 +101,21 @@ module SPARQL; module Algebra
     #       (filter ((= ?g <data-g1.ttl>) || (= ?g <data-g2.ttl>))
     #         (graph ?g (bgp (triple ?s ?p ?o))))))
     #
-    # @example Dataset with multiple named graphs
+    #
+    # @example SPARQL Grammar
+    #   BASE     <http://example.org/>
+    #   PREFIX : <http://example.com/>
+    #   
+    #   SELECT * 
+    #   FROM <data-g1.ttl>
+    #   { ?s ?p ?o }
+    #
+    # @example SSE
+    #   (base <http://example.org/>
+    #    (prefix ((: <http://example.com/>))
+    #     (dataset (<data-g1.ttl>)
+    #      (bgp (triple ?s ?p ?o)))))
+    #
     # @see https://www.w3.org/TR/sparql11-query/#specifyingDataset
     class Dataset < Binary
       include Query
@@ -163,17 +177,11 @@ module SPARQL; module Algebra
       #
       # Returns a partial SPARQL grammar for this operator.
       #
+      # Extracts datasets
+      #
       # @return [String]
       def to_sparql(**options)
-        operands[0].each_with_object('') do |graph, str|
-          str << if graph.is_a?(Array)
-            "FROM #{graph[0].upcase} #{graph[1].to_sparql(**options)}\n"
-          else
-            "FROM #{graph.to_sparql(**options)}\n"
-          end
-        end.tap do |str|
-          str << operands[1].to_sparql(**options)
-        end
+        operands.last.to_sparql(datasets: operands.first, **options)
       end
     end # Dataset
   end # Operator

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

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

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

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

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

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

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

@@ -12,8 +12,8 @@ module SPARQL; module Algebra
     #   WHERE { ?x ?p ?v }
     #
     # @example SSE
-    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (: <http://example/>))
+    #   (prefix ((: <http://example.org/>)
+    #            (xsd: <http://www.w3.org/2001/XMLSchema#>))
     #     (distinct
     #       (project (?v)
     #         (bgp (triple ?x ?p ?v)))))

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

@@ -60,7 +60,7 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        "#{operands.first.to_sparql(**options)} / #{operands.last.to_sparql(**options)}"
+        "(#{operands.first.to_sparql(**options)} / #{operands.last.to_sparql(**options)})"
       end
     end # Divide
   end # Operator

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

@@ -10,12 +10,18 @@ module SPARQL; module Algebra
     #
     # [33]  Drop                    ::= 'DROP' 'SILENT'? GraphRefAll
     #
-    # @example SPARQL Grammar
-    #   DROP DEFAULT
+    # @example SPARQL Grammar (SILENT DEFAULT)
+    #   DROP SILENT DEFAULT
     #
-    # @example SSE
+    # @example SSE (SILENT DEFAULT)
     #   (update
-    #    (drop default))
+    #    (drop silent default))
+    #
+    # @example SPARQL Grammar (IRI)
+    #   DROP GRAPH <http://example.com/>
+    #
+    # @example SSE (IRI)
+    #   (update (drop <http://example.com/>))
     #
     # @see https://www.w3.org/TR/sparql11-update/#drop
     class Drop < Operator
@@ -40,7 +46,6 @@ module SPARQL; module Algebra
       def execute(queryable, **options)
         debug(options) {"Drop"}
         silent = operands.first == :silent
-        silent = operands.first == :silent
         operands.shift if silent
 
         raise ArgumentError, "drop expected operand to be 'default', 'named', 'all', or an IRI" unless operands.length == 1
@@ -74,7 +79,11 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        "DROP " + operands.to_sparql(**options)
+        silent = operands.first == :silent
+        str = "DROP "
+        str << "SILENT " if operands.first == :silent
+        str << "GRAPH " if operands.last.is_a?(RDF::URI)
+        str << operands.last.to_sparql(**options)
       end
     end # Drop
   end # Operator

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

@@ -9,15 +9,13 @@ module SPARQL; module Algebra
     #
     # @example SPARQL Grammar
     #   PREFIX : <http://example.org/>
-    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
     #   SELECT ?s ?str (ENCODE_FOR_URI(?str) AS ?encoded) WHERE {
     #     ?s :str ?str
     #   }
     #
     # @example SSE
-    #   (prefix
-    #    ((: <http://example.org/>))
-    #    (project (?str ?encoded)
+    #   (prefix ((: <http://example.org/>))
+    #    (project (?s ?str ?encoded)
     #     (extend ((?encoded (encode_for_uri ?str)))
     #      (bgp (triple ?s :str ?str)))))
     #

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

@@ -8,6 +8,8 @@ module SPARQL; module Algebra
     # [72]  ExpressionList ::= NIL | '(' Expression ( ',' Expression )* ')'
     #
     # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #
     #   SELECT ?v ?w
     #   { 
     #     FILTER (?v = 2)
@@ -17,7 +19,7 @@ module SPARQL; module Algebra
     #   }
     #
     # @example SSE
-    #   (prefix ((: <http://example/>))
+    #   (prefix ((: <http://example.org/>))
     #     (project (?v ?w)
     #       (filter (exprlist (= ?v 2) (= ?w 3))
     #         (bgp

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

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

@@ -89,7 +89,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