sparql 3.1.0 → 3.1.6

data/lib/sparql/algebra/operator.rb

@@ -54,6 +54,10 @@ module SPARQL; module Algebra
     autoload :Timezone,           'sparql/algebra/operator/timezone'
     autoload :TZ,                 'sparql/algebra/operator/tz'
     autoload :Year,               'sparql/algebra/operator/year'
+    autoload :IsTriple,           'sparql/algebra/operator/is_triple'
+    autoload :Subject,            'sparql/algebra/operator/subject'
+    autoload :Predicate,          'sparql/algebra/operator/predicate'
+    autoload :Object,             'sparql/algebra/operator/object'
 
     # Binary operators
     autoload :And,                'sparql/algebra/operator/and'
@@ -146,8 +150,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`.
     #
@@ -296,6 +298,14 @@ module SPARQL; module Algebra
         when :update          then Update
         when :using           then Using
         when :with            then With
+
+        # RDF-star
+        when :istriple        then IsTriple
+        when :triple          then Triple
+        when :subject         then Subject
+        when :predicate       then Predicate
+        when :object          then Object
+
         else                       nil # not found
       end
     end
@@ -338,8 +348,8 @@ module SPARQL; module Algebra
     #   @option options [Boolean] :memoize (false)
     #     whether to memoize results for particular operands
     # @raise  [TypeError] if any operand is invalid
-    def initialize(*operands)
-      @options  = operands.last.is_a?(Hash) ? operands.pop.dup : {}
+    def initialize(*operands, **options)
+      @options  = options.dup
       @operands = operands.map! do |operand|
         case operand
           when Array
@@ -357,6 +367,22 @@ module SPARQL; module Algebra
       end
     end
 
+    ##
+    # Deep duplicate operands
+    def deep_dup
+      self.class.new(*operands.map(&:deep_dup), **@options)
+    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 +460,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,21 +517,35 @@ 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
 
     ##
@@ -532,7 +572,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 +583,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 +680,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
@@ -724,7 +757,7 @@ module SPARQL; module Algebra
       ##
       # @param  [Hash{Symbol => Object}] options
       #   any additional options (see {Operator#initialize})
-      def initialize(options = {})
+      def initialize(**options)
         super
       end
     end # Nullary
@@ -743,7 +776,7 @@ module SPARQL; module Algebra
       #   the operand
       # @param  [Hash{Symbol => Object}] options
       #   any additional options (see {Operator#initialize})
-      def initialize(arg, options = {})
+      def initialize(arg, **options)
         super
       end
     end # Unary
@@ -764,7 +797,7 @@ module SPARQL; module Algebra
       #   the second operand
       # @param  [Hash{Symbol => Object}] options
       #   any additional options (see {Operator#initialize})
-      def initialize(arg1, arg2, options = {})
+      def initialize(arg1, arg2, **options)
         super
       end
     end # Binary
@@ -787,7 +820,7 @@ module SPARQL; module Algebra
       #   the third operand
       # @param  [Hash{Symbol => Object}] options
       #   any additional options (see {Operator#initialize})
-      def initialize(arg1, arg2, arg3, options = {})
+      def initialize(arg1, arg2, arg3, **options)
         super
       end
     end # Ternary
@@ -812,7 +845,7 @@ module SPARQL; module Algebra
       #   the forth operand
       # @param  [Hash{Symbol => Object}] options
       #   any additional options (see {Operator#initialize})
-      def initialize(arg1, arg2, arg3, arg4, options = {})
+      def initialize(arg1, arg2, arg3, arg4, **options)
         super
       end
     end # Ternary

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,7 +28,7 @@ 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/
+      # @see    https://www.w3.org/TR/sparql11-update/
       def execute(queryable, **options)
         debug(options) {"Add"}
         silent = operands.first == :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,7 +32,7 @@ module SPARQL; module Algebra
       #   each matching solution
       # @yieldparam  [RDF::Query::Solution] solution
       # @yieldreturn [void] ignored
-      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
+      # @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}"}

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

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
+      # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, **options)
         debug(options) {"Ask #{operands.first}"}
         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

@@ -10,12 +10,19 @@ module SPARQL; module Algebra
     #          (group () ((??.0 (avg ?o)))
     #            (bgp (triple ?s :dec ?o))))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#defn_aggAvg
+    # @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.
       #

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
+      # @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, 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
 
@@ -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
 

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,7 +28,7 @@ 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/
+      # @see    https://www.w3.org/TR/sparql11-update/
       def execute(queryable, **options)
         debug(options) {"Clear"}
         silent = operands.first == :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
 
@@ -50,16 +50,6 @@ module SPARQL; module Algebra
         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