sparql 3.0.0 → 3.1.3

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

@@ -11,7 +11,7 @@ module SPARQL; module Algebra
     # @example
     #   (drop default)
     #
-    # @see http://www.w3.org/TR/sparql11-update/#drop
+    # @see https://www.w3.org/TR/sparql11-update/#drop
     class Drop < Operator
       include SPARQL::Algebra::Update
 
@@ -30,8 +30,8 @@ module SPARQL; module Algebra
       #   Returns queryable.
       # @raise [IOError]
       #   If `from` does not exist, unless the `silent` operator is present
-      # @see    http://www.w3.org/TR/sparql11-update/
-      def execute(queryable, options = {})
+      # @see    https://www.w3.org/TR/sparql11-update/
+      def execute(queryable, **options)
         debug(options) {"Drop"}
         silent = operands.first == :silent
         silent = operands.first == :silent

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

@@ -8,8 +8,8 @@ module SPARQL; module Algebra
     # @example
     #   (encode_for_uri ?x)
     #
-    # @see http://www.w3.org/TR/sparql11-query/#func-encode
-    # @see http://www.w3.org/TR/xpath-functions/#func-abs
+    # @see https://www.w3.org/TR/sparql11-query/#func-encode
+    # @see https://www.w3.org/TR/xpath-functions/#func-abs
     class EncodeForURI < Operator::Unary
       include Evaluatable
 
@@ -29,7 +29,7 @@ module SPARQL; module Algebra
       # @raise  [TypeError] if the operand is not a literal value
       def apply(operand)
         case operand
-          when RDF::Literal then RDF::Literal(::URI.encode(operand.to_s))
+          when RDF::Literal then RDF::Literal(CGI.escape(operand.to_s))
           else raise TypeError, "expected an RDF::Literal, but got #{operand.inspect}"
         end
       end

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

@@ -6,8 +6,8 @@ module SPARQL; module Algebra
     # @example
     #   (= ?x ?y)
     #
-    # @see http://www.w3.org/TR/sparql11-query/#OperatorMapping
-    # @see http://www.w3.org/TR/sparql11-query/#func-RDFterm-equal
+    # @see https://www.w3.org/TR/sparql11-query/#OperatorMapping
+    # @see https://www.w3.org/TR/sparql11-query/#func-RDFterm-equal
     class Equal < Compare
       NAME = :'='
 
@@ -25,7 +25,7 @@ module SPARQL; module Algebra
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is not an RDF term or operands are not comperable
       #
-      # @see {RDF::Term#==}
+      # @see RDF::Term#==
       def apply(term1, term2)
         term1 = term1.dup.extend(RDF::TypeCheck)
         term2 = term2.dup.extend(RDF::TypeCheck)

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

@@ -10,7 +10,7 @@ module SPARQL; module Algebra
     #      (filter (exists (bgp (triple ?s ?p ex:o)))
     #      (bgp (triple ?s ?p ?o))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#func-filter-exists
+    # @see https://www.w3.org/TR/sparql11-query/#func-filter-exists
     class Exists < Operator::Unary
       include Evaluatable
 
@@ -26,11 +26,11 @@ module SPARQL; module Algebra
       # @option options[RDF::Queryable] queryable
       #   queryable to execute, using bindings as an initial solution.
       # @return [RDF::Literal::Boolean] `true` or `false`
-      def evaluate(bindings, options = {})
+      def evaluate(bindings, **options)
         queryable = options[:queryable]
-        !operand(0).execute(queryable, options.merge(
-                                        solutions: RDF::Query::Solutions(bindings),
-                                        depth: options[:depth].to_i + 1)).empty?
+        !operand(0).execute(queryable, solutions: RDF::Query::Solutions(bindings),
+                                       depth: options[:depth].to_i + 1,
+                                       **options).empty?
       end
     end # Exists
   end # Operator

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

@@ -14,7 +14,7 @@ module SPARQL; module Algebra
     #           (triple ?s :q ?w)
     #         ))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#evaluation
+    # @see https://www.w3.org/TR/sparql11-query/#evaluation
     class Exprlist < Operator
       include Evaluatable
 
@@ -36,20 +36,10 @@ module SPARQL; module Algebra
       #   options passed from query
       # @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, options.merge(depth: options[:depth].to_i + 1))).true? }
+      def evaluate(bindings, **options)
+        res = operands.all? {|op| boolean(op.evaluate(bindings, depth: options[:depth].to_i + 1, **options)).true? }
         RDF::Literal(res) # FIXME: error handling
       end
-
-      ##
-      # Returns an optimized version of this query.
-      #
-      # Return optimized query
-      #
-      # @return [Union, RDF::Query] `self`
-      def optimize
-        operands = operands.map(&:optimize)
-      end
     end # Exprlist
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -11,7 +11,7 @@ module SPARQL; module Algebra
     #       (extend ((?z (+ ?o 10)))
     #         (bgp (triple ?s <http://example/p> ?o)))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#evaluation
+    # @see https://www.w3.org/TR/sparql11-query/#evaluation
     class Extend < Operator::Binary
       include Query
       
@@ -28,6 +28,12 @@ module SPARQL; module Algebra
       # 
       # Extend(Ω, var, expr) = { Extend(μ, var, expr) | μ in Ω }
       #
+      # For SPARQL*, expr may be an embedded tiple pattern
+      #
+      #    (extend
+      #     ((?t (triple ?bob foaf:age ?age)))
+      #     (bgp (triple ?t dct:source ?src)))
+      #
       # @param  [RDF::Queryable] queryable
       #   the graph or repository to query
       # @param  [Hash{Symbol => Object}] options
@@ -38,19 +44,24 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
-      # @see http://www.w3.org/TR/sparql11-query/#evaluation
-      def execute(queryable, options = {}, &block)
+      # @see https://www.w3.org/TR/sparql11-query/#evaluation
+      def execute(queryable, **options, &block)
         debug(options) {"Extend"}
-        @solutions = operand(1).execute(queryable, options.merge(depth: options[:depth].to_i + 1))
+        @solutions = operand(1).execute(queryable, depth: options[:depth].to_i + 1, **options)
         @solutions.each do |solution|
           debug(options) {"===> soln #{solution.to_h.inspect}"}
           operand(0).each do |(var, expr)|
             begin
-              val = expr.evaluate(solution, options.merge(
-                                              queryable: queryable,
-                                              depth: options[:depth].to_i + 1))
+              val = expr.evaluate(solution, queryable: queryable,
+                                            depth: options[:depth].to_i + 1,
+                                            **options)
               debug(options) {"===> + #{var} => #{val.inspect}"}
-              solution.bindings[var.to_sym] = val
+              solution.bindings[var.to_sym] = if val.is_a?(RDF::Query::Pattern)
+                # Variable is bound to the solution
+                val.bind(solution)
+              else
+                val
+              end
             rescue TypeError => e
               # Evaluates to error, ignore
               debug(options) {"===> #{var} error: #{e.message}"}
@@ -63,8 +74,8 @@ module SPARQL; module Algebra
 
       # 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
       def validate!
-        bind_vars = operand(0).map(&:first)
-        query_vars = operand(1).vars
+        bind_vars = operand(0).map(&:first).map(&:name)
+        query_vars = operand(1).vars.map(&:name)
         
         unless (bind_vars.compact & query_vars.compact).empty?
           raise ArgumentError,
@@ -72,16 +83,6 @@ module SPARQL; module Algebra
         end
         super
       end
-
-      ##
-      # Returns an optimized version of this query.
-      #
-      # Return optimized query
-      #
-      # @return FIXME
-      def optimize
-        operands = operands.map(&:optimize)
-      end
     end # Filter
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -9,7 +9,7 @@ module SPARQL; module Algebra
     #       (filter (= ?v 2)
     #         (bgp (triple ?s <http://example/p> ?v)))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#evaluation
+    # @see https://www.w3.org/TR/sparql11-query/#evaluation
     class Filter < Operator::Binary
       include Query
       
@@ -34,15 +34,15 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
-      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      # @see    http://www.w3.org/TR/sparql11-query/#ebv
-      def execute(queryable, options = {}, &block)
+      # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
+      # @see    https://www.w3.org/TR/sparql11-query/#ebv
+      def execute(queryable, **options, &block)
         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, options.merge(depth: options[:depth].to_i + 1)) do |solution|
+        queryable.query(operands.last, depth: options[:depth].to_i + 1, **options) do |solution|
           begin
-            pass = boolean(operands.first.evaluate(solution, opts)).true?
+            pass = boolean(operands.first.evaluate(solution, **opts)).true?
             debug(options) {"(filter) #{pass.inspect} #{solution.to_h.inspect}"}
             @solutions << solution if pass
           rescue
@@ -69,16 +69,6 @@ module SPARQL; module Algebra
         end
         self
       end
-
-      ##
-      # Returns an optimized version of this query.
-      #
-      # Return optimized query
-      #
-      # @return [Union, RDF::Query] `self`
-      def optimize
-        operands = operands.map(&:optimize)
-      end
     end # Filter
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,8 +6,8 @@ module SPARQL; module Algebra
     # @example
     #   (floor ?x)
     #
-    # @see http://www.w3.org/TR/sparql11-query/#func-floor
-    # @see http://www.w3.org/TR/xpath-functions/#func-floor
+    # @see https://www.w3.org/TR/sparql11-query/#func-floor
+    # @see https://www.w3.org/TR/xpath-functions/#func-floor
     class Floor < Operator::Unary
       include Evaluatable
 

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

@@ -15,7 +15,7 @@ module SPARQL; module Algebra
     #     (graph :g
     #       ((triple :s :p :o))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
+    # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class Graph < Operator::Binary
       include Query
       
@@ -63,26 +63,15 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
-      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      def execute(queryable, options = {}, &block)
+      # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
+      def execute(queryable, **options, &block)
         debug(options) {"Graph #{operands.first}"}
         graph_name, query = operands.first, operands.last
-        @solutions = queryable.query(query, options.merge(graph_name: graph_name), &block)
+        @solutions = queryable.query(query, graph_name: graph_name, **options, &block)
       end
-      
-      ##
-      # Returns an optimized version of this query.
-      #
-      # Return optimized query
-      #
-      # @return [Union, RDF::Query] `self`
-      def optimize
-        operands = operands.map(&:optimize)
-      end
-      
+
       ##
       # Don't do any more rewriting
-      # FIXME: if ooperator is JOIN, and rewritten sub-operators are queries, can do simple merge of sub-graphs
       # @return [SPARQL::Algebra::Expression] `self`
       def rewrite(&block)
         self

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

@@ -6,11 +6,11 @@ module SPARQL; module Algebra
     # @example
     #   (> ?x ?y)
     #
-    # @see http://www.w3.org/TR/sparql11-query/#OperatorMapping
-    # @see http://www.w3.org/TR/xpath-functions/#func-compare
-    # @see http://www.w3.org/TR/xpath-functions/#func-numeric-greater-than
-    # @see http://www.w3.org/TR/xpath-functions/#func-boolean-greater-than
-    # @see http://www.w3.org/TR/xpath-functions/#func-dateTime-greater-than
+    # @see https://www.w3.org/TR/sparql11-query/#OperatorMapping
+    # @see https://www.w3.org/TR/xpath-functions/#func-compare
+    # @see https://www.w3.org/TR/xpath-functions/#func-numeric-greater-than
+    # @see https://www.w3.org/TR/xpath-functions/#func-boolean-greater-than
+    # @see https://www.w3.org/TR/xpath-functions/#func-dateTime-greater-than
     class GreaterThan < Compare
       NAME = :>
 

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

@@ -7,11 +7,11 @@ module SPARQL; module Algebra
     # @example
     #   (>= ?x ?y)
     #
-    # @see http://www.w3.org/TR/sparql11-query/#OperatorMapping
-    # @see http://www.w3.org/TR/xpath-functions/#func-compare
-    # @see http://www.w3.org/TR/xpath-functions/#func-numeric-greater-than
-    # @see http://www.w3.org/TR/xpath-functions/#func-boolean-greater-than
-    # @see http://www.w3.org/TR/xpath-functions/#func-dateTime-greater-than
+    # @see https://www.w3.org/TR/sparql11-query/#OperatorMapping
+    # @see https://www.w3.org/TR/xpath-functions/#func-compare
+    # @see https://www.w3.org/TR/xpath-functions/#func-numeric-greater-than
+    # @see https://www.w3.org/TR/xpath-functions/#func-boolean-greater-than
+    # @see https://www.w3.org/TR/xpath-functions/#func-dateTime-greater-than
     class GreaterThanOrEqual < Compare
       NAME = :>=
 

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

@@ -11,13 +11,13 @@ module SPARQL; module Algebra
     # @example
     #     (prefix ((: <http://example/>))
     #       (project (?w ?S)
-    #         (extend ((?S ?.0))
-    #           (group (?w) ((?.0 (sample ?v)))
+    #         (extend ((?S ??.0))
+    #           (group (?w) ((??.0 (sample ?v)))
     #             (leftjoin
     #               (bgp (triple ?s :p ?v))
     #               (bgp (triple ?s :q ?w)))))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
+    # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class Group < Operator
       include Query
       
@@ -37,13 +37,13 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
-      # @see    http://www.w3.org/TR/sparql11-query/#sparqlGroupAggregate
-      def execute(queryable, options = {}, &block)
+      # @see    https://www.w3.org/TR/sparql11-query/#sparqlGroupAggregate
+      def execute(queryable, **options, &block)
         debug(options) {"Group"}
         exprlist = operands.first
         query = operands.last
         aggregates = operands.length == 3 ? operand(1) : []
-        solutions = queryable.query(query, options.merge(depth: options[:depth].to_i + 1))
+        solutions = queryable.query(query, depth: options[:depth].to_i + 1, **options)
 
         groups = solutions.group_by do |solution|
           # Evaluate each exprlist operand to get groups where each key is a new solution
@@ -54,14 +54,14 @@ module SPARQL; module Algebra
               if operand.is_a?(Array)
                 # Form is [variable, expression]
                 soln[operand.first] = operand.last.evaluate(solution,
-                                                            options.merge(
-                                                             queryable: queryable,
-                                                             depth: options[:depth].to_i + 1))
+                                                            queryable: queryable,
+                                                            depth: options[:depth].to_i + 1,
+                                                            **options)
               else
                 # Form is variable
-                soln[operand] = operand.evaluate(solution, options.merge(
-                                                            queryable: queryable,
-                                                            depth: options[:depth].to_i + 1))
+                soln[operand] = operand.evaluate(solution, queryable: queryable,
+                                                           depth: options[:depth].to_i + 1,
+                                                           **options)
               end
             rescue TypeError
               # Ignore expression
@@ -76,7 +76,7 @@ module SPARQL; module Algebra
         @solutions = RDF::Query::Solutions(groups.map do |group_soln, solns|
           aggregates.each do |(var, aggregate)|
             begin
-              group_soln[var] = aggregate.aggregate(solns, options)
+              group_soln[var] = aggregate.aggregate(solns, **options)
             rescue TypeError
               # Ignored in output
             end
@@ -84,8 +84,18 @@ module SPARQL; module Algebra
           group_soln
         end)
 
-        # Make sure that's at least an empty solution
-        @solutions << RDF::Query::Solution.new if @solutions.empty?
+        # If there exprlist is empty, make sure that's at least an empty solution
+        if @solutions.empty? && exprlist.empty?
+          soln = RDF::Query::Solution.new
+          aggregates.each do |(var, aggregate)|
+            begin
+              soln[var] = aggregate.aggregate([], **options)
+            rescue TypeError
+              # Ignored in output
+            end
+          end
+          @solutions << soln
+        end
 
         debug(options) {"=>(solutions) #{@solutions.inspect}"}
         @solutions.each(&block) if block_given?
@@ -112,16 +122,6 @@ module SPARQL; module Algebra
         end
         super
       end
-
-      ##
-      # Returns an optimized version of this query.
-      #
-      # TODO
-      #
-      # @return [Group] `self`
-      def optimize
-        self
-      end
     end # Group
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -9,11 +9,11 @@ module SPARQL; module Algebra
     #    (prefix ((: <http://www.example.org/>))
     #      (filter (|| (= ?g "1 22") (= ?g "22 1"))
     #        (project (?g)
-    #          (extend ((?g ?.0))
-    #            (group () ((?.0 (group_concat ?o)))
-    #              (bgp (triple ??0 :p1 ?o)))))))
+    #          (extend ((?g ??.0))
+    #            (group () ((??.0 (group_concat ?o)))
+    #              (bgp (triple ??.0 :p1 ?o)))))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#defn_aggGroupConcat
+    # @see https://www.w3.org/TR/sparql11-query/#defn_aggGroupConcat
     class GroupConcat < Operator
       include Aggregate
 
@@ -29,12 +29,12 @@ module SPARQL; module Algebra
       # @return [RDF::Term]
       # @raise [TypeError]
       # @abstract
-      def aggregate(solutions = [], options = {})
+      def aggregate(solutions = [], **options)
         operands.shift if distinct = (operands.first == :distinct)
         sep = operands.length == 2 ? operand(0).last : RDF::Literal(' ')
         args_enum = solutions.map do |solution|
           begin
-            operands.last.evaluate(solution, options.merge(depth: options[:depth].to_i + 1))
+            operands.last.evaluate(solution, depth: options[:depth].to_i + 1, **options)
           rescue TypeError
             # Ignore errors
             nil