sparql 3.0.2 → 3.1.5

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,16 +6,23 @@ 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
 
+      def initialize(*operands, **options)
+        raise ArgumentError,
+          "avg operator accepts at most one argument with an optional :distinct" if
+          (operands - %i{distinct}).length != 1
+        super
+      end
+
       ##
       # The Avg set function calculates the average value for an expression over a group. It is defined in terms of Sum and Count.
       #
@@ -23,6 +30,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]
       ##
@@ -22,7 +22,7 @@ module SPARQL; module Algebra
       # @yieldparam  [RDF::Query::Solution] solution
       # @yieldreturn [void] ignored
       # @return [RDF::Query]
-      def self.new(*patterns, &block)
+      def self.new(*patterns, **options, &block)
         RDF::Query.new(*patterns, graph_name: false, &block)
       end
     end # 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

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

@@ -15,7 +15,7 @@ module SPARQL; module Algebra
     #             (bgp (triple ?s :p ?o))
     #             (bgp (triple ?s :q ?x))))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#func-coalesce
+    # @see https://www.w3.org/TR/sparql11-query/#func-coalesce
     class Coalesce < Operator
       include Evaluatable
 
@@ -41,25 +41,15 @@ module SPARQL; module Algebra
       #   options passed from query
       # @return [RDF::Term]
       # @raise  [TypeError] if none of the operands succeeds
-      def evaluate(bindings, options = {})
+      def evaluate(bindings, **options)
         operands.each do |op|
           begin
-            return op.evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))
+            return op.evaluate(bindings, depth: options[:depth].to_i + 1, **options)
           rescue
           end
         end
         raise TypeError, "None of the operands evaluated"
       end
-
-      ##
-      # Returns an optimized version of this query.
-      #
-      # Return optimized query
-      #
-      # @return [Union, RDF::Query] `self`
-      def optimize
-        operands = operands.map(&:optimize)
-      end
     end # Coalesce
   end # Operator
 end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/compare.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/xpath-functions/#func-compare
+    # @see https://www.w3.org/TR/sparql11-query/#OperatorMapping
+    # @see https://www.w3.org/TR/xpath-functions/#func-compare
     class Compare < Operator::Binary
       include Evaluatable
 
@@ -33,14 +33,14 @@ module SPARQL; module Algebra
       # @raise  [TypeError] if either operand is not a literal
       def apply(left, right)
         case
-        # @see http://www.w3.org/TR/sparql11-query/#OperatorMapping
-        # @see http://www.w3.org/TR/sparql11-query/#modOrderBy
+        # @see https://www.w3.org/TR/sparql11-query/#OperatorMapping
+        # @see https://www.w3.org/TR/sparql11-query/#modOrderBy
         when left.is_a?(RDF::Literal) && right.is_a?(RDF::Literal)
           case
-          # @see http://www.w3.org/TR/xpath-functions/#string-compare
-          # @see http://www.w3.org/TR/xpath-functions/#comp.numeric
-          # @see http://www.w3.org/TR/xpath-functions/#op.boolean
-          # @see http://www.w3.org/TR/xpath-functions/#comp.duration.datetime
+          # @see https://www.w3.org/TR/xpath-functions/#string-compare
+          # @see https://www.w3.org/TR/xpath-functions/#comp.numeric
+          # @see https://www.w3.org/TR/xpath-functions/#op.boolean
+          # @see https://www.w3.org/TR/xpath-functions/#comp.duration.datetime
           when (left.simple? && right.simple?) ||
                (left.is_a?(RDF::Literal::Numeric) && right.is_a?(RDF::Literal::Numeric)) ||
                (left.datatype == right.datatype && left.language == right.language)

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

@@ -8,8 +8,8 @@ module SPARQL; module Algebra
     # @example
     #   (concat ?a ?b ...)
     #
-    # @see http://www.w3.org/TR/sparql11-query/#func-concat
-    # @see http://www.w3.org/TR/xpath-functions/#func-concat
+    # @see https://www.w3.org/TR/sparql11-query/#func-concat
+    # @see https://www.w3.org/TR/xpath-functions/#func-concat
     class Concat < Operator
       include Evaluatable
 
@@ -32,8 +32,8 @@ module SPARQL; module Algebra
       #   options passed from query
       # @return [RDF::Term]
       # @raise  [TypeError] if any operand is not a literal
-      def evaluate(bindings, options = {})
-        ops = operands.map {|op| op.evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))}
+      def evaluate(bindings, **options)
+        ops = operands.map {|op| op.evaluate(bindings, depth: options[:depth].to_i + 1, **options)}
 
         raise TypeError, "expected all plain literal operands" unless ops.all? {|op| op.literal? && op.plain?}
 

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

@@ -12,7 +12,7 @@ module SPARQL; module Algebra
     #       (project (?s ?p ?o)
     #         (bgp (triple ?s ?p ?o)))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#construct
+    # @see https://www.w3.org/TR/sparql11-query/#construct
     class Construct < Operator::Binary
       include Query
       
@@ -34,14 +34,14 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Queryable]
       #   A Queryable with constructed triples
-      # @see    http://www.w3.org/TR/sparql11-query/#construct
-      def execute(queryable, options = {}, &block)
+      # @see    https://www.w3.org/TR/sparql11-query/#construct
+      def execute(queryable, **options, &block)
         debug(options) {"Construct #{operands.first}, #{options.inspect}"}
         graph = RDF::Graph.new
         patterns = operands.first
         query = operands.last
 
-        queryable.query(query, options.merge(depth: options[:depth].to_i + 1)).each do |solution|
+        queryable.query(query, depth: options[:depth].to_i + 1, **options).each do |solution|
           debug(options) {"(construct apply) #{solution.inspect} to BGP"}
           
           # Create a mapping from BNodes within the pattern list to newly constructed BNodes
@@ -74,16 +74,6 @@ module SPARQL; module Algebra
         graph.each(&block) if block_given?
         graph
       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 statements (e.g., CONSTRUCT, DESCRIBE, CREATE)
       # @return [Boolean]