rdf-blazegraph 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8e2e77f00c85d5d33fa1138638238040525b0311
-  data.tar.gz: d3cc73a2b6bd389a3206999ff1a8105d8764f065
+  metadata.gz: c0c6c5c91cbcc317617576f87509b86b8ffd55c4
+  data.tar.gz: 0ce51a89e9f46712dae6274cc92da5650f962a90
 SHA512:
-  metadata.gz: 34f1525cf7ded366446347c4b6721649943f6674d2e0f8bd03b494386cd8876c7671e891a664db3b6a3e282aebbf88eb851bc20a9d4a953aeee817fce236f014
-  data.tar.gz: 612f391cff097c9631f03f08b14d4350690a3c7db1bc10703043e3d72f8975d888eb4d5c60bca8df26e7362d15bde483846c19d908be48906e072d51f6a8f102
+  metadata.gz: 140fd3ac3b4dc9dd63c3640d78653290eda10648fe6a8c3c302cca9ee5b03dacd2f1ecdee372879e8b21a09a39f3c48495bee79ceafef1221a426d624cfc31d2
+  data.tar.gz: 71435e52775795d154b5c5a8d1b7ce9b80038bba3adb73a3c3a457e637fa1183efd3c8d65bbfe011f08e52a6436ae181e4ccd372ee041c29c51044c385ba06f4

data/README.md

@@ -1,6 +1,26 @@
 RDF::Blazegraph
 ================
 
+An RDF::Repository implementation for [Blazegraph](http://blazegraph.com); a REST client for [NanoSparqlServer](https://wiki.blazegraph.com/wiki/index.php/NanoSparqlServer).
+
+## Usage
+
+Run `gem install rdf-blazegraph` or add `gem 'rdf-blazegraph'` to your Gemspec.
+
+```ruby
+require 'rdf/blazegraph'
+
+# as an RDF::Repository
+repo = RDF::Blazegraph::Repository.new('http://localhost:9999/bigdata/sparql')
+repo << RDF::Statement(RDF::URI('http://example.org/#moomin'), RDF::FOAF.name, 'Moomin')
+repo.count # => 1
+
+# with REST interface
+nano = RDF::Blazegraph::RestClient.new('http://localhost:9999/bigdata/sparql')
+nano.get_statements.each { |s| puts s.inspect }
+# #<RDF::Statement:0x3ff0d450e5ec(<http://example.org/#moomin> <http://xmlns.com/foaf/0.1/name> "Moomin" .)>
+```
+
 ## Running the Tests
 
 ```bash

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/lib/rdf/blazegraph.rb

@@ -1,5 +1,4 @@
 require 'rdf'
-require 'sparql/client'
 require 'rexml/document'
 require 'net/http/persistent'
 
@@ -12,8 +11,14 @@ module RDF
   module Blazegraph
     VOCAB_BD = RDF::Vocabulary.new('http://www.bigdata.com/rdf#')
     NULL_GRAPH_URI = Blazegraph::VOCAB_BD.nullGraph
-    
+
     autoload :Repository, 'rdf/blazegraph/repository'
     autoload :RestClient, 'rdf/blazegraph/rest_client'
   end
+
+  module NQuads
+    class Format
+      content_type     'application/n-quads', :extension => :nq, :alias => ['text/x-nquads']
+    end
+  end
 end

data/lib/rdf/blazegraph/repository.rb

@@ -1,3 +1,5 @@
+require 'sparql/client'
+
 module RDF::Blazegraph
   ##
   # An RDF::Repository implementaton for Blazegraph (formerly BigData).
@@ -16,8 +18,15 @@ module RDF::Blazegraph
       rest_client.fast_range_count
     end
 
+    ##
+    # @see RDF::Mutable#delete_insert
+    def delete_insert(deletes, inserts)
+      rest_client.delete_insert(deletes, inserts)
+    end
+
     ##
     # @see RDF::Repository#each
+    # @todo this won't scale
     def each(&block)
       rest_client.get_statements.each_statement(&block)
     end
@@ -29,9 +38,9 @@ module RDF::Blazegraph
     end
 
     ##
-    # @see RDF::Repository#has_predicate?
-    def has_context?(context)
-      rest_client.has_statement?(context: context)
+    # @see RDF::Repository#has_graph_name?
+    def has_graph?(graph_name)
+      rest_client.has_statement?(context: graph_name)
     end
 
     ##
@@ -78,40 +87,51 @@ module RDF::Blazegraph
       rest_client.has_statement?(subject:   statement.subject,
                                  predicate: statement.predicate,
                                  object:    statement.object,
-                                 context:   statement.context)
+                                 context:   statement.graph_name)
     end
 
     ##
     # @see SPARQL::Client::Repository#supports?
     def supports?(feature)
       return true if feature.to_sym == :context
+      return true if feature.to_sym == :graph_name
       super
     end
 
     protected
 
+    ##
+    # @private
+    # @see RDF::Mutable#clear
+    def clear_statements
+      rest_client.clear_statements
+    end
+
     ##
     # Deletes the given RDF statements from the underlying storage.
     #
-    # Overridden here to use SPARQL/UPDATE
+    # Overridden here to use the Blazegraph REST client
     #
     # @param  [RDF::Enumerable] statements
     # @return [void]
     def delete_statements(statements)
-      @rest_client.delete(statements)
+      rest_client.delete(statements)
     end
 
     ##
     # Queries `self` for RDF statements matching the given `pattern`.
     #
     # @see SPARQL::Client::Repository#query_pattern
-    def query_pattern(pattern, &block)
+    def query_pattern(pattern, options = {}, &block)
       pattern = pattern.dup
       pattern.subject   ||= RDF::Query::Variable.new
       pattern.predicate ||= RDF::Query::Variable.new
       pattern.object    ||= RDF::Query::Variable.new
       pattern.initialize!
 
+      return fast_pattern(pattern, &block) unless 
+        pattern.subject.node? || pattern.predicate.node? || pattern.object.node?
+
       # Blazegraph objects to bnodes shared across the CONSTRUCT & WHERE scopes
       # so we dup the pattern with fresh bnodes
       where_pattern = pattern.dup
@@ -122,11 +142,11 @@ module RDF::Blazegraph
 
       query = client.construct(pattern).where(where_pattern)
       
-      unless where_pattern.context.nil?
-        where_pattern.context ||= NULL_GRAPH_URI
-        query.graph(where_pattern.context)
-        query.filter("#{where_pattern.context} != #{NULL_GRAPH_URI.to_base}") if
-          where_pattern.context.variable?
+      unless where_pattern.graph_name.nil?
+        where_pattern.graph_name ||= NULL_GRAPH_URI
+        query.graph(where_pattern.graph_name)
+        query.filter("#{where_pattern.graph_name} != #{NULL_GRAPH_URI.to_base}") if
+          where_pattern.graph_name.variable?
       end
 
       if block_given?
@@ -136,6 +156,20 @@ module RDF::Blazegraph
       end
     end
 
+    def fast_pattern(pattern, &block)
+      pattern = pattern.dup
+      pattern.graph_name = NULL_GRAPH_URI if pattern.graph_name == false
+
+      reader = 
+        rest_client.get_statements(subject: variable_to_nil(pattern.subject),
+                                   predicate: variable_to_nil(pattern.predicate),
+                                   object: variable_to_nil(pattern.object),
+                                   context: variable_to_nil(pattern.graph_name))
+
+      return reader.each_statement(&block) if block_given?
+      reader.each_statement
+    end
+
     def insert_statements(statements)
       rest_client.insert(statements)
     end
@@ -143,5 +177,10 @@ module RDF::Blazegraph
     def insert_statement(statement)
       rest_client.insert([statement])
     end
+
+    def variable_to_nil(term)
+      return nil unless term
+      term.variable? ? nil : term
+    end
   end
 end

data/lib/rdf/blazegraph/rest_client.rb

@@ -18,6 +18,12 @@ module RDF::Blazegraph
       @sparql_client = SPARQL::Client.new(@url)
     end
 
+    ##
+    # Deletes all statements from the server
+    def clear_statements
+      send_delete_request('')
+    end
+
     ##
     # Send a request to the server
     #
@@ -104,9 +110,16 @@ module RDF::Blazegraph
     ##
     # @param [RDF::Enumerable] statements
     #
+    # @raise [ArugmentError] when a statement is invalid
     # @todo handle blank nodes
     def insert(statements)
-      send_post_request(url, statements)
+      sts = statements.lazy.map do |st|
+        raise ArgumentError, "Invalid statement #{st}" if 
+          st.respond_to?(:invalid?) && st.invalid?
+        st
+      end
+
+      send_post_request(url, sts)
       return self
     end
 
@@ -118,13 +131,19 @@ module RDF::Blazegraph
       return self if statements.empty?
 
       statements.map! do |s| 
-        statement = RDF::Statement.from(s)
-        statement.context ||= NULL_GRAPH_URI 
+        statement = RDF::Statement.from(s).dup
+        statement.graph_name ||= NULL_GRAPH_URI 
         statement
       end
 
+      if statements.count == 1 && !statements.first.has_blank_nodes?
+        st = statements.first
+        query = access_path_query(st.subject, st.predicate, st.object, st.graph_name)
+        send_delete_request(query)
+      end
+
       constant = statements.all? do |statement|
-        !statement.respond_to?(:each_statement) && statement.constant? && 
+        !statement.respond_to?(:each_statement) && statement.constant? &&
           !statement.has_blank_nodes?
       end
 
@@ -137,6 +156,16 @@ module RDF::Blazegraph
       return self
     end
 
+    ##
+    # @param [RDF::Enumerable<RDF::Statement>, Array<RDF::Statement>] dels
+    # @param [RDF::Enumerable<RDF::Statement>, Array<RDF::Statement>] ins
+    #
+    # @return [RDF::Blazegraph::RestClient] self
+    def delete_insert(deletes, ins)
+      delete(deletes)
+      insert(ins)
+    end
+
     private
 
     def sparql_ask_statement(triple, context)
@@ -156,24 +185,27 @@ module RDF::Blazegraph
     end
     
     def send_post_request(request_url, statements)
-      io = StringIO.new
       writer = RDF::Writer.for(:nquads)
       
-      io.rewind
-
       request = Net::HTTP::Post.new(request_url)
-      request['Content-Type'] = 
-        RDF::Writer.for(:nquads).format.content_type.last # use text/x-nquads
+      request['Content-Type'] = 'text/x-nquads'
       request.body = writer.dump(statements)
       
       @http.request(url, request)
     end
-    
+
+    def send_delete_request(query)
+      query = "#{query[1..-1]}" if query.start_with? '&'
+      request = Net::HTTP::Delete.new(url + "?#{::URI::encode(query)}")
+      
+      @http.request(url, request)
+    end
+
     ## 
     # @param [Net::HTTPResponse] response
     # @return [RDF::Enumerable]
     def read_rdf_response(response)
-      RDF::Reader.for(content_type: response.content_type).new(response.body)
+      RDF::Reader.for(content_type: 'application/n-quads').new(response.body)
     end
 
     ## 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rdf-blazegraph
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Tom Johnson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-13 00:00:00.000000000 Z
+date: 2016-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.99'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.99'
 - !ruby/object:Gem::Dependency
   name: sparql-client
   requirement: !ruby/object:Gem::Requirement
@@ -134,7 +134,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: A Blazegraph Repository adapter for RDF.rb