activerdf_rdflite 1.0 → 1.1

data/Rakefile

@@ -14,7 +14,7 @@ desc "test and package gem"
 task :default => [:test, :package]
 
 # get ActiveRdfVersion from commandline
-ActiveRdfVersion = ENV['REL'] || '0.9.7'
+ActiveRdfVersion = ENV['REL'] || '1.0'
 NAME="activerdf_rdflite"
 GEMNAME="#{NAME}-#{ActiveRdfVersion}.gem"
 

data/lib/activerdf_rdflite/fetching.rb

@@ -0,0 +1,43 @@
+#class String
+#  alias _match match
+#  def match(*args)
+#    m = _match(args.first)
+#    if m && m.length > 1
+#      args[1..-1].each_with_index do |name, index|
+#        m.instance_eval "def #{name}; self[#{index+1}] end"
+#      end
+#    end
+#    m
+#  end
+#end
+
+class FetchingAdapter < RDFLite
+  ConnectionPool.register_adapter(:fetching,self)
+
+	# fetches RDF/XML data from given url and adds it to the datastore, using the 
+	# source url as context identifier.
+  def fetch url
+		return unless url.match(/http:\/\/(.*)/)
+
+		# remove fragment identifier from url
+		hashidx = url.rindex('#')
+		url = url[0..url.rindex('#')-1] unless hashidx.nil?
+
+		$activerdflog.debug "fetching from #{url}"
+
+		#model = Redland::Model.new
+		#parser = Redland::Parser.new('rdfxml')
+		#scan = Redland::Uri.new('http://feature.librdf.org/raptor-scanForRDF')
+		#enable = Redland::Literal.new('1')
+		#Redland::librdf_parser_set_feature(parser, scan.uri, enable.node)
+		#parser.parse_into_model(model, url)
+		#triples = Redland::Serializer.ntriples.model_to_string(nil, model)
+
+		triples = `rapper --scan "#{url}"`
+		lines = triples.split($/)
+		$activerdflog.debug "found #{lines.size} triples"
+
+		context = RDFS::Resource.new(url)
+		add_ntriples(triples, context)
+  end
+end

data/lib/activerdf_rdflite/init.rb

@@ -9,3 +9,5 @@ end
 $: << File.dirname(File.expand_path(file))
 
 require 'rdflite'
+require 'fetching'
+require 'suggesting'

data/lib/activerdf_rdflite/rdflite.rb

@@ -1,7 +1,3 @@
-# RDFLite is a lightweight RDF database on top of sqlite3. It can act as adapter 
-# in ActiveRDF. It supports on-disk and in-memory usage, and allows keyword 
-# search if ferret is installed.
-#
 # Author:: Eyal Oren
 # Copyright:: (c) 2005-2006 Eyal Oren
 # License:: LGPL
@@ -10,20 +6,23 @@ require 'sqlite3'
 require 'active_rdf'
 require 'federation/connection_pool'
 
-$log.info "loading RDFLite adapter"
+$activerdflog.info "loading RDFLite adapter"
 
 begin 
 	require 'ferret'
 	@@have_ferret = true
 rescue LoadError
-	$log.info "Keyword search is disabled since we could not load Ferret. To 
+	$activerdflog.info "Keyword search is disabled since we could not load Ferret. To 
 	enable, please do \"gem install ferret\""
 	@@have_ferret = false
 end
 
+# RDFLite is a lightweight RDF database on top of sqlite3. It can act as adapter 
+# in ActiveRDF. It supports on-disk and in-memory usage, and allows keyword 
+# search if ferret is installed.
 class RDFLite < ActiveRdfAdapter
 	ConnectionPool.register_adapter(:rdflite,self)
-	bool_accessor :keyword_search
+	bool_accessor :keyword_search, :reasoning
 
 	# instantiates RDFLite database
 	# available parameters:
@@ -31,7 +30,7 @@ class RDFLite < ActiveRdfAdapter
 	# * :keyword => true/false (defaults to true)
 	# * :pidx, :oidx, etc. => true/false (enable/disable these indices)
 	def initialize(params = {})
-		$log.info "initialised rdflite with params #{params.to_s}"
+		$activerdflog.info "initialised rdflite with params #{params.to_s}"
 
 		@reads = true
 		@writes = true
@@ -40,22 +39,17 @@ class RDFLite < ActiveRdfAdapter
 		file = params[:location] || ':memory:'
 		@db = SQLite3::Database.new(file) 
 
-		# we enable keyword unless the user specifies otherwise
-		@keyword_search = if params[:keyword].nil?
-												true
-											else
-											  params[:keyword]
-											end
-
-		# we can only do keyword search if ferret is found
+		# enable keyword search by default, but only if ferret is found
+		@keyword_search = params[:keyword].nil? ? true : params[:keyword]
 		@keyword_search &= @@have_ferret
-		$log.debug "we #{keyword_search? ? "do" : "don't"} have keyword search"
+
+		@reasoning = params[:reasoning] || false
 
 		if keyword_search?
 			# we initialise the ferret index, either as a file or in memory
+			infos = Ferret::Index::FieldInfos.new
 
 			# we setup the fields not to store object's contents
-			infos = Ferret::Index::FieldInfos.new
 			infos.add_field(:subject, :store => :yes, :index => :no, :term_vector => :no)
 			infos.add_field(:object, :store => :no) #, :index => :omit_norms)
 			
@@ -69,13 +63,11 @@ class RDFLite < ActiveRdfAdapter
 		# turn off filesystem synchronisation for speed
 		@db.synchronous = 'off'
 
-		# create triples table. since triples are unique, inserted duplicates are 
-		@db.execute('create table if not exists triple(s,p,o, unique(s,p,o) on conflict ignore)')
+		# create triples table. ignores duplicated triples
+		@db.execute('create table if not exists triple(s,p,o,c, unique(s,p,o,c) on conflict ignore)')
 
 		create_indices(params)
-
-		$log.debug("opened connection to #{file}")
-		$log.debug("database contains #{size} triples")
+		@db
 	end
 
 	# returns the number of triples in the datastore (incl. possible duplicates)
@@ -85,8 +77,8 @@ class RDFLite < ActiveRdfAdapter
 
 	# returns all triples in the datastore
 	def dump
-		@db.execute('select s,p,o from triple') do |s,p,o|
-			[s,p,o].join(' ')
+		@db.execute('select s,p,o,c from triple').collect do |s,p,o,c|
+			[s,p,o,c].join(' ')
 		end
 	end
 
@@ -95,37 +87,23 @@ class RDFLite < ActiveRdfAdapter
 		@db.execute('delete from triple')
 	end
 
-	# deletes triple(s,p,o) from datastore
-	# nil parameters match anything: delete(nil,nil,nil) will delete all triples
-	def delete(s,p,o)
+	# deletes triple(s,p,o,c) from datastore
+	# symbol parameters match anything: delete(:s,:p,:o) will delete all triples
+	# you can specify a context to limit deletion to that context: 
+	# delete(:s,:p,:o, 'http://context') will delete all triples with that context
+	def delete(s,p,o,c=nil)
 		# convert input to internal format
-		# leave nil input alone (we'll deal with it later)
-		s = "<#{s.uri}>" unless s.nil?
-		p = "<#{p.uri}>" unless p.nil?
-		o = case o
-				when RDFS::Resource
-					"<#{o.uri}>"
-				else
-					"\"#{o.to_s}\""
-				end unless o.nil?
-
-		# construct where clause for deletion (for all non-nil input)
-		where_clauses = []
-		conditions = []
-		unless s.nil?
-			conditions << s
-			where_clauses << 's = ?' 
-		end
+		quad = [s,p,o,c].collect {|r| internalise(r) }
 
-		unless p.nil?
-			conditions << p
-			where_clauses << 'p = ?' 
-		end
-
-		unless o.nil?
-			conditions << o
-			where_clauses << 'o = ?' 
-		end
+    # construct where clause for deletion (for all non-nil input)
+		where_clauses = []
+		conditions = []		
+    quad.each_with_index do |r,i|
+      unless r.nil?
+			 conditions << r
+			 where_clauses << "#{SPOC[i]} = ?"
+		  end
+    end
 
 		# construct delete string
 		ds = 'delete from triple'
@@ -133,28 +111,29 @@ class RDFLite < ActiveRdfAdapter
 
 		# execute delete string with possible deletion conditions (for each 
 		# non-empty where clause)
+		$activerdflog.debug("deleting #{[s,p,o,c].join(' ')}")
 		@db.execute(ds, *conditions)
-		$log.debug(sprintf("sending delete query: #{ds}", *conditions))
 
 		# delete literal from ferret index
 		@ferret.search_each("subject:\"#{s}\", object:\"#{o}\"") do |idx, score|
-			$log.debug "deleting #{o} => #{s} from ferret index"
 			@ferret.delete(idx)
 		end if keyword_search?
+
+		@db
 	end
 	
 	# adds triple(s,p,o) to datastore
 	# s,p must be resources, o can be primitive data or resource
-	def add(s,p,o)
+	def add(s,p,o,c=nil)
 		# check illegal input
 		raise(ActiveRdfError, "adding non-resource #{s}") unless s.respond_to?(:uri)
 		raise(ActiveRdfError, "adding non-resource #{p}") unless p.respond_to?(:uri)
 
 		# get internal representation (array)
-		triple = internal_triple_representation(s,p,o)
+		quad = [s,p,o,c].collect {|r| internalise(r) }
 
 		# add triple to database
-		add_internal(*triple)
+		add_internal(@db,*quad)
 	end
 
 	# flushes openstanding changes to underlying sqlite3
@@ -167,38 +146,70 @@ class RDFLite < ActiveRdfAdapter
 	# loads triples from file in ntriples format
 	def load(file)
 		ntriples = File.readlines(file)
+		$activerdflog.debug "read #{ntriples.size} triples from file #{file}"
 
-		@db.transaction do 
+		context = "<file:#{file}>"
+		add_ntriples(ntriples, context)
+	end
+
+	# adds string of ntriples from given context to database
+	def add_ntriples(ntriples, context=nil)
+		# convert context to internal format if RDFS::Resource
+		context = internalise(context)
+
+		# need unique identifier for this batch of triples (to detect occurence of 
+		# same bnodes _:#1
+		uuid = `uuidgen`
+
+		# add each triple to db
+		@db.transaction do |tr|
 			ntriples.each do |triple|
 				nodes = triple.scan(Node)
-				add_internal(nodes[0], nodes[1], nodes[2])
+
+				# handle bnodes if necessary (bnodes need to have uri generated)
+				subject = case nodes[0]
+									when BNode
+										"<http://www.activerdf.org/bnode/#$1/#{uuid}>"
+									else
+										nodes[0]
+									end
+
+				predicate = nodes[1]
+
+				# handle bnodes and literals if necessary (literals need unicode fixing)
+				object = case nodes[2]
+								 when BNode
+									 "<http://www.activerdf.org/bnode/#$1/#{uuid}>"
+								 when Literal
+									 fix_unicode(nodes[2])
+								 else
+									 nodes[2]
+								 end
+
+				add_internal(tr, subject, predicate, object, context)
 			end
 		end
 
-		$log.debug "read #{ntriples.size} triples from file #{file}"
 		@db
 	end
 
 	# executes ActiveRDF query on datastore
 	def query(query)
-		# log received query
-		$log.debug "received query: #{query.to_sp}"
-
 		# construct query clauses
-		sql = translate(query)
+		sql, conditions = translate(query)
 
 		# executing query, passing all where-clause values as parameters (so that 
 		# sqlite will encode quotes correctly)
-		constraints = @right_hand_sides.collect { |value| value.to_s }
-
-		$log.debug format("executing: #{sql.gsub('?','"%s"')}", *constraints)
+		#constraints = right_hand_sides.collect { |value| value.to_s }
 
 		# executing query
-		results = @db.execute(sql, *constraints)
+		results = @db.execute(sql, *conditions)
 
 		# if ASK query, we check whether we received a positive result count
 		if query.ask?
-			return [results[0][0].to_i > 0]
+			return [[results[0][0].to_i > 0]]
+		elsif query.count?
+			return [[results[0][0].to_i]]
 		else
 			# otherwise we convert results to ActiveRDF nodes and return them
 			return wrap(query, results)
@@ -207,22 +218,23 @@ class RDFLite < ActiveRdfAdapter
 
 	# translates ActiveRDF query into internal sqlite query string
 	def translate(query)
-		construct_select(query) + construct_join(query) + construct_where(query) + 
-			construct_limit(query)
+		where, conditions = construct_where(query)
+		[construct_select(query) + construct_join(query) + where + construct_sort(query) + construct_limit(query), conditions]
 	end
 
 	private
 	# constants for extracting resources/literals from sql results
+	BNode = /_:(\S*)/
 	Resource = /<([^>]*)>/
 	Literal = /"([^"]*)"/
-	Node = Regexp.union(/<[^>]*>/,/"[^"]*"/)
-	SPO = ['s','p','o']
+	Node = Regexp.union(/_:\S*/,/<[^>]*>/,/"[^"]*"/)
+	SPOC = ['s','p','o','c']
 
 	# adds s,p,o into sqlite and ferret
 	# s,p,o should be in internal format: <uri> and "literal"
-	def add_internal(s,p,o)
+	def add_internal(db, s, p, o, c)
 		# insert the triple into the datastore
-		@db.execute('insert into triple values (?,?,?)', s,p,o)
+		db.execute('insert into triple values (?,?,?,?)', s,p,o,c)
 
 		# if keyword-search available, insert the object into keyword search
 		@ferret << {:subject => s, :object => o} if keyword_search?
@@ -262,6 +274,16 @@ class RDFLite < ActiveRdfAdapter
 		clause
 	end
 
+	# sort query results on variable clause (optionally)
+	def construct_sort(query)
+		return "" if query.sort_clauses.empty?
+
+		sort = query.sort_clauses.collect do |term|
+			variable_name(query, term)
+		end
+		" order by (#{sort.join(',')})"
+	end
+
 	# construct join clause
 	# TODO: joins don't work this way, they have to be linear (in one direction 
 	# only, and we should only alias tables we didnt alias yet)
@@ -298,8 +320,8 @@ class RDFLite < ActiveRdfAdapter
 
 			# construct t0,t1,... as aliases for term
 			# and construct join condition, e.g. t0.s
-			termalias = "t#{index / 3}"
-			termjoin = "#{termalias}.#{SPO[index % 3]}"
+			termalias = "t#{index / 4}"
+			termjoin = "#{termalias}.#{SPOC[index % 4]}"
 
 			join = if join_stmt.include?(termalias)
 							 ""
@@ -313,8 +335,8 @@ class RDFLite < ActiveRdfAdapter
 
 				# construct t0,t1, etc. as aliases for buddy,
 				# and construct join condition, e.g. t0.s = t1.p
-				buddyalias = "t#{i/3}"
-				buddyjoin = "#{buddyalias}.#{SPO[i%3]}"
+				buddyalias = "t#{i/4}"
+				buddyjoin = "#{buddyalias}.#{SPOC[i%4]}"
 
 				# TODO: fix reuse of same table names as aliases, e.g.
 				# "from triple as t1 join triple as t2 on ... join t1 on ..."
@@ -345,20 +367,22 @@ class RDFLite < ActiveRdfAdapter
 		# collecting all the right-hand sides of where clauses (e.g. where name = 
 		# 'abc'), to add to query string later using ?-notation, because then 
 		# sqlite will automatically encode quoted literals correctly
-		@right_hand_sides = []
+		right_hand_sides = []
 
 		# convert each where clause to SQL:
 		# add where clause for each subclause, except if it's a variable
 		query.where_clauses.each_with_index do |clause,level|
+			raise ActiveRdfError, "where clause #{clause} is not a triple" unless clause.is_a?(Array)
 			clause.each_with_index do |subclause, i|
 				# dont add where clause for variables
 				unless subclause.is_a?(Symbol)
-					where << "t#{level}.#{SPO[i]} = ?"
-					@right_hand_sides << case subclause
-				 	when RDFS::Resource
-						"<#{subclause.uri}>"
+					conditions = compute_where_condition(i, subclause, query.reasoning? && reasoning?)
+					if conditions.size == 1
+						where << "t#{level}.#{SPOC[i]} = ?"
+						right_hand_sides << conditions.first
 					else
-						subclause.to_s
+						conditions = conditions.collect {|c| "'#{c}'"}
+						where << "t#{level}.#{SPOC[i]} in (#{conditions.join(',')})"
 					end
 				end
 			end
@@ -371,18 +395,53 @@ class RDFLite < ActiveRdfAdapter
 			raise ActiveRdfError, "cannot do keyword search over multiple subjects" if select_subject.size > 1
 
 			keywords = query.keywords.collect {|subj,key| key}
-			@ferret.search_each("object:\"#{keywords}\"") do |idx,score|
+			@ferret.search_each("object:#{keywords}") do |idx,score|
 				subjects << @ferret[idx][:subject]
 			end
 			subjects.uniq! if query.distinct?
 			where << "#{variable_name(query,select_subject.first)} in (#{subjects.collect {'?'}.join(',')})"
-			@right_hand_sides += subjects
+			right_hand_sides += subjects
 		end
 
 		if where.empty?
-			''
+			['',[]]
+		else
+			["where " + where.join(' and '), right_hand_sides]
+		end
+	end
+
+	def compute_where_condition(index, subclause, reasoning)
+		conditions = [subclause]
+
+		# expand conditions with rdfs rules if reasoning enabled
+		if reasoning
+			case index
+			when 0: ;
+				# no rule for subjects
+			when 1:
+				# expand properties to include all subproperties
+				conditions = subproperties(subclause) if subclause.respond_to?(:uri)
+			when 2:
+				# no rule for objects
+			when 3:
+				# no rule for contexts
+			end
+		end
+
+		# convert conditions into internal format
+		conditions.collect { |c| c.respond_to?(:uri) ? "<#{c.uri}>" : c.to_s }
+	end
+
+	def subproperties(resource)
+		subproperty = Namespace.lookup(:rdfs,:subPropertyOf)
+		children_query = Query.new.distinct(:sub).where(:sub, subproperty, resource)
+		children_query.reasoning = false
+		children = children_query.execute
+
+		if children.empty?
+			[resource]
 		else
-			"where " + where.join(' and ')
+			[resource] + children.collect{|c| subproperties(c)}.flatten.compact
 		end
 	end
 
@@ -412,28 +471,31 @@ class RDFLite < ActiveRdfAdapter
 			end
 		end
 
-		termtable = "t#{index / 3}"
-		termspo = SPO[index % 3]
+		termtable = "t#{index / 4}"
+		termspo = SPOC[index % 4]
 		return "#{termtable}.#{termspo}"
 	end
 
 	# wrap resources into ActiveRDF resources, literals into Strings
 	def wrap(query, results)
 		results.collect do |row|
-			row.collect do |result|
-				case result
-				when Resource
-					RDFS::Resource.new($1)
-				when Literal
-					String.new($1)
-				else
-					# when we do a count(*) query we get a number, not a resource/literal
-					results
-				end
-			end
+			row.collect { |result| parse(result) }
+		end
+	end
+
+	def parse(result)
+		case result
+		when Resource
+			RDFS::Resource.new($1)
+		when Literal
+			String.new($1)
+		else
+			# when we do a count(*) query we get a number, not a resource/literal
+			result
 		end
 	end
 
+
 	def create_indices(params)
 		sidx = params[:sidx] || false
 		pidx = params[:pidx] || false
@@ -457,15 +519,21 @@ class RDFLite < ActiveRdfAdapter
 
 	# transform triple into internal format <uri> and "literal"
 	# returns array [s,p,o] 
-	def internal_triple_representation(s,p,o)
-		s = "<#{s.uri}>"
-		p = "<#{p.uri}>"
-		o = case o
-				when RDFS::Resource
-					"<#{o.uri}>"
-				else
-					"\"#{o.to_s}\""
-				end
-		[s,p,o]
+	def internalise(r)
+		if r.respond_to?(:uri)
+			"<#{r.uri}>"
+		elsif r.is_a?(Symbol)
+			nil
+		else
+			"\"#{r.to_s}\""
+		end
 	end
+
+	# fixes unicode characters in literals (because we parse them wrongly somehow)
+	def fix_unicode(str)
+		tmp = str.gsub(/\\\u([0-9a-fA-F]{4,4})/u){ "U+#$1" }
+    tmp.gsub(/U\+([0-9a-fA-F]{4,4})/u){["#$1".hex ].pack('U*')}
+	end
+
+	public :subproperties
 end

data/lib/activerdf_rdflite/suggesting.rb

@@ -0,0 +1,73 @@
+require 'pp'
+class SuggestingAdapter < FetchingAdapter
+  ConnectionPool.register_adapter(:suggesting,self)
+
+	alias _old_initialize initialize
+	
+	def initialize params
+		_old_initialize(params)
+		@db.execute('drop view if exists occurrence')
+		@db.execute('create view occurrence as select p, count(distinct s) as count from triple group by p')
+
+		@db.execute('drop view if exists cooccurrence')
+		@db.execute('create view cooccurrence as select t0.p as p1,t1.p as p2, count(distinct t0.s) as count from triple as t0 join triple as t1 on t0.s=t1.s and t0.p!=t1.p group by t0.p, t1.p')
+	end
+
+	def suggest(resource)
+		$activerdflog.debug "starting suggestions for #{size} triples"
+		time = Time.now
+
+    predicates = []
+		own_predicates = resource.direct_predicates
+
+		construct_occurrence_matrix
+		construct_cooccurrence_matrix
+
+		own_predicates.each do |p|
+			predicates << p if occurrence(p) > 1
+		end
+
+		# fetch all predicates co-occurring with our predicates
+		candidates = predicates.collect {|p| cooccurring(p) }
+
+		# perform set intersection
+		candidates = candidates.inject {|intersect, n| intersect & n }.flatten
+		candidates = candidates - own_predicates
+
+		suggestions = candidates.collect do |candidate|
+			score = predicates.inject(1.0) do |score, p|
+				score * cooccurrence(candidate, p) / occurrence(p)
+			end
+			[candidate, score]
+		end
+		$activerdflog.debug "suggestions for #{resource} took #{Time.now-time}s"
+		suggestions
+	end
+
+	def construct_occurrence_matrix
+		@occurrence = {}
+		@db.execute('select * from occurrence where count > 1') do |p,count|
+			@occurrence[parse(p)] = count.to_i
+		end
+	end
+
+	def construct_cooccurrence_matrix
+		@cooccurrence = {}
+		@db.execute('select * from cooccurrence') do |p1, p2, count|
+			@cooccurrence[parse(p1)] ||= {}
+			@cooccurrence[parse(p1)][parse(p2)] = count.to_i
+		end
+	end
+
+	def occurrence(predicate)
+		@occurrence[predicate] || 0
+	end
+
+	def cooccurrence(p1, p2)
+		@cooccurrence[p1][p2] || 0
+	end
+
+	def cooccurring(predicate)
+		@cooccurrence[predicate].keys
+	end
+end

data/test/test_data.nt

@@ -27,3 +27,6 @@
 <http://www.w3.org/1999/02/22-rdf-syntax-ns#Property> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2000/01/rdf-schema#Resource> .
 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2000/01/rdf-schema#domain> <http://www.w3.org/2000/01/rdf-schema#Resource> .
 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2000/01/rdf-schema#range> <http://www.w3.org/2000/01/rdf-schema#Class> .
+_:#1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://activerdf.org/test/Person> .
+_:#1 <http://activerdf.org/test/age> "29" .
+_:#1 <http://activerdf.org/test/name> "Another Person" .

data/test/test_rdflite.rb

@@ -92,8 +92,45 @@ class TestRdfLiteAdapter < Test::Unit::TestCase
 	def test_loading_data
     adapter = ConnectionPool.add_data_source :type => :rdflite
 		adapter.load(File.dirname(File.expand_path(__FILE__)) + '/test_data.nt')
-		assert_equal 29, adapter.size
-		assert_equal 29, Query.new.count(:s).where(:s,:p,:o).execute.to_i
+		assert_equal 32, adapter.size
+	end
+
+	def test_count_query
+    adapter = ConnectionPool.add_data_source :type => :rdflite
+		adapter.load(File.dirname(File.expand_path(__FILE__)) + '/test_data.nt')
+		assert_kind_of Fixnum, Query.new.count(:s).where(:s,:p,:o).execute
+		assert_equal 32, Query.new.count(:s).where(:s,:p,:o).execute
+	end
+
+	def test_single_context
+    adapter = ConnectionPool.add_data_source :type => :rdflite
+		file = File.dirname(File.expand_path(__FILE__)) + '/test_data.nt'
+		adapter.load(file)
+
+		context = Query.new.distinct(:c).where(:s,:p,:o,:c).execute
+		assert_instance_of RDFS::Resource, context
+		assert_equal RDFS::Resource.new("file:#{file}"), context
+	end
+
+	def test_multiple_context
+    adapter = ConnectionPool.add_data_source :type => :rdflite
+		file = File.dirname(File.expand_path(__FILE__)) + '/test_data.nt'
+		adapter.load(file)
+		file_context = RDFS::Resource.new("file:#{file}") 
+		
+    eyal = RDFS::Resource.new 'eyaloren.org'
+    age = RDFS::Resource.new 'foaf:age'
+    test = RDFS::Resource.new 'test'
+    adapter.add(eyal, age, test)
+
+		context = Query.new.distinct(:c).where(:s,:p,:o,:c).execute
+		assert_equal file_context, context[0]
+		assert_equal '', context[1]
+
+		n1 = Query.new.distinct(:s).where(:s,:p,:o,'').execute(:flatten => false)
+		n2 = Query.new.distinct(:s).where(:s,:p,:o,file_context).execute(:flatten => false)
+		assert_equal 1, n1.size
+		assert_equal 9, n2.size
 	end
 
 	def test_person_data 
@@ -119,11 +156,11 @@ class TestRdfLiteAdapter < Test::Unit::TestCase
 	def test_delete_data
     adapter = ConnectionPool.add_data_source :type => :rdflite
 		adapter.load(File.dirname(File.expand_path(__FILE__)) + '/test_data.nt')
-		assert_equal 29, adapter.size
+		assert_equal 32, adapter.size
 
     eyal = RDFS::Resource.new('http://activerdf.org/test/eyal')
 		adapter.delete(eyal, nil, nil)
-		assert_equal 24, adapter.size
+		assert_equal 27, adapter.size
 
 		adapter.delete(nil,nil,nil)
 		assert_equal 0, adapter.size
@@ -136,7 +173,17 @@ class TestRdfLiteAdapter < Test::Unit::TestCase
     eyal = RDFS::Resource.new('http://activerdf.org/test/eyal')
 		assert_equal eyal, Query.new.distinct(:s).where(:s,:keyword,"blue").execute
 		assert_equal eyal, Query.new.distinct(:s).where(:s,:keyword,"27").execute
-
 		assert_equal eyal, Query.new.distinct(:s).where(:s,:keyword,"eyal oren").execute
 	end
+
+	def test_bnodes
+    adapter = ConnectionPool.add_data_source :type => :rdflite
+		adapter.load(File.dirname(File.expand_path(__FILE__)) + '/test_data.nt')
+
+    Namespace.register(:test, 'http://activerdf.org/test/')
+    ObjectManager.construct_classes
+    assert_equal 2, TEST::Person.find_all.size
+		assert_equal 29, TEST::Person.find_all[1].age.to_i
+		assert_equal "Another Person", TEST::Person.find_all[1].name
+	end
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: activerdf_rdflite
 version: !ruby/object:Gem::Version 
-  version: "1.0"
-date: 2006-11-02 00:00:00 +00:00
+  version: "1.1"
+date: 2006-12-08 00:00:00 +00:00
 summary: an RDF database for usage in ActiveRDF (based on sqlite3)
 require_paths: 
 - lib
@@ -37,6 +37,8 @@ files:
 - lib/activerdf_rdflite
 - lib/activerdf_rdflite/init.rb
 - lib/activerdf_rdflite/rdflite.rb
+- lib/activerdf_rdflite/fetching.rb
+- lib/activerdf_rdflite/suggesting.rb
 test_files: []
 
 rdoc_options: []