Changeset 482

Show
Ignore:
Timestamp:
06/02/10 18:42:50 (8 years ago)
Author:
samuraraujo
Message:
 
Location:
Explorator/trunk/vendor/plugins
Files:
8 modified

Legend:

Unmodified
Added
Removed
  • Explorator/trunk/vendor/plugins/active_rdf/lib/active_rdf/federation/connection_pool.rb

    r466 r482  
    4747    @@adapter_pool.dup 
    4848  end 
    49    
     49  def ConnectionPool.get_adapter(name)     
     50    adapter = @@adapter_pool.select {|adapter|  
     51      adapter.title == name 
     52    } 
     53    adapter.first() 
     54  end 
    5055  # flushes all openstanding changes into the original datasource. 
    5156  def ConnectionPool.flush 
     
    6368    } 
    6469  end 
    65   def ConnectionPool.write_adapters 
    66      
     70  def ConnectionPool.write_adapters     
    6771    @@adapter_pool.select {|x| (x.writes? && x.enabled?) } 
    68      
    6972  end 
    7073   
     
    7376    $activerdflog.info "ConnectionPool: add_data_source with params: #{connection_params.inspect}" 
    7477     
     78    #Verifies if the adapter with same uri was added before. 
     79    adapter  = ConnectionPool.find_by_uri(connection_params[:url]) 
     80   
     81    return adapter if adapter != nil 
    7582    # either get the adapter-instance from the pool 
    7683    # or create new one (and add it to the pool) 
    77     index = @@adapter_parameters.index(connection_params) 
     84    index = @@adapter_parameters.index(connection_params)     
    7885    if index.nil? 
    7986      # adapter not in the pool yet: create it, 
     
    8390      adapter = create_adapter(connection_params) 
    8491      # this is necessary because activerdf search in the order repositories were added 
    85       if adapter.title == 'INTERNAL'  
    86          
     92      if adapter.title == 'INTERNAL'          
    8793        @@adapter_parameters << connection_params 
    8894        @@adapter_pool << adapter 
     
    96102      $activerdflog.debug("Reusing existing adapter") 
    97103      adapter = @@adapter_pool[index] 
    98     end 
    99      
     104    end     
    100105    # sets the adapter as current write-source if it can write 
    101106    self.write_adapter = adapter if adapter.writes? 
    102      
    103     void_source =  adapter.query(Query.new.select(:o).where(:s,RDFS::Resource.new('<http://xmlns.com/foaf/0.1/homepage>') ,:o).where(:s,RDF::type,RDFS::Resource.new('<http://rdfs.org/ns/void#Dataset>'))).uniq 
    104     @@void[void_source.to_s.gsub(/>/,'').gsub(/</,'')]=adapter if void_source != nil 
     107    begin 
     108      void_source =  adapter.query(Query.new.select(:o).where(:s,RDFS::Resource.new('<http://xmlns.com/foaf/0.1/homepage>') ,:o).where(:s,RDF::type,RDFS::Resource.new('<http://rdfs.org/ns/void#Dataset>'))).uniq 
     109      @@void[void_source.to_s.gsub(/>/,'').gsub(/</,'')]=adapter if void_source != nil 
     110    rescue Exception => e 
     111      remove_data_source(adapter) 
     112    end     
    105113    return adapter 
    106114  end 
     
    127135     
    128136  end 
    129    def ConnectionPool.remove_last_data_source_added() 
    130     RDFS::Resource.reset_cache()  
    131       
    132     $activerdflog.info "ConnectionPool: remove_last_data_source with params: " 
    133      
    134     index =0 
    135      
    136     # remove_data_source mit be called repeatedly, e.g because the adapter object is stale 
    137     unless index.nil? 
    138       @@adapter_parameters.delete_at(index) 
    139       @@adapter_pool.delete_at(index) 
    140       #      if self.write_adapters.empty? 
    141       #        self.write_adapter = nil 
    142       #      else 
    143       #        self.write_adapter = self.write_adapters.first 
    144       #      end 
    145        
    146     end 
    147     
    148   end 
     137   
    149138  # sets adapter-instance for connection parameters (if you want to re-enable an existing adapter) 
    150139  def ConnectionPool.set_data_source(adapter, connection_params = {}) 
     
    200189  end 
    201190   
    202   private_class_method :create_adapter 
     191#  private_class_method :create_adapter 
    203192end 
  • Explorator/trunk/vendor/plugins/active_rdf/lib/active_rdf/federation/federation_manager.rb

    r455 r482  
    2828  # and aggregating the results 
    2929  def FederationManager.query(q, options={:flatten => true})    
     30    # puts 'Querying .. .' 
    3031    if ConnectionPool.read_adapters.empty? 
    3132      raise ActiveRdfError, "cannot execute query without data sources"  
     
    3435    # and yield them consequtively 
    3536    if block_given? 
    36       ConnectionPool.read_adapters.each do |source|         
     37      ConnectionPool.read_adapters.each do |source|        
    3738        source.query(q) do |*clauses| 
    3839          yield(*clauses) 
    3940        end 
     41         
    4042      end 
    4143    else 
     
    4547      # were filtered out when doing results.union) 
    4648      results = [] 
    47       ConnectionPool.read_adapters.each do |source|     
     49       
     50      federation = q.adapter_to_use if q.adapter_to_use.size > 0 
     51      skip = true if federation != nil 
     52      federation =ConnectionPool.read_adapters if federation == nil         
     53       
     54      federation.each do |source|    
     55       
    4856        #verifies if the repository was enabled by the Explorator's user. 
    49         begin 
    50           if Thread.current[:disablerepositories] != nil && !(Thread.current[:disablerepositories].include? source.title)  
    51             next 
     57        if !skip   
     58          begin         
     59            if (Thread.current[:enablerepositories] == nil || !(Thread.current[:enablerepositories].include? source.title))   
     60              next 
     61            end 
     62          rescue                 
     63            #outside the Explorator. 
    5264          end 
    53         rescue     
     65        end 
     66        
    5467           
    55           #outside the Explorator. 
    56         end 
    5768        #Forces skip INTERNAL repository searches for users's queries, or not system' queries. 
     69#        puts q.to_s 
    5870        if source.title == "INTERNAL" && !q.to_s.include?('http://www.tecweb.inf.puc-rio.br') 
    5971          next 
    6072        end 
    61         # puts source.title 
     73         puts "Using ... #{source.title}" 
    6274        q.limit(source.limit) if source.limit != nil 
    6375        source_results = source.query(q) 
     76#        return source_results if source.raw 
    6477        source_results.each do |clauses| 
    6578          results << clauses 
  • Explorator/trunk/vendor/plugins/active_rdf/lib/active_rdf/objectmanager/literal.rb

    r272 r482  
    66  def xsd_type 
    77    case self 
    8     when String 
     8      when String 
    99      XSD::string 
    10     when Integer 
     10      when Integer 
    1111      XSD::integer 
    12     when Float 
     12      when Float 
    1313      XSD::double 
    14     when TrueClass, FalseClass 
     14      when TrueClass, FalseClass 
    1515      XSD::boolean 
    16     when DateTime, Date, Time 
     16      when DateTime, Date, Time 
    1717      XSD::date 
    1818    end 
    1919  end 
    20  
     20   
    2121  def self.typed(value, type) 
    2222    case type 
    23     when XSD::string 
     23      when XSD::string 
    2424      String.new(value) 
    25     when XSD::date 
     25      when XSD::date 
    2626      DateTime.parse(value) 
    27        when XSD::dateTime, XSD::Time 
     27      when XSD::dateTime, XSD::Time 
    2828      DateTime.parse(value) 
    29     when XSD::boolean 
     29      when XSD::boolean 
    3030      value == 'true' or value == 1 
    31     when XSD::integer 
     31      when XSD::integer 
    3232      value.to_i 
    33     when XSD::double 
     33      when XSD::double 
    3434      value.to_f 
    3535    else 
     
    3737    end 
    3838  end 
    39  
     39   
    4040  def to_ntriple 
    4141    if $activerdf_without_xsdtype 
     
    6161  def initialize value, lang=nil 
    6262    super(value) 
    63  
    64     @lang = lang 
    65     @lang = lang[1..-1] if @lang[0..0] == '@' 
     63    if lang != nil 
     64      @lang = lang 
     65      @lang = lang[1..-1] if @lang[0..0] == '@' 
     66    end 
    6667  end 
    67  
     68   
    6869  def to_ntriple 
    6970    if @lang 
  • Explorator/trunk/vendor/plugins/active_rdf/lib/active_rdf/queryengine/query.rb

    r413 r482  
    77# Query.new.select(:s).where(:s,:p,:o). 
    88class Query 
    9   attr_reader :select_clauses, :where_clauses, :sort_clauses, :keywords, :limits, :optional_clauses, :offsets, :reverse_sort_clauses, :filter_clauses 
    10    
    11   bool_accessor :distinct, :ask, :select, :count, :keyword, :reasoning 
     9  attr_reader :adapter_to_use,:insert_clauses,:delete_clauses, :select_clauses, :where_clauses, :sort_clauses, :keywords, :limits, :optional_clauses, :offsets, :reverse_sort_clauses, :filter_clauses, :sparql_query 
     10   
     11  bool_accessor :distinct, :ask, :select, :count, :keyword, :reasoning, :insert, :delete 
    1212   
    1313  def initialize 
     
    1919    @sort_clauses = [] 
    2020    @filter_clauses = [] 
    21     @optional_clauses = []    
     21    @optional_clauses = [] 
     22    @adapter_to_use = [] 
     23    @insert_clauses= [] 
     24    @delete_clauses= [] 
    2225     
    2326    @keywords = {} 
     
    2528    @reverse_sort_clauses = [] 
    2629  end 
    27    
     30  def sparql(q) 
     31    @sparql_query=q 
     32    self     
     33  end 
    2834  # Clears the select clauses 
    2935  def clear_select 
     
    3137    @select_clauses = [] 
    3238    distinct = false 
    33   end 
    34    
     39  end   
     40  # Adds variables to select clause 
     41  def adapters *s      
     42    s.each do |e| 
     43      @adapter_to_use << (e)  
     44    end     
     45    self 
     46  end 
    3547  # Adds variables to select clause 
    3648  def select *s 
     
    4355    self 
    4456  end 
    45    
     57  def insert s,p,o,c=nil       
     58    @insert=true  
     59    @insert_clauses = [s,p,o,c]      
     60#    puts @insert_clauses 
     61      
     62    self 
     63  end 
     64  def delete s,p,o,c=nil       
     65    @delete=true  
     66    @delete_clauses = [s,p,o,c]     
     67    self 
     68  end 
    4669  # Adds variables to ask clause (see SPARQL specification) 
    4770  def ask 
     
    84107  def filter_regexp(variable, regexp) 
    85108    raise(ActiveRdfError, "variable must be a symbol") unless variable.is_a? Symbol 
    86    # raise(ActiveRdfError, "regexp must be a ruby regexp") unless regexp.is_a? Regexp 
    87    # filter "regex(str(?#{variable}), #{regexp.inspect.gsub('/','"')})" 
    88    filter "regex(str(?#{variable}),'#{regexp}','i')" 
     109    # raise(ActiveRdfError, "regexp must be a ruby regexp") unless regexp.is_a? Regexp 
     110    # filter "regex(str(?#{variable}), #{regexp.inspect.gsub('/','"')})" 
     111    filter "regex(str(?#{variable}),'#{regexp}','i')" 
    89112  end 
    90113  alias :filter_regex :filter_regexp 
    91  
     114   
    92115  # adds operator filter one one variable 
    93116  # variable is a Ruby symbol that appears in select/where clause, operator is a  
     
    95118  def filter_operator(variable, operator, operand) 
    96119    raise(ActiveRdfError, "variable must be a Symbol") unless variable.is_a? Symbol 
    97  
     120     
    98121    filter "?#{variable} #{operator} #{operand}" 
    99122  end 
     
    105128    if exact 
    106129      filter "lang(?#{variable} = '#{tag}'" 
    107   else 
    108     filter "regex(lang(?#{variable}), '^#{tag.gsub(/_.*/,'')}$')" 
    109   end 
    110 end 
    111  
    112 # adds reverse sorting predicates 
    113 def reverse_sort *s 
    114   # add sort clauses without duplicates 
    115   s.each { |clause| @reverse_sort_clauses << (clause) } 
    116   @reverse_sort_clauses.uniq! 
    117    
    118   self 
    119 end 
    120  
    121 # Adds limit clause (maximum number of results to return) 
    122 def limit(i) 
    123   @limits = i.to_i 
    124   self 
    125 end 
    126  
    127 # Add offset clause (ignore first n results) 
    128 def offset(i) 
    129   @offsets = i.to_i 
    130   self 
    131 end 
    132  
    133 def optional s,p,o,c=nil 
    134   
     130    else 
     131      filter "regex(lang(?#{variable}), '^#{tag.gsub(/_.*/,'')}$')" 
     132    end 
     133  end 
     134   
     135  # adds reverse sorting predicates 
     136  def reverse_sort *s 
     137    # add sort clauses without duplicates 
     138    s.each { |clause| @reverse_sort_clauses << (clause) } 
     139    @reverse_sort_clauses.uniq! 
     140     
     141    self 
     142  end 
     143   
     144  # Adds limit clause (maximum number of results to return) 
     145  def limit(i) 
     146    @limits = i.to_i 
     147    self 
     148  end 
     149   
     150  # Add offset clause (ignore first n results) 
     151  def offset(i) 
     152    @offsets = i.to_i 
     153    self 
     154  end 
     155   
     156  def optional s,p,o,c=nil 
     157     
    135158    # remove duplicate variable bindings, e.g. 
    136159    # where(:s,type,:o).where(:s,type,:oo) we should remove the second clause,  
     
    149172    @optional_clauses << [s,p,o,c] 
    150173     
    151  
    152   self 
     174     
     175    self 
     176  end 
     177  # Adds where clauses (s,p,o) where each constituent is either variable (:s) or  
     178  # an RDFS::Resource. Keyword queries are specified with the special :keyword  
     179  # symbol: Query.new.select(:s).where(:s, :keyword, 'eyal') 
     180  def where s,p,o,c=nil 
     181    case p 
     182      when :keyword 
     183      # treat keywords in where-clauses specially 
     184      keyword_where(s,o) 
     185    else 
     186      # remove duplicate variable bindings, e.g. 
     187      # where(:s,type,:o).where(:s,type,:oo) we should remove the second clause,  
     188      # since it doesn't add anything to the query and confuses the query  
     189      # generator.  
     190      # if you construct this query manually, you shouldn't! if your select  
     191      # variable happens to be in one of the removed clauses: tough luck. 
     192       
     193      unless s.respond_to?(:uri) or s.is_a?(Symbol) 
     194        raise(ActiveRdfError, "cannot add a where clause with s #{s}: s must be a resource or a variable") 
     195      end 
     196      unless p.respond_to?(:uri) or p.is_a?(Symbol) 
     197        raise(ActiveRdfError, "cannot add a where clause with p #{p}: p must be a resource or a variable") 
     198      end 
     199       
     200      @where_clauses << [s,p,o,c] 
     201       
     202    end 
     203    self 
     204  end 
     205   
     206  # Adds keyword constraint to the query. You can use all Ferret query syntax in  
     207  # the constraint (e.g. keyword_where(:s,'eyal|benjamin') 
     208  def keyword_where s,o 
     209    @keyword = true 
     210     
     211    if @keywords.include?(s) 
     212      @keywords[s] = @keywords[s] + ' ' + o 
     213    else 
     214      @keywords[s] = o 
     215    end 
     216    self 
     217  end 
     218   
     219  # Executes query on data sources. Either returns result as array 
     220  # (flattened into single value unless specified otherwise) 
     221  # or executes a block (number of block variables should be 
     222  # same as number of select variables) 
     223  # 
     224  # usage:: results = query.execute 
     225  # usage:: query.execute do |s,p,o| ... end 
     226  def execute(options={:flatten => false}, &block) 
     227    puts 'Executing. .. ' 
     228    options = {:flatten => true} if options == :flatten   
     229    if block_given? 
     230      for result in FederationManager.query(self, options) 
     231        yield result 
     232      end 
     233    else 
     234      FederationManager.query(self, options) 
     235    end 
     236  end 
     237   
     238  # Returns query string depending on adapter (e.g. SPARQL, N3QL, etc.) 
     239  def to_s 
     240    if ConnectionPool.read_adapters.empty? 
     241      inspect  
     242    else 
     243      if @sparql_query != nil  
     244        @sparql_query 
     245      else 
     246        ConnectionPool.read_adapters.first.translate(self) 
     247      end 
     248       
     249    end 
     250  end 
     251   
     252  # Returns SPARQL serialisation of query 
     253  def to_sp 
     254    require 'queryengine/query2sparql' 
     255    Query2SPARQL.translate(self) 
     256  end  
    153257end 
    154 # Adds where clauses (s,p,o) where each constituent is either variable (:s) or  
    155 # an RDFS::Resource. Keyword queries are specified with the special :keyword  
    156 # symbol: Query.new.select(:s).where(:s, :keyword, 'eyal') 
    157 def where s,p,o,c=nil 
    158   case p 
    159     when :keyword 
    160     # treat keywords in where-clauses specially 
    161     keyword_where(s,o) 
    162   else 
    163     # remove duplicate variable bindings, e.g. 
    164     # where(:s,type,:o).where(:s,type,:oo) we should remove the second clause,  
    165     # since it doesn't add anything to the query and confuses the query  
    166     # generator.  
    167     # if you construct this query manually, you shouldn't! if your select  
    168     # variable happens to be in one of the removed clauses: tough luck. 
    169      
    170     unless s.respond_to?(:uri) or s.is_a?(Symbol) 
    171       raise(ActiveRdfError, "cannot add a where clause with s #{s}: s must be a resource or a variable") 
    172     end 
    173     unless p.respond_to?(:uri) or p.is_a?(Symbol) 
    174       raise(ActiveRdfError, "cannot add a where clause with p #{p}: p must be a resource or a variable") 
    175     end 
    176      
    177     @where_clauses << [s,p,o,c] 
    178      
    179   end 
    180   self 
    181 end 
    182  
    183 # Adds keyword constraint to the query. You can use all Ferret query syntax in  
    184 # the constraint (e.g. keyword_where(:s,'eyal|benjamin') 
    185 def keyword_where s,o 
    186   @keyword = true 
    187   
    188   if @keywords.include?(s) 
    189     @keywords[s] = @keywords[s] + ' ' + o 
    190   else 
    191     @keywords[s] = o 
    192   end 
    193   self 
    194 end 
    195  
    196 # Executes query on data sources. Either returns result as array 
    197 # (flattened into single value unless specified otherwise) 
    198 # or executes a block (number of block variables should be 
    199 # same as number of select variables) 
    200 # 
    201 # usage:: results = query.execute 
    202 # usage:: query.execute do |s,p,o| ... end 
    203 def execute(options={:flatten => false}, &block) 
    204   options = {:flatten => true} if options == :flatten   
    205   if block_given? 
    206     for result in FederationManager.query(self, options) 
    207       yield result 
    208     end 
    209   else 
    210     FederationManager.query(self, options) 
    211   end 
    212 end 
    213  
    214 # Returns query string depending on adapter (e.g. SPARQL, N3QL, etc.) 
    215 def to_s 
    216   if ConnectionPool.read_adapters.empty? 
    217     inspect  
    218   else 
    219     ConnectionPool.read_adapters.first.translate(self) 
    220   end 
    221 end 
    222  
    223 # Returns SPARQL serialisation of query 
    224 def to_sp 
    225   require 'queryengine/query2sparql' 
    226   Query2SPARQL.translate(self) 
    227 end  
    228 end 
  • Explorator/trunk/vendor/plugins/active_rdf/lib/active_rdf/queryengine/query2sparql.rb

    r364 r482  
    99   
    1010  def self.translate(query, engine=nil) 
    11     str = ""     
     11    return query.sparql_query if query.sparql_query != nil  
     12    str = "" 
     13    # puts query.insert?       
    1214    if query.select?       
    1315      distinct = query.distinct? ? "DISTINCT " : "" 
    1416      select_clauses = query.select_clauses.collect{|s| construct_clause(s)} 
    15        
    16       str << "SELECT #{distinct}#{select_clauses.join(' ')} " 
     17      str << "SELECT #{distinct}#{select_clauses.join(' ')} "       
    1718      str << "WHERE { #{where_clauses(query)} #{optional_clauses(query)} #{filter_clauses(query)} #{keywords_clauses(query,engine)}} " 
    1819      str << "ORDER BY #{query.sort_clauses} " unless query.sort_clauses.empty? 
     
    2122    elsif query.ask? 
    2223      str << "ASK { #{where_clauses(query)} } " 
     24    elsif query.insert?       
     25       
     26      str << "INSERT INTO #{insert_clauses(query)} " 
     27    elsif query.delete?       
     28       tmp = delete_clauses(query) 
     29      str << "DELETE FROM GRAPH #{tmp} FROM #{tmp} "      
     30      
    2331    end     
     32     
    2433    return str 
    2534  end 
     
    6170      filters= Array.new 
    6271      query.keywords.each do |term, keyword| 
    63       
     72         
    6473        if engine == :virtuoso 
    6574          filters << "bif:contains (?#{term}, '\"#{keyword}\"')"     
     
    97106    "#{where_clauses.join(' . ')} ." unless where_clauses.empty?     
    98107  end 
     108   
     109  def self.insert_clauses(query)        
     110    s= query.insert_clauses[0] 
     111    p= query.insert_clauses[1] 
     112    o= query.insert_clauses[2] 
     113    c= query.insert_clauses[3] 
     114    insert_clauses =  " GRAPH #{construct_clause(c)} { #{construct_clause(s)} #{construct_clause(p)} #{construct_clause(o)} }"       
     115     
     116    # puts insert_clauses 
     117#    "#{insert_clauses.join('  ')} " unless insert_clauses.empty?     
     118  end 
     119  def self.delete_clauses(query)       
     120    s= query.delete_clauses[0] 
     121    p= query.delete_clauses[1] 
     122    o= query.delete_clauses[2] 
     123    c= query.delete_clauses[3] 
     124    delete_clauses =  "  #{construct_clause(c)} { #{construct_clause(s)} #{construct_clause(p)} #{construct_clause(o)} }"       
     125     
     126    # puts insert_clauses 
     127#    "#{delete_clauses.join('  ')} " unless insert_clauses.empty?     
     128  end 
    99129  def self.construct_clause(term)    
     130    
    100131    if term.is_a?(Symbol) 
    101132      "?#{term}" 
     
    104135    end 
    105136  end 
    106    
     137  def self.insert(query) 
     138     
     139     
     140  end 
    107141  def self.sparql_engine 
    108142    sparql_adapters = ConnectionPool.read_adapters.select{|adp| adp.is_a? SparqlAdapter} 
  • Explorator/trunk/vendor/plugins/activerdf_sparql-1.3.6/lib/activerdf_sparql/sparql.rb

    r467 r482  
    1111  ConnectionPool.register_adapter(:sparql, self)   
    1212  attr_reader :engine 
    13   attr_reader :caching , :url  
     13  attr_reader :caching , :url #,:raw 
    1414  def reset_cache()      
    1515    @sparql_cache = {} 
     
    3434    @url = params[:url] || '' 
    3535    @caching = params[:caching] || false 
     36#    @preprocess = params[:preprocess] || false 
     37#    @raw = params[:raw] || false 
     38      
    3639    @timeout = params[:timeout] || 100 
    3740    @auth = params[:auth] || nil 
     
    6366  # may be called with a block 
    6467  def query(query, &block)     
    65     qs = Query2SPARQL.translate(query,@engine) 
    66      
     68    puts "Querying ...#{@title}" 
     69    qs = Query2SPARQL.translate(query,@engine)    
     70      
     71    puts qs.to_s   
     72    if query.insert? || query.delete?      
     73      reset_cache() 
     74      return execute_sparql_query(qs, header(query), query.select_clauses, &block) 
     75    end 
     76    
    6777    if @caching  
    6878      if is_into_cache(qs)  
    6979        $activerdflog.debug "cache hit for query #{qs}" 
    70         return  query_cache(qs) 
     80         
     81        resp = query_cache(qs) 
     82         
     83        return  resp 
    7184      end 
    7285    end     
    7386     
    74     result = execute_sparql_query(qs, header(query), &block) 
     87    result = execute_sparql_query(qs, header(query), query.select_clauses, &block) 
    7588    add_to_cache(qs, result) if @caching 
    7689    result = [] if result == "timeout" 
    77    puts @title 
    78     puts qs.to_s   
     90  
    7991    return result 
    8092  end 
    8193   
     94    
    8295  # do the real work of executing the sparql query 
    83   def execute_sparql_query(qs, header=nil, &block) 
     96  def execute_sparql_query(qs, header=nil, select_clauses=nil, &block) 
    8497    header = header(nil) if header.nil? 
    8598     
     99#    puts select_clauses 
    86100    # querying sparql endpoint 
    87101    require 'timeout' 
     
    97111          url = "#@url&query=#{CGI.escape(qs)}"           
    98112        end 
    99         puts url 
     113        #puts url 
    100114        $activerdflog.debug "GET #{url}"         
    101115        timeout(@timeout) do           
    102            puts url 
     116           puts url 
    103117          open(url, header) do |f|             
    104118            response = f.read    
     
    106120          end 
    107121        end 
    108         when :post 
     122      when :post 
     123        puts 'Via POST' 
    109124        $activerdflog.debug "POST #@url with #{qs}" 
    110125        response = Net::HTTP.post_form(URI.parse(@url),{'query'=>qs}).body        
     
    122137    end 
    123138     
    124     # we parse content depending on the result format 
    125      
     139#    results =  preprocess(results) if @preprocess 
     140#    return results if @raw   
     141    # we parse content depending on the result format     
    126142    results = case @result_format 
    127143      when :json  
    128144      parse_json(response) 
    129       when :xml, :sparql_xml 
    130       parse_xml(response) 
     145    when :xml, :sparql_xml 
     146      parse_xml(response,select_clauses) 
    131147    end 
    132148     
     
    138154      results 
    139155    end 
    140   end    
     156  end  
    141157  def close 
    142158    ConnectionPool.remove_data_source(self) 
     
    204220   
    205221  # parse xml stream result into array 
    206   def parse_xml(s)     
    207     parser = SparqlResultParser.new 
     222  def parse_xml(s,select_clauses=nil)     
     223    parser = SparqlResultParser.new(select_clauses) 
    208224    REXML::Document.parse_stream(s, parser)  
    209225    parser.result 
  • Explorator/trunk/vendor/plugins/activerdf_sparql-1.3.6/lib/activerdf_sparql/sparql_result_parser.rb

    r418 r482  
    33  attr_reader :result 
    44   
    5   def initialize 
     5  def initialize(select_clauses=nil) 
     6    @ignorevar=false  
    67    @result = [] 
    7     @vars = [] 
     8     @vars = []  
     9    if select_clauses != nil    && select_clauses.size>0     
     10      @ignorevar=true 
     11      @vars = select_clauses.map{|x| x.to_s} 
     12       
     13    end 
    814    @current_type = nil 
    915  end 
     
    1218    case name 
    1319      when 'variable' 
    14       @vars << attrs['name'] 
     20      @vars << attrs['name'] if @ignorevar ==false       
    1521      when 'result' 
    1622      @current_result = [] 
    1723      when 'binding' 
    1824      @index = @vars.index(attrs['name']) 
     25        
    1926      when 'bnode', 'literal', 'typed-literal', 'uri','boolean' 
    2027      @current_type = name 
     
    3441    if !@current_type.nil? 
    3542      if @current_type == 'boolean' 
    36        @result <<  (text) 
    37      else 
     43        @result <<  (text) 
     44      else 
    3845        @current_result[@index] = create_node(@current_type, text)   
    3946      end 
  • Explorator/trunk/vendor/plugins/activerdf_sparql-1.3.6/lib/activerdf_sparql/sparql_sesame_api.rb

    r467 r482  
    3636      vmargs = [ '-Xms256m', '-Xmx1024m' ] 
    3737      vmargs << ('-Dinfo.aduna.platform.appdata.basedir=' + @sesamedir) 
    38       Rjb::load sesame_jars , vmargs 
     38   Rjb::load sesame_jars , vmargs 
    3939       
    4040    rescue => ex 
     
    5454  # may be called with a block 
    5555  def query(query, &block)     
     56    puts "Quering .. #{@title} "  
    5657    qs = Query2SPARQL.translate(query) 
    5758      
     
    6465      end  
    6566    end 
     67     
    6668    result = execute_sparql_query(qs, &block) 
     69#   puts result 
    6770    add_to_cache(qs, result) if @caching 
    6871    result = [] if result == "timeout" 
     
    7578  def execute_sparql_query(qs, header=nil, &block)     
    7679    response = '' 
    77     begin  
    78        
    79       response = @bridge.query(qs.to_s) 
    80        
    81       #  puts response 
     80    begin      
     81      response = @bridge.query(qs.to_s)       
     82#        puts response 
    8283    rescue  
    8384      raise ActiveRdfError, "JAVA BRIDGE ERRO ON SPARQL ADAPTER" 
     
    121122    #     
    122123    quad = [s,p,o,c].collect {|r| r.nil? ? nil : internalise(r) } 
    123     puts quad[0] 
    124     puts quad[1] 
    125     puts quad[2] 
    126     puts quad[3] 
     124    
    127125    response = @bridge.delete(quad[0],quad[1],quad[2],quad[3]) 
    128126