activerdf_net7 1.7.1 → 1.7.2

data/activerdf-sesame/lib/activerdf_sesame/sesame.rb

@@ -155,8 +155,7 @@ module ActiveRDF
       check_input = [s,p,o]
       raise ActiveRdfError, "cannot add triple with nil or blank node subject, predicate, or object" if check_input.any? {|r| r.nil? || r.is_a?(Symbol) }
 
-      params = activerdf_to_sesame(s, p, o, c)
-      @db.add(params[0], params[1], params[2], wrap_contexts(c))
+      @db.add(*activerdf_to_sesame(s, p, o, c))
       true
     rescue Exception => e
       raise ActiveRdfError, "Sesame add triple failed: #{e.message}"
@@ -370,7 +369,7 @@ module ActiveRDF
       }
 
       # wrap Context
-      params << wrap_contexts(c) unless (c.nil?)
+      params << wrap_contexts(c)
 
       params
     end
@@ -381,7 +380,7 @@ module ActiveRDF
     def wrap(item, use_nil = false)
       result = 
       if(item.respond_to?(:uri))
-        if (item.uri.to_s[0..4].match(/http:/).nil?)
+        if (item.uri.to_s[0..4].match(/http:/i).nil?)
           @valueFactory.createLiteral(item.uri.to_s)
         else
           @valueFactory.createURI(item.uri.to_s)

data/lib/active_rdf/federation/federation_manager.rb

@@ -7,7 +7,7 @@ include ActiveRdfBenchmark
 
 module ActiveRDF
   class FederationManager
-	def FederationManager.contexts
+    def FederationManager.contexts
       ConnectionPool.adapters.collect{|adapter| adapter.contexts if adapter.respond_to?(:contexts)}.flatten.compact
     end
 
@@ -15,21 +15,21 @@ module ActiveRDF
     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
+        # 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)
-    end
+      end
     end
 
     # 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
+        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)
       end
     end
@@ -57,56 +57,56 @@ module ActiveRDF
       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.execute(q) do |*clauses|
-            yield(*clauses)
+        # ask each adapter for query results
+        # and yield them consequtively
+        if block_given?
+          ConnectionPool.read_adapters.each do |source|
+            source.execute(q) do |*clauses|
+              yield(*clauses)
+            end
           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.execute(q)
-          source_results.each do |clauses|
-            results << clauses
+        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.execute(q)
+            source_results.each do |clauses|
+              results << clauses
+            end
           end
-        end
 
-        # count
-        return results.flatten.inject{|mem,c| mem + c} if q.count?
+          # count
+          return results.flatten.inject{|mem,c| mem + c} if q.count?
 
-        # filter the empty results
-        results.reject {|ary| ary.empty? }
+          # 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?
+          # 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?
+          # 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?
 
-        # remove array (return single value or nil) if asked to
-        if options[:flatten]
-          case results.size
-          when 0
-            results = nil
-          when 1
-            results = results.first
+          # remove array (return single value or nil) if asked to
+          if options[:flatten]
+            case results.size
+            when 0
+              results = nil
+            when 1
+              results = results.first
+            end
           end
         end
-      end
 
-      results
+        results
       end # End benchmark
     end # End query
-    end
   end
+end

data/lib/active_rdf/objectmanager/reslike

@@ -0,0 +1,28 @@
+module ActiveRDF
+  
+  # Helper Module that contains same additional methods that
+  # are expected from classes that want to behave like
+  # RDFS::Resource.
+  #
+  # The module expects that the including class has an uri
+  # method or property.
+  module ResourceLike
+    
+    # returns uri of resource, can be overridden in subclasses
+    def to_s
+      "<#{uri}>"
+    end
+    
+    # overriding sort based on uri
+    def <=>(other) 
+      uri <=> other.uri
+    end
+    
+    # NTriple representation of element
+    def to_literal_s
+      "<#{uri}>"
+    end
+    
+  end
+  
+end

data/lib/active_rdf/query/query.rb.orig

@@ -0,0 +1,317 @@
+require 'active_rdf/federation/federation_manager'
+
+# Represents a query on a datasource, abstract representation of SPARQL
+# features. Query is passed to federation manager or adapter for execution on
+# data source.  In all clauses symbols represent variables:
+# Query.new.select(:s).where(:s,:p,:o).
+module ActiveRDF
+  class Query
+    attr_reader :select_clauses, :where_clauses, :filter_clauses, :sort_clauses, :limits, :offsets, :keywords
+
+    bool_accessor :distinct, :ask, :select, :count, :keyword, :all_types
+
+    # Creates a new query. You may pass a different class that is used for "resource"
+    # type objects instead of RDFS::Resource
+    def initialize(resource_type = RDFS::Resource)
+      @distinct = false
+      @select_clauses = []
+      @where_clauses = []
+      @filter_clauses = {}
+      @sort_clauses = []
+      @limits = nil
+      @offsets = nil
+      @keywords = {}
+      @reasoning = nil
+      @all_types = false
+      @nil_clause_idx = -1
+      set_resource_class(resource_type)
+    end
+
+<<<<<<< HEAD:lib/active_rdf/queryengine/query.rb
+    # This returns the class that is be used for resources, by default this
+    # is RDFS::Resource
+    def resource_class
+      @resource_class ||= RDFS::Resource
+    end
+
+    # Sets the resource_class. Any class may be used, however it is required
+    # that it can be created using the uri of the resource as it's only 
+    # parameter and that it has an 'uri' property
+    def set_resource_class(resource_class)
+      raise(ArgumentError, "resource_class must be a class") unless(resource_class.class == Class)
+
+      test = resource_class.new("http://uri")
+      raise(ArgumentError, "Must have an uri property") unless(test.respond_to?(:uri))
+      @resource_class = resource_class
+    end
+
+=======
+>>>>>>> 9e1004bb8cd871b9a465a676ffde1a3c16790611:lib/active_rdf/query/query.rb
+    def initialize_copy(orig)
+      # dup the instance variables so we're not messing with the original query's values
+      instance_variables.each do |iv|
+        orig_val = instance_variable_get(iv)
+        case orig_val
+        when Array,Hash
+          instance_variable_set(iv,orig_val.dup)
+        end
+      end
+    end
+
+    # Clears the select clauses
+    def clear_select
+<<<<<<< HEAD:lib/active_rdf/queryengine/query.rb
+      ActiveRdfLogger::log_debug "Cleared select clause", self
+=======
+      ActiveRdfLogger::log_debug(self) { "Cleared select clause" }
+>>>>>>> 9e1004bb8cd871b9a465a676ffde1a3c16790611:lib/active_rdf/query/query.rb
+      @select_clauses = []
+      @distinct = false
+    end
+
+    # Adds variables to select clause
+    def select *s
+      raise(ActiveRdfError, "variable must be a Symbol") unless s.all?{|var| var.is_a?(Symbol)}
+      @select = true
+      # removing duplicate select clauses
+      @select_clauses.concat(s).uniq!
+      self
+    end
+
+    # Adds variables to ask clause (see SPARQL specification)
+    def ask
+      @ask = true
+      self
+    end
+
+    # Request reasoning be performed on query
+    def reasoning(bool)
+      @reasoning = truefalse(bool)
+      self
+    end
+
+    def reasoning=(bool)
+      self.reasoning(bool)
+    end
+
+    def reasoning?
+      @reasoning
+    end
+
+    # Set query to ignore language & datatypes for objects
+    def all_types(enabled = true)
+      @all_types = enabled
+      self
+    end
+
+    # Adds variables to select distinct clause
+    def distinct *s
+      @distinct = true
+      select(*s)
+    end
+    alias_method :select_distinct, :distinct
+
+    # Adds variables to count clause
+    def count *s
+      @count = true
+      select(*s)
+    end
+
+    # Adds sort predicates
+    # 
+    def sort *s
+      s.each do |var| 
+<<<<<<< HEAD:lib/active_rdf/queryengine/query.rb
+
+=======
+        raise(ActiveRdfError, "variable must be a Symbol") unless var.is_a? Symbol
+>>>>>>> 9e1004bb8cd871b9a465a676ffde1a3c16790611:lib/active_rdf/query/query.rb
+        @sort_clauses << [var,:asc]
+      end
+      self
+    end
+
+    # adds reverse sorting predicates
+    def reverse_sort *s
+      s.each do |var| 
+        raise(ActiveRdfError, "variable must be a Symbol") unless var.is_a? Symbol
+        @sort_clauses << [var,:desc]
+      end
+      self
+    end
+
+    # adds operator filter on one variable
+    # variable is a Ruby symbol that appears in select/where clause, operator is a
+    # SPARQL operator (e.g. '>','lang','datatype'), operand is a SPARQL value (e.g. 15)
+    def filter(variable, operator, operand)
+      raise(ActiveRdfError, "variable must be a Symbol") unless variable.is_a? Symbol
+      @filter_clauses[variable] = [operator.to_sym,operand]
+      self
+    end
+
+    # adds regular expression filter on one variable
+    # variable is Ruby symbol that appears in select/where clause, regex is Ruby
+    # regular expression
+    def regexp(variable, regexp)
+      raise(ActiveRdfError, "variable must be a symbol") unless variable.is_a? Symbol
+      regexp = regexp.source if(regexp.is_a?(Regexp))
+<<<<<<< HEAD:lib/active_rdf/queryengine/query.rb
+
+=======
+>>>>>>> 9e1004bb8cd871b9a465a676ffde1a3c16790611:lib/active_rdf/query/query.rb
+      filter(variable, :regexp, regexp)
+    end
+    alias :regex :regexp
+
+    # filter variable on specified language tag, e.g. lang(:o, 'en', true)
+    # optionally matches exactly on language dialect, otherwise only
+    # language-specifier is considered
+    def lang(variable, tag, exact=true)
+      filter(variable,:lang,[tag.sub(/^@/,''),exact])
+    end
+
+    def datatype(variable, type)
+      filter(variable,:datatype,type)
+    end
+
+    # Adds limit clause (maximum number of results to return)
+    def limit(i)
+      @limits = i.to_i
+      self
+    end
+
+    # Add offset clause (ignore first n results)
+    def offset(i)
+      @offsets = i.to_i
+      self
+    end
+
+    # Adds where clauses (s,p,o) where each constituent is either variable (:s) or
+    # an RDFS::Resource (or equivalent class). Keyword queries are specified with the special :keyword 
+    # symbol: Query.new.select(:s).where(:s, :keyword, 'eyal')
+    def where s,p,o,c=nil
+      case p
+      when :keyword
+        # treat keywords in where-clauses specially
+        keyword_where(s,o)
+      else
+        # give nil clauses a unique variable
+        s,p,o = [s,p,o].collect{|clause| clause.nil? ? "nil#{@nil_clause_idx += 1}".to_sym : clause}
+
+        # remove duplicate variable bindings, e.g.
+        # where(:s,type,:o).where(:s,type,:oo) we should remove the second clause,
+        # since it doesn't add anything to the query and confuses the query
+        # generator.
+        # if you construct this query manually, you shouldn't! if your select
+        # variable happens to be in one of the removed clauses: tough luck.
+        unless (s.respond_to?(:uri) or s.is_a?(Symbol)) and (s.class != RDFS::BNode)
+          raise(ActiveRdfError, "Cannot add a where clause with s #{s}: s must be a resource or a variable, is a #{s.class.name}")
+        end
+        unless (p.respond_to?(:uri) or p.is_a?(Symbol)) and (s.class != RDFS::BNode)
+          raise(ActiveRdfError, "Cannot add a where clause with p #{p}: p must be a resource or a variable, is a #{p.class.name}")
+        end
+        raise(ActiveRdfErrror, "Cannot add a where clause where o is a blank node") if(o.class == RDFS::BNode)
+
+        @where_clauses << [s,p,o,c]
+      end
+      self
+    end
+
+    # Adds keyword constraint to the query. You can use all Ferret query syntax in
+    # the constraint (e.g. keyword_where(:s,'eyal|benjamin')
+    def keyword_where s,o
+      @keyword = true
+      if @keywords.include?(s)
+        @keywords[s] = @keywords[s] + ' ' + o
+      else
+        @keywords[s] = o
+      end
+      self
+    end
+
+    # Executes query on data sources. Either returns result as array
+    # (flattened into single value unless specified otherwise)
+    # or executes a block (number of block variables should be
+    # same as number of select variables)
+    #
+    # usage:: results = query.execute
+    # usage:: query.execute do |s,p,o| ... end
+    def execute(options={:flatten => false}, &block)
+      options = {:flatten => true} if options == :flatten
+
+      prepared_query = prepare_query(options)
+
+      if block_given?
+        for result in FederationManager.execute(prepared_query, options.merge(:flatten => false))
+          yield result
+        end
+      else
+        FederationManager.execute(prepared_query, options)
+      end
+    end
+
+    # Returns query string depending on adapter (e.g. SPARQL, N3QL, etc.)
+    def to_s
+      if ConnectionPool.read_adapters.empty?
+        inspect
+      else
+        ConnectionPool.read_adapters.first.translate(prepare_query)
+      end
+    end
+
+    # Returns SPARQL serialisation of query
+    def to_sp
+<<<<<<< HEAD:lib/active_rdf/queryengine/query.rb
+      require 'queryengine/query2sparql' unless(defined?(Query2SPARQL))
+=======
+    require 'active_rdf/queryengine/query2sparql' unless(defined?(Query2SPARQL))
+>>>>>>> 9e1004bb8cd871b9a465a676ffde1a3c16790611:lib/active_rdf/query/query.rb
+      Query2SPARQL.translate(self)
+    end
+
+    private
+    def prepare_query(options = {})
+      # leave the original query intact
+      dup = self.dup
+      dup.expand_obj_values
+      # dup.reasoned_query if dup.reasoning?
+
+      # extract options
+      if options.include?(:order)
+        dup.sort(:sort_value)
+        dup.where(:s, options.delete(:order), :sort_value)
+      end
+
+      if options.include?(:reverse_order)
+        dup.reverse_sort(:sort_value)
+        dup.where(:s, options.delete(:reverse_order), :sort_value)
+      end
+
+      dup.limit(options.delete(:limit)) if options.include?(:limit)
+      dup.offset(options.delete(:offset)) if options.include?(:offset)
+
+      dup
+    end
+
+    protected
+    def expand_obj_values
+      new_where_clauses = []
+      @where_clauses.each do |s,p,o,c|
+        if o.respond_to?(:to_ary)
+          o.to_ary.each{|elem| new_where_clauses << [s,p,elem,c]}
+        else
+          new_where_clauses << [s,p,o,c]
+        end
+      end
+      @where_clauses = new_where_clauses
+    end
+
+    #  def reasoned_query
+    #    new_where_clauses = []
+    #    @where_clauses.each do |s,p,o,c|
+    #      # other reasoning should be added here
+    #    end
+    #    @where_clauses += new_where_clauses
+    #  end
+  end
+end

data/lib/active_rdf/queryengine/query.rb

@@ -11,9 +11,9 @@ module ActiveRDF
 
     bool_accessor :distinct, :ask, :select, :count, :keyword, :all_types
 
-  # Creates a new query. You may pass a different class that is used for "resource"
-  # type objects instead of RDFS::Resource
-  def initialize(resource_type = RDFS::Resource)
+    # Creates a new query. You may pass a different class that is used for "resource"
+    # type objects instead of RDFS::Resource
+    def initialize(resource_type = RDFS::Resource)
       @distinct = false
       @select_clauses = []
       @where_clauses = []
@@ -25,41 +25,40 @@ module ActiveRDF
       @reasoning = nil
       @all_types = false
       @nil_clause_idx = -1
-    set_resource_class(resource_type)
+      set_resource_class(resource_type)
     end
 
-  # This returns the class that is be used for resources, by default this
-  # is RDFS::Resource
-  def resource_class
-    @resource_class ||= RDFS::Resource
-  end
+    # This returns the class that is be used for resources, by default this
+    # is RDFS::Resource
+    def resource_class
+      @resource_class ||= RDFS::Resource
+    end
 
-  # Sets the resource_class. Any class may be used, however it is required
-  # that it can be created using the uri of the resource as it's only 
-  # parameter and that it has an 'uri' property
-  def set_resource_class(resource_class)
-    raise(ArgumentError, "resource_class must be a class") unless(resource_class.class == Class)
+    # Sets the resource_class. Any class may be used, however it is required
+    # that it can be created using the uri of the resource as it's only 
+    # parameter and that it has an 'uri' property
+    def set_resource_class(resource_class)
+      raise(ArgumentError, "resource_class must be a class") unless(resource_class.class == Class)
 
-    test = resource_class.new("http://uri")
-    raise(ArgumentError, "Must have an uri property") unless(test.respond_to?(:uri))
-    @resource_class = resource_class
-  end
+      test = resource_class.new("http://uri")
+      raise(ArgumentError, "Must have an uri property") unless(test.respond_to?(:uri))
+      @resource_class = resource_class
+    end
 
     def initialize_copy(orig)
       # dup the instance variables so we're not messing with the original query's values
       instance_variables.each do |iv|
         orig_val = instance_variable_get(iv)
         case orig_val
-          when Array,Hash
-            instance_variable_set(iv,orig_val.dup)
+        when Array,Hash
+          instance_variable_set(iv,orig_val.dup)
         end
       end
     end
 
-
     # Clears the select clauses
     def clear_select
-    ActiveRdfLogger::log_debug "Cleared select clause", self
+      ActiveRdfLogger::log_debug "Cleared select clause", self
       @select_clauses = []
       @distinct = false
     end
@@ -84,9 +83,11 @@ module ActiveRDF
       @reasoning = truefalse(bool)
       self
     end
+
     def reasoning=(bool)
       self.reasoning(bool)
     end
+
     def reasoning?
       @reasoning
     end
@@ -114,7 +115,7 @@ module ActiveRDF
     # 
     def sort *s
       s.each do |var| 
-         
+
         @sort_clauses << [var,:asc]
       end
       self
@@ -142,10 +143,10 @@ module ActiveRDF
     # variable is Ruby symbol that appears in select/where clause, regex is Ruby
     # regular expression
     def regexp(variable, regexp)
-    raise(ActiveRdfError, "variable must be a symbol") unless variable.is_a? Symbol
-    regexp = regexp.source if(regexp.is_a?(Regexp))
+      raise(ActiveRdfError, "variable must be a symbol") unless variable.is_a? Symbol
+      regexp = regexp.source if(regexp.is_a?(Regexp))
 
-    filter(variable, :regexp, regexp)
+      filter(variable, :regexp, regexp)
     end
     alias :regex :regexp
 
@@ -173,7 +174,7 @@ module ActiveRDF
     end
 
     # Adds where clauses (s,p,o) where each constituent is either variable (:s) or
-  # an RDFS::Resource (or equivalent class). Keyword queries are specified with the special :keyword 
+    # an RDFS::Resource (or equivalent class). Keyword queries are specified with the special :keyword 
     # symbol: Query.new.select(:s).where(:s, :keyword, 'eyal')
     def where s,p,o,c=nil
       case p
@@ -190,13 +191,13 @@ module ActiveRDF
         # generator.
         # if you construct this query manually, you shouldn't! if your select
         # variable happens to be in one of the removed clauses: tough luck.
-      unless (s.respond_to?(:uri) or s.is_a?(Symbol)) and (s.class != RDFS::BNode)
-        raise(ActiveRdfError, "Cannot add a where clause with s #{s}: s must be a resource or a variable, is a #{s.class.name}")
+        unless (s.respond_to?(:uri) or s.is_a?(Symbol)) and (s.class != RDFS::BNode)
+          raise(ActiveRdfError, "Cannot add a where clause with s #{s}: s must be a resource or a variable, is a #{s.class.name}")
         end
-      unless (p.respond_to?(:uri) or p.is_a?(Symbol)) and (s.class != RDFS::BNode)
-        raise(ActiveRdfError, "Cannot add a where clause with p #{p}: p must be a resource or a variable, is a #{p.class.name}")
+        unless (p.respond_to?(:uri) or p.is_a?(Symbol)) and (s.class != RDFS::BNode)
+          raise(ActiveRdfError, "Cannot add a where clause with p #{p}: p must be a resource or a variable, is a #{p.class.name}")
         end
-      raise(ActiveRdfErrror, "Cannot add a where clause where o is a blank node") if(o.class == RDFS::BNode)
+        raise(ActiveRdfErrror, "Cannot add a where clause where o is a blank node") if(o.class == RDFS::BNode)
 
         @where_clauses << [s,p,o,c]
       end
@@ -247,7 +248,7 @@ module ActiveRDF
 
     # Returns SPARQL serialisation of query
     def to_sp
-    require 'queryengine/query2sparql' unless(defined?(Query2SPARQL))
+      require 'queryengine/query2sparql' unless(defined?(Query2SPARQL))
       Query2SPARQL.translate(self)
     end
 
@@ -288,12 +289,12 @@ module ActiveRDF
       @where_clauses = new_where_clauses
     end
 
-  #  def reasoned_query
-  #    new_where_clauses = []
-  #    @where_clauses.each do |s,p,o,c|
-  #      # other reasoning should be added here
-  #    end
-  #    @where_clauses += new_where_clauses
-  #  end
+    #  def reasoned_query
+    #    new_where_clauses = []
+    #    @where_clauses.each do |s,p,o,c|
+    #      # other reasoning should be added here
+    #    end
+    #    @where_clauses += new_where_clauses
+    #  end
   end
 end

data/lib/active_rdf/storage/federated_store.rb.orig

@@ -0,0 +1,116 @@
+require 'active_rdf/federation/connection_pool'
+
+include ActiveRdfBenchmark
+
+# Manages the federation of datasources: distributes queries to right
+# datasources and merges their results
+
+module ActiveRDF
+  class FederationManager
+<<<<<<< HEAD:lib/active_rdf/federation/federation_manager.rb
+    def FederationManager.contexts
+=======
+  def FederationManager.contexts
+>>>>>>> 9e1004bb8cd871b9a465a676ffde1a3c16790611:lib/active_rdf/storage/federated_store.rb
+      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)
+      end
+    end
+
+    # 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)
+      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
+
+    # 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.execute(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.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? }
+
+          # 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?
+
+          # remove array (return single value or nil) if asked to
+          if options[:flatten]
+            case results.size
+            when 0
+              results = nil
+            when 1
+              results = results.first
+            end
+          end
+        end
+
+        results
+      end # End benchmark
+    end # End query
+  end
+end

data/lib/active_rdf_log.rb

@@ -27,6 +27,7 @@ class ActiveRdfLogger
 
     # Assign a new logger
     def logger=(logger)
+      raise(ArgumentError, "Empty Logger") if(logger == nil)
       @logger = logger
       @native_logger = false
     end
@@ -55,8 +56,8 @@ class ActiveRdfLogger
     end
 
     def get_active_rdf_logger
-      if(defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER)
-        RAILS_DEFAULT_LOGGER
+      if(defined?(Rails) && !Rails.logger.nil?)
+        Rails.logger
       else
         @native_logger = true
 

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: activerdf_net7
 version: !ruby/object:Gem::Version 
-  version: 1.7.1
+  prerelease: false
+  segments: 
+    - 1
+    - 7
+    - 2
+  version: 1.7.2
 platform: ruby
 authors: 
   - Eyal Oren
@@ -10,29 +15,37 @@ autorequire: active_rdf
 bindir: bin
 cert_chain: []
 
-date: 2010-02-15 00:00:00 +01:00
+date: 2010-07-19 00:00:00 +02:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: gem_plugin
-    type: :runtime
-    version_requirement: 
-    version_requirements: !ruby/object:Gem::Requirement 
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
+            segments: 
+              - 0
+              - 2
+              - 1
             version: 0.2.1
-      version: 
+    type: :runtime
+    version_requirements: *id001
   - !ruby/object:Gem::Dependency 
     name: grit
-    type: :runtime
-    version_requirement: 
-    version_requirements: !ruby/object:Gem::Requirement 
+    prerelease: false
+    requirement: &id002 !ruby/object:Gem::Requirement 
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
+            segments: 
+              - 1
+              - 1
+              - 1
             version: 1.1.1
-      version: 
+    type: :runtime
+    version_requirements: *id002
 description: Offers object-oriented access to RDF (with adapters to several datastores). Version of the Talia project. THIS IS NOT THE OFFICIAL VERSION.
 email: hahn@netseven.it
 executables: []
@@ -201,13 +214,16 @@ files:
   - lib/active_rdf/objectmanager/property.rb
   - lib/active_rdf/objectmanager/property_list.rb
   - lib/active_rdf/objectmanager/property_lookup.rb
+  - lib/active_rdf/objectmanager/reslike
   - lib/active_rdf/objectmanager/resource.rb
   - lib/active_rdf/objectmanager/resource_like.rb
   - lib/active_rdf/objectmanager/resource_query.rb
+  - lib/active_rdf/query/query.rb.orig
   - lib/active_rdf/queryengine/ntriples_parser.rb
   - lib/active_rdf/queryengine/query.rb
   - lib/active_rdf/queryengine/query2jars2.rb
   - lib/active_rdf/queryengine/query2sparql.rb
+  - lib/active_rdf/storage/federated_store.rb.orig
   - lib/active_rdf_helpers.rb
   - lib/active_rdf_log.rb
   - CHANGELOG
@@ -226,18 +242,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+          - 0
         version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+          - 0
         version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Offers object-oriented access to RDF (with adapters to several datastores). Version of the Talia project.