sparql 1.0.6 → 1.0.7

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

@@ -0,0 +1,38 @@
+require 'uri'
+
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL logical `abs` operator.
+    #
+    # @example
+    #   (encode_for_uri ?x)
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-encode
+    # @see http://www.w3.org/TR/xpath-functions/#func-abs
+    class EncodeForURI < Operator::Unary
+      include Evaluatable
+
+      NAME = :encode_for_uri
+
+      ##
+      # The ENCODE_FOR_URI function corresponds to the XPath fn:encode-for-uri function. It returns a simple literal with the lexical form obtained from the lexical form of its input after translating reserved characters according to the fn:encode-for-uri function.
+      #
+      # @example
+      #     encode_for_uri("Los Angeles")	"Los%20Angeles"
+      #     encode_for_uri("Los Angeles"@en)	"Los%20Angeles"
+      #     encode_for_uri("Los Angeles"^^xsd:string)	"Los%20Angeles"
+      #
+      # @param  [RDF::Literal] operand
+      #   the operand
+      # @return [RDF::Literal] literal of same type
+      # @raise  [TypeError] if the operand is not a literal value
+      def apply(operand)
+        case operand
+          when RDF::Literal then RDF::Literal(::URI.encode(operand.to_s))
+          else raise TypeError, "expected an RDF::Literal, but got #{operand.inspect}"
+        end
+      end
+    end # EncodeForURI
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -1,7 +1,9 @@
 module SPARQL; module Algebra
   class Operator
     ##
-    # The SPARQL Bind `extend` operator.
+    # The SPARQL `Extend` operator.
+    #
+    # Extends a solution
     #
     # @example
     #   (select (?z)
@@ -16,8 +18,35 @@ module SPARQL; module Algebra
       NAME = [:extend]
 
       ##
-      # FIXME
+      # Let μ be a solution mapping, Ω a multiset of solution mappings, var a variable and expr be an expression, then we define:
+      # 
+      # Extend(μ, var, expr) = μ ∪ { (var,value) | var not in dom(μ) and value = expr(μ) }
+      # 
+      # Extend(μ, var, expr) = μ if var not in dom(μ) and expr(μ) is an error
+      # 
+      # Extend is undefined when var in dom(μ).
+      # 
+      # Extend(Ω, var, expr) = { Extend(μ, var, expr) | μ in Ω }
+      # @return [RDF::Query::Solutions]
+      #   the resulting solution sequence
+      # @see http://www.w3.org/TR/rdf-sparql-query/#evaluation
       def execute(queryable, options = {})
+        debug(options) {"Extend"}
+        @solutions = operands.last.execute(queryable, options.merge(:depth => options[:depth].to_i + 1))
+        @solutions.each do |solution|
+          debug(options) {"===> soln #{solution.to_hash.inspect}"}
+          operands.first.each do |(var, expr)|
+            begin
+              val = expr.evaluate(solution)
+              debug(options) {"===> + #{var} => #{val.inspect}"}
+              solution.bindings[var.to_sym] = val
+            rescue TypeError => e
+              # Evaluates to error, ignore
+              debug(options) {"===> #{var} error: #{e.message}"}
+            end
+          end
+        end
+        @solutions
       end
       
       ##

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

@@ -0,0 +1,33 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL logical `floor` operator.
+    #
+    # @example
+    #   (floor ?x)
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-floor
+    # @see http://www.w3.org/TR/xpath-functions/#func-floor
+    class Floor < Operator::Unary
+      include Evaluatable
+
+      NAME = [:floor]
+
+      ##
+      # Returns the largest (closest to positive infinity) number with no fractional part that is not greater than the value of $arg. If type of $arg is one of the four numeric types xs:float, xs:double, xs:decimal or xs:integer the type of the result is the same as the type of $arg. If the type of $arg is a type derived from one of the numeric types, the result is an instance of the base numeric type.
+      #
+      # For float and double arguments, if the argument is positive zero, then positive zero is returned. If the argument is negative zero, then negative zero is returned.
+      #
+      # @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.floor
+          else raise TypeError, "expected an RDF::Literal::Numeric, but got #{operand.inspect}"
+        end
+      end
+    end # Floor
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,31 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL logical `hours` operator.
+    #
+    # @example
+    #     (prefix ((: <http://example.org/>))
+    #       (project (?s ?x)
+    #         (extend ((?x (hours ?date)))
+    #           (bgp (triple ?s :date ?date)))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-hours
+    class Hours < Operator::Unary
+      include Evaluatable
+
+      NAME = :hours
+
+      ##
+      # Returns the hours 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.hour)
+      end
+    end # Hours
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,55 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `if` function.
+    #
+    # @example
+    #     (base <http://example.org/>
+    #       (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #         (project (?o ?integer)
+    #           (extend ((?integer (if (= (lang ?o) "ja") true false)))
+    #             (bgp (triple ?s ?p ?o))))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-if
+    class If < Operator::Ternary
+      include Evaluatable
+      
+      NAME = :if
+
+      ##
+      # The IF function form evaluates the first argument, interprets it as a effective boolean value, then returns the value of expression2 if the EBV is true, otherwise it returns the value of expression3. Only one of expression2 and expression3 is evaluated. If evaluating the first argument raises an error, then an error is raised for the evaluation of the IF expression.
+      #
+      # @example
+      #
+      #     IF(?x = 2, "yes", "no") #=> "yes"
+      #     IF(bound(?y), "yes", "no") #=> "no"
+      #     IF(?x=2, "yes", 1/?z) #=> "yes", the expression 1/?z is not evaluated
+      #     IF(?x=1, "yes", 1/?z) #=> raises an error
+      #     IF("2" > 1, "yes", "no") #=> raises an error
+      #
+      # Evaluates the first operand and returns the evaluation of either the second or third operands
+      #
+      # @param  [RDF::Query::Solution, #[]] bindings
+      #   a query solution containing zero or more variable bindings
+      # @return [RDF::Term]
+      # @raise [TypeError]
+      def evaluate(bindings = {})
+        operand(0).evaluate(bindings) == RDF::Literal::TRUE ?
+          operand(1).evaluate(bindings) :
+          operand(2).evaluate(bindings)
+        rescue
+          raise TypeError
+      end
+      
+      ##
+      # Returns an optimized version of this query.
+      #
+      # Return optimized query
+      #
+      # @return [Union, RDF::Query] `self`
+      def optimize
+        operands = operands.map(&:optimize)
+      end
+    end # If
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,68 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL GraphPattern `in` operator.
+    #
+    # Used for filters with more than one expression.
+    #
+    # @example
+    #   (ask (filter (in 2 1 2 3) (bgp)))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-in
+    class In < Operator
+      include Evaluatable
+
+      NAME = :in
+
+      ##
+      # The IN operator tests whether the RDF term on the left-hand side is found in the values of list of expressions on the right-hand side. The test is done with "=" operator, which tests for 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 IN expression to raise an error if the RDF term being tested is not found elsewhere in the list of terms.
+      # 
+      # The IN operator is equivalent to the SPARQL expression:
+      # 
+      #     (lhs = expression1) || (lhs = expression2) || ...
+      # 
+      # @example
+      #
+      #     2 IN (1, 2, 3) #=> true
+      #     2 IN () #=> false
+      #     2 IN (<http://example/iri>, "str", 2.0) #=> true
+      #     2 IN (1/0, 2) #=> true
+      #     2 IN (2, 1/0) #=> true
+      #     2 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::TRUE
+        when error_found then raise TypeError
+        else RDF::Literal::FALSE
+        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 # In
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,40 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `iri` operator.
+    #
+    # @example
+    #     (base <http://example.org/> (project (?uri ?iri)
+    #       (extend ((?uri (uri "uri")) (?iri (iri "iri")))
+    #         (bgp))))
+    #
+    # @see http://www.w3.org/TR/rdf-sparql-query/#func-iri
+    class IRI < Operator::Unary
+      include Evaluatable
+
+      NAME = [:iri, :uri]
+
+      ##
+      # The IRI function constructs an IRI by resolving the string argument (see RFC 3986 and RFC 3987 or any later RFC that superceeds RFC 3986 or RFC 3987). The IRI is resolved against the base IRI of the query and must result in an absolute IRI.
+      #
+      # The URI function is a synonym for IRI.
+      #
+      # If the function is passed an IRI, it returns the IRI unchanged.
+      #
+      # Passing any RDF term other than a simple literal, xsd:string or an IRI is an error.
+      #
+      # An implementation may normalize the IRI.
+      #
+      # @param  [RDF::Term] literal
+      #   a simple literal
+      # @return [RDF::URI]
+      # @raise  [TypeError] if the operand is not a simple literal
+      def apply(literal)
+        raise TypeError, "expected an simple literal, but got #{literal.inspect}" unless literal.literal? && literal.simple?
+        Operator.base_uri.join(literal.to_s)
+      end
+
+      Operator::URI = IRI
+    end # IRI
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,41 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `isNumeric` operator.
+    #
+    # Note numeric denotes typed literals with datatypes xsd:integer, xsd:decimal, xsd:float, and xsd:double, not derived types.
+    #
+    # @example
+    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
+    #            (: <http://example.org/things#>))
+    #     (project (?x ?v)
+    #       (filter (isNumeric ?v)
+    #         (bgp (triple ?x :p ?v)))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-isNumeric
+    class IsNumeric < Operator::Unary
+      include Evaluatable
+
+      NAME = :isnumeric
+
+      ##
+      # Returns `true` if the operand is an `RDF::Literal::Numeric`, `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)
+        case term
+          when RDF::Literal::NonPositiveInteger then RDF::Literal::FALSE
+          when RDF::Literal::NonNegativeInteger then RDF::Literal::FALSE
+          when RDF::Literal::Long then RDF::Literal::FALSE
+          when RDF::Literal::Numeric 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 # IsNumeric
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -28,10 +28,10 @@ module SPARQL; module Algebra
       # @raise  [TypeError] if either operand is unbound
       # @raise  [TypeError] if either operand is not a simple literal
       def apply(language_tag, language_range)
-        raise TypeError, "expected a plain RDF::Literal for language_tag, but got #{language_tag.inspect}" unless language_tag.is_a?(RDF::Literal) && language_tag.plain?
+        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
 
-        raise TypeError, "expected a plain RDF::Literal for language_range, but got #{language_range.inspect}" unless language_range.is_a?(RDF::Literal) && language_range.plain?
+        raise TypeError, "expected a plain RDF::Literal for language_range, but got #{language_range.inspect}" unless language_range.is_a?(RDF::Literal) && language_range.simple?
         language_range = language_range.to_s.downcase
 
         case

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

@@ -0,0 +1,31 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL logical `lcase` operator.
+    #
+    # @example
+    #   (lcase ?x)
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-lcase
+    # @see http://www.w3.org/TR/xpath-functions/#func-lcase
+    class LCase < Operator::Unary
+      include Evaluatable
+
+      NAME = :lcase
+
+      ##
+      # The LCASE function corresponds to the XPath fn:lower-case function. It returns a string literal whose lexical form is the lower case of the lexcial form of the argument.
+      #
+      # @param  [RDF::Literal] operand
+      #   the operand
+      # @return [RDF::Literal] literal of same type
+      # @raise  [TypeError] if the operand is not a literal value
+      def apply(operand)
+        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}"
+        end
+      end
+    end # LCase
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,34 @@
+require 'digest'
+
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL logical `md5` operator.
+    #
+    # @example
+    #     (prefix ((: <http://example.org/>))
+    #       (project (?hash)
+    #         (extend ((?hash (md5 ?l)))
+    #           (bgp (triple :s1 :str ?l)))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-md5
+    class MD5 < Operator::Unary
+      include Evaluatable
+
+      NAME = :md5
+
+      ##
+      # Returns the MD5 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::MD5.new.hexdigest(operand.to_s))
+      end
+    end # MD5
+  end # Operator
+end; end # SPARQL::Algebra