Class: ActiveFedora::SolrService

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



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

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.



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

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



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

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



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

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 



144
145
146
 
# File 'lib/active_fedora/solr_service.rb', line 144

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



85
86
87
88
89
 
# File 'lib/active_fedora/solr_service.rb', line 85

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



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

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



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

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 



102
103
104
105
 
# File 'lib/active_fedora/solr_service.rb', line 102

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:



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

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 



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

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 



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

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) 


94
95
96
 
# File 'lib/active_fedora/solr_service.rb', line 94

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

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



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

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

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



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

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 



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

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

.reset! ⇒ Object 



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

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

.solr_name(*args) ⇒ Object 



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

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