activerdf 1.6.2 → 1.6.3

data/CHANGELOG

@@ -1,3 +1,6 @@
+== activerdf (1.6.3) Thu, 09 Aug 2007 15:11:15 +0100
+  * added support for LANG filters and engine-specific keyword search in SPARQL
+
 == activerdf (1.6.2) Fri, 03 Aug 2007 14:07:54 +0100
   * initial support for FILTERs in SPARQL
 

data/lib/active_rdf/objectmanager/resource.rb

@@ -322,7 +322,11 @@ module RDFS
 			end
 		end
 
-		def add_predicate localname, fulluri
+    # define a localname for a predicate URI
+    #
+    # localname should be a Symbol or String, fulluri a Resource or String, e.g. 
+    # add_predicate(:name, FOAF::lastName)
+    def add_predicate localname, fulluri
 			localname = localname.to_s
 			fulluri = RDFS::Resource.new(fulluri) if fulluri.is_a? String
 

data/lib/active_rdf/queryengine/query.rb

@@ -90,12 +90,21 @@ class Query
   end
   alias :filter_regex :filter_regexp
 
+  # adds operator filter one one variable
+  # variable is a Ruby symbol that appears in select/where clause, operator is a 
+  # SPARQL operator (e.g. '>'), operand is a SPARQL value (e.g. 15)
   def filter_operator(variable, operator, operand)
     raise(ActiveRdfError, "variable must be a Symbol") unless variable.is_a? Symbol
 
-    filter "(?#{variable} #{operator} #{operand}"
+    filter "?#{variable} #{operator} #{operand}"
   end
 
+  # filter variable on specified language tag, e.g. lang(:o, 'en')
+  def lang variable, tag
+    #filter "regex(lang(?#{variable}), '^#{tag}(-|$)', 'i')"
+    filter "lang(?#{variable}) = '#{tag}'"
+    #filter "langMatches(lang(?#{variable}), '#{tag}')"
+  end
 
   # adds reverse sorting predicates
   def reverse_sort *s
@@ -168,11 +177,11 @@ class Query
   # usage:: query.execute do |s,p,o| ... end
   def execute(options={:flatten => false}, &block)
     options = {:flatten => true} if options == :flatten
+    $activerdflog.debug("executing: #{self.to_sp}")
 
-    $activerdflog.debug("query: #{self.to_sp}")
     if block_given?
-      FederationManager.query(self) do |*clauses|
-        block.call(*clauses)
+      for result in FederationManager.query(self, options)
+        yield result
       end
     else
       FederationManager.query(self, options)

data/lib/active_rdf/queryengine/query2sparql.rb

@@ -1,16 +1,21 @@
 require 'active_rdf'
 
+# TODO: support limit and offset
+
 # Translates abstract query into SPARQL that can be executed on SPARQL-compliant
 # data source.
 class Query2SPARQL
-  def self.translate(query)
+  Engines_With_Keyword = [:yars2, :virtuoso]
+  def self.translate(query, engine=nil)
     str = ""
     if query.select?
       distinct = query.distinct? ? "DISTINCT " : ""
 			select_clauses = query.select_clauses.collect{|s| construct_clause(s)}
 
       str << "SELECT #{distinct}#{select_clauses.join(' ')} "
-      str << "WHERE { #{where_clauses(query)} #{filter_clauses(query)}}"
+      str << "WHERE { #{where_clauses(query)} #{filter_clauses(query)}} "
+      str << "LIMIT #{query.limits}" if query.limits
+      str << "OFFSET #{query.offsets}" if query.offsets
     elsif query.ask?
       str << "ASK { #{where_clauses(query)} }"
     end
@@ -20,22 +25,36 @@ class Query2SPARQL
 
   # concatenate filters in query
   def self.filter_clauses(query)
-    "FILTER #{query.filter_clauses.join(" ")}" unless query.filter_clauses.empty?
+    "FILTER (#{query.filter_clauses.join(" && ")})" unless query.filter_clauses.empty?
   end
 
   # concatenate each where clause using space (e.g. 's p o')
   # and concatenate the clauses using dot, e.g. 's p o . s2 p2 o2 .'
   def self.where_clauses(query)
+    if query.keyword?
+      case sparql_engine
+      when :yars2
+        query.keywords.each do |term, keyword|
+          query.where(term, keyword_predicate, keyword)
+        end
+      when :virtuoso
+        query.keywords.each do |term, keyword|
+          query.filter("#{keyword_predicate}(#{construct_clause(term)}, '#{keyword}')")
+        end
+      end
+    end
+
 		where_clauses = query.where_clauses.collect do |s,p,o,c|
 			# ignore context parameter
 			[s,p,o].collect {|term| construct_clause(term) }.join(' ')
 		end
+
     "#{where_clauses.join('. ')} ."
   end
 
 	def self.construct_clause(term)
     if term.respond_to? :uri
-      '<' + term.uri + '>'
+      term.to_s
     else
       case term
       when Symbol
@@ -45,6 +64,40 @@ class Query2SPARQL
       end
     end
 	end
+
+  def self.sparql_engine
+    sparql_adapters = ConnectionPool.read_adapters.select{|adp| adp.is_a? SparqlAdapter}
+    engines = sparql_adapters.collect {|adp| adp.engine}.uniq
+
+    unless engines.all?{|eng| Engines_With_Keyword.include?(eng)}
+      raise ActiveRdfError, "one or more of the specified SPARQL engines do not support keyword queries" 
+    end
+
+    if engines.size > 1
+      raise ActiveRdfError, "we currently only support keyword queries for one type of SPARQL engine (e.g. Yars2 or Virtuoso) at a time"
+    end
+
+    return engines.first
+  end
+
+  def self.keyword_predicate
+    case sparql_engine
+    when :yars
+      RDFS::Resource.new("http://sw.deri.org/2004/06/yars#keyword")
+    when :virtuoso
+      VirtuosoBIF.new("bif:contains")
+    else
+      raise ActiveRdfError, "default SPARQL does not support keyword queries, remove the keyword clause or specify the type of SPARQL engine used"
+    end
+  end
 	
-  private_class_method :where_clauses, :construct_clause
+  private_class_method :where_clauses, :construct_clause, :keyword_predicate, :sparql_engine
+end
+
+# treat virtuoso built-ins slightly different: they are URIs but without <> 
+# surrounding them
+class VirtuosoBIF < RDFS::Resource
+  def to_s
+    uri
+  end
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: activerdf
 version: !ruby/object:Gem::Version 
-  version: 1.6.2
-date: 2007-08-03 00:00:00 +01:00
+  version: 1.6.3
+date: 2007-08-09 00:00:00 +01:00
 summary: Offers object-oriented access to RDF (with adapters to several datastores).
 require_paths: 
 - lib