sparql 3.0.0 → 3.1.3

data/lib/sparql/algebra/operator.rb

@@ -146,8 +146,6 @@ module SPARQL; module Algebra
     autoload :Using,              'sparql/algebra/operator/using'
     autoload :With,               'sparql/algebra/operator/with'
 
-
-
     ##
     # Returns an operator class for the given operator `name`.
     #
@@ -331,7 +329,7 @@ module SPARQL; module Algebra
     # @overload initialize(*operands)
     #   @param  [Array<RDF::Term>] operands
     #
-    # @overload initialize(*operands, options)
+    # @overload initialize(*operands, **options)
     #   @param  [Array<RDF::Term>] operands
     #   @param  [Hash{Symbol => Object}] options
     #     any additional options
@@ -357,6 +355,22 @@ module SPARQL; module Algebra
       end
     end
 
+    ##
+    # Deep duplicate operands
+    def deep_dup
+      self.class.new(*operands.map(&:deep_dup))
+    end
+
+    ##
+    # Binds the pattern to a solution, making it no longer variable if all variables are resolved to bound variables
+    #
+    # @param [RDF::Query::Solution] solution
+    # @return [self]
+    def bind(solution)
+      @operands.each {|op| op.bind(solution)}
+      self
+    end
+
     ##
     # Base URI used for reading data sources with relative URIs
     #
@@ -434,7 +448,7 @@ module SPARQL; module Algebra
     # @return [Boolean] `true` or `false`
     # @see    #constant?
     def variable?
-      operands.any?(&:variable?)
+      operands.any? {|op| op.respond_to?(:variable?) && op.variable?}
     end
 
     ##
@@ -491,23 +505,37 @@ module SPARQL; module Algebra
     #
     # For constant expressions containing no variables, returns the result
     # of evaluating the expression with empty bindings; otherwise returns
-    # `self`.
+    # a copy of `self`.
     #
     # Optimization is not possible if the expression raises an exception,
     # such as a `TypeError` or `ZeroDivisionError`, which must be conserved
     # at runtime.
     #
     # @return [SPARQL::Algebra::Expression]
-    def optimize
+    # @see    RDF::Query#optimize
+    def optimize(**options)
       if constant?
         # Note that if evaluation results in a `TypeError` or other error,
         # we must return `self` so that the error is conserved at runtime:
         evaluate(RDF::Query::Solution.new) rescue self
       else
-        super # returns `self`
+        super # returns a copy of `self`
       end
     end
 
+    ##
+    # Optimizes this query by optimizing its constituent operands
+    # according to their cost estimates.
+    #
+    # @return [self]
+    # @see    RDF::Query#optimize!
+    def optimize!(**options)
+      @operands.map! do |op|
+        op.optimize(**options) if op.respond_to?(:optimize)
+      end
+      self
+    end
+
     ##
     # Rewrite operands by yielding each operand. Recursively descends
     # through operands implementing this method.
@@ -532,7 +560,7 @@ module SPARQL; module Algebra
     # Returns the SPARQL S-Expression (SSE) representation of this operator.
     #
     # @return [Array]
-    # @see    http://openjena.org/wiki/SSE
+    # @see    https://openjena.org/wiki/SSE
     def to_sxp_bin
       operator = [self.class.const_get(:NAME)].flatten.first
       [operator, *(operands || []).map(&:to_sxp_bin)]
@@ -543,13 +571,6 @@ module SPARQL; module Algebra
     #
     # @return [String]
     def to_sxp
-      begin
-        require 'sxp' # @see http://rubygems.org/gems/sxp
-      rescue LoadError
-        abort "SPARQL::Algebra::Operator#to_sxp requires the SXP gem (hint: `gem install sxp')."
-      end
-      require 'sparql/algebra/sxp_extensions'
-
       to_sxp_bin.to_sxp
     end
 
@@ -647,7 +668,7 @@ module SPARQL; module Algebra
     # @param  [RDF::Literal] literal
     # @return [RDF::Literal::Boolean] `true` or `false`
     # @raise  [TypeError] if the literal could not be coerced to an `RDF::Literal::Boolean`
-    # @see    http://www.w3.org/TR/sparql11-query/#ebv
+    # @see    https://www.w3.org/TR/sparql11-query/#ebv
     def boolean(literal)
       case literal
         when FalseClass then RDF::Literal::FALSE

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

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

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

@@ -9,7 +9,7 @@ module SPARQL; module Algebra
     # @example
     #   (add default <a>)
     #
-    # @see http://www.w3.org/TR/sparql11-update/#add
+    # @see https://www.w3.org/TR/sparql11-update/#add
     class Add < Operator
       include SPARQL::Algebra::Update
 
@@ -28,8 +28,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) {"Add"}
         silent = operands.first == :silent
         operands.shift if silent

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

@@ -10,7 +10,7 @@ module SPARQL; module Algebra
     # @example
     #   (alt a b)
     #
-    # @see http://www.w3.org/TR/sparql11-query/#defn_evalPP_alternative
+    # @see https://www.w3.org/TR/sparql11-query/#defn_evalPP_alternative
     class Alt < Operator::Binary
       include Query
       
@@ -32,8 +32,8 @@ module SPARQL; module Algebra
       #   each matching solution
       # @yieldparam  [RDF::Query::Solution] solution
       # @yieldreturn [void] ignored
-      # @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)
         subject, object = options[:subject], options[:object]
         debug(options) {"Alt #{[subject, operands, object].to_sse}"}
 
@@ -55,7 +55,7 @@ module SPARQL; module Algebra
         end
 
         query = Union.new(qa, qb)
-        queryable.query(query, options.merge(depth: options[:depth].to_i + 1), &block)
+        queryable.query(query, depth: options[:depth].to_i + 1, **options, &block)
       end
     end # Alt
   end # Operator

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

@@ -7,8 +7,8 @@ module SPARQL; module Algebra
     #   (&& ?x ?y)
     #   (and ?x ?y)
     #
-    # @see http://www.w3.org/TR/sparql11-query/#func-logical-and
-    # @see http://www.w3.org/TR/sparql11-query/#evaluation
+    # @see https://www.w3.org/TR/sparql11-query/#func-logical-and
+    # @see https://www.w3.org/TR/sparql11-query/#evaluation
     class And < Operator::Binary
       include Evaluatable
 
@@ -24,7 +24,7 @@ module SPARQL; module Algebra
       # @param  [Hash{Symbol => Object}] options
       #   any additional options (see {Operator#initialize})
       # @raise  [TypeError] if any operand is invalid
-      def initialize(left, right, options = {})
+      def initialize(left, right, **options)
         super
       end
 
@@ -37,20 +37,20 @@ 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 boolean literals
-      def evaluate(bindings, options = {})
+      def evaluate(bindings, **options)
         begin
-          left = boolean(operand(0).evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))).true?
+          left = boolean(operand(0).evaluate(bindings, depth: options[:depth].to_i + 1, **options)).true?
         rescue TypeError
           left = nil
         end
         
         begin
-          right = boolean(operand(1).evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))).true?
+          right = boolean(operand(1).evaluate(bindings, depth: options[:depth].to_i + 1, **options)).true?
         rescue TypeError
           right = nil
         end
 
-        # From http://www.w3.org/TR/sparql11-query/#evaluation
+        # From https://www.w3.org/TR/sparql11-query/#evaluation
         # A logical-and that encounters an error on only one branch will return an error if the other branch is
         # TRUE and FALSE if the other branch is FALSE.
         case

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

@@ -9,7 +9,7 @@ module SPARQL; module Algebra
     #       (order ((asc ?name))
     #         (bgp (triple ?x foaf:name ?name)))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#modOrderBy
+    # @see https://www.w3.org/TR/sparql11-query/#modOrderBy
     class Asc < Operator::Unary
       include Evaluatable
 
@@ -24,8 +24,8 @@ module SPARQL; module Algebra
       # @param [Hash{Symbol => Object}] options ({})
       #   options passed from query
       # @return [RDF::Term]
-      def evaluate(bindings, options = {})
-        operand(0).evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))
+      def evaluate(bindings, **options)
+        operand(0).evaluate(bindings, depth: options[:depth].to_i + 1, **options)
       end
     end # Asc
   end # Operator

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

@@ -10,7 +10,7 @@ module SPARQL; module Algebra
     #     (ask
     #       (bgp (triple :x :p ?x))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#ask
+    # @see https://www.w3.org/TR/sparql11-query/#ask
     class Ask < Operator::Unary
       include Query
       
@@ -28,23 +28,13 @@ module SPARQL; module Algebra
       # @yieldparam  [RDF::Query::Solution] solution
       # @yieldreturn [void] ignored
       # @return [RDF::Literal::Boolean]\
-      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      def execute(queryable, options = {})
+      # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
+      def execute(queryable, **options)
         debug(options) {"Ask #{operands.first}"}
-        res = boolean(!queryable.query(operands.last, options.merge(depth: options[:depth].to_i + 1)).empty?)
+        res = boolean(!queryable.query(operands.last, depth: options[:depth].to_i + 1, **options).empty?)
         yield res if block_given?
         res
       end
-      
-      ##
-      # Returns an optimized version of this query.
-      #
-      # Return optimized query
-      #
-      # @return [Union, RDF::Query] `self`
-      def optimize
-        operands = operands.map(&:optimize)
-      end
 
       # Query results in a boolean result (e.g., ASK)
       # @return [Boolean]

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

@@ -6,12 +6,12 @@ module SPARQL; module Algebra
     # @example
     #    (prefix ((: <http://www.example.org/>))
     #      (project (?avg)
-    #        (extend ((?avg ?.0))
-    #          (group () ((?.0 (avg ?o)))
+    #        (extend ((?avg ??.0))
+    #          (group () ((??.0 (avg ?o)))
     #            (bgp (triple ?s :dec ?o))))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#defn_aggAvg
-    class Avg < Operator::Unary
+    # @see https://www.w3.org/TR/sparql11-query/#defn_aggAvg
+    class Avg < Operator
       include Aggregate
 
       NAME = :avg
@@ -23,6 +23,8 @@ module SPARQL; module Algebra
       #   enum of evaluated operand
       # @return [RDF::Literal::Numeric] The numeric average of the terms
       def apply(enum)
+        # FIXME: we don't actually do anything with distinct
+        operands.shift if distinct = (operands.first == :distinct)
         if enum.empty?
           RDF::Literal(0)
         elsif enum.flatten.all? {|n| n.is_a?(RDF::Literal::Numeric)}

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

@@ -7,7 +7,7 @@ module SPARQL; module Algebra
     #   (base <http://example.org/>
     #     (bgp (triple <a> <b> 123.0)))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#QSynIRI
+    # @see https://www.w3.org/TR/sparql11-query/#QSynIRI
     class Base < Binary
       include Query
       
@@ -28,21 +28,21 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Queryable, 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) {"Base #{operands.first}"}
         Operator.base_uri = operands.first
-        queryable.query(operands.last, options.merge(depth: options[:depth].to_i + 1), &block)
+        queryable.query(operands.last, depth: options[:depth].to_i + 1, **options, &block)
       end
-      
+
       ##
-      # Returns an optimized version of this query.
-      #
       # Return optimized query
       #
-      # @return [Union, RDF::Query] `self`
-      def optimize
-        operands.last.optimize
+      # @return [Base] a copy of `self`
+      # @see SPARQL::Algebra::Expression#optimize
+      def optimize(**options)
+        Operator.base_uri = operands.first
+        operands.last.optimize(**options)
       end
 
       # Query results in a boolean result (e.g., ASK)

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

@@ -9,7 +9,7 @@ module SPARQL; module Algebra
     #   (prefix ((: <http://example/>))
     #     (bgp (triple ?s ?p ?o)))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
+    # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class BGP < Operator
       NAME = [:bgp]
       ##

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

@@ -16,7 +16,7 @@ module SPARQL; module Algebra
     #               (triple ?b :str ?s2)
     #             )))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#func-bnode
+    # @see https://www.w3.org/TR/sparql11-query/#func-bnode
     class BNode < Operator::Unary
       include Evaluatable
 
@@ -30,7 +30,7 @@ module SPARQL; module Algebra
       # @param  [Hash{Symbol => Object}] options
       #   any additional options (see {Operator#initialize})
       # @raise  [TypeError] if any operand is invalid
-      def initialize(literal = false, options = {})
+      def initialize(literal = false, **options)
         super
       end
 
@@ -42,8 +42,8 @@ module SPARQL; module Algebra
       # @param [Hash{Symbol => Object}] options ({})
       #   options passed from query
       # @return [RDF::Term]
-      def evaluate(bindings, options = {})
-        args = operands.map { |operand| operand.evaluate(bindings, options.merge(depth: options[:depth].to_i + 1)) }
+      def evaluate(bindings, **options)
+        args = operands.map { |operand| operand.evaluate(bindings, depth: options[:depth].to_i + 1, **options) }
         apply(args.first, bindings)
       end
 
@@ -82,7 +82,7 @@ module SPARQL; module Algebra
       # Remove the optional argument.
       #
       # @return [Array] `self`
-      # @see    http://openjena.org/wiki/SSE
+      # @see    https://openjena.org/wiki/SSE
       def to_sxp_bin
         [NAME] + operands.reject {|o| o == false}
       end

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

@@ -11,7 +11,7 @@ module SPARQL; module Algebra
     #           (bgp (triple ?a :b ?c))
     #           (bgp (triple ?c :d ?e))))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#func-bound
+    # @see https://www.w3.org/TR/sparql11-query/#func-bound
     class Bound < Operator::Unary
       include Evaluatable
 
@@ -25,7 +25,7 @@ module SPARQL; module Algebra
       # @param  [Hash{Symbol => Object}] options
       #   any additional options (see {Operator#initialize})
       # @raise  [TypeError] if any operand is invalid
-      def initialize(var, options = {})
+      def initialize(var, **options)
         super
       end
 
@@ -38,7 +38,7 @@ module SPARQL; module Algebra
       #   options passed from query
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operand is not a variable
-      def evaluate(bindings, options = {})
+      def evaluate(bindings, **options)
         case var = operand
           when Variable
             bindings.respond_to?(:bound?) && bindings.bound?(var) ?

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

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

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

@@ -9,7 +9,7 @@ module SPARQL; module Algebra
     # @example
     #   (clear silent default)
     #
-    # @see http://www.w3.org/TR/sparql11-update/#clear
+    # @see https://www.w3.org/TR/sparql11-update/#clear
     class Clear < Operator
       include SPARQL::Algebra::Update
 
@@ -28,8 +28,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) {"Clear"}
         silent = operands.first == :silent
         operands.shift if silent