Class: ActiveFedora::SolrService

Inherits:
Object
  • Object
show all
Extended by:
Deprecation
Includes:
Loggable
Defined in:
lib/active_fedora/solr_service.rb

Constant Summary collapse

HAS_MODEL_SOLR_FIELD = 
solr_name("has_model", :symbol).freeze

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(host, args) ⇒ SolrService

Returns a new instance of SolrService.



11
12
13
14
15
16
 
# File 'lib/active_fedora/solr_service.rb', line 11

def initialize(host, args)
  host = 'http://localhost:8080/solr' unless host
  args = {:read_timeout => 120, :open_timeout => 120}.merge(args.dup)
  args.merge!(:url=>host)
  @conn = RSolr.connect args
end

Instance Attribute Details

#conn ⇒ Object (readonly)

Returns the value of attribute conn.



9
10
11
 
# File 'lib/active_fedora/solr_service.rb', line 9

def conn
  @conn
end

Class Method Details

.add(doc, params = {}) ⇒ Object

Parameters:

  • doc (Hash) —

    the document to index

  • params (Hash) (defaults to: {}) —

    :commit => commits immediately :softCommit => commit to memory, but don’t flush to disk



147
148
149
 
# File 'lib/active_fedora/solr_service.rb', line 147

def add(doc, params = {})
  SolrService.instance.conn.add(doc, params: params)
end

.class_from_solr_document(hit, opts = {}) ⇒ Object

Returns the best singular class for the solr object



70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/active_fedora/solr_service.rb', line 70

def class_from_solr_document(hit, opts = {})
  #Set the default starting point to the class specified, if available.
  best_model_match = Model.from_class_uri(opts[:class]) unless opts[:class].nil?
  hit[HAS_MODEL_SOLR_FIELD].each do |value|

    model_value = Model.from_class_uri(value)

    if model_value

      # Set as the first model in case opts[:class] was nil
      best_model_match ||= model_value

      # If there is an inheritance structure, use the most specific case.
      if best_model_match > model_value
        best_model_match = model_value
      end
    end
  end

  logger.warn "Could not find a model for #{hit["id"]}, defaulting to ActiveFedora::Base" unless best_model_match
  best_model_match || ActiveFedora::Base
end

.classes_from_solr_document(hit, opts = {}) ⇒ Object

Returns all possible classes for the solr object



60
61
62
63
64
65
66
67
 
# File 'lib/active_fedora/solr_service.rb', line 60

def classes_from_solr_document(hit, opts = {})
  #Add ActiveFedora::Base as never stored in Solr explicitely.
  classes = [ActiveFedora::Base]

  hit[HAS_MODEL_SOLR_FIELD].each { |value| classes << Model.from_class_uri(value) }

  classes
end

.commit ⇒ Object 



151
152
153
 
# File 'lib/active_fedora/solr_service.rb', line 151

def commit
  SolrService.instance.conn.commit
end

.construct_query_for_pids(pid_array) ⇒ Object

Construct a solr query for a list of pids This is used to get a solr response based on the list of pids in an object’s RELS-EXT relationhsips If the pid_array is empty, defaults to a query of “id:NEVER_USE_THIS_ID”, which will return an empty solr response

Parameters:

  • pid_array (Array) —

    the pids that you want included in the query



97
98
99
100
101
 
# File 'lib/active_fedora/solr_service.rb', line 97

def construct_query_for_pids(pid_array)
  q = pid_array.reject { |x| x.empty? }.map { |pid| raw_query(SOLR_DOCUMENT_ID, pid) }

  q.empty? ? "id:NEVER_USE_THIS_ID" : q.join(" OR ".freeze)
end

.construct_query_for_rel(args) ⇒ Object

Create a query with a clause for each key, value

Parameters:

  • args (Hash) —

    key is the predicate, value is the target_uri



121
122
123
124
 
# File 'lib/active_fedora/solr_service.rb', line 121

def construct_query_for_rel(args)
  clauses = args.map { |predicate, target_uri| raw_query(solr_name(predicate, :symbol), target_uri) }
  clauses.join(" AND ".freeze)
end

.count(query, args = {}) ⇒ Integer

Get the count of records that match the query

Parameters:

  • query (String) —

    a solr query

  • args (Hash) (defaults to: {}) —

    arguments to pass through to ‘args’ param of SolrService.query (note that :rows will be overwritten to 0)

Returns:

  • (Integer) —

    number of records matching



138
139
140
141
 
# File 'lib/active_fedora/solr_service.rb', line 138

def count(query, args={})
  args = args.merge(:raw=>true, :rows=>0)
  SolrService.query(query, args)['response']['numFound'].to_i
end

.escape_uri_for_query(uri) ⇒ Object 



114
115
116
117
 
# File 'lib/active_fedora/solr_service.rb', line 114

def escape_uri_for_query(uri)
  Deprecation.warn SolrService, "escape_uri_for_query is deprecated and will be removed in active-fedora 8.0.0. Use RSolr.escape instead."
  RSolr.escape(uri)
end

.instance ⇒ Object

Raises:



27
28
29
30
31
32
33
34
35
36
 
# File 'lib/active_fedora/solr_service.rb', line 27

def instance
# Register Solr
    
  unless Thread.current[:solr_service]
    register(ActiveFedora.solr_config[:url])
  end

  raise SolrNotInitialized unless Thread.current[:solr_service]
  Thread.current[:solr_service]
end

.lazy_reify_solr_results(solr_results, opts = {}) ⇒ Object 



38
39
40
41
42
43
44
 
# File 'lib/active_fedora/solr_service.rb', line 38

def lazy_reify_solr_results(solr_results, opts = {})
  Enumerator.new do |yielder|
    solr_results.each do |hit|
      yielder.yield(reify_solr_result(hit, opts))
    end
  end
end

.query(query, args = {}) ⇒ Object 



126
127
128
129
130
131
132
 
# File 'lib/active_fedora/solr_service.rb', line 126

def query(query, args={})
  raw = args.delete(:raw)
  args = args.merge(:q=>query, :qt=>'standard')
  result = SolrService.instance.conn.get('select', :params=>args)
  return result if raw
  result['response']['docs']
end

.raw_query(key, value) ⇒ Object

Create a raw query clause suitable for sending to solr as an fq element

Parameters:

  • key (String)
  • value (String) 


106
107
108
 
# File 'lib/active_fedora/solr_service.rb', line 106

def raw_query(key, value)
  "_query_:\"{!raw f=#{key}}#{value.gsub('"', '\"')}\""
end

.register(host = nil, args = {}) ⇒ Object 



19
20
21
 
# File 'lib/active_fedora/solr_service.rb', line 19

def register(host=nil, args={})
  Thread.current[:solr_service] = new(host, args)
end

.reify_solr_result(hit, opts = {}) ⇒ Object 



50
51
52
53
54
55
56
57
 
# File 'lib/active_fedora/solr_service.rb', line 50

def reify_solr_result(hit, opts = {})
  klass = class_from_solr_document(hit)
  if opts[:load_from_solr]
    klass.load_instance_from_solr(hit[SOLR_DOCUMENT_ID], hit)
  else
    klass.find(hit[SOLR_DOCUMENT_ID], cast: true)
  end
end

.reify_solr_results(solr_results, opts = {}) ⇒ Object 



46
47
48
 
# File 'lib/active_fedora/solr_service.rb', line 46

def reify_solr_results(solr_results, opts = {})
  solr_results.collect {|hit| reify_solr_result(hit, opts)}
end

.reset! ⇒ Object 



23
24
25
 
# File 'lib/active_fedora/solr_service.rb', line 23

def reset!
  Thread.current[:solr_service] = nil
end

.solr_name(*args) ⇒ Object 



110
111
112
 
# File 'lib/active_fedora/solr_service.rb', line 110

def solr_name(*args)
  Solrizer.default_field_mapper.solr_name(*args)
end