sparql 1.0.1 → 1.0.2

data/README.markdown

@@ -54,6 +54,8 @@ passing HTTP Accept headers for various available RDF formats. For best results,
 a full set of RDF formats in the `GET` request. Also, consider overriding `RDF::Util::File.open_file` with
 an implementation with support for HTTP Get headers (such as `Net::HTTP`).
 
+Queries using datasets are re-written to use the identified graphs for `FROM` and `FROM NAMED` by filtering the results, allowing the use of a repository that contains many graphs without confusing information.
+
 ### Result formats
 
 `SPARQL.serialize_results` may be used on it's own, or in conjunction with {Rack::SPARQL} or {Sinatra::SPARQL}

data/VERSION

@@ -1 +1 @@
-1.0.1
+1.0.2

data/lib/sparql/algebra.rb

@@ -147,17 +147,17 @@ module SPARQL
   # 
   # ## Constructing operator expressions using SSE forms
   # 
-  #     Expression[:isBlank, RDF::Node(:foobar)].to_sxp                          #=> "(isBlank _:foobar)"
-  #     Expression[:isIRI, RDF::URI('http://rdf.rubyforge.org/')].to_sxp         #=> "(isIRI <http://rdf.rubyforge.org/>)"
-  #     Expression[:isLiteral, RDF::Literal(3.1415)].to_sxp                      #=> "(isLiteral 3.1415)"
-  #     Expression[:str, [:datatype, RDF::Literal(3.1415)]].to_sxp               #=> "(str (datatype 3.1415))"
+  #     SPARQL::Algebra::Expression[:isBlank, RDF::Node(:foobar)].to_sxp                          #=> "(isBlank _:foobar)"
+  #     SPARQL::Algebra::Expression[:isIRI, RDF::URI('http://rdf.rubyforge.org/')].to_sxp         #=> "(isIRI <http://rdf.rubyforge.org/>)"
+  #     SPARQL::Algebra::Expression[:isLiteral, RDF::Literal(3.1415)].to_sxp                      #=> "(isLiteral 3.1415)"
+  #     SPARQL::Algebra::Expression[:str, [:datatype, RDF::Literal(3.1415)]].to_sxp               #=> "(str (datatype 3.1415))"
   # 
   # ## Constructing operator expressions using SSE strings
   # 
-  #     Expression.parse('(isBlank _:foobar)')
-  #     Expression.parse('(isIRI <http://rdf.rubyforge.org/>)')
-  #     Expression.parse('(isLiteral 3.1415)')
-  #     Expression.parse('(str (datatype 3.1415))')
+  #     SPARQL::Algebra::Expression.parse('(isBlank _:foobar)')
+  #     SPARQL::Algebra::Expression.parse('(isIRI <http://rdf.rubyforge.org/>)')
+  #     SPARQL::Algebra::Expression.parse('(isLiteral 3.1415)')
+  #     SPARQL::Algebra::Expression.parse('(str (datatype 3.1415))')
   # 
   # ## Evaluating operators standalone
   # 
@@ -167,8 +167,8 @@ module SPARQL
   # 
   # ## Optimizing expressions containing constant subexpressions
   # 
-  #     Expression.parse('(sameTerm ?var ?var)').optimize            #=> RDF::Literal::TRUE
-  #     Expression.parse('(* -2 (- (* (+ 1 2) (+ 3 4))))').optimize  #=> RDF::Literal(42)
+  #     SPARQL::Algebra::Expression.parse('(sameTerm ?var ?var)').optimize            #=> RDF::Literal::TRUE
+  #     SPARQL::Algebra::Expression.parse('(* -2 (- (* (+ 1 2) (+ 3 4))))').optimize  #=> RDF::Literal(42)
   # 
   # ## Evaluating expressions on a solution sequence
   # 
@@ -180,8 +180,8 @@ module SPARQL
   #     end
   # 
   #     # Find people who have a name but don't have a known e-mail address:
-  #     expression = Expression[:not, [:bound, Variable(:email)]]    # ...or just...
-  #     expression = Expression.parse('(not (bound ?email))')
+  #     expression = SPARQL::Algebra::Expression[:not, [:bound, Variable(:email)]]    # ...or just...
+  #     expression = SPARQL::Algebra::Expression.parse('(not (bound ?email))')
   #     solutions.filter!(expression)
   # 
   # @example Optimizations
@@ -189,7 +189,7 @@ module SPARQL
   # Some very simple optimizations are currently implemented for `FILTER`
   # expressions. Use the following to obtain optimized SSE forms:
   # 
-  #     Expression.parse(sse).optimize.to_sxp_bin
+  #     SPARQL::Algebra::Expression.parse(sse).optimize.to_sxp_bin
   # 
   # ## Constant comparison folding
   # 
@@ -209,7 +209,7 @@ module SPARQL
   # Expressions can optionally be [memoized][memoization], which can speed up
   # repeatedly executing the expression on a solution sequence:
   # 
-  #     Expression.parse(sse, :memoize => true)
+  #     SPARQL::Algebra::Expression.parse(sse, :memoize => true)
   #     Operator.new(*operands, :memoize => true)
   # 
   # Memoization is implemented using RDF.rb's [RDF::Util::Cache][] utility

data/lib/sparql/algebra/extensions.rb

@@ -107,6 +107,13 @@ class RDF::Query
   def ==(other)
     other.is_a?(RDF::Query) && patterns == other.patterns && context == context
   end
+      
+  ##
+  # Don't do any more rewriting
+  # @return [SPARQL::Algebra::Expression] `self`
+  def rewrite(&block)
+    self
+  end
 
   # Transform Query into an Array form of an SSE
   #

data/lib/sparql/algebra/operator.rb

@@ -322,6 +322,26 @@ module SPARQL; module Algebra
       end
     end
 
+    ##
+    # Rewrite operands by yielding each operand. Recursively descends
+    # through operands implementing this method.
+    #
+    # @yield operand
+    # @yieldparam [] operand
+    # @yieldreturn [SPARQL::Algebra::Expression] the re-written operand
+    # @return [SPARQL::Algebra::Expression] `self`
+    def rewrite(&block)
+      @operands = @operands.map do |op|
+        # Rewrite the operand
+        unless new_op = block.call(op)
+          # Not re-written, rewrite
+          new_op = op.respond_to?(:rewrite) ? op.rewrite(&block) : op
+        end
+        new_op
+      end
+      self
+    end
+
     ##
     # Returns the SPARQL S-Expression (SSE) representation of this operator.
     #
@@ -362,6 +382,7 @@ module SPARQL; module Algebra
       other.class == self.class && other.operands == self.operands
     end
     alias_method :==, :eql?
+
   protected
 
     ##
@@ -401,6 +422,27 @@ module SPARQL; module Algebra
       end
     end
 
+    ##
+    # Transform an array of expressions into a recursive set
+    # of binary operations
+    # e.g.: a || b || c => (|| a (|| b c))
+    # @param [Class] Binary Operator class
+    # @param [Array<SPARQL::Algebra::Expression>] *expressions
+    # @return [SPARQL::Algebra::Expression]
+    def to_binary(klass, *expressions)
+      case expressions.length
+      when 0
+        # Oops!
+        raise "Operator#to_binary requires two or more expressions"
+      when 1
+        expressions.first
+      when 2
+        klass.new(*expressions)
+      else
+        klass.new(expressions.shift, to_binary(klass, *expressions))
+      end
+    end
+
   private
 
     @@subclasses = [] # @private

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

@@ -4,25 +4,109 @@ rescue LoadError => e
   require 'rdf/ntriples'
 end
 
+# 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
     ##
     # The SPARQL GraphPattern `dataset` operator.
     #
-    # Instintiated with two operands, the first being an array of data source URIs,
+    # Instantiated with two operands, the first being an array of data source URIs,
     # either bare, indicating a default dataset, or expressed as an array `\[:named, \<uri\>\]`,
     # indicating that it represents a named data source.
     #
-    # @example
+    # This operator loads from the datasource, unless a graph named by
+    # the datasource URI already exists in the repository.
+    #
+    # The contained BGP queries are then performed against the specified
+    # default and named graphs. Rather than using the actual default
+    # graph of the dataset, queries against the default dataset are
+    # run against named graphs matching a non-distinctive variable
+    # and the results are filtered against those URIs included in
+    # the default dataset.
+    #
+    # Specifically, each BGP which is not part of a graph pattern
+    # is replaced with a union of graph patterns with that BGP repeated
+    # for each graph URI in the default dataset. This requires recursively
+    # updating the operator.
+    #
+    # Each graph pattern containing a variable graph name is replaced
+    # by a filter on that variable such that the variable must match
+    # only those named datasets specified.
+    #
+    # @example Dataset with one default and one named data source
     #
     #     (prefix ((: <http://example/>))
     #       (dataset (<data-g1.ttl> (named <data-g2.ttl>))
+    #         (union
+    #           (bgp (triple ?s ?p ?o))
+    #           (graph ?g (bgp (triple ?s ?p ?o))))))
+    #
+    #     is effectively re-written to the following:
+    #
+    #     (prefix ((: <http://example/>))
+    #       (union
+    #         (graph <data-g1.ttl> (bgp (triple ?s ?p ?o)))
+    #         (filter (= ?g <data-g2.ttl>)
+    #           (graph ?g (bgp (triple ?s ?p ?o))))))
+    #
+    # If no default or no named graphs are specified, these queries
+    # are eliminated.
+    #
+    # @example Dataset with one default no named data sources
+    #
+    #     (prefix ((: <http://example/>))
+    #       (dataset (<data-g1.ttl>)
+    #         (union
+    #           (bgp (triple ?s ?p ?o))
+    #           (graph ?g (bgp (triple ?s ?p ?o))))))
+    #
+    #     is effectively re-written to the following:
+    #
+    #     (prefix ((: <http://example/>))
+    #       (union
+    #         (graph <data-g1.ttl> (bgp (triple ?s ?p ?o)))
+    #         (bgp))
+    #
+    # Multiple default graphs union the information from a graph query
+    # on each default datasource.
+    #
+    # @example Dataset with two default data sources
+    #
+    #     (prefix ((: <http://example/>))
+    #       (dataset (<data-g1.ttl> <data-g1.ttl)
     #         (bgp (triple ?s ?p ?o))))
     #
+    #     is effectively re-written to the following:
+    #
+    #     (prefix ((: <http://example/>))
+    #       (union
+    #         (graph <data-g1.ttl> (bgp (triple ?s ?p ?o)))
+    #         (graph <data-g2.ttl> (bgp (triple ?s ?p ?o)))))
+    #
+    # Multiple named graphs place a filter on all variables used
+    # to identify those named graphs so that they are restricted
+    # to come only from the specified set. Note that this requires
+    # descending through expressions to find graph patterns using
+    # variables and placing a filter on each identified variable.
+    #
+    # @example Dataset with two named data sources
+    #
+    #     (prefix ((: <http://example/>))
+    #       (dataset ((named <data-g1.ttl>) (named <data-g2.ttl>))
+    #         (graph ?g (bgp (triple ?s ?p ?o)))))
+    #
+    #     is effectively re-written to the following:
+    #
+    #     (prefix ((: <http://example/>))
+    #       (filter ((= ?g <data-g1.ttl>) || (= ?g <data-g2.ttl>))
+    #         (graph ?g (bgp (triple ?s ?p ?o))))))
+    #
+    # @example Dataset with multiple named graphs
     # @see http://www.w3.org/TR/rdf-sparql-query/#specifyingDataset
     class Dataset < Binary
       include Query
-      
+
       NAME = [:dataset]
       # Selected accept headers, from those available
       ACCEPTS = (%w(
@@ -52,6 +136,8 @@ module SPARQL; module Algebra
       # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
       def execute(queryable, options = {})
         debug(options) {"Dataset"}
+        default_datasets = []
+        named_datasets = []
         operand(0).each do |ds|
           load_opts = {
             :headers => {"Accept" => ACCEPTS}
@@ -69,18 +155,66 @@ module SPARQL; module Algebra
             end
             uri = self.base_uri ? self.base_uri.join(ds.last) : ds.last
             uri.lexical = ds.last
-            load_opts[:context] = uri
-            debug(options) {"=> read named data source #{uri}"}
+            debug(options) {"=> named data source #{uri}"}
+            named_datasets << uri
           else
-            debug(options) {"=> array: join #{self.base_uri.inspect} to #{ds.inspect}"}
             uri = self.base_uri ? self.base_uri.join(ds) : ds
-            debug(options) {"=> read default data source #{uri}"}
+            debug(options) {"=> default data source #{uri}"}
+            default_datasets << uri
+          end
+          load_opts[:context] = load_opts[:base_uri] = uri
+          unless queryable.has_context?(uri)
+            debug(options) {"=> load #{uri}"}
+            queryable.load(uri.to_s, load_opts)
+          end
+        end
+        require 'rdf/nquads'
+        debug(options) { 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
-          load_opts[:base_uri] = uri
-          queryable.load(uri.to_s, load_opts)
         end
+        executable = operator.operands.last
+        debug(options) {"=> rewritten: #{executable.to_sxp}"}
 
-        @solutions = operands.last.execute(queryable, options.merge(:depth => options[:depth].to_i + 1))
+        @solutions = executable.execute(queryable, options.merge(:depth => options[:depth].to_i + 1))
       end
       
       ##

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

@@ -33,7 +33,7 @@ module SPARQL; module Algebra
       # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
       # @see    http://www.w3.org/TR/rdf-sparql-query/#ebv
       def execute(queryable, options = {})
-        debug(options) {"Filter #{operands.first}"}
+        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}"}
         @solutions = @solutions.filter do |solution|

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

@@ -1,3 +1,4 @@
+# FIXME: This depends on an update to RDF::Query#execute to be able to pass the context as an option.
 module SPARQL; module Algebra
   class Operator
     ##
@@ -12,16 +13,44 @@ module SPARQL; module Algebra
     #
     # @see http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
     class Graph < Operator::Binary
+      include Query
+      
       NAME = [:graph]
+
       ##
-      # A `graph` is an RDF::Query with a context.
+      # Executes this query on the given `queryable` graph or repository.
+      # Applies the given `context` to the query, limiting the scope of the query to the specified `context`, which may be an `RDF::URI` or `RDF::Query::Variable`.
       #
-      # @param [RDF::URI, RDF::Query::Variable] context
-      # @param [RDF::Query] bgp
-      # @return [RDF::Query]
-      def self.new(context, bgp)
-        bgp.context = context
-        bgp
+      # @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/rdf-sparql-query/#sparqlAlgebra
+      def execute(queryable, options = {})
+        debug(options) {"Graph #{operands.first}"}
+        context, query = operands.first, operands.last
+        @solutions = query.execute(queryable, options.merge(:context => context))
+        debug(options) {"=>(after) #{@solutions.map(&:to_hash).inspect}"}
+        @solutions
+      end
+      
+      ##
+      # Returns an optimized version of this query.
+      #
+      # Return optimized query
+      #
+      # @return [Union, RDF::Query] `self`
+      def optimize
+        operands = operands.map(&:optimize)
+      end
+      
+      ##
+      # Don't do any more rewriting
+      # @return [SPARQL::Algebra::Expression] `self`
+      def rewrite(&block)
+        self
       end
     end # Graph
   end # Operator

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

@@ -29,11 +29,11 @@ module SPARQL; module Algebra
       # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
       def execute(queryable, options = {})
         debug(options) {"Union"}
-        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 = RDF::Query::Solutions.new(solutions1 + solutions2)
+        @solutions = RDF::Query::Solutions.new(operands.inject([]) do |memo, op|
+          solns = op.execute(queryable, options.merge(:depth => options[:depth].to_i + 1))
+          debug(options) {"=> (op) #{solns.inspect}"}
+          memo + solns
+        end)
         debug(options) {"=> #{@solutions.inspect}"}
         @solutions
       end
@@ -41,8 +41,7 @@ module SPARQL; module Algebra
       ##
       # Returns an optimized version of this query.
       #
-      # If optimize operands, and if the first two operands are both Queries, replace
-      # with the unique sum of the query elements
+      # Optimize operands and remove any which are empty.
       #
       # @return [Union, RDF::Query] `self`
       def optimize

data/lib/sparql/grammar.rb

@@ -35,12 +35,6 @@ module SPARQL
   #
   #     SELECT * WHERE { ?a ?b ?c }
   # 
-  # SSE:
-  #
-  #     RDF::Query.new {
-  #       pattern [RDF::Query::Variable.new("a"), RDF::Query::Variable.new("b"), RDF::Query::Variable.new("c")]
-  #     }
-  # 
   # SXP:
   #
   #     (bgp (triple ?a ?b ?c))
@@ -49,15 +43,6 @@ module SPARQL
   #
   #     SELECT * FROM <a> WHERE { ?a ?b ?c }
   # 
-  # SSE:
-  #
-  #     SPARQL::Algebra::Operator::Dataset.new(
-  #       [RDF::URI("a")],
-  #       RDF::Query.new {
-  #         pattern [RDF::Query::Variable.new("a"), RDF::Query::Variable.new("b"), RDF::Query::Variable.new("c")]
-  #       }
-  #     )
-  # 
   # SXP:
   #
   #     (dataset (<a>) (bgp (triple ?a ?b ?c)))
@@ -66,15 +51,6 @@ module SPARQL
   #
   #     SELECT * FROM NAMED <a> WHERE { ?a ?b ?c }
   # 
-  # SSE:
-  #
-  #     SPARQL::Algebra::Operator::Dataset.new(
-  #       [[:named, RDF::URI("a")]],
-  #       RDF::Query.new {
-  #         pattern [RDF::Query::Variable.new("a"), RDF::Query::Variable.new("b"), RDF::Query::Variable.new("c")]
-  #       }
-  #     )
-  # 
   # SXP:
   #
   #     (dataset ((named <a>)) (bgp (triple ?a ?b ?c)))
@@ -83,14 +59,6 @@ module SPARQL
   #
   #     SELECT DISTINCT * WHERE {?a ?b ?c}
   # 
-  # SSE:
-  #
-  #     SPARQL::Algebra::Operator::Distinct.new(
-  #       RDF::Query.new {
-  #         pattern [RDF::Query::Variable.new("a"), RDF::Query::Variable.new("b"), RDF::Query::Variable.new("c")]
-  #       }
-  #     )
-  # 
   # SXP:
   #
   #     (distinct (bgp (triple ?a ?b ?c)))
@@ -99,15 +67,6 @@ module SPARQL
   #
   #     SELECT ?a ?b WHERE {?a ?b ?c}
   # 
-  # SSE:
-  #
-  #     SPARQL::Algebra::Operator::Project.new(
-  #       [RDF::Query::Variable.new("a"), RDF::Query::Variable.new("b")], 
-  #       RDF::Query.new {
-  #         pattern [RDF::Query::Variable.new("a"), RDF::Query::Variable.new("b"), RDF::Query::Variable.new("c")]
-  #       }
-  #     )
-  # 
   # SXP:
   #
   #     (project (?a ?b) (bgp (triple ?a ?b ?c)))
@@ -116,18 +75,6 @@ module SPARQL
   #
   #     CONSTRUCT {?a ?b ?c} WHERE {?a ?b ?c FILTER (?a)}
   # 
-  # SSE:
-  #
-  #     SPARQL::Algebra::Operator::Construct.new(
-  #       [RDF::Query::Pattern.new(RDF::Query::Variable.new("a"), RDF::Query::Variable.new("b"), RDF::Query::Variable.new("c"))],
-  #       SPARQL::Algebra::Operator::Filter.new(
-  #         RDF::Query::Variable.new("a"),
-  #         RDF::Query.new {
-  #           pattern [RDF::Query::Variable.new("a"), RDF::Query::Variable.new("b"), RDF::Query::Variable.new("c")]
-  #         }
-  #       )
-  #     )
-  # 
   # SXP:
   #
   #     (construct ((triple ?a ?b ?c)) (filter ?a (bgp (triple ?a ?b ?c))))
@@ -136,17 +83,6 @@ module SPARQL
   #
   #     SELECT * WHERE {<a> <b> <c> OPTIONAL {<d> <e> <f>}}
   # 
-  # SSE:
-  #
-  #     SPARQL::Algebra::Operator::LeftJoin.new(
-  #       RDF::Query.new {
-  #         pattern [RDF::URI("a"), RDF::URI("b"), RDF::URI("c")]
-  #       },
-  #       RDF::Query.new {
-  #         pattern [RDF::URI("d"), RDF::URI("e"), RDF::URI("f")]
-  #       }
-  #     )
-  # 
   # SXP:
   #
   #     (leftjoin (bgp (triple <a> <b> <c>)) (bgp (triple <d> <e> <f>)))
@@ -155,17 +91,6 @@ module SPARQL
   #
   #     SELECT * WHERE {<a> <b> <c> {<d> <e> <f>}}
   # 
-  # SSE:
-  #
-  #     SPARQL::Algebra::Operator::Join.new(
-  #       RDF::Query.new {
-  #         pattern [RDF::URI("a"), RDF::URI("b"), RDF::URI("c")]
-  #       },
-  #       RDF::Query.new {
-  #         pattern [RDF::URI("d"), RDF::URI("e"), RDF::URI("f")]
-  #       }
-  #     )
-  # 
   # SXP:
   #
   #     (join (bgp (triple <a> <b> <c>)) (bgp (triple <d> <e> <f>)))
@@ -181,20 +106,6 @@ module SPARQL
   #        { GRAPH ?g { ?s ?p ?o } }
   #     }
   # 
-  # SSE:
-  #
-  #     SPARQL::Algebra::Operator::Prefix.new(
-  #       [[:":", RDF::URI("http://example/")]],
-  #       SPARQL::Algebra::Operator::Union.new(
-  #         RDF::Query.new {
-  #           pattern [RDF::Query::Variable.new("s"), RDF::Query::Variable.new("p"), RDF::Query::Variable.new("o")]
-  #         },
-  #         RDF::Query.new(:context => RDF::Query::Variable.new("g")) {
-  #           pattern [RDF::Query::Variable.new("s"), RDF::Query::Variable.new("p"), RDF::Query::Variable.new("o")]
-  #         }
-  #       )
-  #     )
-  # 
   # SXP:
   #
   #     (prefix ((: <http://example/>))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sparql
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-22 00:00:00.000000000 Z
+date: 2013-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -20,7 +20,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -28,7 +28,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.0.1
 - !ruby/object:Gem::Dependency
   name: builder
   requirement: !ruby/object:Gem::Requirement
@@ -386,7 +386,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: sparql
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: SPARQL library for Ruby.