sparql 1.0.8 → 1.1.0p0

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

@@ -24,11 +24,14 @@ module SPARQL; module Algebra
       #     concat("foo"@en, "bar")                      #=> "foobar"
       #     concat("foo"@en, "bar"^^xsd:string)          #=> "foobar"
       #
-      # @param  [RDF::Query::Solution, #[]] bindings
+      # @param  [RDF::Query::Solution] bindings
+      #   a query solution containing zero or more variable bindings
+      # @param [Hash{Symbol => Object}] options ({})
+      #   options passed from query
       # @return [RDF::Term]
       # @raise  [TypeError] if any operand is not a literal
-      def evaluate(bindings = {})
-        ops = operands.map {|op| op.evaluate(bindings)}
+      def evaluate(bindings, options = {})
+        ops = operands.map {|op| op.evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1))}
 
         raise TypeError, "expected all plain literal operands" unless ops.all? {|op| op.literal? && op.plain?}
 

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

@@ -0,0 +1,30 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `count` set function.
+    #
+    # @example
+    #    (prefix ((: <http://www.example.org>))
+    #      (project (?C)
+    #        (extend ((?C ?.0))
+    #          (group () ((?.0 (count ?O)))
+    #            (bgp (triple ?S ?P ?O))))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#defn_aggCount
+    class Count < Operator
+      include Aggregate
+
+      NAME = :count
+
+      ##
+      # Count is a SPARQL set function which counts the number of times a given expression has a bound, and non-error value within the aggregate group.
+      #
+      # @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)
+        RDF::Literal(enum.length)
+      end
+    end # Count
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,39 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL logical `exists` operator.
+    #
+    # @example
+    #    (prefix ((ex: <http://www.example.org/>))
+    #      (filter (exists
+    #                 (filter (notexists (bgp (triple ?s ?p ex:o2)))
+    #                   (bgp (triple ?s ?p ex:o1))))
+    #        (bgp (triple ?s ?p ex:o))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-abs
+    # @see http://www.w3.org/TR/xpath-functions/#func-abs
+    class Exists < Operator::Unary
+      include Evaluatable
+
+      NAME = [:exists]
+
+      ##
+      # Exvaluating this operator executes the query in the first operator passing in each existing bindings.
+      #
+      # @param  [RDF::Query::Solution] bindings
+      #   a query solution containing zero or more variable bindings
+      # @param [Hash{Symbol => Object}] options ({})
+      #   options passed from query
+      # @option options[RDF::Queryable] queryable
+      #   queryable to execute, using bindings as an initial solution.
+      # @return [RDF::Literal::Boolean] `true` or `false`
+      def evaluate(bindings, options = {})
+        solutions = RDF::Query::Solutions.new << bindings
+        queryable = options[:queryable]
+        !operand(0).execute(queryable, options.merge(
+                                        :solutions => solutions,
+                                        :depth => options[:depth].to_i + 1)).empty?
+      end
+    end # Exists
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -30,11 +30,14 @@ module SPARQL; module Algebra
       #
       #   (exprlist (= 1 1) (!= 1 0))
       #
-      # @param  [RDF::Query::Solution, #[]] bindings
+      # @param  [RDF::Query::Solution] bindings
+      #   a query solution containing zero or more variable bindings
+      # @param [Hash{Symbol => Object}] options ({})
+      #   options passed from query
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operands could not be coerced to a boolean literal
-      def evaluate(bindings = {})
-        res = operands.all? {|op| boolean(op.evaluate(bindings)).true? }
+      def evaluate(bindings, options = {})
+        res = operands.all? {|op| boolean(op.evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1))).true? }
         RDF::Literal(res) # FIXME: error handling
       end
 

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

@@ -37,7 +37,9 @@ module SPARQL; module Algebra
           debug(options) {"===> soln #{solution.to_hash.inspect}"}
           operands.first.each do |(var, expr)|
             begin
-              val = expr.evaluate(solution)
+              val = expr.evaluate(solution, options.merge(
+                                              :queryable => queryable,
+                                              :depth => options[:depth].to_i + 1))
               debug(options) {"===> + #{var} => #{val.inspect}"}
               solution.bindings[var.to_sym] = val
             rescue TypeError => e

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

@@ -36,6 +36,7 @@ module SPARQL; module Algebra
         debug(options) {"Filter #{operands.first.to_sxp}"}
         @solutions = operands.last.execute(queryable, options.merge(:depth => options[:depth].to_i + 1))
         debug(options) {"=>(before) #{@solutions.map(&:to_hash).inspect}"}
+        opts = options.merge(:queryable => queryable, :depth => options[:depth].to_i + 1)
         @solutions = @solutions.filter do |solution|
           # Evaluate the solution, which will return true or false
           #debug(options) {"===>(evaluate) #{operands.first.inspect} against #{solution.to_hash.inspect}"}
@@ -44,7 +45,7 @@ module SPARQL; module Algebra
           # FILTERs eliminate any solutions that, when substituted into the expression, either
           # result in an effective boolean value of false or produce an error.
           begin
-            res = boolean(operands.first.evaluate(solution)).true?
+            res = boolean(operands.first.evaluate(solution, opts)).true?
             debug(options) {"===>#{res} #{solution.to_hash.inspect}"}
             res
           rescue

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

@@ -0,0 +1,101 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `group` operator.
+    #
+    # `group` takes either two or three operands. The first operand
+    # is an array of grouped variables. The last operand is the
+    # query to be grouped. If three operands are provided,
+    # the second is an array of temporary bindings.
+    #
+    # @example
+    #     (prefix ((: <http://example/>))
+    #       (project (?w ?S)
+    #         (extend ((?S ?.0))
+    #           (group (?w) ((?.0 (sample ?v)))
+    #             (leftjoin
+    #               (bgp (triple ?s :p ?v))
+    #               (bgp (triple ?s :q ?w)))))))
+    #
+    # @see http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+    class Group < Operator
+      include Query
+      
+      NAME = [:group]
+
+      ##
+      # Executes `query` with `queryable` and groups results based
+      # on the first operand.
+      #
+      # @param  [RDF::Queryable] queryable
+      #   the graph or repository to query
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional keyword options
+      # @return [RDF::Query::Solutions]
+      #   the resulting solution sequence
+      # @see    http://www.w3.org/TR/sparql11-query/#sparqlGroupAggregate
+      def execute(queryable, options = {})
+        debug(options) {"Group"}
+        exprlist = operands.first
+        query = operands.last
+        aggregates = operands.length == 3 ? operand(1) : []
+        solutions = query.execute(queryable, options.merge(:depth => options[:depth].to_i + 1)) || {}
+
+        groups = solutions.group_by do |solution|
+          # Evaluate each exprlist operand to get groups where each key is a new solution
+          # ListEval((expr1, ..., exprn), μ) returns a list (e1, ..., en), where ei = expri(μ) or error.
+          soln = RDF::Query::Solution.new
+          exprlist.each do |operand|
+            begin
+              if operand.is_a?(Array)
+                # Form is [variable, expression]
+                soln[operand.first] = operand.last.evaluate(solution,
+                                                            options.merge(
+                                                             :queryable => queryable,
+                                                             :depth => options[:depth].to_i + 1))
+              else
+                # Form is variable
+                soln[operand] = operand.evaluate(solution, options.merge(
+                                                            :queryable => queryable,
+                                                            :depth => options[:depth].to_i + 1))
+              end
+            rescue TypeError
+              # Ignore expression
+            end
+          end
+          soln
+        end
+
+        debug(options) {"=>(groups) #{groups.inspect}"}
+
+        # Aggregate solutions in each group using aggregates to get solutions
+        @solutions = groups.map do |group_soln, solns|
+          aggregates.each do |(var, aggregate)|
+            begin
+              group_soln[var] = aggregate.aggregate(solns, options)
+            rescue TypeError
+              # Ignored in output
+            end
+          end
+          group_soln
+        end
+
+        # Make sure that's at least an empty solution
+        @solutions << RDF::Query::Solution.new if @solutions.empty?
+
+        debug(options) {"=>(solutions) #{@solutions.inspect}"}
+        @solutions = RDF::Query::Solutions.new(@solutions)
+      end
+      
+      ##
+      # Returns an optimized version of this query.
+      #
+      # TODO
+      #
+      # @return [Group] `self`
+      def optimize
+        self
+      end
+    end # Group
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,55 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `groupconcat` set function.
+    #
+    # @example
+    #    (prefix ((: <http://www.example.org/>))
+    #      (filter (|| (= ?g "1 22") (= ?g "22 1"))
+    #        (project (?g)
+    #          (extend ((?g ?.0))
+    #            (group () ((?.0 (group_concat ?o)))
+    #              (bgp (triple ??0 :p1 ?o)))))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#defn_aggGroupConcat
+    class GroupConcat < Operator
+      include Aggregate
+
+      NAME = :group_concat
+      ##
+      # One or two operands, the second operand, if it exists, is a separator, defaulting to ' '.
+      #
+      # @param  [Enumerable<RDF::Query::Solution>] solutions ([])
+      #   an enumerable set of query solutions
+      # @param [Hash{Symbol => Object}] options ({})
+      #   options passed from query
+      # @return [RDF::Term]
+      # @raise [TypeError]
+      # @abstract
+      def aggregate(solutions = [], options = {})
+        sep = operands.length == 2 ? operand(0).last : RDF::Literal(' ')
+        args_enum = solutions.map do |solution|
+          begin
+            operands.last.evaluate(solution, options.merge(:depth => options[:depth].to_i + 1))
+          rescue TypeError
+            # Ignore errors
+            nil
+          end
+        end
+        apply(args_enum, sep)
+      end
+
+
+      ##
+      # GroupConcat is a set function which performs a string concatenation across the values of an expression with a group. The order of the strings is not specified. The separator character used in the concatenation may be given with the scalar argument SEPARATOR.
+      #
+      # @param  [Enumerable<Array<RDF::Term>>] enum
+      #   enum of evaluated operand
+      # @return [RDF::Term] An arbitrary term
+      # @raise  [TypeError] If enum is empty
+      def apply(enum, separator)
+        RDF::Literal(enum.flatten.map(&:to_s).join(separator.to_s))
+      end
+    end # GroupConcat
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -29,14 +29,14 @@ module SPARQL; module Algebra
       #
       # Evaluates the first operand and returns the evaluation of either the second or third operands
       #
-      # @param  [RDF::Query::Solution, #[]] bindings
+      # @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)
+      def evaluate(bindings, options = {})
+        operand(0).evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1)) == RDF::Literal::TRUE ?
+          operand(1).evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1).merge(:depth => options[:depth].to_i + 1)) :
+          operand(2).evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1))
         rescue
           raise TypeError
       end

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

@@ -34,15 +34,18 @@ module SPARQL; module Algebra
       #     2 IN (2, 1/0) #=> true
       #     2 IN (3, 1/0) #=> raises an error
       #
-      # @param  [RDF::Query::Solution, #[]] bindings
+      # @param  [RDF::Query::Solution] bindings
+      #   a query solution containing zero or more variable bindings
+      # @param [Hash{Symbol => Object}] options ({})
+      #   options passed from query
       # @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)
+      def evaluate(bindings, options = {})
+        lhs = operands.shift.evaluate(bindings, options)
         error_found = false
         found = operands.any? do |op|
           begin
-            lhs == op.evaluate(bindings)
+            lhs == op.evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1))
           rescue TypeError
             error_found = true
           end

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

@@ -0,0 +1,38 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `max` set function.
+    #
+    # @example
+    #    (prefix ((: <http://www.example.org/>))
+    #      (project (?max)
+    #        (extend ((?max ?.0))
+    #          (group () ((?.0 (max ?o)))
+    #            (bgp (triple ?s ?p ?o))))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#defn_aggMax
+    class Max < Operator::Unary
+      include Aggregate
+
+      NAME = :max
+
+      ##
+      # Max is a SPARQL set function that return the maximum value from a group respectively.
+      #
+      # It makes use of the SPARQL ORDER BY ordering definition, to allow ordering over arbitrarily typed expressions.
+      #
+      # @param  [Enumerable<Array<RDF::Term>>] enum
+      #   enum of evaluated operand
+      # @return [RDF::Literal] The maximum value of the terms
+      def apply(enum)
+        if enum.empty?
+          raise TypeError, "Maximum of an empty multiset"
+        elsif enum.flatten.all? {|n| n.literal?}
+          RDF::Literal(enum.flatten.max)
+        else
+          raise TypeError, "Maximum of non-literals: #{enum.flatten}"
+        end
+      end
+    end # Max
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,38 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `min` set function.
+    #
+    # @example
+    #    (prefix ((: <http://www.example.org/>))
+    #      (project (?max)
+    #        (extend ((?min ?.0))
+    #          (group () ((?.0 (min ?o)))
+    #            (bgp (triple ?s ?p ?o))))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#defn_aggMin
+    class Min < Operator::Unary
+      include Aggregate
+
+      NAME = :min
+
+      ##
+      # Min is a SPARQL set function that return the minimum value from a group respectively.
+      #
+      # It makes use of the SPARQL ORDER BY ordering definition, to allow ordering over arbitrarily typed expressions.
+      #
+      # @param  [Enumerable<Array<RDF::Term>>] enum
+      #   enum of evaluated operand
+      # @return [RDF::Literal] The maximum value of the terms
+      def apply(enum)
+        if enum.empty?
+          raise TypeError, "Minumuim of an empty multiset"
+        elsif enum.flatten.all? {|n| n.literal?}
+          RDF::Literal(enum.flatten.min)
+        else
+          raise TypeError, "Minumuim of non-literals: #{enum.flatten}"
+        end
+      end
+    end # Min
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -1,30 +1,65 @@
 module SPARQL; module Algebra
   class Operator
     ##
-    # The SPARQL numeric unary `-` (negation) operator.
+    # The SPARQL GraphPattern `minus` operator.
     #
     # @example
-    #   (- ?x)
-    #   (minus ?x)
+    #    (prefix ((ex: <http://www.w3.org/2009/sparql/docs/tests/data-sparql11/negation#>))
+    #      (project (?animal)
+    #        (minus
+    #          (bgp (triple ?animal <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ex:Animal))
+    #          (filter (|| (= ?type ex:Reptile) (= ?type ex:Insect))
+    #            (bgp (triple ?animal <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ?type))))))
     #
     # @see http://www.w3.org/TR/xpath-functions/#func-numeric-unary-minus
-    class Minus < Operator::Unary
-      include Evaluatable
+    # @see http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+    class Minus < Operator::Binary
+      include Query
 
-      NAME = [:-, :minus]
+      NAME = :minus
 
       ##
-      # Returns the operand with its sign reversed.
+      # Executes each operand with `queryable` and performs the `join` operation
+      # by creating a new solution set containing the `merge` of all solutions
+      # from each set that are `compatible` with each other.
       #
-      # @param  [RDF::Literal::Numeric] term
-      #   a numeric literal
-      # @return [RDF::Literal::Numeric]
-      # @raise  [TypeError] if the operand is not a numeric literal
-      def apply(term)
-        case term
-          when RDF::Literal::Numeric then -term
-          else raise TypeError, "expected an RDF::Literal::Numeric, but got #{term.inspect}"
-        end
+      # @param  [RDF::Queryable] queryable
+      #   the graph or repository to query
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional keyword options
+      # @return [RDF::Query::Solutions]
+      #   the resulting solution sequence
+      # @see    http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#defn_algMinus
+      # @see    http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#negation
+      def execute(queryable, options = {})
+        # Let Ω1 and Ω2 be multisets of solution mappings. We define:
+        # 
+        # Minus(Ω1, Ω2) = { μ | μ in Ω1 . ∀ μ' in Ω2, either μ and μ' are not compatible or dom(μ) and dom(μ') are disjoint }
+        # 
+        # card[Minus(Ω1, Ω2)](μ) = card[Ω1](μ)
+        debug(options) {"Minus"}
+        solutions1 = operand(0).execute(queryable, options.merge(:depth => options[:depth].to_i + 1)) || {}
+        debug(options) {"=>(left) #{solutions1.inspect}"}
+        solutions2 = operand(1).execute(queryable, options.merge(:depth => options[:depth].to_i + 1)) || {}
+        debug(options) {"=>(right) #{solutions2.inspect}"}
+        @solutions = solutions1.minus(solutions2)
+        debug(options) {"=> #{@solutions.inspect}"}
+        @solutions
+      end
+      
+      ##
+      # Returns an optimized version of this query.
+      #
+      # Groups of one graph pattern (not a filter) become join(Z, A) and can be replaced by A.
+      # The empty graph pattern Z is the identity for join:
+      #   Replace join(Z, A) by A
+      #   Replace join(A, Z) by A
+      #
+      # @return [Join, RDF::Query] `self`
+      def optimize
+        ops = operands.map {|o| o.optimize }.select {|o| o.respond_to?(:empty?) && !o.empty?}
+        @operands = ops
+        self
       end
     end # Minus
   end # Operator

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

@@ -0,0 +1,31 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL numeric unary `-` (negation) operator.
+    #
+    # @example
+    #   (- ?x)
+    #   (negate ?x)
+    #
+    # @see http://www.w3.org/TR/xpath-functions/#func-numeric-unary-minus
+    class Negate < Operator::Unary
+      include Evaluatable
+
+      NAME = [:-, :negate]
+
+      ##
+      # Returns the operand with its sign reversed.
+      #
+      # @param  [RDF::Literal::Numeric] term
+      #   a numeric literal
+      # @return [RDF::Literal::Numeric]
+      # @raise  [TypeError] if the operand is not a numeric literal
+      def apply(term)
+        case term
+          when RDF::Literal::Numeric then -term
+          else raise TypeError, "expected an RDF::Literal::Numeric, but got #{term.inspect}"
+        end
+      end
+    end # Negate
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,37 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL logical `exists` operator.
+    #
+    # @example
+    #    (prefix ((ex: <http://www.example.org/>))
+    #      (filter (exists
+    #                 (filter (notexists (bgp (triple ?s ?p ex:o2)))
+    #                   (bgp (triple ?s ?p ex:o1))))
+    #        (bgp (triple ?s ?p ex:o))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-abs
+    # @see http://www.w3.org/TR/xpath-functions/#func-abs
+    class NotExists < Operator::Unary
+      include Evaluatable
+
+      NAME = [:notexists]
+
+      ##
+      # Exvaluating this operator executes the query in the first operator passing in each existing bindings.
+      #
+      # @param  [RDF::Query::Solution] bindings
+      #   a query solution containing zero or more variable bindings
+      # @param [Hash{Symbol => Object}] options ({})
+      #   options passed from query
+      # @option options[RDF::Queryable] queryable
+      #   queryable to execute, using bindings as an initial solution.
+      # @return [RDF::Literal::Boolean] `true` or `false`
+      def evaluate(bindings, options = {})
+        solutions = RDF::Query::Solutions.new << bindings
+        queryable = options[:queryable]
+        operand(0).execute(queryable, options.merge(:solutions => solutions)).empty?
+      end
+    end # NotExists
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -36,15 +36,18 @@ module SPARQL; module Algebra
       #     2 NOT IN (2, 1/0)	false
       #     2 NOT IN (3, 1/0)	raises an error
       #
-      # @param  [RDF::Query::Solution, #[]] bindings
+      # @param  [RDF::Query::Solution] bindings
+      #   a query solution containing zero or more variable bindings
+      # @param [Hash{Symbol => Object}] options ({})
+      #   options passed from query
       # @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)
+      def evaluate(bindings, options = {})
+        lhs = operands.shift.evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1))
         error_found = false
         found = operands.any? do |op|
           begin
-            lhs == op.evaluate(bindings)
+            lhs == op.evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1))
           rescue TypeError
             error_found = true
           end

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

@@ -34,18 +34,21 @@ module SPARQL; module Algebra
       # Note that this operator operates on the effective boolean value
       # (EBV) of its operands.
       #
-      # @param  [RDF::Query::Solution, #[]] bindings
+      # @param  [RDF::Query::Solution] bindings
+      #   a query solution containing zero or more variable bindings
+      # @param [Hash{Symbol => Object}] options ({})
+      #   options passed from query
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operands could not be coerced to a boolean literal
-      def evaluate(bindings = {})
+      def evaluate(bindings, options = {})
         begin
-          left = boolean(operand(0).evaluate(bindings)).true?
+          left = boolean(operand(0).evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1))).true?
         rescue TypeError
           left = nil
         end
         
         begin
-          right = boolean(operand(1).evaluate(bindings)).true?
+          right = boolean(operand(1).evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1))).true?
         rescue TypeError
           right = nil
         end

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

@@ -33,8 +33,8 @@ module SPARQL; module Algebra
           operand(0).inject(false) do |memo, op|
             debug(options) {"=> #{op.inspect}"}
             memo ||= begin
-              a_eval = op.evaluate(a) rescue nil
-              b_eval = op.evaluate(b) rescue nil
+              a_eval = op.evaluate(a, options.merge(:queryable => queryable, :depth => options[:depth].to_i + 1)) rescue nil
+              b_eval = op.evaluate(b, options.merge(:queryable => queryable, :depth => options[:depth].to_i + 1)) rescue nil
               comp = if a_eval.nil?
                 RDF::Literal(-1)
               elsif b_eval.nil?

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

@@ -0,0 +1,32 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `sample` set function.
+    #
+    # @example
+    #   (prefix ((: <http://www.example.org/>))
+    #     (filter (|| (|| (= ?sample 1.0) (= ?sample 2.2)) (= ?sample 3.5))
+    #       (project (?sample)
+    #         (extend ((?sample ?.0))
+    #           (group () ((?.0 (sample ?o)))
+    #             (bgp (triple ?s :dec ?o)))))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#defn_aggSample
+    class Sample < Operator::Unary
+      include Aggregate
+
+      NAME = :sample
+
+      ##
+      # Sample is a set function which returns an arbitrary value from the multiset passed to it.
+      #
+      # @param  [Enumerable<Array<RDF::Term>>] enum
+      #   enum of evaluated operand
+      # @return [RDF::Term] An arbitrary term
+      # @raise  [TypeError] If enum is empty
+      def apply(enum)
+        enum.detect(lambda {raise TypeError, "Sampling an empty multiset"}) {|e| e.first}.first
+      end
+    end # LCase
+  end # Operator
+end; end # SPARQL::Algebra