activerdf_net7 1.6.11

data/lib/active_rdf/objectmanager/resource_like.rb

@@ -0,0 +1,28 @@
+module RDFS
+  
+  # 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_ntriple
+      "<#{uri}>"
+    end
+    
+  end
+  
+end

data/lib/active_rdf/queryengine/ntriples_parser.rb

@@ -0,0 +1,90 @@
+# Author:: Eyal Oren
+# Copyright:: (c) 2005-2006 Eyal Oren
+# License:: LGPL
+# require 'active_rdf'
+require 'uuidtools'
+require 'strscan'
+
+# ntriples parser
+class NTriplesParser
+  def self.parse_node(input, resource_class = RDFS::Resource)
+    case input
+    when MatchBNode
+      resource_class.new("http://www.activerdf.org/bnode/#{UUID.random_create}/#$1")
+    when MatchLiteral
+      value = fix_unicode($1)
+      if $2
+        Literal.typed(value, resource_class.new($2))
+      else
+        value
+      end
+    when MatchResource
+      resource_class.new($1)
+    else
+      nil
+    end
+  end
+
+  # parses an input string of ntriples and returns a nested array of [s, p, o] 
+  # (which are in turn ActiveRDF objects)
+  def self.parse(input)
+    # need unique identifier for this batch of triples (to detect occurence of 
+    # same bnodes _:#1
+    uuid = UUID.random_create.to_s
+
+    input.collect do |triple|
+      nodes = []
+      scanner = StringScanner.new(triple)
+      scanner.skip(/\s+/)
+      while not scanner.eos?
+        nodes << scanner.scan(MatchNode)
+        scanner.skip(/\s+/)
+        scanner.terminate if nodes.size == 3 
+      end
+
+      # handle bnodes if necessary (bnodes need to have uri generated)
+      subject = case nodes[0]
+      when MatchBNode
+        RDFS::Resource.new("http://www.activerdf.org/bnode/#{uuid}/#$1")
+      when MatchResource
+        RDFS::Resource.new($1)
+      end
+
+      predicate = case nodes[1]
+      when MatchResource
+        RDFS::Resource.new($1)
+      end
+
+      # handle bnodes and literals if necessary (literals need unicode fixing)
+      object = case nodes[2]
+      when MatchBNode
+        RDFS::Resource.new("http://www.activerdf.org/bnode/#{uuid}/#$1")
+      when MatchLiteral
+        value = fix_unicode($1)
+        if $2
+          Literal.typed(value, RDFS::Resource.new($2))
+        else
+          value
+        end
+      when MatchResource
+        RDFS::Resource.new($1)
+      end
+
+      # collect s, p, o into array to be returned
+      [subject, predicate, object]
+    end
+  end
+
+  private
+  # constants for extracting resources/literals from sql results
+  MatchNode = Regexp.union(/"(?:\\"|[^"])*"(?:\^\^\S+)?/,/_:\S*/,/<[^>]*>/)
+  MatchBNode = /_:(\S*)/
+  MatchResource = /<([^>]*)>/
+  MatchLiteral = /"((?:\\"|[^"])*)"(?:\^\^<(\S+)>)?/
+
+  # fixes unicode characters in literals (because we parse them wrongly somehow)
+  def self.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
+end

data/lib/active_rdf/queryengine/query.rb

@@ -0,0 +1,245 @@
+# require 'active_rdf'
+require 'federation/federation_manager'
+require 'queryengine/query2sparql'
+
+require 'rubygems'
+
+# 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).
+class Query
+  attr_reader :select_clauses, :where_clauses, :sort_clauses, :keywords, :limits, :offsets, :reverse_sort_clauses, :filter_clauses
+
+  bool_accessor :distinct, :ask, :select, :count, :keyword, :reasoning
+
+  # 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
+    @limits = nil
+    @offsets = nil
+    @select_clauses = []
+    @where_clauses = []
+    @sort_clauses = []
+    @filter_clauses = []
+    @keywords = {}
+    @reasoning = true
+    @reverse_sort_clauses = []
+    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
+
+  # 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.is_a?(Class))
+
+    test = resource_class.new("http://uri")
+    raise(ArgumentError, "Must have an uri property") unless(test.respond_to?(:uri))
+    @resource_class = resource_class
+  end
+
+  # Clears the select clauses
+  def clear_select
+    ActiveRdfLogger::log_debug "Cleared select clause"
+    @select_clauses = []
+    @distinct = false
+  end
+
+  # Adds variables to select clause
+  def select *s
+    @select = true
+    s.each do |e|
+      @select_clauses << parametrise(e) 
+    end
+    # removing duplicate select clauses
+    @select_clauses.uniq!
+    self
+  end
+
+  # Adds variables to ask clause (see SPARQL specification)
+  def ask
+    @ask = true
+    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
+    # add sort clauses without duplicates
+    s.each { |clause| @sort_clauses << parametrise(clause) }
+    @sort_clauses.uniq!
+
+    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
+
+  # adds regular expression filter on one variable
+  # variable is Ruby symbol that appears in select/where clause, regex is Ruby 
+  # regular expression
+  def filter_regexp(variable, regexp)
+    raise(ActiveRdfError, "variable must be a symbol") unless variable.is_a? Symbol
+    raise(ActiveRdfError, "regexp must be a ruby regexp") unless regexp.is_a? Regexp
+
+    filter "regex(str(?#{variable}), #{regexp.inspect.gsub('/','"')})"
+  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}"
+  end
+
+  # filter variable on specified language tag, e.g. lang(:o, 'en')
+  # optionally matches exactly on language dialect, otherwise only 
+  # language-specifier is considered
+  def lang variable, tag, exact=false
+    if exact
+      filter "lang(?#{variable} = '#{tag}'"
+    else
+      filter "regex(lang(?#{variable}), '^#{tag.gsub(/_.*/,'')}$')"
+    end
+  end
+
+  # adds reverse sorting predicates
+  def reverse_sort *s
+    # add sort clauses without duplicates
+    s.each { |clause| @reverse_sort_clauses << parametrise(clause) }
+    @reverse_sort_clauses.uniq!
+    
+    self
+  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
+      # 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.is_a?(RDFS::BNode))
+        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)) and (!s.is_a?(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.is_a?(RDFS::BNode))
+
+      @where_clauses << [s,p,o,c].collect{|arg| parametrise(arg)}
+    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
+    s = parametrise(s)
+    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
+
+    if block_given?
+      for result in FederationManager.query(self, options)
+        yield result
+      end
+    else
+      FederationManager.query(self, 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(self)
+    end
+  end
+
+  # Returns SPARQL serialisation of query
+  def to_sp
+    Query2SPARQL.translate(self)
+  end
+
+  private
+  def parametrise s
+    case s
+    when Symbol, Literal, Class, nil
+      s
+    else
+      if(s.respond_to?(:uri))
+        s
+      else
+        '"' + s.to_s + '"'
+      end
+    end
+  end
+end

data/lib/active_rdf/queryengine/query2jars2.rb

@@ -0,0 +1,22 @@
+# require 'active_rdf'
+
+# Translates abstract query into jars2 query.
+# (ignores ASK queries)
+class Query2Jars2
+  def self.translate(query)
+    str = ""
+    if query.select?
+      # concatenate each where clause using space: s p o
+      # and then concatenate the clauses using dot: s p o . s2 p2 o2 .
+      str << "#{query.where_clauses.collect{|w| w.collect{|w| '?'+w.to_s}.join(' ')}.join(" .\n")} ."
+      # TODO: should we maybe reverse the order on the where_clauses? it depends 
+      # on Andreas' answer of the best order to give to jars2. Users would 
+      # probably put the most specific stuff first, and join to get the 
+      # interesting information. Maybe we should not touch it and let the user 
+      # figure it out.
+    end
+
+    ActiveRdfLogger::log_debug(self) { "Query2Jars2: translated #{query} to #{str}" }
+    return str
+  end
+end

data/lib/active_rdf/queryengine/query2sparql.rb

@@ -0,0 +1,139 @@
+# require 'active_rdf'
+
+# TODO: support limit and offset
+
+# Translates abstract query into SPARQL that can be executed on SPARQL-compliant
+# data source.
+class Query2SPARQL
+  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 << "LIMIT #{query.limits} " if query.limits
+      str << "OFFSET #{query.offsets} " if query.offsets
+      if (!query.sort_clauses.empty? || !query.reverse_sort_clauses.empty?)
+        str << "ORDER BY "
+        str << "#{sort_clauses(query)} " if !query.sort_clauses.empty?
+        str << "#{reverse_sort_clauses(query)} " if !query.reverse_sort_clauses.empty?
+      end
+    elsif query.ask?
+      str << "ASK { #{where_clauses(query)} } "
+    end
+
+    return str
+  end
+
+  # concatenate each from clause using space
+  def self.from_clauses(query)
+    params = []
+    # construct single context clauses if context is present
+    query.where_clauses.each {|s,p,o,c|
+      params << "FROM #{construct_clause(c)}" unless c.nil?
+    }
+
+    # return FROM sintax or "" if no context is speficied
+    if (params.empty?)
+      ""
+    else
+      "#{params.join(' ')} "
+    end
+  end
+
+  # concatenate filters in query
+  def self.filter_clauses(query)
+    "FILTER (#{query.filter_clauses.join(" && ")})" unless query.filter_clauses.empty?
+  end
+
+  def self.sort_clauses(query)
+    sort_clauses = query.sort_clauses.collect do |term|
+      "ASC(#{construct_clause(term)})"
+    end
+
+    sort_clauses.join(' ')
+  end
+
+  def self.reverse_sort_clauses(query)
+    reverse_sort_clauses = query.reverse_sort_clauses.collect do |term|
+      "DESC(#{construct_clause(term)})"
+    end
+
+    "#{reverse_sort_clauses.join(' ')}"
+  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|
+      # 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
+
+    "#{where_clauses.join(' . ')} ."
+  end
+
+  def self.construct_clause(term)
+    if term.is_a?(Symbol)
+      "?#{term}"
+    else
+      term.to_ntriple
+    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, :yars2
+      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, :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