Class: ActiveFedora::SolrService

Inherits:
Object
  • Object
show all
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.



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

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.



6
7
8
 
# File 'lib/active_fedora/solr_service.rb', line 6

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



133
134
135
 
# File 'lib/active_fedora/solr_service.rb', line 133

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



57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/active_fedora/solr_service.rb', line 57

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

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

.commit ⇒ Object 



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

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



83
84
85
86
87
 
# File 'lib/active_fedora/solr_service.rb', line 83

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(field_pairs, join_with = 'AND') ⇒ Object

Create a query with a clause for each key, value

Examples:

construct_query_for_rel [[:has_model, "info:fedora/afmodel:ComplexCollection"], [:has_model, "info:fedora/afmodel:ActiveFedora_Base"]], 'OR'
# => _query_:"{!raw f=has_model_ssim}info:fedora/afmodel:ComplexCollection" OR _query_:"{!raw f=has_model_ssim}info:fedora/afmodel:ActiveFedora_Base"

Parameters:

  • args (Hash, Array<Array<String>>) —

    key is the predicate, value is the target_uri

  • join_with (String) (defaults to: 'AND') —

    (‘AND’) the value we’re joining the clauses with



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

def construct_query_for_rel(field_pairs, join_with = 'AND')
  field_pairs = field_pairs.to_a if field_pairs.kind_of? Hash
  clauses = field_pairs.map { |(predicate, target_uri)| raw_query(solr_name(predicate, :symbol), target_uri) }
  clauses.join(" #{join_with} ".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



124
125
126
127
 
# File 'lib/active_fedora/solr_service.rb', line 124

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

.instance ⇒ Object

Raises:



24
25
26
27
28
29
30
31
32
33
 
# File 'lib/active_fedora/solr_service.rb', line 24

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 



35
36
37
38
39
40
41
 
# File 'lib/active_fedora/solr_service.rb', line 35

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 



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

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) 


92
93
94
 
# File 'lib/active_fedora/solr_service.rb', line 92

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

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



16
17
18
 
# File 'lib/active_fedora/solr_service.rb', line 16

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

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



47
48
49
50
51
52
53
54
 
# File 'lib/active_fedora/solr_service.rb', line 47

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 



43
44
45
 
# File 'lib/active_fedora/solr_service.rb', line 43

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

.reset! ⇒ Object 



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

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

.solr_name(*args) ⇒ Object 



96
97
98
 
# File 'lib/active_fedora/solr_service.rb', line 96

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