activerdf_net7 1.6.16 → 1.7.0

data/lib/active_rdf/federation/active_rdf_adapter.rb

@@ -2,46 +2,33 @@
 require 'queryengine/query2sparql'
 
 # Generic superclass of all adapters
-
-class ActiveRdfAdapter
-  # indicate if adapter can read and write
-  bool_accessor :reads, :writes, :enabled
-
-  def initialize
-    @enabled = true
-  end
-
-  # Indicate if the adapter supports contexts
-  def supports_context?
-    self.class.supports_context?
-  end
-
-  # translate a query to its string representation
-  def translate(query)
-    Query2SPARQL.translate(query)
-  end
-
-  # Clear the adapter. Crude default implementation, which can be overwritten
-  # in subclasses. TODO: This queries all adapters, this may lead to problems...
-  def clear
-    raise(ActiveRdfError, "Can only delete from writing adapters") unless(writes?)
-    to_delete = Query.new.select(:s, :p, :o).where(:s, :p, :o).execute
-    to_delete.each do |s, p, o|
-      delete(s, p, o)
+module ActiveRDF
+  class ActiveRdfAdapter
+    # indicate if adapter can read and write
+    bool_accessor :reads, :writes, :contexts, :enabled
+
+    def initialize(params = {})
+      # defaults
+      @enabled =                               true
+      @reads =                                 true
+      @writes =      truefalse(params[:write], true)
+      @new =           truefalse(params[:new], false)
+      @contexts = truefalse(params[:contexts], false)
     end
-  end
-
-  # Indicates if this adapter class supports contexts  
-  def self.supports_context?
-    @context_supported = false if(@context_supported == nil)
-    @context_supported
-  end
 
-  private
+    # translate a query to its string representation
+    def translate(query)
+      Query2SPARQL.translate(query)
+    end
 
-  # Method to set the "context_supported" flag
-  def self.supports_context
-    @context_supported = true
+    # Clear the adapter. Crude default implementation, which can be overwritten
+    # in subclasses. TODO: This queries all adapters, this may lead to problems...
+    def clear
+      raise(ActiveRdfError, "Can only delete from writing adapters") unless(writes?)
+      to_delete = Query.new.select(:s, :p, :o).where(:s, :p, :o).execute
+      to_delete.each do |s, p, o|
+        delete(s, p, o)
+      end
+    end
   end
-
-end
+end

data/lib/active_rdf/federation/connection_pool.rb

@@ -1,138 +1,146 @@
 # require 'active_rdf'
 
-# Maintains pool of adapter instances that are connected to datasources. Returns 
+# Maintains pool of adapter instances that are connected to datasources. Returns
 # right adapter for a given datasource, by either reusing an
 # existing adapter-instance or creating new a adapter-instance.
 
-class ConnectionPool
-  class << self
-    attr_accessor :write_adapter
+module ActiveRDF
+  class ConnectionPool
+    class << self
+      attr_accessor :write_adapter
 
-    # sets automatic flushing of data from adapters to original datasources 
-    # (e.g. redland on-file database). If disabled, changes to an adapter are 
-    # not written back into the original source: you need to invoke 
-    # ConnectionPool.flush manually
-    bool_accessor :auto_flush
-  end
-  # pool of all adapters
-  @@adapter_pool = Array.new
+      # sets automatic flushing of data from adapters to original datasources
+      # (e.g. redland on-file database). If disabled, changes to an adapter are
+      # not written back into the original source: you need to invoke
+      # ConnectionPool.flush manually
+      bool_accessor :auto_flush
+    end
+    # pool of all adapters
+    @@adapter_pool = Array.new
 
-  # pool of connection parameters to all adapter
-  @@adapter_parameters = Array.new
+    # pool of connection parameters to all adapter
+    @@adapter_parameters = Array.new
 
-  # currently active write-adapter (we can only write to one at a time)
-  self.write_adapter = nil
+    # currently active write-adapter (we can only write to one at a time)
+    self.write_adapter = nil
 
-  # default setting for auto_flush
-  self.auto_flush = true
+    # default setting for auto_flush
+    self.auto_flush = true
 
-  # adapters-classes known to the pool, registered by the adapter-class
-  # itself using register_adapter method, used to select new
-  # adapter-instance for requested connection type
-  @@registered_adapter_types = Hash.new
+    # adapters-classes known to the pool, registered by the adapter-class
+    # itself using register_adapter method, used to select new
+    # adapter-instance for requested connection type
+    @@registered_adapter_types = Hash.new
 
-  # clears the pool: removes all registered data sources
-  def ConnectionPool.clear
+    # clears the pool: removes all registered data sources
+    def ConnectionPool.clear
     ActiveRdfLogger::log_info "Clear called", self
-    @@adapter_pool.clear
-    @@adapter_parameters.clear
-    self.write_adapter = nil
-  end
+      @@adapter_pool = []
+      @@adapter_parameters = []
+      self.write_adapter = nil
+    end
 
-  def ConnectionPool.adapters
-    @@adapter_pool.dup
-  end
+    def ConnectionPool.adapters
+      @@adapter_pool.dup
+    end
 
-  # flushes all openstanding changes into the original datasource.
-  def ConnectionPool.flush
-    write_adapter.flush
-  end
+    # flushes all openstanding changes into the original datasource.
+    def ConnectionPool.flush
+      write_adapter.flush
+    end
 
-  def ConnectionPool.adapter_types
-    @@registered_adapter_types.keys
-  end
+    def ConnectionPool.adapter_types
+      @@registered_adapter_types.keys
+    end
 
-  # returns the set of currently registered read-access datasources
-  def ConnectionPool.read_adapters
-    @@adapter_pool.select {|adapter| adapter.reads? && adapter.enabled?}
-  end
+    # returns the set of currently registered read-access datasources
+    def ConnectionPool.read_adapters
+      @@adapter_pool.select {|adapter| adapter.reads? && adapter.enabled?}
+    end
 
-  def ConnectionPool.write_adapters
-    @@adapter_pool.select {|adapter| adapter.writes? && adapter.enabled?}
-  end
+    def ConnectionPool.write_adapters
+      @@adapter_pool.select {|adapter| adapter.writes? && adapter.enabled?}
+    end
 
-  # returns adapter-instance for given parameters (either existing or new)
-  def ConnectionPool.add_data_source(connection_params)
+    # returns adapter-instance for given parameters (either existing or new)
+    def ConnectionPool.add_data_source(connection_params)
     ActiveRdfLogger::log_info(self) { "add_data_source with params: #{connection_params.inspect}" }
 
-    # either get the adapter-instance from the pool
-    # or create new one (and add it to the pool)
-    index = @@adapter_parameters.index(connection_params)
-    if index.nil?
-      # adapter not in the pool yet: create it,
-      # register its connection parameters in parameters-array
-      # and add it to the pool (at same index-position as parameters)
+      # either get the adapter-instance from the pool
+      # or create new one (and add it to the pool)
+      index = @@adapter_parameters.index(connection_params)
+      if index.nil?
+        # adapter not in the pool yet: create it,
+        # register its connection parameters in parameters-array
+        # and add it to the pool (at same index-position as parameters)
       ActiveRdfLogger::log_debug(self) { "Create a new adapter for parameters #{connection_params.inspect}" }
-      adapter = create_adapter(connection_params)
-      @@adapter_parameters << connection_params
-      @@adapter_pool << adapter
-    else
-      # if adapter parametrs registered already,
-      # then adapter must be in the pool, at the same index-position as its parameters
+        adapter = create_adapter(connection_params)
+        @@adapter_parameters << connection_params
+        @@adapter_pool << adapter
+      else
+        # if adapter parametrs registered already,
+        # then adapter must be in the pool, at the same index-position as its parameters
       ActiveRdfLogger::log_debug("Reusing existing adapter")
-      adapter = @@adapter_pool[index]
-    end
+        adapter = @@adapter_pool[index]
+      end
 
-    # sets the adapter as current write-source if it can write
-    self.write_adapter = adapter if adapter.writes?
+      # sets the adapter as current write-source if it can write
+      self.write_adapter = adapter if adapter.writes?
 
-    return adapter
-  end
+      return adapter
+    end
 
-  # remove one adapter from activerdf
-  def ConnectionPool.remove_data_source(adapter)
+    # remove one adapter from activerdf
+    def ConnectionPool.remove_data_source(adapter)
     ActiveRdfLogger.log_info(self) { "ConnectionPool: remove_data_source with params: #{adapter.to_s}" }
 
-    index = @@adapter_pool.index(adapter)
-
-    # remove_data_source mit be called repeatedly, e.g because the adapter object is stale
-    unless index.nil?
-      @@adapter_parameters.delete_at(index)
-      @@adapter_pool.delete_at(index)
-      if self.write_adapters.empty?
-        self.write_adapter = nil
-      else
-        self.write_adapter = self.write_adapters.first
+      index = @@adapter_pool.index(adapter)
+
+      # remove_data_source mit be called repeatedly, e.g because the adapter object is stale
+      unless index.nil?
+        @@adapter_parameters.delete_at(index)
+        @@adapter_pool.delete_at(index)
+        if self.write_adapters.empty?
+          self.write_adapter = nil
+        else
+          self.write_adapter = self.write_adapters.first
+        end
       end
+
     end
 
-  end
+    # closes and removes adapter from pool
+    def ConnectionPool.close_data_source(adapter)
+      remove_data_source(adapter)
+      adapter.close
+    end
 
-  # sets adapter-instance for connection parameters (if you want to re-enable an existing adapter)
-  def ConnectionPool.set_data_source(adapter, connection_params = {})
-    index = @@adapter_parameters.index(connection_params)
-    if index.nil?
-      @@adapter_parameters << connection_params
-      @@adapter_pool << adapter
-    else
-      @@adapter_pool[index] = adapter
+    # sets adapter-instance for connection parameters (if you want to re-enable an existing adapter)
+    def ConnectionPool.set_data_source(adapter, connection_params = {})
+      index = @@adapter_parameters.index(connection_params)
+      if index.nil?
+        @@adapter_parameters << connection_params
+        @@adapter_pool << adapter
+      else
+        @@adapter_pool[index] = adapter
+      end
+      self.write_adapter = adapter if adapter.writes?
+      adapter
     end
-    self.write_adapter = adapter if adapter.writes?
-    adapter
-  end
 
-  # aliasing add_data_source as add
-  # (code bit more complicad since they are class methods)
-  class << self
-    alias add add_data_source
-  end
+    # aliasing add_data_source as add
+    # (code bit more complicad since they are class methods)
+    class << self
+      alias add add_data_source
+      alias close close_data_source
+    end
 
-  # adapter-types can register themselves with connection pool by
-  # indicating which adapter-type they are
-  def ConnectionPool.register_adapter(type, klass)
+    # adapter-types can register themselves with connection pool by
+    # indicating which adapter-type they are
+    def ConnectionPool.register_adapter(type, klass)
     ActiveRdfLogger::log_info(self) { "Registering adapter of type #{type} for class #{klass}" }
-    @@registered_adapter_types[type] = klass
-  end
+      @@registered_adapter_types[type] = klass
+    end
 
   # unregister adapter-type
   def ConnectionPool.unregister_adapter(type)
@@ -140,17 +148,18 @@ class ConnectionPool
     @@registered_adapter_types.delete type
   end
 
-  # create new adapter from connection parameters
-  def ConnectionPool.create_adapter connection_params
-    # lookup registered adapter klass
+    # create new adapter from connection parameters
+    def ConnectionPool.create_adapter connection_params
+      # lookup registered adapter klass
     klass = @@registered_adapter_types[connection_params[:type].to_sym]
 
-    # raise error if adapter type unknown
-    raise(ActiveRdfError, "unknown adapter type #{connection_params[:type]}") if klass.nil?
+      # raise error if adapter type unknown
+      raise(ActiveRdfError, "unknown adapter type #{connection_params[:type]}") if klass.nil?
 
-    # create new adapter-instance
-    klass.send(:new, connection_params)
-  end
+      # create new adapter-instance
+      klass.send(:new,connection_params)
+    end
 
-  private_class_method :create_adapter
-end
+    private_class_method :create_adapter
+  end
+end

data/lib/active_rdf/federation/federation_manager.rb

@@ -2,61 +2,66 @@ require 'federation/connection_pool'
 
 include ActiveRdfBenchmark
 
-# Manages the federation of datasources: distributes queries to right 
+# Manages the federation of datasources: distributes queries to right
 # datasources and merges their results
 
-class FederationManager
-  # add triple s,p,o (context is optional) to the currently selected write-adapter
-  def FederationManager.add(s,p,o,c=nil)
-    benchmark("SPARQL/RDF", Logger::DEBUG) do |bench_message|
-      bench_message << "ADD #{s} - #{p} - #{o} : #{c}" if(bench_message)
+module ActiveRDF
+  class FederationManager
+	def FederationManager.contexts
+      ConnectionPool.adapters.collect{|adapter| adapter.contexts if adapter.respond_to?(:contexts)}.flatten.compact
+    end
+
+    # add triple s,p,o (context is optional) to the currently selected write-adapter
+    def FederationManager.add(s,p,o,c=nil)
+      benchmark("SPARQL/RDF", Logger::DEBUG) do |bench_message|
+        bench_message << "ADD #{s} - #{p} - #{o} : #{c}" if(bench_message)
       # TODO: allow addition of full graphs
       raise ActiveRdfError, "cannot write without a write-adapter" unless ConnectionPool.write_adapter
-      ConnectionPool.write_adapter.add(s,p,o,c)
+        ConnectionPool.write_adapter.add(s,p,o,c)
+    end
     end
-  end
 
-  # delete triple s,p,o (context is optional) to the currently selected write-adapter
-  def FederationManager.delete(s,p,o,c=nil)
-    benchmark("SPARQL/RDF", Logger::DEBUG) do |bench_message|
-      bench_message << "DELETE #{s} - #{p} - #{o} : #{c}" if(bench_message)
+    # delete triple s,p,o (context is optional) to the currently selected write-adapter
+    def FederationManager.delete(s,p=nil,o=nil,c=nil)
+      benchmark("SPARQL/RDF", Logger::DEBUG) do |bench_message|
+        bench_message << "DELETE #{s} - #{p} - #{o} : #{c}" if(bench_message)
       raise ActiveRdfError, "cannot write without a write-adapter" unless ConnectionPool.write_adapter
       # transform wildcard symbols to nil (for the adaptors)
       s = nil if s.is_a? Symbol
       p = nil if p.is_a? Symbol
       o = nil if o.is_a? Symbol
-      ConnectionPool.write_adapter.delete(s,p,o,c)
+        ConnectionPool.write_adapter.delete(s,p,o,c)
+      end
     end
-  end
 
-  # delete every triples about a specified resource
-  def FederationManager.delete_all(resource)
-    delete(resource, nil, nil)
-  end
-  
-  # Clear the store (or the given context)
-  def FederationManager.clear(context=nil)
-    # FIXME: Make sure that all adapters support clearing
-    raise(RuntimeError, "Adapter #{ConnectionPool.write_adapter.class} doesn't support clear") unless(ConnectionPool.write_adapter.respond_to?(:clear))
-    ConnectionPool.write_adapter.clear(context)
-  end
+    # delete every triples about a specified resource
+    def FederationManager.delete_all(resource)
+      delete(resource, nil, nil)
+    end
 
-  # executes read-only queries
-  # by distributing query over complete read-pool
-  # and aggregating the results
-  def FederationManager.query(q, options={:flatten => true, :result_format => nil})
-    if ConnectionPool.read_adapters.empty?
-      raise ActiveRdfError, "cannot execute query without data sources" 
+    # Clear the store (or the given context)
+    def FederationManager.clear(context=nil)
+      # FIXME: Make sure that all adapters support clearing
+      raise(RuntimeError, "Adapter #{ConnectionPool.write_adapter.class} doesn't support clear") unless(ConnectionPool.write_adapter.respond_to?(:clear))
+      ConnectionPool.write_adapter.clear(context)
     end
 
-    benchmark("SPARQL/RDF", Logger::DEBUG) do |bench_message|
-      # Only build the benchmark message if we need it
-      bench_message << ((q.class == String) ? q : q.to_sp) if(bench_message)
+    # executes read-only queries
+    # by distributing query over complete read-pool
+    # and aggregating the results
+    def FederationManager.execute(q, options={:flatten => false})
+      if ConnectionPool.read_adapters.empty?
+        raise ActiveRdfError, "cannot execute query without data sources"
+      end
+
+      benchmark("SPARQL/RDF", Logger::DEBUG) do |bench_message|
+        # Only build the benchmark message if we need it
+        bench_message << ((q.class == String) ? q : q.to_sp) if(bench_message)
       # ask each adapter for query results
       # and yield them consequtively
       if block_given?
         ConnectionPool.read_adapters.each do |source|
-          source.query(q) do |*clauses|
+          source.execute(q) do |*clauses|
             yield(*clauses)
           end
         end
@@ -65,19 +70,17 @@ class FederationManager
         # TODO: write test for sebastian's select problem
         # (without distinct, should get duplicates, they
         # were filtered out when doing results.union)
-        # FIXME: Calling get_sparql_query_results? This *only* exists on the redland adapter
         results = []
         ConnectionPool.read_adapters.each do |source|
-          if (q.class != String)
-            source_results = source.query(q)
-          else
-            source_results = source.get_sparql_query_results(q, RDFS::Resource, options[:result_format])
-          end
+          source_results = source.execute(q)
           source_results.each do |clauses|
             results << clauses
           end
         end
 
+        # count
+        return results.flatten.inject{|mem,c| mem + c} if q.count?
+
         # filter the empty results
         results.reject {|ary| ary.empty? }
 
@@ -85,18 +88,14 @@ class FederationManager
         # adapters if asked for distinct query
         # (adapters return only distinct results,
         # but they cannot check duplicates against each other)
-        results.uniq! if ((q.class != String) && (q.distinct?))
+        results.uniq! if q.distinct?
 
         # flatten results array if only one select clause
         # to prevent unnecessarily nested array [[eyal],[renaud],...]
-        if (q.class != String)
-          results.flatten! if (q.select_clauses.size == 1 or q.ask?)
-        else
-          results.flatten! if q.scan(/[?]/).length == 2
-        end
+        results.flatten! if q.select_clauses.size == 1 or q.ask?
 
         # remove array (return single value or nil) if asked to
-        if options[:flatten] or ((q.class != String)  && (q.count?))
+        if options[:flatten]
           case results.size
           when 0
             results = nil
@@ -107,6 +106,7 @@ class FederationManager
       end
 
       results
-    end # End benchmark
-  end # End query
-end
+      end # End benchmark
+    end # End query
+    end
+  end

data/lib/active_rdf/objectmanager/bnode.rb

@@ -1,7 +1,13 @@
-module RDFS
-  class BNode < Resource
+require 'active_rdf'
+
+module ActiveRDF
+  Namespace.register(:bnode, "http://www.activerdf.org/bnode#")
+
+  class BNode < RDFS::Resource
     def to_s
       "<_:#{uri}>"
     end
+
+    self.class_uri = RDFS::Resource.new("http://www.activerdf.org/bnode")
   end
 end