sparql 3.0.2 → 3.1.5

data/lib/sparql/algebra/extensions.rb

@@ -4,7 +4,7 @@ require 'json'
 # Extensions for Ruby's `NilClass` class.
 class NilClass
 
-  def evaluate(bindings, options = {})
+  def evaluate(bindings, **options)
     self
   end
 
@@ -27,6 +27,22 @@ class Object
   def to_sse
     SXP::Generator.string(self.to_sxp_bin)
   end
+
+  ##
+  # A duplicate of this object.
+  #
+  # @return [Object] a copy of `self`
+  # @see SPARQL::Algebra::Expression#optimize
+  def optimize(**options)
+    self.deep_dup
+  end
+
+  ##
+  # Default for deep_dup is shallow dup
+  # @return [Object]
+  def deep_dup
+    dup
+  end
 end
 
 ##
@@ -53,8 +69,8 @@ class Array
   #   options passed from query
   # @return [RDF::Term]
   # @see SPARQL::Algebra::Expression.evaluate
-  def evaluate(bindings, options = {})
-    SPARQL::Algebra::Expression.extension(*self.map {|o| o.evaluate(bindings, options)})
+  def evaluate(bindings, **options)
+    SPARQL::Algebra::Expression.extension(*self.map {|o| o.evaluate(bindings, **options)})
   end
 
   ##
@@ -66,11 +82,34 @@ class Array
   # @param  [Hash{Symbol => Object}] options
   # @raise [NotImplementedError]
   #   If an attempt is made to perform an unsupported operation
-  # @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)
     raise NotImplementedError, "SPARQL::Algebra '#{first}' operator not implemented"
   end
 
+  ##
+  # Return an optimized version of this array.
+  #
+  # @return [Array] a copy of `self`
+  # @see SPARQL::Algebra::Expression#optimize
+  def optimize(**options)
+    self.map do |op|
+      op.optimize(**options) if op.respond_to?(:optimize)
+    end
+  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)
+    map! do |op|
+      op.respond_to?(:bind) ? op.bind(solution) : op
+    end
+    self
+  end
+
   ##
   # Returns `true` if any of the operands are variables, `false`
   # otherwise.
@@ -78,7 +117,7 @@ class Array
   # @return [Boolean] `true` or `false`
   # @see    #constant?
   def variable?
-    any?(&:variable?)
+    any? {|op| op.respond_to?(:variable?) && op.variable?}
   end
   def constant?; !(variable?); end
 
@@ -166,6 +205,12 @@ class Array
     each {|e| e.validate! if e.respond_to?(:validate!)}
     self
   end
+
+  ##
+  # Deep duplicate
+  def deep_dup
+    map(&:deep_dup)
+  end
 end
 
 ##
@@ -179,6 +224,21 @@ class Hash
     to_a.to_sxp_bin
   end
   def to_sxp; to_sxp_bin; end
+
+  ##
+  # A duplicate of this hash.
+  #
+  # @return [Hash] a copy of `self`
+  # @see SPARQL::Algebra::Expression#optimize
+  def optimize(**options)
+    self.deep_dup
+  end
+
+  ##
+  # Deep duplicate
+  def deep_dup
+    inject({}) {|memo, (k, v)| memo.merge(k => v.deep_dup)}
+  end
 end
 
 ##
@@ -191,7 +251,7 @@ module RDF::Term
   # @param [Hash{Symbol => Object}] options ({})
   #   options passed from query
   # @return [RDF::Term]
-  def evaluate(bindings, options = {})
+  def evaluate(bindings, **options)
     self
   end
 
@@ -210,8 +270,33 @@ module RDF::Term
   def vars
     variable? ? [self] : []
   end
+
+  ##
+  # A duplicate of this term.
+  #
+  # @return [RDF::Term] a copy of `self`
+  # @see SPARQL::Algebra::Expression#optimize
+  def optimize(**options)
+    optimized = self.deep_dup
+    optimized.lexical = nil if optimized.respond_to?(:lexical=)
+    optimized
+  end
 end # RDF::Term
 
+class RDF::Literal::Double
+  ##
+  # Returns the SXP representation of this object.
+  #
+  # @return [String]
+  def to_sxp
+    case
+      when nan? then 'nan.0'
+      when infinite? then (infinite? > 0 ? '+inf.0' : '-inf.0')
+      else canonicalize.to_s.downcase
+    end
+  end
+end
+
 # Override RDF::Queryable to execute against SPARQL::Algebra::Query elements as well as RDF::Query and RDF::Pattern
 module RDF::Queryable
   alias_method :query_without_sparql, :query
@@ -235,7 +320,7 @@ module RDF::Queryable
   # @yieldreturn [void] ignored
   # @return [Enumerator]
   # @see    RDF::Queryable#query_pattern
-  def query(pattern, options = {}, &block)
+  def query(pattern, **options, &block)
     raise TypeError, "#{self} is not queryable" if respond_to?(:queryable?) && !queryable?
 
     if pattern.is_a?(SPARQL::Algebra::Operator) && pattern.respond_to?(:execute)
@@ -243,7 +328,7 @@ module RDF::Queryable
       solutions = if method(:query_execute).arity == 1
         query_execute(pattern, &block)
       else
-        query_execute(pattern, options, &block)
+        query_execute(pattern, **options, &block)
       end
       after_query(pattern) if respond_to?(:after_query)
 
@@ -252,25 +337,45 @@ module RDF::Queryable
         solutions
       else
         # Return an enumerator
-        enum_for(:query, pattern, options)
+        enum_for(:query, pattern, **options)
       end
     else
-      query_without_sparql(pattern, options, &block)
+      query_without_sparql(pattern, **options, &block)
     end
   end
-  
 end
 
 class RDF::Statement
   # Transform Statement Pattern into an SXP
   # @return [Array]
   def to_sxp_bin
-    if has_graph?
-      [:quad, subject, predicate, object, graph_name]
-    else
-      [:triple, subject, predicate, object]
-    end
+    [ (has_graph? ? :quad : :triple),
+      (:inferred if inferred?),
+      subject,
+      predicate,
+      object,
+      graph_name
+    ].compact.map(&:to_sxp_bin)
   end
+
+  ##
+  # Returns an S-Expression (SXP) representation
+  #
+  # @return [String]
+  def to_sxp
+    to_sxp_bin.to_sxp
+  end
+
+  ##
+  # A duplicate of this Statement.
+  #
+  # @return [RDF::Statement] a copy of `self`
+  # @see SPARQL::Algebra::Expression#optimize
+  def optimize(**options)
+    self.dup
+  end
+
+  def executable?; false; end
 end
 
 class RDF::Query
@@ -306,6 +411,16 @@ class RDF::Query
     end
   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)
+    patterns.each {|p| p.bind(solution)}
+    self
+  end
+
   # Query results in a boolean result (e.g., ASK)
   # @return [Boolean]
   def query_yields_boolean?
@@ -338,25 +453,34 @@ class RDF::Query
     variables.values
   end
 
+  alias_method :optimize_without_expression!, :optimize!
   ##
-  # Returns `true` if this is executable (i.e., contains a graph patterns), `false`
-  # otherwise.
+  # Optimize the query, removing lexical shortcuts in URIs
   #
-  # @return [Boolean] `true` or `false`
+  # @return [self]
+  # @see SPARQL::Algebra::Expression#optimize!
+  def optimize!(**options)
+    @patterns = @patterns.map do |pattern|
+      components = pattern.to_quad.map do |term|
+        if term.respond_to?(:lexical=)
+          term.dup.instance_eval {@lexical = nil; self}
+        else
+          term
+        end
+      end
+      RDF::Query::Pattern.from(components, **pattern.options)
+    end
+    self.optimize_without_expression!(**options)
+  end
+
+  ##
+  # Returns `true` as this is executable.
+  #
+  # @return [Boolean] `true`
   def executable?; true; end
 end
 
 class RDF::Query::Pattern
-  # Transform Query Pattern into an SXP
-  # @return [Array]
-  def to_sxp_bin
-    if has_graph?
-      [:quad, subject, predicate, object, graph_name]
-    else
-      [:triple, subject, predicate, object]
-    end
-  end
-
   ##
   # Return the non-destinguished variables contained within this pattern
   # @return [Array<RDF::Query::Variable>]
@@ -370,6 +494,12 @@ class RDF::Query::Pattern
   def vars
     variables.values
   end
+
+  ##
+  # Returns `true` as this is executable.
+  #
+  # @return [Boolean] `true`
+  def executable?; true; end
 end
 
 ##
@@ -386,14 +516,18 @@ class RDF::Query::Variable
   #   options passed from query
   # @return [RDF::Term] the value of this variable
   # @raise [TypeError] if the variable is not bound
-  def evaluate(bindings, options = {})
+  def evaluate(bindings, **options)
     raise TypeError if bindings.respond_to?(:bound?) && !bindings.bound?(self)
     bindings[name.to_sym]
   end
 
-  def to_s
-    prefix = distinguished? || name.to_s[0,1] == '.' ? '?' : "??"
-    unbound? ? "#{prefix}#{name}" : "#{prefix}#{name}=#{value}"
+  ##
+  # Return self
+  #
+  # @return [RDF::Query::Variable] a copy of `self`
+  # @see SPARQL::Algebra::Expression#optimize
+  def optimize(**options)
+    self
   end
 end # RDF::Query::Variable
 
@@ -424,3 +558,16 @@ class RDF::Query::Solutions
   end
   alias_method :filter!, :filter
 end # RDF::Query::Solutions
+
+##
+# Extensions for `RDF::Query::Solution`.
+class RDF::Query::Solution
+  ##
+  # Returns the SXP representation of this object, defaults to `self`.
+  #
+  # @return [String]
+  def to_sxp_bin
+    to_a.to_sxp_bin
+  end
+  def to_sxp; to_sxp_bin; end
+end # RDF::Query::Solution

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,15 +329,15 @@ 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
     #   @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 +355,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 +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
@@ -724,7 +745,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 +764,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 +785,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 +808,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 +833,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