sparql 1.0.8 → 1.1.0p0

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: eabf23290e66c519d04a3903fb9c10cab87236c5
-  data.tar.gz: ccf93905bff11c897f0fb00b01113095c527aa9e
-SHA512:
-  metadata.gz: de063e0c1d091dcb541f43d00942db7636c1e931f1504337cb9b0c8648085e30856bfbb332b08cfc392aece68c62595c1f6bd2924be9f715bc1fb2574b3b75a6
-  data.tar.gz: d03282b7ed8ae2edadbd9050d8101a9195df45844baa4cf126fefefef38c0b5089a07a67f75902e6a54d3a8404a86358ab13445a161f0b9fdc7fd0ad10aa9ac1
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NWU0YWQ2MjFiNjU1MDZlZmNmMGI4ZGU5ZGRhMDA1ZTI2NDk0NTdmYQ==
+  data.tar.gz: !binary |-
+    ZmNlOTk2OGUzMjQwZDY5OGIxZjM1Yjc3NmFlYjdkMjIyNmZlOWRhNw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    Mzc1ZmQ3NmNjYWJiOGU2ZDUzYjE4Mjk5NzM0NzIzZGU5MDQ4MjM3MzkxZjZh
+    YzIyYzJkNzJmNmMwMTJhNWE5ZjZjMzEyODlhNjkxYjk3MDE3YTg2YTQyZmEz
+    OGExNWMyZjhkYjBjZjQwZDFiOTQzNjFmODA0Y2ZlN2M1ZmYwMTI=
+  data.tar.gz: !binary |-
+    NzE5OTg5NDQ4MjEzOTEyY2E3NmMxYTM2ZDRlZmUwODMzZTAzNGE5ODUzMzVi
+    NGRiMzc0N2EzMTRiZTc0ZmJmZGQ1ZTgwNmY5YzQ5NDFmNGRmYWE1NjYzNTYz
+    ZjZhODkzN2E1NjQ3ZmIwNjUzZTRjZWJmMWIyZWQ1N2MwMDJkNzI=

data/README.md

@@ -9,9 +9,11 @@ This is a [Ruby][] implementation of [SPARQL][] for [RDF.rb][].
 ## Features
 
 * 100% free and unencumbered [public domain](http://unlicense.org/) software.
-* [SPARQL 1.0][] query parsing and execution
-* Limited [SPARQL 1.1][] query parsing and execution
-* SPARQL results as [XML][SPARQL XML], [JSON][SPARQL JSON] or HTML.
+* [SPARQL 1.1 Query][] parsing and execution (excluding [Property Paths][])
+* SPARQL results as [XML][SPARQL XML], [JSON][SPARQL JSON],
+  [CSV][SPARQL 1.1 Query Results CSV and TSV Formats],
+  [TSV][SPARQL 1.1 Query Results CSV and TSV Formats]
+  or HTML.
 * SPARQL CONSTRUCT or DESCRIBE serialized based on Format, Extension of Mime Type
   using available RDF Writers (see [Linked Data][])
 * SPARQL Client for accessing remote SPARQL endpoints.
@@ -24,32 +26,48 @@ This is a [Ruby][] implementation of [SPARQL][] for [RDF.rb][].
 
 ## Description
 
-The {SPARQL} gem implements the [SPARQL 1.0][] using the [SPARQL 1.1][] grammar,
-and provides [Rack][] and [Sinatra][]
+The {SPARQL} gem implements [SPARQL 1.1 Query][], and provides [Rack][] and [Sinatra][]
 middleware to provide results using [HTTP Content Negotiation][conneg].
 
-* {SPARQL::Grammar} implements a [SPARQL 1.1][] parser generating [SPARQL S-Expressions (SSE)][SSE].
-  * [SPARQL 1.1][] capabilities beyond [SPARQL 1.0][] are not yet supported.
-    See the section on [SPARQL 1.1][] extensions and limitations for further detail.
+* {SPARQL::Grammar} implements a [SPARQL 1.1 Query][] parser generating [SPARQL S-Expressions (SSE)][SSE].
+  * Support for [Property Paths][] is excluded.
+    See the section on [SPARQL 1.1 Query][] extensions and limitations for further detail.
 * {SPARQL::Algebra} executes SSE against Any `RDF::Graph` or `RDF::Repository`, including
   compliant [RDF.rb][] repository adaptors such as [RDF::DO][] and [RDF::Mongo][].
 * {Rack::SPARQL} and {Sinatra::SPARQL} provide middleware components to format results
   using an appropriate format based on [HTTP content negotiation][conneg].
 
-### [SPARQL 1.1][] Extensions and Limitations
-The {SPARQL} gem uses the [SPARQL 1.1][] {file:etc/sparql11.bnf EBNF grammar}, which provides
+### [SPARQL 1.1 Query][] Extensions and Limitations
+The {SPARQL} gem uses the [SPARQL 1.1 Query][] {file:etc/sparql11.bnf EBNF grammar}, which provides
 much more capability than [SPARQL 1.0][], but has a few limitations:
 
 * The format for decimal datatypes has changed in [RDF 1.1][]; they may no
   longer have a trailing ".", although they do not need a leading digit.
-* BNodes may now include extended characters, including ".". As a consequence, BNodes
-  used in the object position, where the statement or pattern is terminated by a "."
-  must contain whitespace separating the BNode label, and the ".".
+* BNodes may now include extended characters, including ".".
 
-The SPARQL gem now implements the following [SPARQL 1.1][] operations:
+The SPARQL gem now implements the following [SPARQL 1.1 Query][] operations:
 
-* Support for all [functions](http://www.w3.org/TR/sparql11-query/#SparqlOps).
-* Support for [BIND](http://www.w3.org/TR/sparql11-query/#bind)
+* [Functions](http://www.w3.org/TR/sparql11-query/#SparqlOps)
+* [BIND](http://www.w3.org/TR/sparql11-query/#bind)
+* [GROUP BY](http://www.w3.org/TR/sparql11-query/#groupby)
+* [Aggregates](http://www.w3.org/TR/sparql11-query/#aggregates)
+* [Subqueries](http://www.w3.org/TR/sparql11-query/#subqueries)
+* [Inline Data](http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#inline-data)
+* [Inline Data](http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#inline-data)
+* [Exists](http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#func-filter-exists)
+* [Negation](http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#negation)
+
+The only major area of [SPARQL 1.1 Query][] missing is
+[Property Paths][], which
+will be in later release along with:
+
+* [Update][SPARQL 1.1 Update],
+* [Federated Query][SPARQL 1.1 Federated Query],
+* [Entailment Regimes][SPARQL 1.1 Entailment Regimes],
+* [Protocol][SPARQL 1.1 Protocol], and
+* [Graph Store HTTP Protocol][SPARQL 1.1 Graph Store HTTP Protocol]
+
+either in this, or related gems.
 
 ### SPARQL Extension Functions
 Extension functions may be defined, which will be invoked during query evaluation. For example:
@@ -71,18 +89,21 @@ Then, use the function in a query:
       BIND(rsp:crypt(?email) AS ?crypted)
     }
 
+See {SPARQL::Algebra::Expression.register_extension} for details.
+
 ### Middleware
 
-`Rack::SPARQL` is a superset of [Rack::LinkedData][] to allow content negotiated results
+{Rack::SPARQL} is a superset of [Rack::LinkedData][] to allow content negotiated results
 to be returned any `RDF::Enumerable` or `RDF::Query::Solutions` compatible results.
 You would typically return an instance of `RDF::Graph`, `RDF::Repository` or `RDF::Query::Solutions`
 from your Rack application, and let the `Rack::SPARQL::ContentNegotiation` middleware
 take care of serializing your response into whatever format the HTTP
 client requested and understands.
 
-`Sinatra::SPARQL` is a thin Sinatra-specific wrapper around the
+{Sinatra::SPARQL} is a thin Sinatra-specific wrapper around the
 {Rack::SPARQL} middleware, which implements SPARQL
- content negotiation for Rack applications.
+ content negotiation for Rack applications. {Sinatra::SPARQL} also supports
+ [SPARQL 1.1 Service Description][].
 
 The middleware queries [RDF.rb][] for the MIME content types of known RDF
 serialization formats, so it will work with whatever serialization plugins
@@ -102,8 +123,8 @@ Queries using datasets are re-written to use the identified graphs for `FROM` an
 ### Result formats
 
 `SPARQL.serialize_results` may be used on it's own, or in conjunction with {Rack::SPARQL} or {Sinatra::SPARQL}
-to provide content-negotiated query results. For basic `SELECT` and `ASK` this includes HTML, XML and JSON formats.
-`DESCRIBE` and `CONSTRUCT` create an `RDF::Graph`, which can be serialized through [HTTP Content Netogiation][conneg]
+to provide content-negotiated query results. For basic `SELECT` and `ASK` this includes HTML, XML, CSV, TSV and JSON formats.
+`DESCRIBE` and `CONSTRUCT` create an `RDF::Graph`, which can be serialized through [HTTP Content Negotiation][conneg]
 using available RDF writers. For best results, require [Linked Data][] to enable
 a full set of RDF formats.
 
@@ -212,8 +233,8 @@ Full documentation available on [Rubydoc.info][SPARQL doc]
 ## Dependencies
 
 * [Ruby](http://ruby-lang.org/) (>= 1.9.2)
-* [RDF.rb](http://rubygems.org/gems/rdf) (>= 1.1)
-* [SPARQL::Client](https://rubygems.org/gems/sparql-client) (>= 1.0)
+* [RDF.rb](http://rubygems.org/gems/rdf) (>= 1.0.7)
+* [SPARQL::Client](https://rubygems.org/gems/sparql-client) (>= 1.0.3)
 * [SXP](https://rubygems.org/gems/sxp) (>= 0.1.0)
 * [Builder](https://rubygems.org/gems/builder) (>= 3.0.0)
 * [JSON](https://rubygems.org/gems/json) (>= 1.5.1)
@@ -281,7 +302,6 @@ A copy of the [SPARQL 1.0 tests][] and [SPARQL 1.1 tests][] are included in the
 [SPARQL 1.0]:       http://www.w3.org/TR/rdf-sparql-query/
 [SPARQL 1.0 tests]:http://www.w3.org/2001/sw/DataAccess/tests/
 [SPARQL 1.1 tests]: http://www.w3.org/2009/sparql/docs/tests/
-[SPARQL 1.1]:       http://www.w3.org/TR/sparql11-query/
 [SSE]:              http://openjena.org/wiki/SSE
 [SXP]:              http://sxp.rubyforge.org/
 [grammar]:          http://www.w3.org/TR/rdf-sparql-query/#grammar
@@ -292,9 +312,21 @@ A copy of the [SPARQL 1.0 tests][] and [SPARQL 1.1 tests][] are included in the
 [SPARQL doc]:       http://rubydoc.info/github/ruby-rdf/sparql/frames
 [SPARQL XML]:       http://www.w3.org/TR/rdf-sparql-XMLres/
 [SPARQL JSON]:      http://www.w3.org/TR/rdf-sparql-json-res/
-[SPARQL Protocol]:  http://www.w3.org/TR/rdf-sparql-protocol/
+[Property Paths]:   http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#propertypaths
+
 [SSD]:              http://www.w3.org/TR/sparql11-service-description/
 [Rack]:             http://rack.rubyforge.org/
 [Sinatra]:          http://www.sinatrarb.com/
 [conneg]:           http://en.wikipedia.org/wiki/Content_negotiation
 
+[SPARQL 1.1 Query]:                             http://www.w3.org/TR/sparql11-query/
+[SPARQL 1.1 Update]:                            http://www.w3.org/TR/sparql11-update/
+[SPARQL 1.1 Service Description]:               http://www.w3.org/TR/sparql11-service-description/
+[SPARQL 1.1 Federated Query]:                   http://www.w3.org/TR/sparql11-federated-query/
+[SPARQL 1.1 Query Results JSON Format]:         http://www.w3.org/TR/sparql11-results-json/
+[SPARQL 1.1 Query Results CSV and TSV Formats]: http://www.w3.org/TR/sparql11-results-csv-tsv/
+[SPARQL Query Results XML Format]:              http://www.w3.org/TR/rdf-sparql-XMLres/
+[SPARQL 1.1 Entailment Regimes]:                http://www.w3.org/TR/sparql11-entailment/
+[SPARQL 1.1 Protocol]:                          http://www.w3.org/TR/sparql11-protocol/
+[SPARQL 1.1 Graph Store HTTP Protocol]:         http://www.w3.org/TR/sparql11-http-rdf-update/
+

data/VERSION

@@ -1 +1 @@
-1.0.8
+1.1.0p0

data/lib/sinatra/sparql.rb

@@ -42,7 +42,7 @@ module Sinatra
         node = RDF::Node.new
         g << [node, RDF.type, sd.join("#Service")]
         g << [node, sd.join("#endpoint"), options[:endpoint] || url("/sparql")]
-        g << [node, sd.join("#supportedLanguage"), sd.join("#SPARQL10Query")]
+        g << [node, sd.join("#supportedLanguage"), sd.join("#SPARQL11Query")]
       
         # Result formats, both RDF and SPARQL Results.
         # FIXME: We should get this from the avaliable serializers
@@ -50,8 +50,10 @@ module Sinatra
         g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/Turtle")]
         g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/RDFa")]
         g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/N-Triples")]
-        g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/SPARQL_RESULTS_XML")]
-        g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/SPARQL_RESULTS_JSON")]
+        g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/SPARQL_Results_XML")]
+        g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/SPARQL_Results_JSON")]
+        g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/SPARQL_Results_CSV")]
+        g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/SPARQL_Results_TSV")]
       
         # Features
         g << [node, sd.join("#feature"), sd.join("#DereferencesURIs")]

data/lib/sparql/algebra/aggregate.rb

@@ -0,0 +1,67 @@
+module SPARQL; module Algebra
+  ##
+  # A SPARQL algebra aggregate.
+  #
+  # Aggregates are for SPARQL set functions. Aggregates take one
+  # or more operands which are `Enumerable` lists of `RDF::Term`
+  # and return a single `RDF::Term` or `TypeError`.
+  #
+  # @see http://www.w3.org/TR/sparql11-query/#setFunctions
+  # @see http://www.w3.org/TR/sparql11-query/#aggregates
+  #
+  # @abstract
+  module Aggregate
+    ##
+    # Aggregates this operator accross its operands using
+    # a solutions enumerable.
+    #
+    # @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 = {})
+      args_enum = solutions.map do |solution|
+        operands.map do |operand|
+          begin
+            operand.evaluate(solution, options.merge(:depth => options[:depth].to_i + 1))
+          rescue TypeError
+            # Ignore errors
+            nil
+          end
+        end.compact
+      end
+      apply(args_enum)
+    end
+
+    ##
+    # @param  [Enumerable<Array<RDF::Term>>] enum
+    #   Enumerable yielding evaluated operands
+    # @return [RDF::Term]
+    # @abstract
+    def apply(enum)
+      raise NotImplementedError, "#{self.class}#apply(#{operands.map(&:class).join(', ')})"
+    end
+
+    ##
+    # This is a no-op for Aggregates.
+    #
+    # @return [SPARQL::Algebra::Evaluatable] self
+    def replace_vars!(&block)
+      self
+    end
+
+    ##
+    # Replace ourselves with a variable returned from the block
+    #
+    # @yield agg
+    # @yieldparam [SPARQL::Algebra::Aggregate] agg
+    # @yieldreturn [RDF::Query::Variable]
+    # @return [RDF::Query::Variable] the returned variable
+    def replace_aggregate!(&block)
+      yield self
+    end
+  end # Aggregate
+end; end # SPARQL::Algebra

data/lib/sparql/algebra/evaluatable.rb

@@ -7,12 +7,14 @@ module SPARQL; module Algebra
     ##
     # Evaluates this operator using the given variable `bindings`.
     #
-    # @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]
     # @abstract
-    def evaluate(bindings = {})
-      args = operands.map { |operand| operand.evaluate(bindings) }
+    def evaluate(bindings, options = {})
+      args = operands.map { |operand| operand.evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1)) }
       options[:memoize] ? memoize(*args) : apply(*args)
     end
 
@@ -33,5 +35,48 @@ module SPARQL; module Algebra
     def apply(*operands)
       raise NotImplementedError, "#{self.class}#apply(#{operands.map(&:class).join(', ')})"
     end
-  end # Query
+
+    ##
+    # Replace operators which are variables with the result of the block
+    # descending into operators which are also evaluatable
+    #
+    # @yield var
+    # @yieldparam [RDF::Query::Variable] var
+    # @yieldreturn [RDF::Query::Variable, SPARQL::Algebra::Evaluatable]
+    # @return [SPARQL::Algebra::Evaluatable] self
+    def replace_vars!(&block)
+      @operands.map! do |op|
+        case
+        when op.is_a?(RDF::Query::Variable)
+          yield op
+        when op.respond_to?(:replace_vars!)
+          op.replace_vars!(&block) 
+        else
+          op
+        end
+      end
+      self
+    end
+
+    ##
+    # Recursively re-map operators to replace aggregates with temporary variables returned from the block
+    #
+    # @yield agg
+    # @yieldparam [SPARQL::Algebra::Aggregate] agg
+    # @yieldreturn [RDF::Query::Variable]
+    # @return [SPARQL::Algebra::Evaluatable, RDF::Query::Variable] self
+    def replace_aggregate!(&block)
+      @operands.map! do |op|
+        case
+        when op.aggregate?
+          yield op
+        when op.respond_to?(:replace_aggregate!)
+          op.replace_aggregate!(&block) 
+        else
+          op
+        end
+      end
+      self
+    end
+  end # Evaluatable
 end; end # SPARQL::Algebra

data/lib/sparql/algebra/expression.rb

@@ -149,7 +149,6 @@ module SPARQL; module Algebra
     # @yield *args
     # @yieldparam [Array<RDF::Term>] *args
     # @yieldreturn [RDF::Term]
-    # @param [Proc] function
     # @return [void]
     # @raise [TypeError] if `uri` is not an RDF::URI or no block is given
     def self.register_extension(uri, &block)
@@ -174,7 +173,7 @@ module SPARQL; module Algebra
     # that.
     #
     # @param [RDF::URI] function
-    # @param [Array<RDF::Term>] *args
+    # @param [Array<RDF::Term>] args splat of args to function
     # @return [RDF::Term]
     # @see http://www.w3.org/TR/sparql11-query/#extensionFunctions
     # @see http://www.w3.org/TR/sparql11-query/#FunctionMapping
@@ -289,9 +288,12 @@ module SPARQL; module Algebra
     # Subclasses can override this method in order to implement something
     # more useful.
     #
-    # @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 [Expression] `self`
-    def evaluate(bindings = {})
+    def evaluate(bindings, options = {})
       self
     end
 

data/lib/sparql/algebra/extensions.rb

@@ -20,7 +20,7 @@ class Object
 end
 
 ##
-# Extensions for Ruby's `Object` class.
+# Extensions for Ruby's `Array` class.
 class Array
   ##
   # Returns the SXP representation of this object, defaults to `self`.
@@ -29,7 +29,7 @@ class Array
   def to_sxp_bin
     map {|x| x.to_sxp_bin}
   end
-  
+
   ##
   # Evaluates the array using the given variable `bindings`.
   #
@@ -37,12 +37,14 @@ class Array
   # an XSD datatype, and the second is the expression to be evaluated.
   # The result is cast as a literal of the appropriate type
   #
-  # @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]
-  def evaluate(bindings)
-    dt, val = self.map {|o| o.evaluate(bindings)}
-    SPARQL::Algebra::Expression.extension(*self.map {|o| o.evaluate(bindings)})
+  # @see {SPARQL::Algebra::Expression.evaluate}
+  def evaluate(bindings, options = {})
+    SPARQL::Algebra::Expression.extension(*self.map {|o| o.evaluate(bindings, options)})
   end
 
   ##
@@ -58,6 +60,79 @@ class Array
   def execute(queryable, options = {})
     raise NotImplementedError, "SPARQL::Algebra '#{first}' operator not implemented"
   end
+
+  ##
+  # Returns `true` if any of the operands are variables, `false`
+  # otherwise.
+  #
+  # @return [Boolean] `true` or `false`
+  # @see    #constant?
+  def variable?
+    any? do |operand|
+      operand.is_a?(Variable) ||
+        (operand.respond_to?(:variable?) && operand.variable?)
+    end
+  end
+  def constant?; !(variable?); end
+  def evaluatable?; true; end
+  def executable?; false; end
+  def aggregate?; false; end
+
+  ##
+  # Replace operators which are variables with the result of the block
+  # descending into operators which are also evaluatable
+  #
+  # @yield var
+  # @yieldparam [RDF::Query::Variable] var
+  # @yieldreturn [RDF::Query::Variable, SPARQL::Algebra::Evaluatable]
+  # @return [SPARQL::Algebra::Evaluatable] self
+  def replace_vars!(&block)
+    map! do |op|
+      case
+      when op.respond_to?(:variable?) && op.variable?
+        yield op
+      when op.respond_to?(:replace_vars!)
+        op.replace_vars!(&block) 
+      else
+        op
+      end
+    end
+    self
+  end
+
+  ##
+  # Recursively re-map operators to replace aggregates with temporary variables returned from the block
+  #
+  # @yield agg
+  # @yieldparam [SPARQL::Algebra::Aggregate] agg
+  # @yieldreturn [RDF::Query::Variable]
+  # @return [SPARQL::Algebra::Evaluatable, RDF::Query::Variable] self
+  def replace_aggregate!(&block)
+    map! do |op|
+      case
+      when op.respond_to?(:aggregate?) && op.aggregate?
+        yield op
+      when op.respond_to?(:replace_aggregate!)
+        op.replace_aggregate!(&block) 
+      else
+        op
+      end
+    end
+    self
+  end
+end
+
+##
+# Extensions for Ruby's `Hash` class.
+class Hash
+  ##
+  # Returns the SXP representation of this object, defaults to `self`.
+  #
+  # @return [String]
+  def to_sxp_bin
+    to_a.to_sxp_bin
+  end
+  def to_sxp; to_sxp_bin; end
 end
 
 ##
@@ -65,10 +140,17 @@ end
 module RDF::Term
   include SPARQL::Algebra::Expression
   
-  def evaluate(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]
+  def evaluate(bindings, options = {})
     self
   end
 
+  def aggregate?; false; end
+
   # Term compatibility according to SPARQL
   #
   # Compatibility of two arguments is defined as:
@@ -185,13 +267,21 @@ class RDF::Query::Variable
   ##
   # Returns the value of this variable in the given `bindings`.
   #
-  # @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] the value of this variable
   # @raise [TypeError] if the variable is not bound
-  def evaluate(bindings = {})
+  def evaluate(bindings, options = {})
     raise TypeError if bindings.respond_to?(:bound?) && !bindings.bound?(self)
     bindings[name.to_sym]
   end
+
+  def to_s
+    prefix = distinguished? || name.to_s[0,1] == '.' ? '?' : "??"
+    unbound? ? "#{prefix}#{name}" : "#{prefix}#{name}=#{value}"
+  end
 end # RDF::Query::Variable
 
 ##

data/lib/sparql/algebra/operator/and.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 boolean literals
-      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/asc.rb

@@ -19,10 +19,13 @@ module SPARQL; module Algebra
       # Returns the evaluation of it's operand. Default comparison is in
       # ascending order. Ordering is applied in {Order}.
       #
-      # @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]
-      def evaluate(bindings = {})
-        operand(0).evaluate(bindings)
+      def evaluate(bindings, options = {})
+        operand(0).evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1))
       end
     end # Asc
   end # Operator

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

@@ -0,0 +1,36 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `avg` set function.
+    #
+    # @example
+    #    (prefix ((: <http://www.example.org/>))
+    #      (project (?avg)
+    #        (extend ((?avg ?.0))
+    #          (group () ((?.0 (avg ?o)))
+    #            (bgp (triple ?s :dec ?o))))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#defn_aggAvg
+    class Avg < Operator::Unary
+      include Aggregate
+
+      NAME = :avg
+
+      ##
+      # The Avg set function calculates the average value for an expression over a group. It is defined in terms of Sum and Count.
+      #
+      # @param  [Enumerable<Array<RDF::Term>>] enum
+      #   enum of evaluated operand
+      # @return [RDF::Literal::Numeric] The numeric average of the terms
+      def apply(enum)
+        if enum.empty?
+          RDF::Literal(0)
+        elsif enum.flatten.all? {|n| n.is_a?(RDF::Literal::Numeric)}
+          enum.flatten.reduce(:+) / RDF::Literal::Decimal.new(enum.length)
+        else
+          raise TypeError, "Averaging non-numeric types: #{enum.flatten}"
+        end
+      end
+    end # Avg
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -35,12 +35,13 @@ module SPARQL; module Algebra
       ##
       # Evaluates this operator using the given variable `bindings`.
       #
-      # @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]
-      # @abstract
-      def evaluate(bindings = {})
-        args = operands.map { |operand| operand.evaluate(bindings) }
+      def evaluate(bindings, options = {})
+        args = operands.map { |operand| operand.evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1)) }
         apply(args.first, bindings)
       end
 

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

@@ -33,10 +33,13 @@ module SPARQL; module Algebra
       # Returns `true` if the operand is a variable that is bound to a
       # value in the given `bindings`, `false` otherwise.
       #
-      # @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 operand is not a variable
-      def evaluate(bindings = {})
+      def evaluate(bindings, options = {})
         case var = operand
           when Variable
             bindings.respond_to?(:bound?) && bindings.bound?(var) ?

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

@@ -38,13 +38,16 @@ module SPARQL; module Algebra
       #     COALESCE(?y, 3) #=> 3
       #     COALESCE(?y) #=> raises an error because y is not bound.
       #
-      # @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 none of the operands succeeds
-      def evaluate(bindings = {})
+      def evaluate(bindings, options = {})
         operands.each do |op|
           begin
-            return op.evaluate(bindings)
+            return op.evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1))
           rescue
           end
         end