sparql 1.0.6 → 1.0.7

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

@@ -0,0 +1,31 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL logical `abs` operator.
+    #
+    # @example
+    #   (abs ?x)
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-abs
+    # @see http://www.w3.org/TR/xpath-functions/#func-abs
+    class Abs < Operator::Unary
+      include Evaluatable
+
+      NAME = [:abs]
+
+      ##
+      # Returns the absolute value of the operand. An error is raised if operand 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.abs
+          else raise TypeError, "expected an RDF::Literal::Numeric, but got #{operand.inspect}"
+        end
+      end
+    end # Abs
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -27,6 +27,7 @@ module SPARQL; module Algebra
       # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
       def execute(queryable, options = {})
         debug(options) {"Base #{operands.first}"}
+        Operator.base_uri = operands.first
         @solutions = operands.last.execute(queryable, options.merge(:depth => options[:depth].to_i + 1))
         debug(options) {"=> #{@solutions.inspect}"}
         @solutions

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

@@ -0,0 +1,88 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `bnode` operator.
+    #
+    # @example
+    #     (prefix ((: <http://example.org/>)
+    #              (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #       (project (?s1 ?s2 ?b1 ?b2)
+    #         (extend ((?b1 (bnode ?s1)) (?b2 (bnode ?s2)))
+    #           (filter (exprlist (|| (= ?a :s1) (= ?a :s3)) (|| (= ?b :s1) (= ?b :s3)))
+    #             (bgp
+    #               (triple ?a :str ?s1)
+    #               (triple ?b :str ?s2)
+    #             )))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-bnode
+    class BNode < Operator::Unary
+      include Evaluatable
+
+      NAME = :bnode
+
+
+      ##
+      # Initializes a new operator instance.
+      #
+      # @param  [RDF::Literal] literal (false)
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional options (see {Operator#initialize})
+      # @raise  [TypeError] if any operand is invalid
+      def initialize(literal = false, options = {})
+        super
+      end
+
+      ##
+      # Evaluates this operator using the given variable `bindings`.
+      #
+      # @param  [RDF::Query::Solution, #[]] bindings
+      #   a query solution containing zero or more variable bindings
+      # @return [RDF::Term]
+      # @abstract
+      def evaluate(bindings = {})
+        args = operands.map { |operand| operand.evaluate(bindings) }
+        apply(args.first, bindings)
+      end
+
+      ##
+      # The BNODE function constructs a blank node that is distinct from all blank nodes in the dataset being queried and distinct from all blank nodes created by calls to this constructor for other query solutions. If the no argument form is used, every call results in a distinct blank node. If the form with a simple literal is used, every call results in distinct blank nodes for different simple literals, and the same blank node for calls with the same simple literal within expressions for one solution mapping.
+      #
+      # This functionality is compatible with the treatment of blank nodes in SPARQL CONSTRUCT templates.
+      #
+      # @param  [RDF::Literal] literal (nil)
+      # @param  [RDF::Query::Solution, #[]] bindings
+      #   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)
+        @@bnode_base ||= "b0"
+        @@bindings ||= bindings
+        @@bnodes ||= {}
+
+        if literal == RDF::Literal::FALSE
+          l, @@bnode_base = @@bnode_base, @@bnode_base.succ
+          RDF::Node.new(l)
+        else
+          raise TypeError, "expected an simple literal, but got #{literal.inspect}" unless literal.literal? && literal.simple?
+          # Return the same BNode if used with the same binding
+          @@bnodes, @@bindings = {}, bindings unless @@bindings == bindings
+          @@bnodes[literal.to_s.to_sym] ||= begin
+            l, @@bnode_base = @@bnode_base, @@bnode_base.succ
+            RDF::Node.new(l)
+          end
+        end
+      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 == false}
+      end
+    end # BNode
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -39,7 +39,8 @@ module SPARQL; module Algebra
       def evaluate(bindings = {})
         case var = operand
           when Variable
-            operand.evaluate(bindings) ? RDF::Literal::TRUE : RDF::Literal::FALSE
+            bindings.respond_to?(:bound?) && bindings.bound?(var) ?
+              RDF::Literal::TRUE : RDF::Literal::FALSE
           else raise TypeError, "expected an RDF::Query::Variable, but got #{var.inspect}"
         end
       end

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

@@ -0,0 +1,31 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL logical `ceil` operator.
+    #
+    # @example
+    #   (ceil ?x)
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-ceil
+    # @see http://www.w3.org/TR/xpath-functions/#func-ceil
+    class Ceil < Operator::Unary
+      include Evaluatable
+
+      NAME = [:ceil]
+
+      ##
+      # Returns the smallest (closest to negative infinity) number with no fractional part that is not less than the value of arg. 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.ceil
+          else raise TypeError, "expected an RDF::Literal::Numeric, but got #{operand.inspect}"
+        end
+      end
+    end # Ceil
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,65 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `coalesce` function.
+    #
+    # Used for filters with more than one expression.
+    #
+    # @example
+    #     (prefix ((: <http://example.org/>)
+    #              (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #       (project (?cx ?div ?def ?err)
+    #         (extend ((?cx (coalesce ?x -1))
+    #                  (?div (coalesce (/ ?o ?x) -2))
+    #                  (?def (coalesce ?z -3))
+    #                  (?err (coalesce ?z)))
+    #           (leftjoin
+    #             (bgp (triple ?s :p ?o))
+    #             (bgp (triple ?s :q ?x))))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-coalesce
+    class Coalesce < Operator
+      include Evaluatable
+
+      NAME = :coalesce
+
+      ##
+      # The COALESCE function form returns the RDF term value of the first expression that evaluates without error. In SPARQL, evaluating an unbound variable raises an error.
+      # 
+      # If none of the arguments evaluates to an RDF term, an error is raised. If no expressions are evaluated without error, an error is raised.
+      # 
+      #
+      # @example
+      #   Suppose ?x = 2 and ?y is not bound in some query solution:
+      #
+      #     COALESCE(?x, 1/0) #=> 2, the value of x
+      #     COALESCE(1/0, ?x) #=> 2
+      #     COALESCE(5, ?x) #=> 5
+      #     COALESCE(?y, 3) #=> 3
+      #     COALESCE(?y) #=> raises an error because y is not bound.
+      #
+      # @param  [RDF::Query::Solution, #[]] bindings
+      # @return [RDF::Term]
+      # @raise  [TypeError] if none of the operands succeeds
+      def evaluate(bindings = {})
+        operands.each do |op|
+          begin
+            return op.evaluate(bindings)
+          rescue
+          end
+        end
+        raise TypeError, "None of the operands evaluated"
+      end
+
+      ##
+      # Returns an optimized version of this query.
+      #
+      # Return optimized query
+      #
+      # @return [Union, RDF::Query] `self`
+      def optimize
+        operands = operands.map(&:optimize)
+      end
+    end # Coalesce
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,49 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # A SPARQL `concat` operator.
+    #
+    # @example
+    #   (concat ?a ?b)
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-concat
+    # @see http://www.w3.org/TR/xpath-functions/#func-concat
+    class Concat < Operator::Binary
+      include Evaluatable
+
+      NAME = :concat
+
+      ##
+      # The lexical form of the returned literal is obtained by concatenating the lexical forms of its inputs. If all input literals are typed literals of type xsd:string, then the returned literal is also of type xsd:string, if all input literals are plain literals with identical language tag, then the returned literal is a plain literal with the same language tag, in all other cases, the returned literal is a simple literal.
+      #
+      # @example
+      #     concat("foo", "bar")                         #=> "foobar"
+      #     concat("foo"@en, "bar"@en)                   #=> "foobar"@en
+      #     concat("foo"^^xsd:string, "bar"^^xsd:string) #=> "foobar"^^xsd:string
+      #     concat("foo", "bar"^^xsd:string)             #=> "foobar"
+      #     concat("foo"@en, "bar")                      #=> "foobar"
+      #     concat("foo"@en, "bar"^^xsd:string)          #=> "foobar"
+      #
+      # @param  [RDF::Literal] left
+      #   a literal
+      # @param  [RDF::Literal] right
+      #   a literal
+      # @return [RDF::Literal] 
+      # @raise  [TypeError] if either operand is not a literal
+      def apply(left, right)
+        case
+        when !left.literal? || !right.literal?
+          raise TypeError, "expected two plain literal operands, but got #{left.inspect} and #{right.inspect}"
+        when ![left.datatype, right.datatype].compact.all? {|dt| dt == RDF::XSD.string}
+          raise TypeError, "expected two plain literal operands, but got #{left.inspect} and #{right.inspect}"
+        when left.datatype == RDF::XSD.string && right.datatype == RDF::XSD.string
+          RDF::Literal.new("#{left}#{right}", :datatype => RDF::XSD.string)
+        when left.has_language? && left.language == right.language
+          RDF::Literal.new("#{left}#{right}", :language => left.language)
+        else
+          RDF::Literal.new("#{left}#{right}")
+        end
+      end
+    end # Concat
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,44 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # A SPARQL `contains` operator.
+    #
+    # @example
+    #   (contains ?x ?y)
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-contains
+    # @see http://www.w3.org/TR/xpath-functions/#func-contains
+    class Contains < Operator::Binary
+      include Evaluatable
+
+      NAME = :contains
+
+      ##
+      # The CONTAINS function corresponds to the XPath fn:contains. The arguments must be argument compatible otherwise an error is raised.
+      #
+      # @example
+      #    contains("foobar", "bar") #=> true
+      #    contains("foobar"@en, "foo"@en) #=> true
+      #    contains("foobar"^^xsd:string, "bar"^^xsd:string) #=> true
+      #    contains("foobar"^^xsd:string, "foo") #=> true
+      #    contains("foobar", "bar"^^xsd:string) #=> true
+      #    contains("foobar"@en, "foo") #=> true
+      #    contains("foobar"@en, "bar"^^xsd:string) #=> true
+      #
+      # @param  [RDF::Literal] left
+      #   a literal
+      # @param  [RDF::Literal] right
+      #   a literal
+      # @return [RDF::Literal::Boolean]
+      # @raise  [TypeError] if operands are not compatible
+      def apply(left, right)
+        case
+        when !left.compatible?(right)
+          raise TypeError, "expected two RDF::Literal operands, but got #{left.inspect} and #{right.inspect}"
+        when left.to_s.include?(right.to_s) then RDF::Literal::TRUE
+        else RDF::Literal::FALSE
+        end
+      end
+    end # Contains
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -3,9 +3,8 @@ begin
 rescue LoadError => e
   require 'rdf/ntriples'
 end
+require 'rdf/aggregate_repo'
 
-# FIXME: This version uses named graphs for default graphs, which violates the condition in RDF::Repository#query_pattern, where it specifically does not match variables against the default graph. To work properly, RDF.rb will need to allow some way to specify a set of graphs as being default, and affect the matching within #query_pattern so that variables don't match against this.
-# Note that a graph may be both default and named, so the context of the query is significant.
 module SPARQL; module Algebra
   class Operator
     ##
@@ -168,53 +167,17 @@ module SPARQL; module Algebra
             queryable.load(uri.to_s, load_opts)
           end
         end
-        require 'rdf/nquads'
-        debug(options) { queryable.dump(:nquads) }
+        debug(options) {
+          require 'rdf/nquads'
+          queryable.dump(:nquads)
+        }
 
-        # Re-write the operand:
-        operator = self.rewrite do |op|
-          case op
-          when Operator::Graph
-            if named_datasets.empty?
-              # * If there are no named datasets, remove all (graph)
-              #   operations.
-              debug(options) {"=> #{op.to_sxp} => (bgp)"}
-              Operator::BGP.new
-            elsif (name = op.operand(0)).is_a?(RDF::Resource)
-              # It must match one of the named_datasets
-              debug(options) {"=> #{op.to_sxp} => (bgp)"}
-              named_datasets.include?(name) ? op : Operator::BGP.new
-            else
-              # Name is a variable, replace op with a filter on that
-              # variable and op
-              filter_expressions = named_datasets.map {|u| Operator::Equal.new(name, u)}
-              debug(options) {"=> #{op.to_sxp} => (filter (...) #{op.to_sxp})"}
-              filt = to_binary(Operator::Or, *filter_expressions)
-              Operator::Filter.new(filt, op)
-            end
-          when RDF::Query # Operator::BGP
-            case default_datasets.length
-            when 0
-              # No Default Datasets, no query to run
-              debug(options) {"=> #{op.to_sxp} => (bgp)"}
-              Operator::BGP.new
-            when 1
-              # A single dataset, write as (graph <dataset> (bgp))
-              debug(options) {"=> #{op.to_sxp} => (graph <#{default_datasets.first}> #{op.to_sxp})"}
-              Operator::Graph.new(default_datasets.first, op)
-            else
-              # Several, rewrite as Union
-              debug(options) {"=> #{op.to_sxp} => (union ...)"}
-              to_binary(Operator::Union, *default_datasets.map {|u| Operator::Graph.new(u, op.dup)})
-            end
-          else
-            nil
-          end
-        end
-        executable = operator.operands.last
-        debug(options) {"=> rewritten: #{executable.to_sxp}"}
-
-        @solutions = executable.execute(queryable, options.merge(:depth => options[:depth].to_i + 1))
+        # Create an aggregate based on queryable having just the bits we want
+        aggregate = RDF::AggregateRepo.new(queryable)
+        named_datasets.each {|name| aggregate.named(name) if queryable.has_context?(name)}
+        aggregate.default(*default_datasets.select {|name| queryable.has_context?(name)})
+        executable = operands.last
+        @solutions = executable.execute(aggregate, options.merge(:depth => options[:depth].to_i + 1))
       end
       
       ##

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

@@ -30,9 +30,11 @@ module SPARQL; module Algebra
       def apply(literal)
         case literal
           when RDF::Literal then case
-            when literal.typed?  then RDF::URI(literal.datatype)
+            when RDF::VERSION.to_s >= "1.1" then literal.datatype
             when literal.simple? then RDF::XSD.string
-            else raise TypeError, "expected a typed or simple RDF::Literal, but got #{literal.inspect}"
+            when literal.datatype == RDF::XSD.string then RDF::XSD.string
+            when literal.plain? then RDF.langString
+            else RDF::URI(literal.datatype)
           end
           else raise TypeError, "expected an RDF::Literal, but got #{literal.inspect}"
         end

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

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