Merge lp:~rockwalrus/activerdf/devel into lp:activerdf

[Rockwalrus]

[Rockwalrus (rockwalrus)]

Support for UNION queries.

Unmerged revisions

466. By Rockwalrus on 2009-05-20

Support for UNION queries.

=== modified file 'activerdf-rdflite/lib/activerdf_rdflite/rdflite.rb'
--- activerdf-rdflite/lib/activerdf_rdflite/rdflite.rb	2008-06-11 12:11:39 +0000
+++ activerdf-rdflite/lib/activerdf_rdflite/rdflite.rb	2009-05-20 03:36:52 +0000
@@ -27,7 +27,7 @@
 class RDFLite < ActiveRdfAdapter
 	ConnectionPool.register_adapter(:rdflite,self)
 	bool_accessor :keyword_search, :reasoning
-
+	
 	# instantiates RDFLite database
 	# available parameters:
 	# * :location => filepath (defaults to memory)
@@ -235,7 +235,20 @@
 	# translates ActiveRDF query into internal sqlite query string
 	def translate(query)
 		where, conditions = construct_where(query)
-		[construct_select(query) + construct_join(query) + where + construct_sort(query) + construct_limit(query), conditions]
+		
+		statement = construct_select(query) + construct_join(query.where_clauses) + where 
+		
+		query.union_groups.each do |union|
+        where, new_conditions = construct_union_where(union, query.reasoning?)
+        
+        conditions += new_conditions
+        
+        statement << "union " + construct_select(query, union) + construct_join(union.clauses) + where		  
+		end
+		
+		
+		statement << construct_sort(query) + construct_limit(query)
+		[statement, conditions]
 	end
 
 	private
@@ -243,14 +256,18 @@
 	SPOC = ['s','p','o','c']
 
 	# construct select clause
-	def construct_select(query)
+	def construct_select(query, union = nil)
 		# ASK queries counts the results, and return true if results > 0
 		return "select count(*)" if query.ask?
 
 		# add select terms for each selectclause in the query
 		# the term names depend on the join conditions, e.g. t0.s or t1.p
 		select = query.select_clauses.collect do |term|
-			variable_name(query, term)
+		  if union.nil?
+        variable_name(query, term)
+		  else
+		    union_variable_name(union, term)		    
+		  end
 		end
 
 		# add possible distinct and count functions to select clause
@@ -274,7 +291,7 @@
 
 		clause << " limit #{limit} offset #{offset}"
 		clause
-	end
+	end	
 
 	# sort query results on variable clause (optionally)
 	def construct_sort(query)
@@ -294,13 +311,13 @@
 	# only, and we should only alias tables we didnt alias yet)
 	# we should only look for one join clause in each where-clause: when we find 
 	# one, we skip the rest of the variables in this clause.
-	def construct_join(query)
+	def construct_join(clauses)
 		join_stmt = ''
 
 		# no join necessary if only one where clause given
-		return ' from triple as t0 ' if query.where_clauses.size == 1
+		return ' from triple as t0 ' if clauses.size == 1
 
-		where_clauses = query.where_clauses.flatten
+		where_clauses = clauses.flatten
 		considering = where_clauses.uniq.select{|w| w.is_a?(Symbol)}
 
 		# constructing hash with indices for all terms
@@ -370,32 +387,7 @@
 
 	# construct where clause
 	def construct_where(query)
-		# collecting where clauses, these will be added to the sql string later
-		where = []
-
-		# 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 = []
-
-		# 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) || subclause.nil?
-					conditions = compute_where_condition(i, subclause, query.reasoning? && reasoning?)
-					if conditions.size == 1
-						where << "t#{level}.#{SPOC[i]} = ?"
-						right_hand_sides << conditions.first
-					else
-						conditions = conditions.collect {|c| "'#{c}'"}
-						where << "t#{level}.#{SPOC[i]} in (#{conditions.join(',')})"
-					end
-				end
-			end
-		end
+		where, right_hand_sides = convert_where_clauses(query.where_clauses, query.reasoning?)
 
 		# if keyword clause given, convert it using keyword index
 		if query.keyword? && keyword_search?
@@ -418,6 +410,48 @@
 			["where " + where.join(' and '), right_hand_sides]
 		end
 	end
+	
+# construct union where clause
+  def construct_union_where(union, reasoning)
+    where, right_hand_sides = convert_where_clauses(union.clauses, reasoning)
+
+    if where.empty?
+      ['',[]]
+    else
+      ["where " + where.join(' and '), right_hand_sides]
+    end
+  end
+	
+	def convert_where_clauses(clauses, reasoning)
+    # collecting where clauses, these will be added to the sql string later
+    where = []
+
+    # 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 = []
+
+    # convert each where clause to SQL:
+    # add where clause for each subclause, except if it's a variable
+    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) || subclause.nil?
+          conditions = compute_where_condition(i, subclause, reasoning && reasoning?)
+          if conditions.size == 1
+            where << "t#{level}.#{SPOC[i]} = ?"
+            right_hand_sides << conditions.first
+          else
+            conditions = conditions.collect {|c| "'#{c}'"}
+            where << "t#{level}.#{SPOC[i]} in (#{conditions.join(',')})"
+          end
+        end
+      end
+    end
+    
+    return where, right_hand_sides
+	end
 
 	def compute_where_condition(index, subclause, reasoning)
 		conditions = [subclause]
@@ -490,6 +524,20 @@
 		termspo = SPOC[index % 4]
 		return "#{termtable}.#{termspo}"
 	end
+	
+	def union_variable_name(union,term)
+    # look up the first occurence of this term in the where clauses, and compute 
+    # the level and s/p/o position of it
+    index = union.clauses.flatten.index(term)
+
+    if index.nil? 
+        raise ActiveRdfError, "unbound variable :#{term.to_s} in select of #{union}"
+    end
+
+    termtable = "t#{index / 4}"
+    termspo = SPOC[index % 4]
+    return "#{termtable}.#{termspo}"	  
+	end
 
 	# wrap resources into ActiveRDF resources, literals into Strings
 	def wrap(query, results)
 
=== modified file 'activerdf-redland/lib/activerdf_redland/redland.rb'
--- activerdf-redland/lib/activerdf_redland/redland.rb	2008-11-28 09:29:34 +0000
+++ activerdf-redland/lib/activerdf_redland/redland.rb	2009-05-20 03:36:52 +0000
@@ -106,6 +106,7 @@
 	def query(query)
 		qs = Query2SPARQL.translate(query)
     $activerdflog.debug "RedlandAdapter: executing SPARQL query #{qs}"
+    $activerdflog.warn "RedlandAdapter: UNION not supported before Rasqal 0.9.17" unless query.union_groups.empty? || Redland::rasqal_version_decimal > 916
 		
 		clauses = query.select_clauses.size
 		redland_query = Redland::Query.new(qs, 'sparql')
 
=== modified file 'lib/active_rdf/queryengine/query.rb'
--- lib/active_rdf/queryengine/query.rb	2007-09-20 20:35:26 +0000
+++ lib/active_rdf/queryengine/query.rb	2009-05-20 03:36:52 +0000
@@ -6,7 +6,7 @@
 # data source.  In all clauses symbols represent variables: 
 # Query.new.select(:s).where(:s,:p,:o).
 class Query
-	attr_reader :select_clauses, :where_clauses, :sort_clauses, :keywords, :limits, :offsets, :reverse_sort_clauses, :filter_clauses
+	attr_reader :select_clauses, :where_clauses, :sort_clauses, :keywords, :limits, :offsets, :reverse_sort_clauses, :filter_clauses, :union_groups
 
 	bool_accessor :distinct, :ask, :select, :count, :keyword, :reasoning
 
@@ -21,6 +21,7 @@
 		@keywords = {}
 		@reasoning = true
     @reverse_sort_clauses = []
+    @union_groups = []
 	end
 
 	# Clears the select clauses
@@ -159,6 +160,72 @@
     self
   end
 
+  class UnionGroup
+    attr_reader :clauses, :filter_clauses
+    
+    def initialize
+      @clauses = []
+      @filter_clauses = [] 
+    end
+    
+    # adds a clause to this union group
+    def where s,p,o,c=nil
+      unless s.respond_to?(:uri) or s.is_a?(Symbol)
+        raise(ActiveRdfError, "cannot add a where clause with s #{s}: s must be a resource or a variable")
+      end
+      unless p.respond_to?(:uri) or p.is_a?(Symbol)
+        raise(ActiveRdfError, "cannot add a where clause with p #{p}: p must be a resource or a variable")
+      end
+
+      @clauses << [s,p,o,c].collect{|arg| parametrise(arg)}
+      
+      self     
+    end
+    
+    # adds one or more generic filters
+    # NOTE: you have to use SPARQL syntax for variables, eg. regex(?s, 'abc')
+    def filter *s
+      # add filter clauses
+      @filter_clauses << s
+      @filter_clauses.uniq!
+  
+      self
+    end
+    
+    private
+    #borrowed from outer class
+    def parametrise s
+      case s
+      when Symbol, RDFS::Resource, Literal, Class
+        s
+      when nil
+        nil
+      else
+        '"' + s.to_s + '"'
+      end
+    end
+  end
+  
+  # adds a union group to this query
+  #
+  # usage:: union_group = Query.new.select(:s).where(:s, :p, 'eyal').union
+  # usage:: Query.new.select(:s).where(:s, :p, 'eyal').union {|g| g.where(:s, :p, 'benjamin')}.execute
+  # usage:: Query.new.select(:s).where(:s, :p, 'eyal').union(:s, :p, 'benjamin').execute
+  def union *args
+    union_group = UnionGroup.new
+    @union_groups << union_group
+    
+    union_group.where *args unless args.empty?
+    
+    yield(union_group) if block_given?
+      
+    if !args.empty? || block_given?
+      self
+    else
+      union_group
+    end
+  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
 
=== modified file 'lib/active_rdf/queryengine/query2sparql.rb'
--- lib/active_rdf/queryengine/query2sparql.rb	2008-02-08 12:37:42 +0000
+++ lib/active_rdf/queryengine/query2sparql.rb	2009-05-20 03:36:52 +0000
@@ -13,7 +13,8 @@
 			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.filter_clauses)}} #{union_groups(query)}} "
+      str << 
       str << "LIMIT #{query.limits} " if query.limits
       str << "OFFSET #{query.offsets} " if query.offsets
     elsif query.ask?
@@ -24,8 +25,8 @@
   end
 
   # concatenate filters in query
-  def self.filter_clauses(query)
-    "FILTER (#{query.filter_clauses.join(" && ")})" unless query.filter_clauses.empty?
+  def self.filter_clauses(filter_clauses)
+    "FILTER (#{filter_clauses.join(" && ")})" unless filter_clauses.empty?
   end
 
   # concatenate each where clause using space (e.g. 's p o')
@@ -44,18 +45,22 @@
       end
     end
 
-		where_clauses = query.where_clauses.collect do |s,p,o,c|
+    statements(query.where_clauses)
+  end
+
+  def self.statements(clauses)
+    where_clauses = clauses.collect do |s,p,o,c|
       # does there where clause use a context ? 
-		  if c.nil?
-  			[s,p,o].collect {|term| construct_clause(term) }.join(' ')
-  		else
-  		  "GRAPH #{construct_clause(c)} { #{construct_clause(s)} #{construct_clause(p)} #{construct_clause(o)} }"
-		  end
-		end
+      if c.nil?
+        [s,p,o].collect {|term| construct_clause(term) }.join(' ')
+      else
+        "GRAPH #{construct_clause(c)} { #{construct_clause(s)} #{construct_clause(p)} #{construct_clause(o)} }"
+      end
+    end
 
     "#{where_clauses.join(' . ')} ."
   end
-
+  
 	def self.construct_clause(term)
     if term.is_a?(Symbol)
       "?#{term}"
@@ -63,6 +68,10 @@
       term.to_ntriple
     end
 	end
+	
+	def self.union_groups(query)
+	  query.union_groups.collect {|union| "UNION { #{statements(union.clauses)} #{filter_clauses(union.filter_clauses)}} "}.join
+	end
 
   def self.sparql_engine
     sparql_adapters = ConnectionPool.read_adapters.select{|adp| adp.is_a? SparqlAdapter}
 
=== modified file 'test/queryengine/test_query2sparql.rb'
--- test/queryengine/test_query2sparql.rb	2008-02-08 12:37:42 +0000
+++ test/queryengine/test_query2sparql.rb	2009-05-20 03:36:52 +0000
@@ -19,7 +19,7 @@
     query.where(:s, RDFS::Resource.new('predicate'), 30)
 
     generated = Query2SPARQL.translate(query)
-    expected = "SELECT ?s WHERE { ?s <predicate> \"30\"^^<http://www.w3.org/2001/XMLSchema#integer> . } "
+    expected = "SELECT ?s WHERE { { ?s <predicate> \"30\"^^<http://www.w3.org/2001/XMLSchema#integer> . } } "
     assert_equal expected, generated
 
     query = Query.new
@@ -27,7 +27,7 @@
     query.where(:s, RDFS::Resource.new('foaf:age'), :a)
     query.where(:a, RDFS::Resource.new('rdf:type'), RDFS::Resource.new('xsd:int'))
     generated = Query2SPARQL.translate(query)
-    expected = "SELECT ?s WHERE { ?s <foaf:age> ?a . ?a <rdf:type> <xsd:int> . } "
+    expected = "SELECT ?s WHERE { { ?s <foaf:age> ?a . ?a <rdf:type> <xsd:int> . } } "
     assert_equal expected, generated
   end
 
@@ -36,7 +36,7 @@
     query.distinct(:s)
     query.where(:s, RDFS::Resource.new('foaf:age'), :a)
     generated = Query2SPARQL.translate(query)
-    expected = "SELECT DISTINCT ?s WHERE { ?s <foaf:age> ?a . } "
+    expected = "SELECT DISTINCT ?s WHERE { { ?s <foaf:age> ?a . } } "
     assert_equal expected, generated
   end
 
@@ -46,4 +46,15 @@
     q2 = Query.new.select(:s).select(:a)
     assert_equal Query2SPARQL.translate(q1),Query2SPARQL.translate(q2)
   end
+  
+  def test_union
+    query = Query.new
+    query.distinct(:s)
+    query.where(:s, RDFS::Resource.new('foaf:age'), :a)
+    query.union.where(:s, RDFS::Resource.new('foaf:name'), :n)
+    query.union{|u| u.where(:s, RDFS::Resource.new('foaf:mbox'), :m)}
+    generated = Query2SPARQL.translate(query)
+    expected = "SELECT DISTINCT ?s WHERE { { ?s <foaf:age> ?a . } UNION { ?s <foaf:name> ?n . } UNION { ?s <foaf:mbox> ?m . } } "
+    assert_equal expected, generated
+  end
 end