sparql 3.1.4 → 3.1.8

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, options = {}, &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

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

@@ -24,8 +24,9 @@ module SPARQL; module Algebra
       #   a literal
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is not a literal
-      def apply(left, right)
-        super
+      def apply(left, right, **options)
+        #require 'byebug'; byebug if super == RDF::Literal(1)
+        RDF::Literal(super == RDF::Literal(1))
       end
     end # GreaterThan
   end # Operator

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

@@ -25,8 +25,8 @@ module SPARQL; module Algebra
       #   a literal
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is not a literal
-      def apply(left, right)
-        super
+      def apply(left, right, **options)
+        RDF::Literal(super >= RDF::Literal(0))
       end
     end # GreaterThanOrEqual
   end # Operator

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

@@ -50,7 +50,7 @@ module SPARQL; module Algebra
       #   enum of evaluated operand
       # @return [RDF::Term] An arbitrary term
       # @raise  [TypeError] If enum is empty
-      def apply(enum, separator)
+      def apply(enum, separator, **options)
         RDF::Literal(enum.flatten.map(&:to_s).join(separator.to_s))
       end
     end # GroupConcat

data/lib/sparql/algebra/operator/hours.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.hour)
       end

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

@@ -29,7 +29,7 @@ module SPARQL; module Algebra
       #   a simple literal
       # @return [RDF::URI]
       # @raise  [TypeError] if the operand is not a simple literal
-      def apply(literal)
+      def apply(literal, **options)
         raise TypeError, "expected an simple literal, but got #{literal.inspect}" unless literal.literal? && literal.simple?
         base = Operator.base_uri || RDF::URI("")
         base.join(literal.to_s)

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

@@ -23,7 +23,7 @@ module SPARQL; module Algebra
       #   an RDF term
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operand is not an RDF term
-      def apply(term)
+      def apply(term, **options)
         case term
           when RDF::Node then RDF::Literal::TRUE
           when RDF::Term then RDF::Literal::FALSE

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

@@ -23,7 +23,7 @@ module SPARQL; module Algebra
       #   an RDF term
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operand is not an RDF term
-      def apply(term)
+      def apply(term, **options)
         case term
           when RDF::URI  then RDF::Literal::TRUE
           when RDF::Term then RDF::Literal::FALSE

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

@@ -24,7 +24,7 @@ module SPARQL; module Algebra
       #   an RDF term
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operand is not an RDF term
-      def apply(term)
+      def apply(term, **options)
         case term
           when RDF::Literal then RDF::Literal::TRUE
           when RDF::Term    then RDF::Literal::FALSE

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

@@ -26,7 +26,7 @@ module SPARQL; module Algebra
       #   an RDF term
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operand is not an RDF term
-      def apply(term)
+      def apply(term, **options)
         case term
           when RDF::Literal::NonPositiveInteger then RDF::Literal::FALSE
           when RDF::Literal::NonNegativeInteger then RDF::Literal::FALSE

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

@@ -0,0 +1,30 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `isTRIPLE` operator.
+    #
+    # Returns true if term is an RDF-star triple. Returns false otherwise.
+    #
+    # @see https://w3c.github.io/rdf-star/rdf-star-cg-spec.html#istriple
+    class IsTriple < Operator::Unary
+      include Evaluatable
+
+      NAME = :isTRIPLE
+
+      ##
+      # Returns `true` if the operand is an `RDF::Statement`, `false` otherwise.
+      #
+      # @param  [RDF::Term] term
+      #   an RDF term
+      # @return [RDF::Literal::Boolean] `true` or `false`
+      # @raise  [TypeError] if the operand is not an RDF term
+      def apply(term, **options)
+        case term
+          when RDF::Statement  then RDF::Literal::TRUE
+          when RDF::Term then RDF::Literal::FALSE
+          else raise TypeError, "expected an RDF::Term, but got #{term.inspect}"
+        end
+      end
+    end # IsTriple
+  end # Operator
+end; end # SPARQL::Algebra

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

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

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

@@ -27,7 +27,7 @@ module SPARQL; module Algebra
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is unbound
       # @raise  [TypeError] if either operand is not a simple literal
-      def apply(language_tag, language_range)
+      def apply(language_tag, language_range, **options)
         raise TypeError, "expected a plain RDF::Literal for language_tag, but got #{language_tag.inspect}" unless language_tag.is_a?(RDF::Literal) && language_tag.simple?
         language_tag = language_tag.to_s.downcase
 

data/lib/sparql/algebra/operator/lcase.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 literal value
-      def apply(operand)
+      def apply(operand, **options)
         case operand
           when RDF::Literal then RDF::Literal(operand.to_s.downcase, datatype: operand.datatype, language: operand.language)
           else raise TypeError, "expected an RDF::Literal::Numeric, but got #{operand.inspect}"

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

@@ -37,6 +37,10 @@ module SPARQL; module Algebra
       def execute(queryable, **options, &block)
         filter = operand(2)
 
+        raise ArgumentError,
+          "leftjoin operator accepts at most two arguments with an optional filter" if
+          operands.length < 2 || operands.length > 3
+
         debug(options) {"LeftJoin"}
         left = queryable.query(operand(0), depth: options[:depth].to_i + 1, **options)
         debug(options) {"=>(leftjoin left) #{left.inspect}"}

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

@@ -24,8 +24,9 @@ module SPARQL; module Algebra
       #   a literal
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is not a literal
-      def apply(left, right)
-        super
+      def apply(left, right, **options)
+        #require 'byebug'; byebug if super == RDF::Literal(-1)
+        RDF::Literal(super == RDF::Literal(-1))
       end
     end # LessThan
   end # Operator

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

@@ -24,8 +24,8 @@ module SPARQL; module Algebra
       #   a literal
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is not a literal
-      def apply(left, right)
-        super
+      def apply(left, right, **options)
+        RDF::Literal(super <= RDF::Literal(0))
       end
     end # LessThanOrEqual
   end # Operator

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

@@ -16,6 +16,13 @@ module SPARQL; module Algebra
 
       NAME = :max
 
+      def initialize(*operands, **options)
+        raise ArgumentError,
+          "max operator accepts at most one argument with an optional :distinct" if
+          (operands - %i{distinct}).length != 1
+        super
+      end
+
       ##
       # Max is a SPARQL set function that return the maximum value from a group respectively.
       #
@@ -24,7 +31,7 @@ module SPARQL; module Algebra
       # @param  [Enumerable<Array<RDF::Term>>] enum
       #   enum of evaluated operand
       # @return [RDF::Literal] The maximum value 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/md5.rb

@@ -26,7 +26,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, but got #{operand.inspect}" unless operand.literal?
         raise TypeError, "expected simple literal or xsd:string, but got #{operand.inspect}" unless (operand.datatype || RDF::XSD.string) == RDF::XSD.string
         RDF::Literal(Digest::MD5.new.hexdigest(operand.to_s))

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

@@ -16,6 +16,13 @@ module SPARQL; module Algebra
 
       NAME = :min
 
+      def initialize(*operands, **options)
+        raise ArgumentError,
+          "min operator accepts at most one argument with an optional :distinct" if
+          (operands - %i{distinct}).length != 1
+        super
+      end
+
       ##
       # Min is a SPARQL set function that return the minimum value from a group respectively.
       #
@@ -24,7 +31,7 @@ module SPARQL; module Algebra
       # @param  [Enumerable<Array<RDF::Term>>] enum
       #   enum of evaluated operand
       # @return [RDF::Literal] The maximum value 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/minutes.rb

@@ -24,7 +24,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.minute)
       end

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

@@ -24,7 +24,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.month)
       end

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

@@ -22,7 +22,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)
             left * right

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

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

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

@@ -23,7 +23,7 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operand could not be coerced to a boolean literal
-      def apply(operand)
+      def apply(operand, **options)
         case bool = boolean(operand)
           when RDF::Literal::Boolean
             RDF::Literal(bool.false?)

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

@@ -12,13 +12,15 @@ module SPARQL; module Algebra
       # Returns `true` if the operands are not equal; returns `false`
       # otherwise.
       #
+      # Comparing unknown datatypes might have different lexical forms but be the same value.
+      #
       # @param  [RDF::Term] term1
       #   an RDF term
       # @param  [RDF::Term] term2
       #   an RDF term
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is not an RDF term
-      def apply(term1, term2)
+      def apply(term1, term2, **options)
         RDF::Literal(super.false?)
       end
     end # NotEqual

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

@@ -23,7 +23,7 @@ module SPARQL; module Algebra
       # Returns an XSD dateTime value for the current query execution. All calls to this function in any one query execution must return the same value. The exact moment returned is not specified.
       #
       # @return [RDF::Literal::Double] random value
-      def apply
+      def apply(**options)
         RDF::Literal(DateTime.now)
       end
     end # Now

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

@@ -0,0 +1,27 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `OBJECT` operator.
+    #
+    # If triple is an RDF-star triple, the function returns the object of this triple. Passing anything other than an RDF-star triple is an error.
+    #
+    # @see https://w3c.github.io/rdf-star/rdf-star-cg-spec.html#object
+    class Object < Operator::Unary
+      include Evaluatable
+
+      NAME = :object
+
+      ##
+      # Returns the object part of arg.
+      #
+      # @param  [RDF::Statement] operand
+      #   the operand
+      # @return [RDF::Literal]
+      # @raise  [TypeError] if the operand is not a statement
+      def apply(operand, **options)
+        raise TypeError, "expected an RDF::Statement, but got #{operand.inspect}" unless operand.is_a?(RDF::Statement)
+        operand.object
+      end
+    end # Object
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -40,7 +40,13 @@ module SPARQL; module Algebra
             memo = begin
               a_eval = op.evaluate(a, queryable: queryable, depth: options[:depth].to_i + 1, **options) rescue nil
               b_eval = op.evaluate(b, queryable: queryable, depth: options[:depth].to_i + 1, **options) rescue nil
-              comp = Operator::Compare.evaluate(a_eval, b_eval).to_i
+              comp = begin
+                Operator::Compare.evaluate(a_eval, b_eval, order_by: true).to_s.to_i
+              rescue TypeError
+                # Type sError is effectively zero
+                debug(options) {"(order) rescue(#{$!}): #{a_eval.inspect}, #{b_eval.inspect}"}
+                RDF::Literal(0)
+              end
               comp = -comp if op.is_a?(Operator::Desc)
               comp
             end if memo == 0

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

@@ -23,7 +23,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 = nil)
+      def apply(left, right = nil, **options)
         case
         when left.is_a?(RDF::Literal::Numeric) && right.is_a?(RDF::Literal::Numeric)
           left + right

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

@@ -0,0 +1,27 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `PREDICATE` operator.
+    #
+    # If triple is an RDF-star triple, the function returns the predicate of this triple. Passing anything other than an RDF-star triple is an error.
+    #
+    # @see https://w3c.github.io/rdf-star/rdf-star-cg-spec.html#predicate
+    class Predicate < Operator::Unary
+      include Evaluatable
+
+      NAME = :predicate
+
+      ##
+      # Returns the predicate part of arg.
+      #
+      # @param  [RDF::Statement] operand
+      #   the operand
+      # @return [RDF::Literal]
+      # @raise  [TypeError] if the operand is not a statement
+      def apply(operand, **options)
+        raise TypeError, "expected an RDF::Statement, but got #{operand.inspect}" unless operand.is_a?(RDF::Statement)
+        operand.predicate
+      end
+    end # Predicate
+  end # Operator
+end; end # SPARQL::Algebra