sparql 3.2.1 → 3.2.3

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

@@ -0,0 +1,69 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `adjust` operator.
+    #
+    # [121] BuiltInCall ::= ... | 'ADJUST' '(' Expression ',' Expression ')'
+    #
+    # @example SPARQL Grammar
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT ?id (ADJUST(?d, ?tz) AS ?adjusted) WHERE {
+    #     VALUES (?id ?tz ?d) {
+    #       (1 "-PT10H"^^xsd:dayTimeDuration "2002-03-07"^^xsd:date)
+    #     }
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (project (?id ?adjusted)
+    #     (extend ((?adjusted (adjust ?d ?tz)))
+    #      (table (vars ?id ?tz ?d)
+    #       (row
+    #        (?id 1)
+    #        (?tz "-PT10H"^^xsd:dayTimeDuration)
+    #        (?d "2002-03-07"^^xsd:date))))))
+    #
+    # @see https://www.w3.org/TR/sparql11-query/#func-abs
+    # @see https://www.w3.org/TR/xpath-functions/#func-abs
+    class Adjust < Operator::Binary
+      include Evaluatable
+
+      NAME = [:adjust]
+
+      ##
+      # Returns the first operand adjusted by the dayTimeDuration of the second operand
+      # 
+      # @param  [RDF::Literal::Temporal] operand
+      #   the operand
+      # @param  [RDF::Literal, String] duration
+      #   the dayTimeDuration or an empty string.
+      # @return [RDF::Literal] literal of same type
+      # @raise  [TypeError] if the operand is not a numeric value
+      def apply(operand, duration, **options)
+        case operand
+        when RDF::Literal::Temporal
+          case duration
+          when RDF::Literal::DayTimeDuration
+            operand.adjust_to_timezone(duration)
+          when RDF::Literal
+            raise TypeError, "expected second operand to be an empty literal, but got #{duration.inspect}" unless duration.to_s.empty?
+            operand.adjust_to_timezone(nil)
+          else
+            raise TypeError, "expected second operand to be an RDF::Literal::DayTimeDuration, but got #{duration.inspect}"
+          end
+        else
+          raise TypeError, "expected first operand to be an RDF::Literal::Temporal, but got #{operand.inspect}"
+        end
+      end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "ADJUST(#{operands.to_sparql(delimiter: ', ', **options)})"
+      end
+    end # Abs
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -19,7 +19,7 @@ module SPARQL; module Algebra
     #
     # @example SSE (sparql-star)
     #   (prefix ((: <http://example.com/ns#>))
-    #    (bgp (triple (triple :a :b :c) :p1 :o1)))
+    #    (bgp (triple (qtriple :a :b :c) :p1 :o1)))
     #
     # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class BGP < 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(top_level: false, **options) }.join(". \n") +
         "\n}\n"
 
         str << operands[1].to_sparql(top_level: true, project: nil, **options)

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

@@ -129,6 +129,11 @@ module SPARQL; module Algebra
       #
       # Datasets are specified in operand(1), which is an array of default or named graph URIs.
       #
+      # If `options` contains any of the Protocol attributes, the dataset is constructed on creation, and these operations should be ignored:
+      #
+      # * `default-graph-uri`
+      # * `named-graph-uri`
+      #
       # @param  [RDF::Queryable] queryable
       #   the graph or repository to query
       # @param  [Hash{Symbol => Object}] options
@@ -142,6 +147,11 @@ module SPARQL; module Algebra
       # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, **options, &base)
         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)
+        end
+ 
         default_datasets = []
         named_datasets = []
         operand(0).each do |uri|

data/lib/sparql/algebra/operator/day.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.day)
       end
 

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

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

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(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(top_level: false, delimiter: ". \n", **options) +
           "\n}"
       end
     end # DeleteWhere

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

@@ -104,17 +104,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.
@@ -124,7 +153,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/group.rb

@@ -40,13 +40,13 @@ module SPARQL; module Algebra
     #       (group (?s) ((??.0 (avg ?o)))
     #        (bgp (triple ?s ?p ?o)))))) )
     #
-    # @example SPARQL Grammar (non-triveal filters)
+    # @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-triveal filters)
+    # @example SSE (non-trivial filters)
     #   (prefix ((: <http://example.com/data/#>))
     #    (project (?g ?avg ?c)
     #     (extend ((?avg ??.0) (?c (/ (+ ??.1 ??.2) 2)))
@@ -162,11 +162,39 @@ 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
@@ -188,12 +216,12 @@ module SPARQL; module Algebra
                     operand
                   end
                 end
-                memo.merge(ext_var => new_op)
+                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 => op)
+                memo.merge(ext_var.to_s => op)
               else
                 # Doesn't match this variable, so don't change
-                memo.merge(ext_var => ext_op)
+                memo.merge(ext_var.to_s => ext_op)
               end
             end
 

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/insert.rb

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

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/join.rb

@@ -57,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))
@@ -114,7 +114,7 @@ module SPARQL; module Algebra
       #
       # @param [Boolean] top_level (true)
       #   Treat this as a top-level, generating SELECT ... WHERE {}
-      # @param [Hash{Symbol => Operator}] extensions
+      # @param [Hash{String => Operator}] extensions
       #   Variable bindings
       # @param [Array<Operator>] filter_ops ([])
       #   Filter Operations

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

@@ -44,8 +44,8 @@ module SPARQL; module Algebra
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
       # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      # @see    https://www.rubydoc.info/github/ruby-rdf/rdf/RDF/Query/Solution#merge-instance_method
-      # @see    https://www.rubydoc.info/github/ruby-rdf/rdf/RDF/Query/Solution#compatible%3F-instance_method
+      # @see    https://ruby-rdf.github.io/rdf/RDF/Query/Solution#merge-instance_method
+      # @see    https://ruby-rdf.github.io/rdf/RDF/Query/Solution#compatible%3F-instance_method
       def execute(queryable, **options, &block)
         filter = operand(2)
 
@@ -131,7 +131,7 @@ module SPARQL; module Algebra
       #
       # @param [Boolean] top_level (true)
       #   Treat this as a top-level, generating SELECT ... WHERE {}
-      # @param [Hash{Symbol => Operator}] extensions
+      # @param [Hash{String => Operator}] extensions
       #   Variable bindings
       # @param [Array<Operator>] filter_ops ([])
       #   Filter Operations

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

@@ -100,7 +100,7 @@ module SPARQL; module Algebra
       #
       # 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

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

@@ -31,10 +31,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.minute)
       end
 

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

@@ -6,6 +6,11 @@ module SPARQL; module Algebra
     #
     # Wraps delete/insert
     #
+    # If `options` contains any of the Protocol attributes, it is treated as if there is a USING or USING NAMED clause inserted.
+    #
+    # * `using-graph-uri`
+    # * `using-named-graph-uri`
+    #
     # [41]  Modify ::= ( 'WITH' iri )? ( DeleteClause InsertClause? | InsertClause ) UsingClause* 'WHERE' GroupGraphPattern
     #
     # @example SPARQL Grammar
@@ -35,6 +40,10 @@ module SPARQL; module Algebra
       #
       # Execute the first operand to get solutions, and apply those solutions to the subsequent operators.
       #
+      # If `options` contains any of the Protocol attributes, any `using` clause is removed and a new `using` clause is added with entries taken from the `using-graph-uri` and `using-named-graph-uri`.
+      #
+      # It is an error to supply the using-graph-uri or using-named-graph-uri parameters when using this protocol to convey a SPARQL 1.1 Update request that contains an operation that uses the USING, USING NAMED, or WITH clause.
+      #
       # @param  [RDF::Queryable] queryable
       #   the graph or repository to write
       # @param  [Hash{Symbol => Object}] options
@@ -50,6 +59,18 @@ module SPARQL; module Algebra
         debug(options) {"Modify"}
         query = operands.shift
 
+        if %i(using-graph-uri using-named-graph-uri).any? {|k| options.key?(k)}
+          raise ArgumentError,
+            "query contains USING/WITH clause, which is incompatible with using-graph-uri or using-named-graph-uri query parameters" if
+            query.is_a?(Operator::Using) || query.is_a?(Operator::With)
+
+          debug("=> Insert USING clause", options)
+          defaults = Array(options.delete(:'using-graph-uri')).map {|uri| RDF::URI(uri)}
+          named = Array(options.delete(:'using-named-graph-uri')).map {|uri| [:named, RDF::URI(uri)]}
+          
+          query = Operator::Using.new((defaults + named), query, **options)
+        end
+
         queryable.query(query, depth: options[:depth].to_i + 1, **options) do |solution|
           debug(options) {"(solution)=>#{solution.inspect}"}
 

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

@@ -31,10 +31,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.month)
       end
 

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

@@ -3,8 +3,8 @@ module SPARQL; module Algebra
     ##
     # The SPARQL Property Path `path?` (ZeroOrOnePath) operator.
     #
-    # [91]  PathElt                 ::= PathPrimary PathMod?
-    # [93]  PathMod                 ::= '*' | '?' | '+'
+    # [91]  PathElt ::= PathPrimary PathMod?
+    # [93]  PathMod ::= '*' | '?' | '+' | '{' INTEGER? (',' INTEGER?)? '}'
     
     # @example SPARQL Grammar
     #   PREFIX : <http://example/> 
@@ -23,11 +23,10 @@ module SPARQL; module Algebra
       NAME = :path?
 
       ##
-      # Equivalent to:
+      # Optional path:
       #
       #    (path x (path? :p) y)
-      #     => (union (bgp ((x :p y))) (filter (x = x) (solution x y)))
-      #        
+      #     => (union (bgp ((x :p y))) (filter (x = y) (solution x y)))
       #
       # @param  [RDF::Queryable] queryable
       #   the graph or repository to query
@@ -44,76 +43,21 @@ module SPARQL; module Algebra
         subject, object = options[:subject], options[:object]
         debug(options) {"Path? #{[subject, operands, object].to_sse}"}
 
-        solutions = RDF::Query::Solutions.new
-        # Solutions where subject == object with no predicate
-        case
-        when subject.variable? && object.variable?
-          # Nodes is the set of all subjects and objects in queryable
-          # FIXME: should this be Queryable#enum_nodes?
-          # All subjects which are `object`
-          query = RDF::Query.new {|q| q.pattern({subject: subject})}
-          queryable.query(query, **options) do |solution|
-            solution.merge!(object.to_sym => solution[subject])
-            debug(options) {"(solution-s0)-> #{solution.to_h.to_sse}"}
-            solutions << solution
-          end if query.valid?
-
-          # All objects which are `object`
-          query = RDF::Query.new {|q| q.pattern({object: object})}
-          queryable.query(query, **options) do |solution|
-            solution.merge!(subject.to_sym => solution[object])
-            debug(options) {"(solution-o0)-> #{solution.to_h.to_sse}"}
-            solutions << solution
-          end if query.valid?
-        when subject.variable?
-          # All subjects which are `object`
-          query = RDF::Query.new {|q| q.pattern({subject: object})}
-          queryable.query(query, **options) do |solution|
-            solution.merge!(subject.to_sym => object)
-            debug(options) {"(solution-s0)-> #{solution.to_h.to_sse}"}
-            solutions << solution
-          end if query.valid?
-
-          # All objects which are `object`
-          query = RDF::Query.new {|q| q.pattern({object: object})}
-          queryable.query(query, **options) do |solution|
-            solution.merge!(subject.to_sym => object)
-            debug(options) {"(solution-o0)-> #{solution.to_h.to_sse}"}
-            solutions << solution
-          end if query.valid?
-        when object.variable?
-          # All subjects which are `subject`
-          query = RDF::Query.new {|q| q.pattern({subject: subject})}
-          queryable.query(query, **options) do |solution|
-            solution.merge!(object.to_sym => subject)
-            debug(options) {"(solution-s0)-> #{solution.to_h.to_sse}"}
-            solutions << solution
-          end if query.valid?
-
-          # All objects which are `subject
-          query = RDF::Query.new {|q| q.pattern({object: subject})}
-          queryable.query(query, **options) do |solution|
-            solution.merge!(object.to_sym => subject)
-            debug(options) {"(solution-o0)-> #{solution.to_h.to_sse}"}
-            solutions << solution
-          end if query.valid?
-        else
-          # Otherwise, if subject == object, an empty solution
-          solutions << RDF::Query::Solution.new if subject == object
-        end
+        query = PathZero.new(operand)
+        solutions = query.execute(queryable, **options.merge(depth: options[:depth].to_i + 1))
 
         # Solutions where predicate exists
         query = if operand.is_a?(RDF::Term)
           RDF::Query.new do |q|
             q.pattern [subject, operand, object]
           end
-        else
+        else # path
           operand
         end
 
         # Recurse into query
-        solutions += 
-        queryable.query(query, depth: options[:depth].to_i + 1, **options)
+        solutions += query.execute(queryable, **options.merge(depth: options[:depth].to_i + 1))
+        debug(options) {"(path?)=> #{solutions.to_sxp}"}
         solutions.each(&block) if block_given?
         solutions
       end

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

@@ -3,8 +3,8 @@ module SPARQL; module Algebra
     ##
     # The SPARQL Property Path `path+` (OneOrMorePath) operator.
     #
-    # [91]  PathElt                 ::= PathPrimary PathMod?
-    # [93]  PathMod                 ::= '*' | '?' | '+'
+    # [91]  PathElt ::= PathPrimary PathMod?
+    # [93]  PathMod ::= '*' | '?' | '+' | '{' INTEGER? (',' INTEGER?)? '}'
     
     # @example SPARQL Grammar
     #   PREFIX : <http://example/> 
@@ -25,6 +25,16 @@ module SPARQL; module Algebra
       ##
       # Match on simple relation of subject to object, and then recurse on solutions
       #
+      # Path including at least one:
+      #
+      #    (path :a (path+ :p) :b)
+      #
+      # into
+      #
+      #    (union
+      #     (bgp (triple :a :p :b))
+      #     (path :a (path* :p) :b))
+      #
       # @param  [RDF::Queryable] queryable
       #   the graph or repository to query
       # @param  [Hash{Symbol => Object}] options
@@ -62,10 +72,8 @@ module SPARQL; module Algebra
 
         # Keep track of solutions
         # Recurse into query
-        immediate_solutions = []
-        queryable.query(query, depth: options[:depth].to_i + 1, **options) do |solution|
-          immediate_solutions << solution
-        end
+        immediate_solutions = 
+          query.execute(queryable, depth: options[:depth].to_i + 1, **options)
 
         # For all solutions, if they are not in the accumulator, add them and recurse, otherwise skip
         recursive_solutions = RDF::Query::Solutions.new
@@ -76,23 +84,23 @@ module SPARQL; module Algebra
           case
           when subject.variable? && object.variable?
             # Query starting with bound object as subject, but replace result with subject
-            rs = queryable.query(self, **options.merge(
+            rs = self.execute(queryable, **options.merge(
               subject: solution[object],
               accumulator: (cumulative_solutions + immediate_solutions),
               depth: options[:depth].to_i + 1)).map {|s| s.merge(subject.to_sym => solution[subject])}
             # Query starting with bound subject as object, but replace result with subject
-            ro = queryable.query(self, **options.merge(
+            ro = self.execute(queryable, **options.merge(
               object: solution[subject],
               accumulator: (cumulative_solutions + immediate_solutions),
               depth: options[:depth].to_i + 1)).map {|s| s.merge(object.to_sym => solution[object])}
             recursive_solutions += (rs + ro).uniq
           when subject.variable?
-            recursive_solutions += queryable.query(self, **options.merge(
+            recursive_solutions += self.execute(queryable, **options.merge(
               object: solution[subject],
               accumulator: (cumulative_solutions + immediate_solutions),
               depth: options[:depth].to_i + 1)).uniq
           when object.variable?
-            recursive_solutions += queryable.query(self, **options.merge(
+            recursive_solutions += self.execute(queryable, **options.merge(
               subject: solution[object],
               accumulator: (cumulative_solutions + immediate_solutions),
               depth: options[:depth].to_i + 1)).uniq