sparql 3.2.3 → 3.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 853c52b99bab0b9455b25a81c8c946e5bcb1429dddadf010b66315f1dbafda51
-  data.tar.gz: 90d89877c031476efdaa1d0b119b2a2404925186b4e0b3de99818d75ead76bff
+  metadata.gz: eaf1d4f46a557ae2b96d66c5a8fc8b774eb9819a71304fa2d25ada151ba39671
+  data.tar.gz: e61f360e22fcaf413e71be501368ef36fa8860c71e7a714222a59ec021e44bbc
 SHA512:
-  metadata.gz: 98816c81664147aa0fa4ccd90ed14461eb51b652b011395f38f044934c2ff335197fbc3d2d7f447771a5b1e46fa24042aef45fd1f95356b91f52bafee48d1a72
-  data.tar.gz: 5545d7ddd245d73382229ed6f9996b24bd66a4285ee18d6295f697202ad5901eb4221cbf2533ef1539b98ccc0c095519e531b541db3e1c4757d813ab888cb9fd
+  metadata.gz: ee8251bc196d3851505802091dbcfbc206a26ac01d86eecaa5c90ebaa4b6d2f8ce23b5f9fd4b8e6b8cce5ca7e4a588ef90f981d7c950538986fb3fbf953cc324
+  data.tar.gz: 7392fb08ce46900aea2792bb565c880349e4c2f1f19d42d90e6ada7058d501a18bc5acce45728207800bd74356a331107a20a70ac7ba25497dec9eb3a6a9fd3c

data/VERSION

@@ -1 +1 @@
-3.2.3
+3.2.5

data/lib/sparql/algebra/aggregate.rb

@@ -29,7 +29,7 @@ module SPARQL; module Algebra
       args_enum = solutions.map do |solution|
         operands.map do |operand|
           begin
-            operand.evaluate(solution, depth: options[:depth].to_i + 1, **options)
+            operand.evaluate(solution, **options.merge(depth: options[:depth].to_i + 1))
           rescue TypeError
             # Ignore errors
             nil

data/lib/sparql/algebra/evaluatable.rb

@@ -14,7 +14,7 @@ module SPARQL; module Algebra
     # @return [RDF::Term]
     # @abstract
     def evaluate(bindings, **options)
-      args = operands.map { |operand| operand.evaluate(bindings, depth: options[:depth].to_i + 1, **options) }
+      args = operands.map { |operand| operand.evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1)) }
       options[:memoize] ? memoize(*args, **options) : apply(*args, **options)
     end
 

data/lib/sparql/algebra/expression.rb

@@ -112,7 +112,7 @@ module SPARQL; module Algebra
         return case sse.first
         when Array
           debug(options) {"Map array elements #{sse}"}
-          sse.map {|s| self.new(s, parent_operator: parent_operator, depth: options[:depth].to_i + 1, **options)}
+          sse.map {|s| self.new(s, parent_operator: parent_operator, **options.merge(depth: options[:depth].to_i + 1))}
         else
           debug(options) {"No operator found for #{sse.first}"}
           sse.map do |s|
@@ -127,7 +127,7 @@ module SPARQL; module Algebra
         debug(options) {"Operator=#{operator.inspect}, Operand=#{operand.inspect}"}
         case operand
           when Array
-            self.new(operand, parent_operator: operator, depth: options[:depth].to_i + 1, **options)
+            self.new(operand, parent_operator: operator, **options.merge(depth: options[:depth].to_i + 1))
           when Operator, Variable, RDF::Term, RDF::Query, Symbol
             operand
           when TrueClass, FalseClass, Numeric, String, DateTime, Date, Time
@@ -140,7 +140,7 @@ module SPARQL; module Algebra
       logger = options[:logger]
       options.delete_if {|k, v| [:debug, :logger, :depth, :prefixes, :base_uri, :update, :validate].include?(k) }
       begin
-        # Due to confusiong over (triple) and special-case for (qtriple)
+        # Due to confusion over (triple) and special-case for (qtriple)
         if operator == RDF::Query::Pattern
           options = options.merge(quoted: true) if sse.first == :qtriple
         elsif operator == Operator::Triple && PATTERN_PARENTS.include?(parent_operator)

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

@@ -70,7 +70,7 @@ module SPARQL; module Algebra
         end
 
         query = Union.new(qa, qb)
-        queryable.query(query, depth: options[:depth].to_i + 1, **options, &block)
+        queryable.query(query, **options.merge(depth: options[:depth].to_i + 1), &block)
       end
 
       ##

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

@@ -52,13 +52,13 @@ module SPARQL; module Algebra
       # @raise  [TypeError] if the operands could not be coerced to boolean literals
       def evaluate(bindings, **options)
         begin
-          left = boolean(operand(0).evaluate(bindings, depth: options[:depth].to_i + 1, **options)).true?
+          left = boolean(operand(0).evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))).true?
         rescue TypeError
           left = nil
         end
         
         begin
-          right = boolean(operand(1).evaluate(bindings, depth: options[:depth].to_i + 1, **options)).true?
+          right = boolean(operand(1).evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))).true?
         rescue TypeError
           right = nil
         end

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

@@ -33,7 +33,7 @@ module SPARQL; module Algebra
       #   options passed from query
       # @return [RDF::Term]
       def evaluate(bindings, **options)
-        operand(0).evaluate(bindings, depth: options[:depth].to_i + 1, **options)
+        operand(0).evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))
       end
 
       ##

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

@@ -37,7 +37,7 @@ module SPARQL; module Algebra
       # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, **options)
         debug(options) {"Ask #{operands.first}"}
-        res = boolean(!queryable.query(operands.last, depth: options[:depth].to_i + 1, **options).empty?)
+        res = boolean(!queryable.query(operands.last, **options.merge(depth: options[:depth].to_i + 1)).empty?)
         yield res if block_given?
         res
       end

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

@@ -38,7 +38,7 @@ module SPARQL; module Algebra
       def execute(queryable, **options, &block)
         debug(options) {"Base #{operands.first}"}
         Operator.base_uri = operands.first
-        queryable.query(operands.last, depth: options[:depth].to_i + 1, **options, &block)
+        queryable.query(operands.last, **options.merge(depth: options[:depth].to_i + 1), &block)
       end
 
       ##

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

@@ -57,7 +57,7 @@ module SPARQL; module Algebra
       #   options passed from query
       # @return [RDF::Term]
       def evaluate(bindings, **options)
-        args = operands.map { |operand| operand.evaluate(bindings, depth: options[:depth].to_i + 1, **options) }
+        args = operands.map { |operand| operand.evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1)) }
         apply(args.first, bindings)
       end
 

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

@@ -57,7 +57,7 @@ module SPARQL; module Algebra
       def evaluate(bindings, **options)
         operands.each do |op|
           begin
-            return op.evaluate(bindings, depth: options[:depth].to_i + 1, **options)
+            return op.evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))
           rescue
           end
         end

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

@@ -48,7 +48,7 @@ module SPARQL; module Algebra
       # @return [RDF::Term]
       # @raise  [TypeError] if any operand is not a literal
       def evaluate(bindings, **options)
-        ops = operands.map {|op| op.evaluate(bindings, depth: options[:depth].to_i + 1, **options)}
+        ops = operands.map {|op| op.evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))}
 
         raise TypeError, "expected all plain literal operands" unless ops.all? {|op| op.literal? && op.plain?}
 

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

@@ -51,7 +51,7 @@ module SPARQL; module Algebra
         patterns = operands.first
         query = operands.last
 
-        queryable.query(query, depth: options[:depth].to_i + 1, **options).each do |solution|
+        queryable.query(query, **options.merge(depth: options[:depth].to_i + 1)).each do |solution|
           debug(options) {"(construct apply) #{solution.inspect} to BGP"}
           
           # Create a mapping from BNodes within the pattern list to newly constructed BNodes

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

@@ -149,7 +149,7 @@ module SPARQL; module Algebra
         debug(options) {"Dataset"}
         if %i(default-graph-uri named-graph-uri).any? {|k| options.key?(k)} 
           debug("=> Skip constructing merge repo due to options", options)
-          return queryable.query(operands.last, depth: options[:depth].to_i + 1, **options, &base)
+          return queryable.query(operands.last, **options.merge(depth: options[:depth].to_i + 1), &base)
         end
  
         default_datasets = []
@@ -180,7 +180,7 @@ module SPARQL; module Algebra
         aggregate = RDF::AggregateRepo.new(queryable)
         named_datasets.each {|name| aggregate.named(name) if queryable.has_graph?(name)}
         aggregate.default(*default_datasets.select {|name| queryable.has_graph?(name)})
-        aggregate.query(operands.last, depth: options[:depth].to_i + 1, **options, &base)
+        aggregate.query(operands.last, **options.merge(depth: options[:depth].to_i + 1), &base)
       end
 
       ##

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

@@ -53,7 +53,7 @@ module SPARQL; module Algebra
         end
         query = RDF::Query.new(*patterns, **{}) # FIXME: added hash argument needed until Statement#to_hash removed.
         debug(options) {"DeleteWhere query #{query.to_sse}"}
-        query.execute(queryable, depth: options[:depth].to_i + 1, **options) do |solution|
+        query.execute(queryable, **options.merge(depth: options[:depth].to_i + 1)) do |solution|
           debug(options) {"DeleteWhere solution #{solution.to_sse}"}
           query.each_statement do |pattern|
             pattern = pattern.dup.bind(solution)

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

@@ -40,7 +40,7 @@ module SPARQL; module Algebra
       #   the resulting solution sequence
       # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, **options, &block)
-        @solutions = queryable.query(operands.last, depth: options[:depth].to_i + 1, **options).distinct
+        @solutions = queryable.query(operands.last, **options.merge(depth: options[:depth].to_i + 1)).distinct
         @solutions.each(&block) if block_given?
         @solutions
       end

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

@@ -50,7 +50,7 @@ module SPARQL; module Algebra
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operands could not be coerced to a boolean literal
       def evaluate(bindings, **options)
-        res = operands.all? {|op| boolean(op.evaluate(bindings, depth: options[:depth].to_i + 1, **options)).true? }
+        res = operands.all? {|op| boolean(op.evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))).true? }
         RDF::Literal(res) # FIXME: error handling
       end
     end # Exprlist

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

@@ -82,14 +82,18 @@ module SPARQL; module Algebra
       # @see https://www.w3.org/TR/sparql11-query/#evaluation
       def execute(queryable, **options, &block)
         debug(options) {"Extend"}
-        @solutions = operand(1).execute(queryable, depth: options[:depth].to_i + 1, **options)
+        @solutions = operand(1).execute(queryable, **options.merge(depth: options[:depth].to_i + 1))
         @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
               val = expr.evaluate(solution, queryable: queryable,
-                                            depth: options[:depth].to_i + 1,
-                                            **options)
+                                            **options.merge(depth: options[:depth].to_i + 1))
               debug(options) {"===> + #{var} => #{val.inspect}"}
               val = val.dup.bind(solution) if val.is_a?(RDF::Query::Pattern)
               solution.bindings[var.to_sym] = val

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

@@ -48,7 +48,12 @@ module SPARQL; module Algebra
         debug(options) {"Filter #{operands.first.to_sxp}"}
         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|
+        queryable.query(operands.last, **options.merge(depth: options[:depth].to_i + 1)) 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}"}

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

@@ -82,7 +82,7 @@ module SPARQL; module Algebra
         exprlist = operands.first
         query = operands.last
         aggregates = operands.length == 3 ? operand(1) : []
-        solutions = queryable.query(query, depth: options[:depth].to_i + 1, **options)
+        solutions = queryable.query(query, **options.merge(depth: options[:depth].to_i + 1))
 
         groups = solutions.group_by do |solution|
           # Evaluate each exprlist operand to get groups where each key is a new solution

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

@@ -55,7 +55,7 @@ module SPARQL; module Algebra
         sep = operands.length == 2 ? operand(0).last : RDF::Literal(' ')
         args_enum = solutions.map do |solution|
           begin
-            operands.last.evaluate(solution, depth: options[:depth].to_i + 1, **options)
+            operands.last.evaluate(solution, **options.merge(depth: options[:depth].to_i + 1))
           rescue TypeError
             # Ignore errors
             nil

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

@@ -42,9 +42,9 @@ module SPARQL; module Algebra
       # @return [RDF::Term]
       # @raise [TypeError]
       def evaluate(bindings, **options)
-        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)
+        operand(0).evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1)) == RDF::Literal::TRUE ?
+          operand(1).evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1)) :
+          operand(2).evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))
       rescue
         raise TypeError
       end

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

@@ -48,7 +48,7 @@ module SPARQL; module Algebra
         error_found = false
         found = operands[1..-1].any? do |op|
           begin
-            lhs == op.evaluate(bindings, depth: options[:depth].to_i + 1, **options)
+            lhs == op.evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))
           rescue TypeError
             error_found = true
           end

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

@@ -66,10 +66,10 @@ module SPARQL; module Algebra
         # Generate solutions independently, merge based on solution compatibility
         debug(options) {"Join #{operands.to_sse}"}
  
-        left = queryable.query(operand(0), depth: options[:depth].to_i + 1, **options)
+        left = queryable.query(operand(0), **options.merge(depth: options[:depth].to_i + 1))
         debug(options) {"(join)=>(left) #{left.map(&:to_h).to_sse}"}
 
-        right = queryable.query(operand(1), depth: options[:depth].to_i + 1, **options)
+        right = queryable.query(operand(1), **options.merge(depth: options[:depth].to_i + 1))
         debug(options) {"(join)=>(right) #{right.map(&:to_h).to_sse}"}
 
         @solutions = RDF::Query::Solutions(left.map do |s1|

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

@@ -54,10 +54,10 @@ module SPARQL; module Algebra
           operands.length < 2 || operands.length > 3
 
         debug(options) {"LeftJoin"}
-        left = queryable.query(operand(0), depth: options[:depth].to_i + 1, **options)
+        left = queryable.query(operand(0), **options.merge(depth: options[:depth].to_i + 1))
         debug(options) {"=>(leftjoin left) #{left.inspect}"}
 
-        right = queryable.query(operand(1), depth: options[:depth].to_i + 1, **options)
+        right = queryable.query(operand(1), **options.merge(depth: options[:depth].to_i + 1))
         debug(options) {"=>(leftjoin right) #{right.inspect}"}
 
         # LeftJoin(Ω1, Ω2, expr) =
@@ -66,6 +66,35 @@ module SPARQL; module Algebra
           load_left = true
           right.each do |s2|
             s = s2.merge(s1)
+            # Re-bind to bindings, if defined, as they might not be found in solution
+            options[:bindings].each_binding do |name, value|
+              s[name] = value if filter.variables.include?(name)
+            end if options[:bindings] && filter.respond_to?(:variables)
+
+            # See https://github.com/w3c/rdf-tests/pull/83#issuecomment-1324220844 for @afs's discussion of the simplified/not-simplified issue.
+            #
+            # The difference is when simplification is applied. It matters for OPTIONAL because OPTIONAL { ... FILTER(...) } puts the filter into the LeftJoin expressions. In LeftJoin, the FILTER can see the left-hand-side variables. (SQL: LEFT JOIN ... ON ...)
+            # 
+            # For OPTIONAL { { ... FILTER(...) } }, the inner part is Join({}, {.... FILTER }).
+            # 
+            # if simplify happens while coming back up the tree generating algebra operations, it removes the join i.e. the inner of {{ }}, and passes "... FILTER()" to the OPTIONAL. The effect of the extra nesting in {{ }} is lost and it exposes the filter to the OPTIONAL rule.
+            # 
+            # if simplification happens as a step after the whole algebra is converted, this does not happen. Compiling the OPTIONAL see a join and the filter is not at the top level of the OPTIONAl block and so not handled in the LeftJoin.
+            # 
+            # Use case:
+            # 
+            # # Include name if person over 18
+            # SELECT *
+            # { ?person :age ?age 
+            #    OPTIONAL { ?person :name ?name. FILTER(?age > 18) }
+            # }
+            # Hindsight: a better syntax would be call out if the filter needed access to the LHS.
+            # 
+            # OPTIONAL FILTER(....) { }
+            # 
+            # But we are where we are.
+            # 
+            # (a "no conditions on LeftJoin" approach would mean users having to duplicate parts of their query - possibly quite large parts.)
             expr = filter ? boolean(filter.evaluate(s)).true? : true rescue false
             debug(options) {"===>(evaluate) #{s.inspect}"} if filter
 

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

@@ -71,9 +71,9 @@ module SPARQL; module Algebra
         # 
         # card[Minus(Ω1, Ω2)](μ) = card[Ω1](μ)
         debug(options) {"Minus"}
-        left = queryable.query(operand(0), depth: options[:depth].to_i + 1, **options)
+        left = queryable.query(operand(0), **options.merge(depth: options[:depth].to_i + 1))
         debug(options) {"(minus left) #{left.inspect}"}
-        right = queryable.query(operand(1), depth: options[:depth].to_i + 1, **options)
+        right = queryable.query(operand(1), **options.merge(depth: options[:depth].to_i + 1))
         debug(options) {"(minus right) #{right.inspect}"}
         @solutions = left.minus(right)
         @solutions.each(&block) if block_given?

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

@@ -71,12 +71,12 @@ module SPARQL; module Algebra
           query = Operator::Using.new((defaults + named), query, **options)
         end
 
-        queryable.query(query, depth: options[:depth].to_i + 1, **options) do |solution|
+        queryable.query(query, **options.merge(depth: options[:depth].to_i + 1)) do |solution|
           debug(options) {"(solution)=>#{solution.inspect}"}
 
           # Execute each operand with queryable and solution
           operands.each do |op|
-            op.execute(queryable, solutions: solution, depth: options[:depth].to_i + 1, **options)
+            op.execute(queryable, solutions: solution, **options.merge(depth: options[:depth].to_i + 1))
           end
         end
         queryable

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

@@ -48,11 +48,11 @@ module SPARQL; module Algebra
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if term is not found and any operand raises an error
       def evaluate(bindings, **options)
-        lhs = operands.first.evaluate(bindings, depth: options[:depth].to_i + 1, **options)
+        lhs = operands.first.evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))
         error_found = false
         found = operands[1..-1].any? do |op|
           begin
-            lhs == op.evaluate(bindings, depth: options[:depth].to_i + 1, **options)
+            lhs == op.evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))
           rescue TypeError
             error_found = true
           end

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

@@ -50,7 +50,7 @@ module SPARQL; module Algebra
           q.pattern [subject, v, object]
         end
         query = Filter.new(NotIn.new(v, *operands), bgp)
-        queryable.query(query, depth: options[:depth].to_i + 1, **options) do |solution|
+        queryable.query(query, **options.merge(depth: options[:depth].to_i + 1)) do |solution|
           solution.bindings.delete(v.to_sym)
           debug(options) {"(solution)-> #{solution.to_h.to_sse}"}
           block.call(solution)

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

@@ -56,13 +56,13 @@ module SPARQL; module Algebra
       # @raise  [TypeError] if the operands could not be coerced to a boolean literal
       def evaluate(bindings, **options)
         begin
-          left = boolean(operand(0).evaluate(bindings, depth: options[:depth].to_i + 1, **options)).true?
+          left = boolean(operand(0).evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))).true?
         rescue TypeError
           left = nil
         end
         
         begin
-          right = boolean(operand(1).evaluate(bindings, depth: options[:depth].to_i + 1, **options)).true?
+          right = boolean(operand(1).evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))).true?
         rescue TypeError
           right = nil
         end

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

@@ -86,12 +86,12 @@ module SPARQL; module Algebra
       def execute(queryable, **options, &block)
 
         debug(options) {"Order"}
-        @solutions = queryable.query(operands.last, depth: options[:depth].to_i + 1, **options).order do |a, b|
+        @solutions = queryable.query(operands.last, **options.merge(depth: options[:depth].to_i + 1)).order do |a, b|
           operand(0).inject(0) do |memo, op|
             debug(options) {"(order) #{op.inspect}"}
             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
+              a_eval = op.evaluate(a, queryable: queryable, **options.merge(depth: options[:depth].to_i + 1)) rescue nil
+              b_eval = op.evaluate(b, queryable: queryable, **options.merge(depth: options[:depth].to_i + 1)) rescue nil
               comp = begin
                 Operator::Compare.evaluate(a_eval, b_eval, order_by: true).to_s.to_i
               rescue TypeError

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

@@ -50,8 +50,7 @@ module SPARQL; module Algebra
           subject: subject,
           object: object,
           graph_name: options.fetch(:graph_name, false),
-          depth: options[:depth].to_i + 1,
-          **options
+          **options.merge(depth: options[:depth].to_i + 1)
         ) do |solution|
           @solutions << solution
         end

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

@@ -73,7 +73,7 @@ module SPARQL; module Algebra
         # Keep track of solutions
         # Recurse into query
         immediate_solutions = 
-          query.execute(queryable, depth: options[:depth].to_i + 1, **options)
+          query.execute(queryable, **options.merge(depth: options[:depth].to_i + 1))
 
         # For all solutions, if they are not in the accumulator, add them and recurse, otherwise skip
         recursive_solutions = RDF::Query::Solutions.new

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

@@ -48,7 +48,7 @@ module SPARQL; module Algebra
 
         # (:x :p* :y) => (:x (:p+)? :y)
         query = PathOpt.new(PathPlus.new(*operands))
-        query.execute(queryable, depth: options[:depth].to_i + 1, **options, &block)
+        query.execute(queryable, **options.merge(depth: options[:depth].to_i + 1), &block)
       end
       ##
       #

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

@@ -37,7 +37,7 @@ module SPARQL; module Algebra
       # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, **options, &block)
         debug(options) {"Prefix"}
-        @solutions = queryable.query(operands.last, depth: options[:depth].to_i + 1, **options, &block)
+        @solutions = queryable.query(operands.last, **options.merge(depth: options[:depth].to_i + 1), &block)
       end
 
       ##

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

@@ -101,7 +101,7 @@ module SPARQL; module Algebra
       #   the resulting solution sequence
       # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, **options, &block)
-        @solutions = queryable.query(operands.last, depth: options[:depth].to_i + 1, **options)
+        @solutions = queryable.query(operands.last, **options.merge(depth: options[:depth].to_i + 1))
         @solutions.variable_names = self.variables.keys
         @solutions = @solutions.project(*(operands.first)) unless operands.first.empty?
         @solutions.each(&block) if block_given?

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

@@ -41,7 +41,7 @@ module SPARQL; module Algebra
       # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, **options, &block)
         @solutions = operands.last.
-          execute(queryable, depth: options[:depth].to_i + 1, **options).reduced
+          execute(queryable, **options.merge(depth: options[:depth].to_i + 1)).reduced
         @solutions.each(&block) if block_given?
         @solutions
       end

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

@@ -31,11 +31,11 @@ module SPARQL; module Algebra
       def execute(queryable, **options)
         debug(options) {"Sequence #{operands.to_sse}"}
 
-        last = queryable.query(operands.shift, depth: options[:depth].to_i + 1, **options)
+        last = queryable.query(operands.shift, **options.merge(depth: options[:depth].to_i + 1))
         debug(options) {"(sequence)=>(last) #{last.map(&:to_h).to_sse}"}
 
         operands.each do |op|
-          this = queryable.query(op, depth: options[:depth].to_i + 1, **options)
+          this = queryable.query(op, **options.merge(depth: options[:depth].to_i + 1))
           debug(options) {"(sequence)=>(this) #{this.map(&:to_h).to_sse}"}
 
           last = last.map do |s1|

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

@@ -0,0 +1,86 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL Service operator.
+    #
+    # [59]  ServiceGraphPattern ::= 'SERVICE' 'SILENT'? VarOrIri GroupGraphPattern
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/> 
+    #   
+    #   SELECT ?s ?o1 ?o2  {
+    #     ?s ?p1 ?o1 .
+    #     SERVICE <http://example.org/sparql> {
+    #       ?s ?p2 ?o2
+    #     }
+    #   } 
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>))
+    #     (project (?s ?o1 ?o2)
+    #       (join
+    #         (bgp (triple ?s ?p1 ?o1))
+    #         (service :sparql
+    #           (bgp (triple ?s ?p2 ?o2))))))
+    #
+    # @see https://www.w3.org/TR/sparql11-query/#QSynIRI
+    class Service < Operator
+      include Query
+  
+      NAME = [:service]
+
+      ##
+      # Executes this query on the given `queryable` graph or repository.
+      # Really a pass-through, as this is a syntactic object used for providing
+      # graph_name for URIs.
+      #
+      # @param  [RDF::Queryable] queryable
+      #   the graph or repository to query
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional keyword options
+      # @yield  [solution]
+      #   each matching solution, statement or boolean
+      # @yieldparam  [RDF::Statement, RDF::Query::Solution, Boolean] solution
+      # @yieldreturn [void] ignored
+      # @return [RDF::Query::Solutions]
+      #   the resulting solution sequence
+      # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
+      def execute(queryable, **options, &block)
+        debug(options) {"Service"}
+        silent = operands.first == :silent
+        location, query = operands
+        query_sparql = query.to_sparql
+        debug(options) {"query: #{query_sparql}"}
+        raise NotImplementedError, "SERVICE operator not implemented"
+      end
+
+      ##
+      # Returns an optimized version of this query.
+      #
+      # Replace with the query with URIs having their lexical shortcut removed
+      #
+      # @return [Prefix] a copy of `self`
+      # @see SPARQL::Algebra::Expression#optimize
+      def optimize(**options)
+        operands.last.optimize(**options)
+      end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this term.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        silent = operands.first == :silent
+        ops = silent ? operands[1..-1] : operands
+        location, query = ops
+
+        
+        str = "SERVICE "
+        str << "SILENT " if silent
+        str << location.to_sparql(**options) + " {" + query.to_sparql(**options) + "}"
+        str
+      end
+    end # Service
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -57,7 +57,7 @@ module SPARQL; module Algebra
       def execute(queryable, **options, &block)
         offset = operands[0] == :_ ? 0 : operands[0].to_i
         limit = operands[1] == :_ ? -1 : operands[1].to_i
-        @solutions = operands.last. execute(queryable, depth: options[:depth].to_i + 1, **options)
+        @solutions = operands.last. execute(queryable, **options.merge(depth: options[:depth].to_i + 1))
         @solutions.offset(operands[0]) unless operands[0] == :_
         @solutions.limit(operands[1]) unless operands[1] == :_
         @solutions.each(&block) if block_given?

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

@@ -41,7 +41,7 @@ module SPARQL; module Algebra
       def execute(queryable, **options, &block)
         debug(options) {"Union"}
         @solutions = RDF::Query::Solutions(operands.inject([]) do |memo, op|
-          solns = op.execute(queryable, depth: options[:depth].to_i + 1, **options)
+          solns = op.execute(queryable, **options.merge(depth: options[:depth].to_i + 1))
           debug(options) {"=> (op) #{solns.inspect}"}
           memo + solns
         end)

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

@@ -68,7 +68,7 @@ module SPARQL; module Algebra
         debug(options) {"Update"}
         raise IOError, "queryable is not mutable" unless queryable.mutable?
         operands.each do |op|
-          op.execute(queryable, depth: options[:depth].to_i + 1, **options)
+          op.execute(queryable, **options.merge(depth: options[:depth].to_i + 1))
         end
         queryable
       end

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

@@ -67,7 +67,7 @@ module SPARQL; module Algebra
       # @see    https://www.w3.org/TR/sparql11-update/
       def execute(queryable, **options, &block)
         debug(options) {"Using"}
-        Dataset.new(*operands).execute(queryable, depth: options[:depth].to_i + 1, **options, &block)
+        Dataset.new(*operands).execute(queryable, **options.merge(depth: options[:depth].to_i + 1), &block)
       end
 
       ##

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

@@ -69,12 +69,12 @@ module SPARQL; module Algebra
         query = operands.shift
 
         # Restrict query portion to this graph
-        queryable.query(query, depth: options[:depth].to_i + 1, **options) do |solution|
+        queryable.query(query, **options.merge(depth: options[:depth].to_i + 1)) do |solution|
           debug(options) {"(solution)=>#{solution.inspect}"}
 
           # Execute each operand with queryable and solution
           operands.each do |op|
-            op.execute(queryable, solutions: solution, depth: options[:depth].to_i + 1, **options)
+            op.execute(queryable, solutions: solution, **options.merge(depth: options[:depth].to_i + 1))
           end
         end
       end

data/lib/sparql/algebra/operator.rb

@@ -134,6 +134,7 @@ module SPARQL; module Algebra
     autoload :Prefix,             'sparql/algebra/operator/prefix'
     autoload :Project,            'sparql/algebra/operator/project'
     autoload :Reduced,            'sparql/algebra/operator/reduced'
+    autoload :Service,            'sparql/algebra/operator/service'
     autoload :Slice,              'sparql/algebra/operator/slice'
     autoload :Table,              'sparql/algebra/operator/table'
     autoload :Union,              'sparql/algebra/operator/union'
@@ -236,6 +237,7 @@ module SPARQL; module Algebra
         when :seconds         then Seconds
         when :seq             then Seq
         when :sequence        then Sequence
+        when :service         then Service
         when :sha1            then SHA1
         when :sha256          then SHA256
         when :sha384          then SHA384

data/lib/sparql/grammar/parser11.rb

@@ -916,6 +916,19 @@ module SPARQL::Grammar
       end
     end
 
+    # [59]  ServiceGraphPattern ::= 'SERVICE' 'SILENT'? VarOrIri GroupGraphPattern
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
+    production(:ServiceGraphPattern) do |input, data, callback|
+      args = []
+      args << :silent if data[:silent]
+      args << (data[:VarOrIri]).last
+      args << data.fetch(:query, [SPARQL::Algebra::Operator::BGP.new]).first
+      service = SPARQL::Algebra::Expression.for(:service, *args)
+      add_prod_data(:query, service)
+    end
+
     # [60]  Bind ::= 'BIND' '(' Expression 'AS' Var ')'
     #
     # Input from `data` is TODO.

data/lib/sparql/grammar/terminals11.rb

@@ -94,10 +94,10 @@ module SPARQL::Grammar
     STR_EXPR = %r(ABS|ADD|ADJUST|ALL|ASC|ASK|AS|AVG|BASE|BINDINGS|BIND
                  |BNODE|BOUND|BY|CEIL|CLEAR|COALESCE|CONCAT
                  |CONSTRUCT|CONTAINS|COPY|COUNT|CREATE|DATATYPE|DAY
-                 |DEFAULT|DELETE#{WS}DATA|DELETE#{WS}WHERE|DELETE
+                 |DEFAULT|DELETE\s+DATA|DELETE\s+WHERE|DELETE
                  |DESCRIBE|DESC|DISTINCT|DROP|ENCODE_FOR_URI|EXISTS
                  |FILTER|FLOOR|FROM|GRAPH|GROUP_CONCAT|GROUP|HAVING
-                 |HOURS|IF|INSERT#{WS}DATA|INSERT|INTO|IN|IRI
+                 |HOURS|IF|INSERT\s+DATA|INSERT|INTO|IN|IRI
                  |LANGMATCHES|LANGTAG|LANG|LCASE|LIMIT|LOAD
                  |MAX|MD5|MINUS|MINUTES|MIN|MONTH|MOVE
                  |NAMED|NOT|NOW|OFFSET|OPTIONAL

data/lib/sparql/results.rb

@@ -280,7 +280,8 @@ module SPARQL
     end
 
     content_type ||= SPARQL::Results::MIME_TYPES[format] if format
-    
+
+    serialization = serialization.dup if serialization.frozen?
     serialization.instance_eval do
       define_singleton_method(:content_type) { content_type }
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sparql
 version: !ruby/object:Gem::Version
-  version: 3.2.3
+  version: 3.2.5
 platform: ruby
 authors:
 - Gregg Kellogg
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-05 00:00:00.000000000 Z
+date: 2023-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -20,7 +20,7 @@ dependencies:
         version: '3.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.7
+        version: 3.2.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -30,7 +30,7 @@ dependencies:
         version: '3.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.7
+        version: 3.2.8
 - !ruby/object:Gem::Dependency
   name: rdf-aggregate-repo
   requirement: !ruby/object:Gem::Requirement
@@ -389,6 +389,7 @@ files:
 - lib/sparql/algebra/operator/seconds.rb
 - lib/sparql/algebra/operator/seq.rb
 - lib/sparql/algebra/operator/sequence.rb
+- lib/sparql/algebra/operator/service.rb
 - lib/sparql/algebra/operator/sha1.rb
 - lib/sparql/algebra/operator/sha256.rb
 - lib/sparql/algebra/operator/sha384.rb
@@ -454,7 +455,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: SPARQL Query and Update library for Ruby.