sparql 3.1.2 → 3.1.7

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'
@@ -294,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
@@ -302,8 +314,8 @@ module SPARQL; module Algebra
     # @param  [Array<RDF::Term>] operands
     # @return [RDF::Term]
     # @see    Operator#evaluate
-    def self.evaluate(*operands)
-      self.new(*operands).evaluate(RDF::Query::Solution.new)
+    def self.evaluate(*operands, **options)
+      self.new(*operands, **options).evaluate(RDF::Query::Solution.new, **options)
     end
 
     ##
@@ -336,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
@@ -358,7 +370,7 @@ module SPARQL; module Algebra
     ##
     # Deep duplicate operands
     def deep_dup
-      self.class.new(*operands.map(&:deep_dup))
+      self.class.new(*operands.map(&:deep_dup), **@options)
     end
 
     ##
@@ -571,13 +583,6 @@ module SPARQL; module Algebra
     #
     # @return [String]
     def to_sxp
-      begin
-        require 'sxp' # @see https://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
 
@@ -752,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
@@ -771,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
@@ -792,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
@@ -815,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
@@ -840,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

@@ -20,7 +20,7 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal] literal of same type
       # @raise  [TypeError] if the operand is not a numeric value
-      def apply(operand)
+      def apply(operand, **options)
         case operand
           when RDF::Literal::Numeric then operand.abs
           else raise TypeError, "expected an RDF::Literal::Numeric, but got #{operand.inspect}"

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

@@ -16,13 +16,20 @@ module SPARQL; module Algebra
 
       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.
       #
       # @param  [Enumerable<Array<RDF::Term>>] enum
       #   enum of evaluated operand
       # @return [RDF::Literal::Numeric] The numeric average of the terms
-      def apply(enum)
+      def apply(enum, **options)
         # FIXME: we don't actually do anything with distinct
         operands.shift if distinct = (operands.first == :distinct)
         if enum.empty?

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

@@ -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

@@ -57,7 +57,7 @@ module SPARQL; module Algebra
       #   a query solution containing zero or more variable bindings
       # @return [RDF::Node] 
       # @raise  [TypeError] if the operand is not a simple literal or nil
-      def apply(literal, bindings)
+      def apply(literal, bindings, **options)
         @@bnode_base ||= "b0"
         @@bindings ||= bindings
         @@bnodes ||= {}

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

@@ -20,7 +20,7 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal] literal of same type
       # @raise  [TypeError] if the operand is not a numeric value
-      def apply(operand)
+      def apply(operand, **options)
         case operand
           when RDF::Literal::Numeric then operand.ceil
           else raise TypeError, "expected an RDF::Literal::Numeric, but got #{operand.inspect}"

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

@@ -30,62 +30,68 @@ module SPARQL; module Algebra
       # @param  [RDF::Literal] right
       #   a literal
       # @return [RDF::Literal::Integer] `-1`, `0`, or `1`
-      # @raise  [TypeError] if either operand is not a literal
-      def apply(left, right)
+      # @raise  [TypeError] if either operand is not a term
+      def apply(left, right, **options)
+        RDF::Literal(spaceship(left, right, **options))
+      end
+
+    private
+      # Define <=> as private for recursive statements
+      def spaceship(left, right, **options)
         case
         # @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 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)
-            RDF::Literal(left.send(self.class.const_get(:NAME), right))
-
-          # A plain literal is lower than an RDF literal with type xsd:string of the same lexical form.
-          when left.simple? && right.datatype == RDF::XSD.string && left.value == right.value
-            RDF::Literal(-1)
-          when right.simple? && left.datatype == RDF::XSD.string && right.value == left.value
-            RDF::Literal(-1)
-
-          else
-            left <=> right
-          end
-          
+          left <=> right
         when left.is_a?(RDF::URI) && right.is_a?(RDF::URI)
+          raise TypeError, "Comparing IRIs not supported" unless options[:order_by] || left == right
           # Pairs of IRIs are ordered by comparing them as simple literals.
-          RDF::Literal(RDF::Literal(left.to_s).send(self.class.const_get(:NAME), RDF::Literal(right.to_s)))
+          left.to_s <=> right.to_s
         when left.is_a?(RDF::Node) && right.is_a?(RDF::Node)
+          raise TypeError, "Comparing Blank nodes not supported" unless options[:order_by] || left == right
           # BNode comparison is undefined.
-          RDF::Literal(0)
+          left == right ? 0 : 1
         when left.nil? && right.nil?
-          RDF::Literal(0)
-        
+          0
+
+        when left.is_a?(RDF::Statement) && right.is_a?(RDF::Statement)
+          v = spaceship(left.subject, right.subject, **options)
+          v = spaceship(left.predicate, right.predicate, **options) if v == 0
+          v = spaceship(left.object, right.object, **options) if v == 0
+          v
+        when left.is_a?(RDF::Statement) && right.is_a?(RDF::Term)
+          raise TypeError, "Comparing statement with #{right.inspect}" unless options[:order_by]
+          1
+        when right.is_a?(RDF::Statement) && left.is_a?(RDF::Term)
+          raise TypeError, "Comparing statement with #{left.inspect}" unless options[:order_by]
+          -1
+
         # SPARQL also fixes an order between some kinds of RDF terms that would not otherwise be ordered:
 
         when left.nil? && !right.nil?
-          RDF::Literal(-1)
+          -1
         when right.nil?
-          RDF::Literal(1)
+          1
 
         when left.is_a?(RDF::Node) && right.is_a?(RDF::Term)
-          RDF::Literal(-1)
+          raise TypeError, "Comparing Blank nodes not supported" unless options[:order_by]
+          # Nodes lower than other terms
+          -1
         when right.is_a?(RDF::Node) && left.is_a?(RDF::Term)
-          RDF::Literal(1)
-
-        when left.is_a?(RDF::Node) && right.is_a?(RDF::URI)
-          RDF::Literal(-1)
-        when right.is_a?(RDF::Node) && left.is_a?(RDF::URI)
-          RDF::Literal(1)
+          raise TypeError, "Comparing Blank nodes not supported" unless options[:order_by]
+          1
 
         when left.is_a?(RDF::URI) && right.is_a?(RDF::Term)
-          RDF::Literal(-1)
+          raise TypeError, "Comparing IRIs not supported" unless options[:order_by]
+          # IRIs lower than terms other than nodes
+          -1
         when right.is_a?(RDF::URI) && left.is_a?(RDF::Term)
-          RDF::Literal(1)
+          raise TypeError, "Comparing IRIs not supported" unless options[:order_by]
+          1
         else raise TypeError, "expected two RDF::Term operands, but got #{left.inspect} and #{right.inspect}"
         end
       end

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

@@ -52,10 +52,11 @@ module SPARQL; module Algebra
               terms[r] = case o = pattern.send(r)
               when RDF::Node            then nodes[o] ||= RDF::Node.new
               when RDF::Query::Variable then solution[o]
+              when RDF::Query::Pattern  then RDF::Statement.from(o.dup.bind(solution))
               else                           o
               end
             end
-            
+
             statement = RDF::Statement.from(terms)
 
             # Sanity checking on statement

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

@@ -31,7 +31,7 @@ module SPARQL; module Algebra
       #   a literal
       # @return [RDF::Literal::Boolean]
       # @raise  [TypeError] if operands are not compatible
-      def apply(left, right)
+      def apply(left, right, **options)
         case
         when !left.compatible?(right)
           raise TypeError, "expected two RDF::Literal operands, but got #{left.inspect} and #{right.inspect}"

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

@@ -22,7 +22,7 @@ module SPARQL; module Algebra
       # @param  [Enumerable<Array<RDF::Term>>] enum
       #   enum of evaluated operand
       # @return [RDF::Literal::Integer] The number of non-error terms in the multiset
-      def apply(enum)
+      def apply(enum, **options)
         RDF::Literal(enum.length)
       end
     end # Count

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

@@ -141,7 +141,7 @@ module SPARQL; module Algebra
             debug(options) {"=> default data source #{uri}"}
             default_datasets << uri
           end
-          load_opts = {debug: options.fetch(:debug, nil), graph_name: uri, base_uri: uri}
+          load_opts = {logger: options.fetch(:logger, false), graph_name: uri, base_uri: uri}
           unless queryable.has_graph?(uri)
             debug(options) {"=> load #{uri}"}
             queryable.load(uri.to_s, **load_opts)

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

@@ -27,7 +27,7 @@ module SPARQL; module Algebra
       #   a typed or simple literal
       # @return [RDF::URI] the datatype IRI, or `xsd:string` for simple literals
       # @raise  [TypeError] if the operand is not a typed or simple literal
-      def apply(literal)
+      def apply(literal, **options)
         case literal
           when RDF::Literal then literal.datatype
           else raise TypeError, "expected an RDF::Literal, but got #{literal.inspect}"

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

@@ -22,7 +22,7 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal]
       # @raise  [TypeError] if the operand is not a simple literal
-      def apply(operand)
+      def apply(operand, **options)
         raise TypeError, "expected an RDF::Literal::DateTime, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::DateTime)
         RDF::Literal(operand.object.day)
       end

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

@@ -32,7 +32,7 @@ module SPARQL; module Algebra
       #   If `from` does not exist, unless the `silent` operator is present
       # @see    https://www.w3.org/TR/sparql11-update/
       def execute(queryable, solutions: nil, **options)
-        debug(options) {"Delete: #{solution} against #{operands.to_sse}"}
+        debug(options) {"Delete: #{solutions} against #{operands.to_sse}"}
         # Only binds the first solution
         solution = solutions.is_a?(RDF::Query::Solutions) ? solutions.first : solutions
         # Operands are an array of patterns and Queries (when named).
@@ -47,7 +47,7 @@ module SPARQL; module Algebra
         end
         patterns.each do |pattern|
           pattern = pattern.dup.bind(solution)
-          debug(options) {"Delete statement #{statement.to_sse}"}
+          debug(options) {"Delete pattern #{pattern.to_sse}"}
           queryable.delete(RDF::Statement.from(pattern)) if pattern.bound? || pattern.constant?
         end
         queryable

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

@@ -46,7 +46,7 @@ module SPARQL; module Algebra
           debug(options) {"DeleteWhere solution #{solution.to_sse}"}
           query.each_statement do |pattern|
             pattern = pattern.dup.bind(solution)
-            debug(options) {"DeleteWhere statement #{statement.to_sse}"}
+            debug(options) {"DeleteWhere pattern #{pattern.to_sse}"}
             queryable.delete(RDF::Statement.from(pattern)) if pattern.bound? || pattern.constant?
           end
         end

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

@@ -21,7 +21,7 @@ module SPARQL; module Algebra
       #   a numeric literal
       # @return [RDF::Literal::Numeric]
       # @raise  [TypeError] if either operand is not a numeric literal
-      def apply(left, right)
+      def apply(left, right, **options)
         case
           when left.is_a?(RDF::Literal::Numeric) && right.is_a?(RDF::Literal::Numeric)
             # For xsd:decimal and xsd:integer operands, if the divisor is

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

@@ -27,7 +27,7 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal] literal of same type
       # @raise  [TypeError] if the operand is not a literal value
-      def apply(operand)
+      def apply(operand, **options)
         case operand
           when RDF::Literal then RDF::Literal(CGI.escape(operand.to_s))
           else raise TypeError, "expected an RDF::Literal, but got #{operand.inspect}"

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

@@ -26,7 +26,7 @@ module SPARQL; module Algebra
       # @raise  [TypeError] if either operand is not an RDF term or operands are not comperable
       #
       # @see RDF::Term#==
-      def apply(term1, term2)
+      def apply(term1, term2, **options)
         term1 = term1.dup.extend(RDF::TypeCheck)
         term2 = term2.dup.extend(RDF::TypeCheck)
         RDF::Literal(term1 == term2)

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

@@ -28,12 +28,6 @@ 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
@@ -56,12 +50,8 @@ module SPARQL; module Algebra
                                             depth: options[:depth].to_i + 1,
                                             **options)
               debug(options) {"===> + #{var} => #{val.inspect}"}
-              solution.bindings[var.to_sym] = if val.is_a?(RDF::Query::Pattern)
-                # Variable is bound to the solution
-                val.bind(solution)
-              else
-                val
-              end
+              val = val.dup.bind(solution) if val.is_a?(RDF::Query::Pattern)
+              solution.bindings[var.to_sym] = val
             rescue TypeError => e
               # Evaluates to error, ignore
               debug(options) {"===> #{var} error: #{e.message}"}

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

@@ -24,7 +24,7 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal] literal of same type
       # @raise  [TypeError] if the operand is not a numeric value
-      def apply(operand)
+      def apply(operand, **options)
         case operand
           when RDF::Literal::Numeric then operand.floor
           else raise TypeError, "expected an RDF::Literal::Numeric, but got #{operand.inspect}"

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

@@ -36,7 +36,7 @@ module SPARQL; module Algebra
       #   @param [Array<RDF::Query::Pattern>] patterns
       #     Quads
       # @return [RDF::Query]
-      def self.new(name, patterns, &block)
+      def self.new(name, patterns, **options, &block)
         case patterns
         when RDF::Query
           # Record that the argument as a (bgp) for re-serialization back to SSE