sparql 1.1.1 → 1.1.2

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

@@ -29,13 +29,7 @@ module SPARQL; module Algebra
       # @raise  [TypeError] if the operand is not a typed or simple literal
       def apply(literal)
         case literal
-          when RDF::Literal then case
-            when RDF::VERSION.to_s >= "1.1" then literal.datatype
-            when literal.simple? then RDF::XSD.string
-            when literal.datatype == RDF::XSD.string then RDF::XSD.string
-            when literal.plain? then RDF.langString
-            else RDF::URI(literal.datatype)
-          end
+          when RDF::Literal then literal.datatype
           else raise TypeError, "expected an RDF::Literal, but got #{literal.inspect}"
         end
       end

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

@@ -33,10 +33,14 @@ module SPARQL; module Algebra
       #   the graph or repository to query
       # @param  [Hash{Symbol => Object}] options
       #   any additional keyword options
-      # @return [RDF::Query::Solutions]
-      #   the resulting solution sequence
+      # @yield  [statement]
+      #   each matching statement
+      # @yieldparam  [RDF::Statement] solution
+      # @yieldreturn [void] ignored
+      # @return [RDF::Graph]
+      #   containing the constructed triples
       # @see    http://www.w3.org/TR/rdf-sparql-query/#describe
-      def execute(queryable, options = {})
+      def execute(queryable, options = {}, &block)
         debug(options) {"Describe #{operands.first}, #{options.inspect}"}
 
         # Describe any constand URIs
@@ -44,17 +48,17 @@ module SPARQL; module Algebra
         
         to_describe.each {|t| debug(options) {"=> describe #{t}"}}
 
-        operands.last.execute(queryable).each do |solution|
+        queryable.query(operands.last) do |solution|
           solution.each_variable do |v|
             if operands.first.any? {|bound| v.eql?(bound)}
-              debug(options) {"=> describe #{v}"}
+              debug(options) {"(describe)=> #{v}"}
               to_describe << v.value
             end
           end
         end
 
         # Return Concise Bounded Description
-        queryable.concise_bounded_description(*to_describe)
+        queryable.concise_bounded_description(*to_describe.uniq, &block)
       end
       
       ##
@@ -66,6 +70,12 @@ module SPARQL; module Algebra
       def optimize
         operands = operands.map(&:optimize)
       end
+
+      # Query results statements (e.g., CONSTRUCT, DESCRIBE, CREATE)
+      # @return [Boolean]
+      def query_yields_statements?
+        true
+      end
     end # Construct
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -24,15 +24,16 @@ module SPARQL; module Algebra
       #   the graph or repository to query
       # @param  [Hash{Symbol => Object}] options
       #   any additional keyword options
+      # @yield  [solution]
+      #   each matching solution
+      # @yieldparam  [RDF::Query::Solution] solution
+      # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
       # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
-      def execute(queryable, options = {})
-        debug(options) {"Distinct"}
-        @solutions = operands.last.execute(queryable, options.merge(:depth => options[:depth].to_i + 1))
-        debug(options) {"=>(before) #{@solutions.inspect}"}
-        @solutions = @solutions.distinct
-        debug(options) {"=>(after) #{@solutions.inspect}"}
+      def execute(queryable, options = {}, &block)
+        @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/exists.rb

@@ -5,10 +5,8 @@ module SPARQL; module Algebra
     #
     # @example
     #    (prefix ((ex: <http://www.example.org/>))
-    #      (filter (exists
-    #                 (filter (notexists (bgp (triple ?s ?p ex:o2)))
-    #                   (bgp (triple ?s ?p ex:o1))))
-    #        (bgp (triple ?s ?p ex:o))))
+    #      (filter (exists (bgp (triple ?s ?p ex:o)))
+    #      (bgp (triple ?s ?p ?o))))
     #
     # @see http://www.w3.org/TR/sparql11-query/#func-abs
     # @see http://www.w3.org/TR/xpath-functions/#func-abs
@@ -28,10 +26,9 @@ module SPARQL; module Algebra
       #   queryable to execute, using bindings as an initial solution.
       # @return [RDF::Literal::Boolean] `true` or `false`
       def evaluate(bindings, options = {})
-        solutions = RDF::Query::Solutions.new << bindings
         queryable = options[:queryable]
         !operand(0).execute(queryable, options.merge(
-                                        :solutions => solutions,
+                                        :solutions => RDF::Query::Solutions(bindings),
                                         :depth => options[:depth].to_i + 1)).empty?
       end
     end # Exists

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

@@ -27,10 +27,19 @@ module SPARQL; module Algebra
       # Extend is undefined when var in dom(μ).
       # 
       # Extend(Ω, var, expr) = { Extend(μ, var, expr) | μ in Ω }
+      #
+      # @param  [RDF::Queryable] queryable
+      #   the graph or repository to query
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional keyword options
+      # @yield  [solution]
+      #   each matching solution
+      # @yieldparam  [RDF::Query::Solution] solution
+      # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
       # @see http://www.w3.org/TR/rdf-sparql-query/#evaluation
-      def execute(queryable, options = {})
+      def execute(queryable, options = {}, &block)
         debug(options) {"Extend"}
         @solutions = operands.last.execute(queryable, options.merge(:depth => options[:depth].to_i + 1))
         @solutions.each do |solution|
@@ -48,6 +57,7 @@ module SPARQL; module Algebra
             end
           end
         end
+        @solutions.each(&block) if block_given?
         @solutions
       end
       

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

@@ -28,33 +28,28 @@ module SPARQL; module Algebra
       #   the graph or repository to query
       # @param  [Hash{Symbol => Object}] options
       #   any additional keyword options
+      # @yield  [solution]
+      #   each matching solution
+      # @yieldparam  [RDF::Query::Solution] solution
+      # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
       # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
       # @see    http://www.w3.org/TR/rdf-sparql-query/#ebv
-      def execute(queryable, options = {})
+      def execute(queryable, options = {}, &block)
         debug(options) {"Filter #{operands.first.to_sxp}"}
-        @solutions = operands.last.execute(queryable, options.merge(:depth => options[:depth].to_i + 1))
-        debug(options) {"=>(before) #{@solutions.map(&:to_hash).inspect}"}
         opts = options.merge(:queryable => queryable, :depth => options[:depth].to_i + 1)
-        @solutions = @solutions.filter do |solution|
-          # Evaluate the solution, which will return true or false
-          #debug(options) {"===>(evaluate) #{operands.first.inspect} against #{solution.to_hash.inspect}"}
-          
-          # From http://www.w3.org/TR/rdf-sparql-query/#tests
-          # FILTERs eliminate any solutions that, when substituted into the expression, either
-          # result in an effective boolean value of false or produce an error.
+        @solutions = RDF::Query::Solutions()
+        queryable.query(operands.last, options.merge(:depth => options[:depth].to_i + 1)) do |solution|
           begin
-            res = boolean(operands.first.evaluate(solution, opts)).true?
-            debug(options) {"===>#{res} #{solution.to_hash.inspect}"}
-            res
+            pass = boolean(operands.first.evaluate(solution, opts)).true?
+            debug(options) {"(filter) #{pass.inspect} #{solution.to_hash.inspect}"}
+            @solutions << solution if pass
           rescue
-            debug(options) {"rescue(#{$!}): #{solution.to_hash.inspect}"}
-            false
+            debug(options) {"(filter) rescue(#{$!}): #{solution.to_hash.inspect}"}
           end
         end
-        @solutions = RDF::Query::Solutions.new(@solutions)
-        debug(options) {"=>(after) #{@solutions.map(&:to_hash).inspect}"}
+        @solutions.each(&block) if block_given?
         @solutions
       end
       

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

@@ -25,15 +25,17 @@ module SPARQL; module Algebra
       #   the graph or repository to query
       # @param  [Hash{Symbol => Object}] options
       #   any additional keyword options
+      # @yield  [solution]
+      #   each matching solution
+      # @yieldparam  [RDF::Query::Solution] solution
+      # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
       # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
-      def execute(queryable, options = {})
+      def execute(queryable, options = {}, &block)
         debug(options) {"Graph #{operands.first}"}
         context, query = operands.first, operands.last
-        @solutions = query.execute(queryable, options.merge(:context => context))
-        debug(options) {"=>(after) #{@solutions.map(&:to_hash).inspect}"}
-        @solutions
+        @solutions = queryable.query(query, options.merge(:context => context), &block)
       end
       
       ##

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

@@ -31,15 +31,19 @@ module SPARQL; module Algebra
       #   the graph or repository to query
       # @param  [Hash{Symbol => Object}] options
       #   any additional keyword options
+      # @yield  [solution]
+      #   each matching solution
+      # @yieldparam  [RDF::Query::Solution] solution
+      # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
       # @see    http://www.w3.org/TR/sparql11-query/#sparqlGroupAggregate
-      def execute(queryable, options = {})
+      def execute(queryable, options = {}, &block)
         debug(options) {"Group"}
         exprlist = operands.first
         query = operands.last
         aggregates = operands.length == 3 ? operand(1) : []
-        solutions = query.execute(queryable, options.merge(:depth => options[:depth].to_i + 1)) || {}
+        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
@@ -69,7 +73,7 @@ module SPARQL; module Algebra
         debug(options) {"=>(groups) #{groups.inspect}"}
 
         # Aggregate solutions in each group using aggregates to get solutions
-        @solutions = groups.map do |group_soln, solns|
+        @solutions = RDF::Query::Solutions(groups.map do |group_soln, solns|
           aggregates.each do |(var, aggregate)|
             begin
               group_soln[var] = aggregate.aggregate(solns, options)
@@ -78,13 +82,14 @@ module SPARQL; module Algebra
             end
           end
           group_soln
-        end
+        end)
 
         # Make sure that's at least an empty solution
         @solutions << RDF::Query::Solution.new if @solutions.empty?
 
         debug(options) {"=>(solutions) #{@solutions.inspect}"}
-        @solutions = RDF::Query::Solutions.new(@solutions)
+        @solutions.each(&block) if block_given?
+        @solutions
       end
       
       ##

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

@@ -25,26 +25,33 @@ module SPARQL; module Algebra
       #   the graph or repository to query
       # @param  [Hash{Symbol => Object}] options
       #   any additional keyword options
+      # @yield  [solution]
+      #   each matching solution
+      # @yieldparam  [RDF::Query::Solution] solution
+      # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
       # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
       # @see    http://rdf.rubyforge.org/RDF/Query/Solution.html#merge-instance_method
       # @see    http://rdf.rubyforge.org/RDF/Query/Solution.html#compatible%3F-instance_method
-      def execute(queryable, options = {})
+      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))
         #
         # Generate solutions independently, merge based on solution compatibility
         debug(options) {"Join"}
-        solutions1 = operand(0).execute(queryable, options.merge(:depth => options[:depth].to_i + 1)) || {}
-        debug(options) {"=>(left) #{solutions1.inspect}"}
-        solutions2 = operand(1).execute(queryable, options.merge(:depth => options[:depth].to_i + 1)) || {}
-        debug(options) {"=>(right) #{solutions2.inspect}"}
-        @solutions = solutions1.map do |s1|
-          solutions2.map { |s2| s2.merge(s1) if s2.compatible?(s1) }
-        end.flatten.compact
-        @solutions = RDF::Query::Solutions.new(@solutions)
+ 
+        left = queryable.query(operand(0), options.merge(:depth => options[:depth].to_i + 1))
+        debug(options) {"(join)=>(left) #{left.inspect}"}
+
+        right = queryable.query(operand(1), options.merge(:depth => options[:depth].to_i + 1))
+        debug(options) {"(join)=>(right) #{right.inspect}"}
+
+        @solutions = RDF::Query::Solutions(left.map do |s1|
+          right.map { |s2| s2.merge(s1) if s2.compatible?(s1) }
+        end.flatten.compact)
         debug(options) {"=> #{@solutions.inspect}"}
+        @solutions.each(&block) if block_given?
         @solutions
       end
       

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

@@ -25,23 +25,27 @@ module SPARQL; module Algebra
       #   the graph or repository to query
       # @param  [Hash{Symbol => Object}] options
       #   any additional keyword options
+      # @yield  [solution]
+      #   each matching solution
+      # @yieldparam  [RDF::Query::Solution] solution
+      # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
       # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
       # @see    http://rdf.rubyforge.org/RDF/Query/Solution.html#merge-instance_method
       # @see    http://rdf.rubyforge.org/RDF/Query/Solution.html#compatible%3F-instance_method
-      def execute(queryable, options = {})
+      def execute(queryable, options = {}, &block)
         filter = operand(2)
 
-        
         debug(options) {"LeftJoin"}
-        left = operand(0).execute(queryable, options.merge(:depth => options[:depth].to_i + 1)) || {}
-        debug(options) {"=>(left) #{left.inspect}"}
-        right = operand(1).execute(queryable, options.merge(:depth => options[:depth].to_i + 1)) || {}
-        debug(options) {"=>(right) #{right.inspect}"}
-        
+        left = queryable.query(operand(0), options.merge(:depth => options[:depth].to_i + 1))
+        debug(options) {"=>(leftjoin left) #{left.inspect}"}
+
+        right = queryable.query(operand(1), options.merge(:depth => options[:depth].to_i + 1))
+        debug(options) {"=>(leftjoin right) #{right.inspect}"}
+
         # LeftJoin(Ω1, Ω2, expr) =
-        solutions = []
+        @solutions = RDF::Query::Solutions()
         left.each do |s1|
           load_left = true
           right.each do |s2|
@@ -52,18 +56,18 @@ module SPARQL; module Algebra
             if expr && s1.compatible?(s2)
               # { merge(μ1, μ2) | μ1 in Ω1 and μ2 in Ω2, and μ1 and μ2 are compatible and expr(merge(μ1, μ2)) is true }
               debug(options) {"=>(merge s1 s2) #{s.inspect}"}
-              solutions << s
+              @solutions << s
               load_left = false   # Left solution added one or more times due to merge
             end
           end
           if load_left
             debug(options) {"=>(add) #{s1.inspect}"}
-            solutions << s1
+            @solutions << s1
           end
         end
         
-        @solutions = RDF::Query::Solutions.new(solutions)
         debug(options) {"=> #{@solutions.inspect}"}
+        @solutions.each(&block) if block_given?
         @solutions
       end
       

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

@@ -27,23 +27,27 @@ module SPARQL; module Algebra
       #   the graph or repository to query
       # @param  [Hash{Symbol => Object}] options
       #   any additional keyword options
+      # @yield  [solution]
+      #   each matching solution
+      # @yieldparam  [RDF::Query::Solution] solution
+      # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
       # @see    http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#defn_algMinus
       # @see    http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#negation
-      def execute(queryable, options = {})
+      def execute(queryable, options = {}, &block)
         # Let Ω1 and Ω2 be multisets of solution mappings. We define:
         # 
         # Minus(Ω1, Ω2) = { μ | μ in Ω1 . ∀ μ' in Ω2, either μ and μ' are not compatible or dom(μ) and dom(μ') are disjoint }
         # 
         # card[Minus(Ω1, Ω2)](μ) = card[Ω1](μ)
         debug(options) {"Minus"}
-        solutions1 = operand(0).execute(queryable, options.merge(:depth => options[:depth].to_i + 1)) || {}
-        debug(options) {"=>(left) #{solutions1.inspect}"}
-        solutions2 = operand(1).execute(queryable, options.merge(:depth => options[:depth].to_i + 1)) || {}
-        debug(options) {"=>(right) #{solutions2.inspect}"}
-        @solutions = solutions1.minus(solutions2)
-        debug(options) {"=> #{@solutions.inspect}"}
+        left = queryable.query(operand(0), options.merge(:depth => options[:depth].to_i + 1))
+        debug(options) {"(minus left) #{left.inspect}"}
+        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?
         @solutions
       end
       

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

@@ -28,7 +28,7 @@ module SPARQL; module Algebra
       #   queryable to execute, using bindings as an initial solution.
       # @return [RDF::Literal::Boolean] `true` or `false`
       def evaluate(bindings, options = {})
-        solutions = RDF::Query::Solutions.new << bindings
+        solutions = RDF::Query::Solutions(bindings)
         queryable = options[:queryable]
         operand(0).execute(queryable, options.merge(:solutions => solutions)).empty?
       end

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

@@ -24,14 +24,18 @@ module SPARQL; module Algebra
       #   the graph or repository to query
       # @param  [Hash{Symbol => Object}] options
       #   any additional keyword options
+      # @yield  [solution]
+      #   each matching solution
+      # @yieldparam  [RDF::Query::Solution] solution
+      # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
       # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
-      def execute(queryable, options = {})
+      def execute(queryable, options = {}, &block)
         debug(options) {"Order"}
-        @solutions = operands.last.execute(queryable, options.merge(:depth => options[:depth].to_i + 1)).order do |a, b|
+        @solutions = queryable.query(operands.last, options.merge(:depth => options[:depth].to_i + 1)).order do |a, b|
           operand(0).inject(false) do |memo, op|
-            debug(options) {"=> #{op.inspect}"}
+            debug(options) {"(order) #{op.inspect}"}
             memo ||= begin
               a_eval = op.evaluate(a, options.merge(:queryable => queryable, :depth => options[:depth].to_i + 1)) rescue nil
               b_eval = op.evaluate(b, options.merge(:queryable => queryable, :depth => options[:depth].to_i + 1)) rescue nil
@@ -49,6 +53,8 @@ module SPARQL; module Algebra
             end
           end || 0  # They compare equivalently if there are no matches
         end
+        @solutions.each(&block) if block_given?
+        @solutions
       end
       
       ##

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

@@ -23,11 +23,16 @@ module SPARQL; module Algebra
       #   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    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
-      def execute(queryable, options = {})
-        @solutions = operands.last.execute(queryable, options.merge(:depth => options[:depth].to_i + 1))
+      def execute(queryable, options = {}, &block)
+        debug(options) {"Prefix"}
+        @solutions = queryable.query(operands.last, options.merge(:depth => options[:depth].to_i + 1), &block)
       end
       
       ##
@@ -48,6 +53,18 @@ module SPARQL; module Algebra
         operands[0] += other.operands[0]
         self
       end
+
+      # Query results in a boolean result (e.g., ASK)
+      # @return [Boolean]
+      def query_yields_boolean?
+        operands.last.query_yields_boolean?
+      end
+
+      # Query results statements (e.g., CONSTRUCT, DESCRIBE, CREATE)
+      # @return [Boolean]
+      def query_yields_statements?
+        operands.last.query_yields_statements?
+      end
     end # Prefix
   end # Operator
 end; end # SPARQL::Algebra