sparql 1.0.6 → 1.0.7

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

@@ -0,0 +1,31 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL logical `minutes` operator.
+    #
+    # @example
+    #     (prefix ((: <http://example.org/>))
+    #       (project (?s ?x)
+    #         (extend ((?x (minutes ?date)))
+    #           (bgp (triple ?s :date ?date)))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-minutes
+    class Minutes < Operator::Unary
+      include Evaluatable
+
+      NAME = :minutes
+
+      ##
+      # Returns the minutes part of arg as an integer.
+      #
+      # @param  [RDF::Literal] operand
+      #   the operand
+      # @return [RDF::Literal]
+      # @raise  [TypeError] if the operand is not a simple literal
+      def apply(operand)
+        raise TypeError, "expected an RDF::Literal::DateTime, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::DateTime)
+        RDF::Literal(operand.object.minute)
+      end
+    end # Minutes
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,31 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL logical `month` operator.
+    #
+    # @example
+    #     (prefix ((: <http://example.org/>))
+    #       (project (?s ?x)
+    #         (extend ((?x (month ?date)))
+    #           (bgp (triple ?s :date ?date)))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-month
+    class Month < Operator::Unary
+      include Evaluatable
+
+      NAME = :month
+
+      ##
+      # Returns the month part of arg as an integer.
+      #
+      # @param  [RDF::Literal] operand
+      #   the operand
+      # @return [RDF::Literal]
+      # @raise  [TypeError] if the operand is not a simple literal
+      def apply(operand)
+        raise TypeError, "expected an RDF::Literal::DateTime, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::DateTime)
+        RDF::Literal(operand.object.month)
+      end
+    end # Month
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -4,8 +4,8 @@ module SPARQL; module Algebra
     # The SPARQL logical `not` operator.
     #
     # @example
-    #   (! ?x ?y)
-    #   (not ?x ?y)
+    #   (! ?x)
+    #   (not ?x)
     #
     # @see http://www.w3.org/TR/xpath-functions/#func-not
     class Not < Operator::Unary

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

@@ -0,0 +1,70 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL GraphPattern `in` operator.
+    #
+    # Used for filters with more than one expression.
+    #
+    # @example
+    #   (ask (filter (notin 2) (bgp)))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-notin
+    class NotIn < Operator
+      include Evaluatable
+
+      NAME = :notin
+
+      ##
+      # The NOT IN operator tests whether the RDF term on the left-hand side is not found in the values of list of expressions on the right-hand side. The test is done with "!=" operator, which tests for not the same value, as determined by the operator mapping.
+      # 
+      # A list of zero terms on the right-hand side is legal.
+      # 
+      # Errors in comparisons cause the NOT IN expression to raise an error if the RDF term being tested is not found to be in the list elsewhere in the list of terms.
+      # 
+      # The NOT IN operator is equivalent to the SPARQL expression:
+      # 
+      #     (lhs != expression1) && (lhs != expression2) && ...
+      #
+      # NOT IN (...) is equivalent to !(IN (...)).
+      # 
+      # @example
+      #
+      #     2 NOT IN (1, 2, 3)	false
+      #     2 NOT IN ()	true
+      #     2 NOT IN (<http://example/iri>, "str", 2.0)	false
+      #     2 NOT IN (1/0, 2)	false
+      #     2 NOT IN (2, 1/0)	false
+      #     2 NOT IN (3, 1/0)	raises an error
+      #
+      # @param  [RDF::Query::Solution, #[]] bindings
+      # @return [RDF::Literal::Boolean] `true` or `false`
+      # @raise  [TypeError] if term is not found and any operand raises an error
+      def evaluate(bindings = {})
+        lhs = operands.shift.evaluate(bindings)
+        error_found = false
+        found = operands.any? do |op|
+          begin
+            lhs == op.evaluate(bindings)
+          rescue TypeError
+            error_found = true
+          end
+        end
+        case
+        when found then RDF::Literal::FALSE
+        when error_found then raise TypeError
+        else RDF::Literal::TRUE
+        end
+      end
+
+      ##
+      # Returns an optimized version of this query.
+      #
+      # Return optimized query
+      #
+      # @return [Union, RDF::Query] `self`
+      def optimize
+        operands = operands.map(&:optimize)
+      end
+    end # Exprlist
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,29 @@
+require 'time'
+
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL logical `now` operator.
+    #
+    # @example
+    #     (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #       (ask (filter (= (datatype ?n) xsd:dateTime)
+    #         (extend ((?n (now)))
+    #           (bgp)))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-now
+    class Now < Operator::Nullary
+      include Evaluatable
+
+      NAME = :now
+
+      ##
+      # 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
+        RDF::Literal(DateTime.now)
+      end
+    end # Now
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -33,20 +33,16 @@ module SPARQL; module Algebra
           operand(0).inject(false) do |memo, op|
             debug(options) {"=> #{op.inspect}"}
             memo ||= begin
-              comp = case op
-              when RDF::Query::Variable
-                a[op.to_sym] <=> b[op.to_sym]
-              when Operator, Array
-                a_eval, b_eval = op.evaluate(a), op.evaluate(b)
-                if a_eval.nil?
-                  RDF::Literal(-1)
-                elsif b_eval.nil?
-                  RDF::Literal(1)
-                else
-                  Operator::Compare.evaluate(a_eval, b_eval)
-                end
+              a_eval = op.evaluate(a) rescue nil
+              b_eval = op.evaluate(b) rescue nil
+              comp = if a_eval.nil?
+                RDF::Literal(-1)
+              elsif b_eval.nil?
+                RDF::Literal(1)
+              elsif op.is_a?(RDF::Query::Variable)
+                a_eval <=> b_eval
               else
-                raise TypeError, "Unexpected order expression #{op.inspect}"
+                Operator::Compare.evaluate(a_eval, b_eval)
               end
               comp = -comp if op.is_a?(Operator::Desc)
               comp == 0 ? false : comp

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

@@ -0,0 +1,24 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL logical `rand` operator.
+    #
+    # @example
+    #   (rand)
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#idp2130040
+    class Rand < Operator::Nullary
+      include Evaluatable
+
+      NAME = :rand
+
+      ##
+      # Returns a pseudo-random number between 0 (inclusive) and 1.0e0 (exclusive). Different numbers can be produced every time this function is invoked. Numbers should be produced with approximately equal probability.
+      #
+      # @return [RDF::Literal::Double] random value
+      def apply
+        RDF::Literal::Double.new(Random.rand)
+      end
+    end # Rand
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,81 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `replace` operator.
+    #
+    # @example
+    #     (prefix ((: <http://example.org/>)
+    #              (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #       (project (?s ?new)
+    #         (extend ((?new (replace ?str "[^a-z0-9]" "-")))
+    #           (bgp (triple ?s :str ?str)))))
+    #
+    # @see http://www.w3.org/TR/rdf-sparql-query/#funcex-replace
+    # @see http://www.w3.org/TR/xpath-functions/#func-replace
+    class Replace < Operator::Quaternary
+      include Evaluatable
+
+      NAME = :replace
+
+      ##
+      # Initializes a new operator instance.
+      #
+      # @param  [RDF::Literal] text
+      # @param  [RDF::Literal] pattern
+      # @param  [RDF::Literal] replacement
+      # @param  [RDF::Literal] flags
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional options (see {Operator#initialize})
+      # @raise  [TypeError] if any operand is invalid
+      def initialize(text, pattern, replacement, flags = RDF::Literal(''), options = {})
+        super
+      end
+
+      ##
+      # Matches `text` against a regular expression `pattern`.
+      #
+      # @param  [RDF::Literal] text a simple literal
+      # @param  [RDF::Literal] pattern a simple literal
+      # @param  [RDF::Literal] replacement
+      # @param  [RDF::Literal] flags
+      #   a simple literal (defaults to an empty string)
+      # @return [RDF::Literal] 
+      # @raise  [TypeError] if any operand is unbound
+      # @raise  [TypeError] if any operand is not a plain literal
+      def apply(text, pattern, replacement, flags = RDF::Literal(''))
+        raise TypeError, "expected a plain RDF::Literal, but got #{text.inspect}" unless text.literal? && text.plain?
+        # TODO: validate text syntax
+
+        raise TypeError, "expected a plain RDF::Literal, but got #{pattern.inspect}" unless pattern.literal? && pattern.plain?
+        pattern = pattern.to_s
+        # TODO: validate pattern syntax
+
+        raise TypeError, "expected a plain RDF::Literal, but got #{replacement.inspect}" unless replacement.literal? && replacement.plain?
+        replacement = replacement.to_s.gsub('$', '\\')  # Replace references
+        # TODO: validate flag syntax
+
+        raise TypeError, "expected a plain RDF::Literal, but got #{flags.inspect}" unless flags.literal? && flags.plain?
+        flags = flags.to_s
+        # TODO: validate flag syntax
+
+        options = 0
+        raise NotImplementedError, "unsupported regular expression flag: /s" if flags.include?(?s) # FIXME
+        options |= Regexp::MULTILINE  if flags.include?(?m)
+        options |= Regexp::IGNORECASE if flags.include?(?i)
+        options |= Regexp::EXTENDED   if flags.include?(?x)
+        RDF::Literal(text.to_s.gsub(Regexp.new(pattern, options), replacement), :datatype => text.datatype, :language => text.language)
+      end
+
+      ##
+      # Returns the SPARQL S-Expression (SSE) representation of this expression.
+      #
+      # Remove the optional argument.
+      #
+      # @return [Array] `self`
+      # @see    http://openjena.org/wiki/SSE
+      def to_sxp_bin
+        [NAME] + operands.reject {|o| o.to_s == ""}
+      end
+    end # Replace
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,31 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL logical `round` operator.
+    #
+    # @example
+    #   (round ?x)
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-round
+    # @see http://www.w3.org/TR/xpath-functions/#func-round
+    class Round < Operator::Unary
+      include Evaluatable
+
+      NAME = [:round]
+
+      ##
+      # Returns the number with no fractional part that is closest to the argument. If there are two such numbers, then the one that is closest to positive infinity is returned. An error is raised if arg is not a numeric value.
+      #
+      # @param  [RDF::Literal] operand
+      #   the operand
+      # @return [RDF::Literal] literal of same type
+      # @raise  [TypeError] if the operand is not a numeric value
+      def apply(operand)
+        case operand
+          when RDF::Literal::Numeric then operand.round
+          else raise TypeError, "expected an RDF::Literal::Numeric, but got #{operand.inspect}"
+        end
+      end
+    end # Round
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,31 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL logical `seconds` operator.
+    #
+    # @example
+    #     (prefix ((: <http://example.org/>))
+    #       (project (?s ?x)
+    #         (extend ((?x (seconds ?date)))
+    #           (bgp (triple ?s :date ?date)))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-seconds
+    class Seconds < Operator::Unary
+      include Evaluatable
+
+      NAME = :seconds
+
+      ##
+      # Returns the seconds part of arg as an integer.
+      #
+      # @param  [RDF::Literal] operand
+      #   the operand
+      # @return [RDF::Literal]
+      # @raise  [TypeError] if the operand is not a simple literal
+      def apply(operand)
+        raise TypeError, "expected an RDF::Literal::DateTime, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::DateTime)
+        RDF::Literal(operand.object.second)
+      end
+    end # Seconds
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,34 @@
+require 'digest'
+
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL logical `sha1` operator.
+    #
+    # @example
+    #     (prefix ((: <http://example.org/>))
+    #       (project (?hash)
+    #         (extend ((?hash (sha1 ?l)))
+    #           (bgp (triple :s1 :str ?l)))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-sha1
+    class SHA1 < Operator::Unary
+      include Evaluatable
+
+      NAME = :sha1
+
+      ##
+      # Returns the SHA1 checksum, as a hex digit string, calculated on the UTF-8 representation of the simple literal or lexical form of the xsd:string. Hex digits should be in lower case.
+      #
+      # @param  [RDF::Literal] operand
+      #   the operand
+      # @return [RDF::Literal]
+      # @raise  [TypeError] if the operand is not a simple literal
+      def apply(operand)
+        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::SHA1.new.hexdigest(operand.to_s))
+      end
+    end # SHA1
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,34 @@
+require 'digest'
+
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL logical `sha256` operator.
+    #
+    # @example
+    #     (prefix ((: <http://example.org/>))
+    #       (project (?hash)
+    #         (extend ((?hash (sha256 ?l)))
+    #           (bgp (triple :s1 :str ?l)))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-sha256
+    class SHA256 < Operator::Unary
+      include Evaluatable
+
+      NAME = :sha256
+
+      ##
+      # Returns the SHA256 checksum, as a hex digit string, calculated on the UTF-8 representation of the simple literal or lexical form of the xsd:string. Hex digits should be in lower case.
+      #
+      # @param  [RDF::Literal] operand
+      #   the operand
+      # @return [RDF::Literal]
+      # @raise  [TypeError] if the operand is not a simple literal
+      def apply(operand)
+        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::SHA256.new.hexdigest(operand.to_s))
+      end
+    end # SHA256
+  end # Operator
+end; end # SPARQL::Algebra