activerdf 1.0

data/lib/active_rdf/federation/connection_pool.rb

@@ -0,0 +1,114 @@
+# Maintains pool of adapter instances that are connected to datasources
+# returns right adapter for a given datasource, by either reusing
+# existing adapter-instance or creating new adapter-instance
+#
+# Author:: Eyal Oren
+# Copyright:: (c) 2005-2006
+# License:: LGPL
+
+require 'active_rdf'
+
+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
+
+  # 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
+
+	# 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
+
+  # clears the pool: removes all registered data sources
+  def ConnectionPool.clear
+    $log.info "ConnectionPool: clear called"
+    @@adapter_pool = []
+    @@adapter_parameters = []
+    self.write_adapter = nil
+  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
+
+  # returns the set of currently registered read-access datasources
+  def ConnectionPool.read_adapters
+    @@adapter_pool.select {|adapter| adapter.reads? }
+  end
+
+  # returns adapter-instance for given parameters (either existing or new)
+  def ConnectionPool.add_data_source(connection_params)
+    $log.info "ConnectionPool: 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)
+      $log.debug("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
+      $log.debug("Reusing existing adapter")
+      adapter = @@adapter_pool[index]
+    end
+
+    # sets the adapter as current write-source if it can write
+    self.write_adapter = adapter if adapter.writes?
+
+    return 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
+
+  # adapter-types can register themselves with connection pool by
+  # indicating which adapter-type they are
+  def ConnectionPool.register_adapter(type, klass)
+    $log.info "ConnectionPool: registering adapter of type #{type} for class #{klass}"
+    @@registered_adapter_types[type] = klass
+  end
+
+  # create new adapter from connection parameters
+  def ConnectionPool.create_adapter connection_params
+    # lookup registered adapter klass
+    klass = @@registered_adapter_types[connection_params[:type]]
+
+    # 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
+  
+  private_class_method :create_adapter
+end

data/lib/active_rdf/federation/federation_manager.rb

@@ -0,0 +1,80 @@
+# Manages the federation of datasources
+# distributes queries to right datasources and merges their results
+#
+# Author:: Eyal Oren
+# Copyright:: (c) 2005-2006
+# License:: LGPL
+require 'federation/connection_pool'
+
+class FederationManager
+  # add triple s,p,o to the currently selected write-adapter
+  def FederationManager.add(s,p,o)
+    # TODO: allow addition of full graphs
+    $log.debug "FederationManager: add: triple is #{s} #{p} #{o}"
+    ConnectionPool.write_adapter.add(s,p,o)
+  end
+
+  # executes read-only queries
+  # by distributing query over complete read-pool
+  # and aggregating the results
+  def FederationManager.query(q, options={:flatten => true})
+		if ConnectionPool.read_adapters.empty?
+			raise ActiveRdfError, "cannot execute query without data sources" 
+		end
+
+    $log.debug "FederationManager: query called with: #{q}"
+    # ask each adapter for query results
+    # and yield them consequtively
+    if block_given?
+      ConnectionPool.read_adapters.each do |source|
+        source.query(q) do |*clauses|
+          yield(*clauses)
+        end
+      end
+    else
+      # build Array of results from all sources
+      # TODO: write test for sebastian's select problem
+      # (without distinct, should get duplicates, they
+      # were filtered out when doing results.union)
+      results = []
+      ConnectionPool.read_adapters.each do |source|
+				source_results = source.query(q)
+				source_results.each do |clauses|
+					results << clauses
+				end
+			end
+
+      # filter the empty results
+      results.reject {|ary| ary.empty? }
+
+      # remove duplicate results from multiple
+      # adapters if asked for distinct query
+      # (adapters return only distinct results,
+      # but they cannot check duplicates against each other)
+      results.uniq! if q.distinct?
+
+      # flatten results array if only one select clause
+      # to prevent unnecessarily nested array [[eyal],[renaud],...]
+      results.flatten! if q.select_clauses.size == 1 or q.ask?
+
+      # and remove array (return single value) unless asked not to
+      if options[:flatten]
+        case results.size
+        when 0
+          final_results = nil
+        when 1
+          final_results = results.first
+        else
+          final_results = results
+        end
+      else
+        final_results = results
+      end
+    end
+    
+    $log.debug_pp("FederationManager: query results are %s", final_results)
+    
+    
+    return final_results
+  end
+end

data/lib/active_rdf/objectmanager/namespace.rb

@@ -0,0 +1,77 @@
+# Manages namespace abbreviations and expansions
+#
+# Author:: Eyal Oren
+# Copyright:: (c) 2005-2006
+# License:: LGPL
+
+require 'active_rdf'
+
+class Namespace
+
+  @@namespaces = Hash.new
+  @@inverted_namespaces = Hash.new
+
+  # registers a namespace prefix and its associated expansion (full URI)
+  # e.g. :rdf and 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'
+  def self.register(prefix, fullURI)
+		raise ActiveRdfError, 'prefix nor uri can be empty' if (prefix.to_s.empty? or fullURI.to_s.empty?)
+		$log.info "Namespace: registering #{fullURI} to #{prefix}"
+    @@namespaces[prefix.to_sym] = fullURI.to_s
+    @@inverted_namespaces[fullURI.to_s] = prefix.to_sym
+  end
+
+  # returns a resource whose URI is formed by concatenation of prefix and localname
+  def self.lookup(prefix, localname)
+    full_resource = expand(prefix, localname)
+    $log.debug "Namespace: lookup for Resource #{full_resource} initiated"
+    RDFS::Resource.new(expand(prefix, localname))
+  end
+
+  # returns URI (string) formed by concatenation of prefix and localname
+  def self.expand(prefix, localname)
+    @@namespaces[prefix.to_sym].to_s + localname.to_s
+  end
+
+  # returns prefix (if known) for the non-local part of the URI,
+  # or nil if prefix not registered
+  def self.prefix(resource)
+    # get string representation of resource uri
+    uri = case resource
+    when RDFS::Resource: resource.uri
+    else resource.to_s
+    end
+
+    # uri.to_s gives us the uri of the resource (if resource given)
+    # then we find the last occurrence of # or / (heuristical namespace
+    # delimitor)
+    delimiter = uri.rindex(/#|\//)
+
+    # if delimiter not found, URI cannot be split into (non)local-part
+    return uri if delimiter.nil?
+
+    # extract non-local part (including delimiter)
+    nonlocal = uri[0..delimiter]
+
+    @@inverted_namespaces[nonlocal]
+  end
+
+  # returns local-part of URI
+  def self.localname(resource)
+    # get string representation of resource uri
+    uri = case resource
+    when RDFS::Resource: resource.uri
+    else resource.to_s
+    end
+
+    delimiter = uri.rindex(/#|\//)
+    if delimiter.nil?
+      uri
+    else
+      uri[delimiter+1..-1]
+    end
+  end
+end
+
+Namespace.register(:rdf, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#')
+Namespace.register(:rdfs, 'http://www.w3.org/2000/01/rdf-schema#')
+Namespace.register(:owl, 'http://www.w3.org/2002/07/owl#')

data/lib/active_rdf/objectmanager/object_manager.rb

@@ -0,0 +1,123 @@
+# Constructs Ruby classes for RDFS classes (in the right namespace)
+#
+# Author:: Eyal Oren
+# Copyright:: (c) 2005-2006
+# License:: LGPL
+require 'active_rdf'
+
+class ObjectManager
+  # constructs empty Ruby classes for all RDF types found in the data
+	#
+  # allows users to invoke methods on classes (e.g. FOAF::Person) without
+  # getting symbol undefined errors (because e.g. foaf:person wasnt encountered
+  # before so no class was created for it)
+  def self.construct_classes
+    # find all rdf:types and construct class for each of them
+    #q = Query.new.select(:t).where(:s,Namespace.lookup(:rdf,:type),:t)
+		
+		# find everything defined as rdfs:class or owl:class
+		type = Namespace.lookup(:rdf,:type)
+		rdfsklass = Namespace.lookup(:rdfs,:Class)
+
+		# TODO: we should not do this, we should not support OWL
+		# instead, owl:Class is defined as subclass-of rdfs:Class, so if the 
+		# reasoner has access to owl definition it should work out fine.
+		owlklass = Namespace.lookup(:owl,:Class)
+
+		klasses = []
+    klasses << Query.new.distinct(:s).where(:s,type,rdfsklass).execute
+    klasses << Query.new.distinct(:s).where(:s,type,owlklass).execute
+
+		# flattening to get rid of nested arrays
+		# compacting array to get rid of nil (if one of these queries returned nil)
+		klasses = klasses.flatten.compact
+		$log.debug "ObjectManager: construct_classes: classes found: #{klasses}"
+		
+		# then we construct a Ruby class for each found rdfs:class
+		# and return the set of all constructed classes
+    klasses.collect { |t| construct_class(t) }
+  end
+
+  # constructs Ruby class for the given resource (and puts it into the module as
+  # defined by the registered namespace abbreviations)
+  def self.construct_class(resource)
+    # get prefix abbreviation and localname from type
+    # e.g. :foaf and Person
+    localname = Namespace.localname(resource)
+    prefix = Namespace.prefix(resource)
+
+    # find (ruby-acceptable) names for the module and class
+    # e.g. FOAF and Person
+    if prefix.nil?
+			# if the prefix is unknown, we create our own from the full URI
+      modulename = create_module_name(resource)
+      $log.debug "ObjectManager: construct_class: constructing modulename #{modulename} from URI #{resource}"
+		else
+			# otherwise we convert the registered prefix into a module name
+			modulename = prefix_to_module(prefix)
+			$log.debug "ObjectManager: construct_class: constructing modulename #{modulename} from registered prefix #{prefix}"
+    end
+    klassname = localname_to_class(localname)
+
+    # look whether module defined
+    # else: create it
+    _module = if Object.const_defined?(modulename.to_sym)
+        $log.debug "ObjectManager: construct_class: module name #{modulename} previously defined"
+				Object.const_get(modulename.to_sym)
+			else
+        $log.debug "ObjectManager: construct_class: defining module name #{modulename} now"
+				Object.const_set(modulename, Module.new)
+			end
+
+		# look whether class defined in that module
+		if _module.const_defined?(klassname.to_sym)
+      $log.debug "ObjectManager: construct_class: given class #{klassname} defined in the module"
+			# if so, return the existing class
+			_module.const_get(klassname.to_sym)
+		else
+      $log.debug "ObjectManager: construct_class: creating given class #{klassname}"
+			# otherwise: create it, inside that module, as subclass of RDFS::Resource
+			# (using toplevel Class.new to prevent RDFS::Class.new from being called)
+			klass = _module.module_eval("#{klassname} = Object::Class.new(RDFS::Resource)")
+			klass.class_uri = RDFS::Resource.new(resource.uri)
+			klass
+		end
+	end
+
+	def self.prefix_to_module(prefix)
+		# TODO: remove illegal characters
+		prefix.to_s.upcase
+	end
+
+	def self.localname_to_class(localname)
+		# replace illegal characters inside the uri
+		# and capitalize the classname
+		replace_illegal_chars(localname).capitalize
+	end
+
+	def self.create_module_name(resource)
+		# TODO: write unit test to verify replacement of all illegal characters
+		
+		# extract non-local part (including delimiter)
+		uri = resource.uri
+		delimiter = uri.rindex(/#|\//)
+		nonlocal = uri[0..delimiter]
+
+		# remove illegal characters appearing at the end of the uri (e.g. trailing 
+		# slash)
+		cleaned_non_local = nonlocal.gsub(/[^a-zA-Z0-9]+$/, '')
+
+		# replace illegal chars within the uri
+		replace_illegal_chars(cleaned_non_local).upcase
+	end
+
+	def self.replace_illegal_chars(name)
+		name.gsub(/[^a-zA-Z0-9]+/, '_')
+	end
+
+  #declare the class level methods as private with these directives
+  private_class_method :prefix_to_module
+  private_class_method :localname_to_class
+  private_class_method :create_module_name
+  private_class_method :replace_illegal_chars
+end