Skip to content

Commit

Permalink
Merge commit '7c376ae3362751cb40c75a4b26a94ae5cd370abb' into talia_re…
Browse files Browse the repository at this point in the history 
…merge

Conflicts:
	activerdf-rdflite/lib/activerdf_rdflite/fetching.rb
	activerdf-rdflite/lib/activerdf_rdflite/rdflite.rb
	activerdf-rdflite/lib/activerdf_rdflite/suggesting.rb
	activerdf-sesame/lib/activerdf_sesame/sesame.rb
	activerdf-sparql/lib/activerdf_sparql/sparql.rb
	activerdf-yars/lib/activerdf_yars/jars2.rb
	lib/active_rdf.rb
	lib/active_rdf/federation/active_rdf_adapter.rb
	lib/active_rdf/federation/connection_pool.rb
	lib/active_rdf/federation/federation_manager.rb
	lib/active_rdf/objectmanager/object_manager.rb
	lib/active_rdf/queryengine/ntriples_parser.rb
	lib/active_rdf/queryengine/query.rb
	lib/active_rdf/queryengine/query2jars2.rb
	lib/active_rdf_log.rb
  • Loading branch information
@averell23
averell23 committed Feb 11, 2010
2 parents 4bb09d7 + 7c376ae commit 603a491
Show file tree
Hide file tree
Showing 51 changed files with 1,457 additions and 1,460 deletions.
8 changes: 4 additions & 4 deletions activerdf-jena/lib/activerdf_jena/jena.rb
View file
Original file line number Diff line number Diff line change
Expand Up @@ -17,7 +17,7 @@ module Model

module DB
include_package('com.hp.hpl.jena.db')

# this maps downcased Jena database types into drivers
DRIVER_MAP = {
'oracle' => 'oracle.jdbc.Driver',
Expand All @@ -27,8 +27,8 @@ module DB
'hsql' => 'org.hsqldb.jdbcDriver',
'mssql' => 'com.microsoft.sqlserver.jdbc.SQLServerDriver'
}
DRIVER_MAP.each do |name, driver|

DRIVER_MAP.each do |name, driver|
av = "#{name}_available"
(class << self ; self ; end).send(:bool_accessor, av.to_sym)
begin
Expand All @@ -39,7 +39,7 @@ module DB
end
end
end

module Query
include_package('com.hp.hpl.jena.query')
end
Expand Down
108 changes: 54 additions & 54 deletions activerdf-jena/lib/activerdf_jena/jena_adapter.rb
View file
Original file line number Diff line number Diff line change
Expand Up @@ -32,7 +32,7 @@ def getConnection
def close
self.datasource = nil
end

def valid_connection?(cnxn)
true
end
Expand All @@ -47,9 +47,9 @@ def valid_connection?(cnxn)
attr_accessor :model_maker, :base_model, :model, :lucene_index
attr_accessor :root_directory

# :database
# :database
# either use :url, :type, :username, AND :password (for a
# regular connection) OR :datasource AND :type (for a container
# regular connection) OR :datasource AND :type (for a container
# connection), default to memory data store
# example for a derby connection:
# :database => {:url => "jdbc:derby:superfunky;create=true", :type => "Derby", :username => "", :password => ""}
Expand All @@ -59,12 +59,12 @@ def valid_connection?(cnxn)
# :model
# name of model to use, default is jena's default
# :ontology
# set to language type if this needs to be viewed as an ontology,
# set to language type if this needs to be viewed as an ontology,
# default nil, available :owl, :owl_dl, :owl_lite, :rdfs
# pellet only supports owl reasoning.
# :reasoner
# set to reasoner to use -- default nil (none). options: :pellet,
# :transitive, :rdfs, :rdfs_simple, :owl_micro, :owl_mini, :owl,
# pellet only supports owl reasoning.
# :reasoner
# set to reasoner to use -- default nil (none). options: :pellet,
# :transitive, :rdfs, :rdfs_simple, :owl_micro, :owl_mini, :owl,
# :generic_rule
# :lucene
# set to true to enable true lucene indexing of this store, default false
Expand All @@ -73,7 +73,7 @@ def initialize(params = {})
self.ontology_type = params[:ontology]
self.reasoner = params[:reasoner]
self.keyword_search = params[:lucene]

# if the model name is not provided and file persistence is used, then jena just
# creates random files in the tmp dir. not good, as we need to know the model name
# to have persistence
Expand All @@ -82,7 +82,7 @@ def initialize(params = {})
else
self.model_name = "default"
end

if params[:file]
if params[:file].respond_to? :path
self.root_directory = File.expand_path(params[:file].path)
Expand All @@ -95,7 +95,7 @@ def initialize(params = {})
if self.keyword_search? && !LuceneARQ.lucene_available?
raise JenaAdapterConfigurationError, "Lucene requested but is not available"
end

if self.reasoner == :pellet && !Pellet.pellet_available?
raise JenaAdapterConfigurationError, "Pellet requested but not available"
end
Expand All @@ -117,28 +117,28 @@ def initialize(params = {})
raise JenaAdapterConfigurationError, "database type #{dbparams[:type]} not recognized"
end

self.connection = Jena::DB::DBConnection.new(dbparams[:url],
self.connection = Jena::DB::DBConnection.new(dbparams[:url],
dbparams[:username],
dbparams[:password],
dbparams[:type])
end

self.model_maker = Jena::Model::ModelFactory.createModelRDBMaker(connection)

elsif self.root_directory
self.model_maker = Jena::Model::ModelFactory.createFileModelMaker(self.root_directory)
else
self.model_maker = Jena::Model::ModelFactory.createMemModelMaker
end


self.base_model = self.model_maker.openModel(model_name)

if self.ontology_type
rf = map_reasoner_factory(self.reasoner)
onturi = map_ontology_type(self.ontology_type)

spec =
spec =
Jena::Ontology::OntModelSpec.new(self.model_maker,
Jena::Ontology::OntDocumentManager.new,
rf, onturi)
Expand All @@ -150,10 +150,10 @@ def initialize(params = {})
self.model = self.base_model
self.reasoning = false
end

self.reads = true
self.writes = true

self
end

Expand Down Expand Up @@ -212,17 +212,17 @@ def flush
# :format
# format -- :ntriples, :n3, or :rdfxml, default :rdfxml
# :into
# either the name of a model, :default_model for the main model, or
# either the name of a model, :default_model for the main model, or
# :submodel to load into an anonymous memory model, default is :submodel
# if this is an ontology, :default_model if it's not.
# :rebind
# :rebind
# rebind with the inferencer, default true; no effect if no inferencer
def load(uri, params = {})
into = params[:into] ? params[:into] :
into = params[:into] ? params[:into] :
(self.ontology_type ? :submodel : :default_model)
format = params[:format] ? params[:format] : :rdfxml
rebind = params[:rebind] ? params[:rebind] : true

jena_format =
case format
when :rdfxml
Expand All @@ -236,30 +236,30 @@ def load(uri, params = {})
case into
when :default_model
self.model.read(uri, jena_format)

when :submodel
self.model.addSubModel(Jena::Model::ModelFactory.createDefaultModel.read(uri, jena_format))

else
self.model.addSubModel(self.model_maker.createModel(into).read(uri, jena_format))
end

if rebind && self.reasoner && self.model.respond_to?(:rebind)
self.model.rebind
end

self.lucene_index_behind = true
end

end

# this method gets called by the ActiveRDF query engine
def execute(query)

if self.keyword_search? && query.keyword?

# duplicate the query
query_with_keywords = query.dup

# now duplicate the where stuff so we can fiddle with it...
# this is GROSS -- fix this if Query ever sprouts a proper
# deep copy or a where_clauses setter
Expand All @@ -272,7 +272,7 @@ def execute(query)
#query.where("lucene_literal_#{var}".to_sym, LuceneARQ::KEYWORD_PREDICATE, keyword)
#query.where(var, "lucene_property_#{var}".to_sym, "lucene_literal_#{var}".to_sym)

# use this if activerdf expects the literal to come back, not the
# use this if activerdf expects the literal to come back, not the
# subject, or if using indexbuildersubject (which makes the subject
# come back instead of the literal
query_with_keywords.where(var, RDFS::Resource.new(LuceneARQ::KEYWORD_PREDICATE), keyword)
Expand All @@ -287,7 +287,7 @@ def execute(query)
# search requests expanded.
jena_results = query_jena(query_with_keywords)

# use the conjunctive query facility in pellet to get additional
# use the conjunctive query facility in pellet to get additional
# answers, if we're using pellet and we don't have a pure keyword
# query
if self.reasoner == :pellet && query.where_clauses.size > 0
Expand All @@ -303,17 +303,17 @@ def execute(query)
return [[true]] if results.size > 0
return [[false]]
end

if query.count?
return results.size
end

results

end

# ==========================================================================
# put private methods here to seperate api methods from the
# put private methods here to seperate api methods from the
# inner workings of the adapter
private

Expand All @@ -337,28 +337,28 @@ def map_reasoner_factory(type)
case type
when :pellet
Pellet.reasoner_factory

when :transitive
com.hp.hpl.jena.reasoner.transitiveReasoner.TransitiveReasonerFactory.theInstance

when :rdfs
com.hp.hpl.jena.reasoner.rulesys.RDFSFBRuleReasonerFactory.theInstance

when :rdfs_simple
com.hp.hpl.jena.reasoner.rulesys.RDFSRuleReasonerFactory.theInstance

when :owl_micro
com.hp.hpl.jena.reasoner.rulesys.OWLMicroReasonerFactory.theInstance

when :owl_mini
com.hp.hpl.jena.reasoner.rulesys.OWLMiniReasonerFactory.theInstance
when :owl

when :owl
com.hp.hpl.jena.reasoner.rulesys.OWLFBRuleReasonerFactory.theInstance

when :generic_rule
com.hp.hpl.jena.reasoner.rulesys.GenericRuleReasonerFactory.theInstance

else
type
end
Expand All @@ -379,7 +379,7 @@ def build_object(object, submodel = nil)
else
objlit = object
end

if objlit.type
type = Jena::Datatypes::TypeMapper.getInstance.getTypeByName(objlit.type.uri)
o = mod.createTypedLiteral(objlit.value, type)
Expand All @@ -388,11 +388,11 @@ def build_object(object, submodel = nil)
else
o = mod.createTypedLiteral(objlit.value, nil)
end
end
end
return o
end

def build_subject(subject, submodel = nil)
def build_subject(subject, submodel = nil)
# ensure it exists in the parent model
self.model.getResource(subject.uri) if submodel
appropriate_model(submodel).getResource(subject.uri)
Expand Down Expand Up @@ -426,8 +426,8 @@ def get_model_for_context(context)
end

def query_jena(query)
query_sparql = translate(query)
query_sparql = translate(query)

qexec = Jena::Query::QueryExecutionFactory.create(query_sparql, self.model)

# PROBABLY A VERY EXPENSIVE OPERATION (rebuilds lucene index if ANYTHING
Expand All @@ -437,7 +437,7 @@ def query_jena(query)
LuceneARQ::LARQ.setDefaultIndex(qexec.getContext, retrieve_lucene_index)
end

begin
begin
results = perform_query(query, qexec)
ensure
qexec.close
Expand All @@ -449,25 +449,25 @@ def query_jena(query)
def query_pellet(query)
query_sparql = translate(query)
jena_query = Jena::Query::QueryFactory.create(query_sparql)

# bail if not a select
return [] if !jena_query.isSelectType

qexec = Pellet::Query::PelletQueryExecution.new(jena_query, self.model)

begin
results = perform_query(query, qexec)
ensure
qexec.close
end

results
end

def perform_query(query, qexec)
results = qexec.execSelect
arr_results = []

while results.hasNext
row = results.nextSolution
res_row = []
Expand All @@ -487,7 +487,7 @@ def perform_query(query, qexec)
# datatyped literal
res_row << Literal.new(thing.getValue, RDFS::Resource.new(thing.getDatatypeURI))
elsif thing.getDatatypeURI.nil?
# language tagged literal
# language tagged literal
res_row << Literal.new(thing.getLexicalForm, "@" + thing.getLanguage)
else
raise ActiveRdfError, "Jena Sparql returned a strange literal"
Expand Down
2 changes: 1 addition & 1 deletion activerdf-jena/lib/activerdf_jena/lucene.rb
View file
Original file line number Diff line number Diff line change
Expand Up @@ -11,7 +11,7 @@ class << self

KEYWORD_PREDICATE = "http://jena.hpl.hp.com/ARQ/property#textMatch"

begin
begin
include_class('com.hp.hpl.jena.query.larq.LARQ')
include_package('com.hp.hpl.jena.query.larq')
self.lucene_available = true
Expand Down
Loading

0 comments on commit 603a491

Please sign in to comment.