Module Sunspot::Rails::Searchable::ClassMethods

  1. lib/sunspot/rails/searchable.rb

Public instance methods

searchable? ()

Classes that have been defined as searchable return true for this method.

Returns

true

[show source] 
# File lib/sunspot/rails/searchable.rb, line 288
        def searchable?
          true
        end
solr_clean_index_orphans ()

Find IDs of records of this class that are indexed in Solr but do not exist in the database, and remove them from Solr. Under normal circumstances, this should not be necessary; this method is provided in case something goes wrong.

[show source] 
# File lib/sunspot/rails/searchable.rb, line 272
        def solr_clean_index_orphans
          solr_index_orphans.each do |id|
            new do |fake_instance|
              fake_instance.id = id
            end.solr_remove_from_index
          end
        end
solr_index (opts={})

Add/update all existing records in the Solr index. The batch_size argument specifies how many records to load out of the database at a time. The default batch size is 500; if nil is passed, records will not be indexed in batches. By default, a commit is issued after each batch; passing false for batch_commit will disable this, and only issue a commit at the end of the process. If associated objects need to indexed also, you can specify include in format accepted by ActiveRecord to improve your sql select performance

Options (passed as a hash)

batch_size:Batch size with which to load records. Passing ‘nil’ will skip batches. Default is 500.
batch_commit:Flag signalling if a commit should be done after after each batch is indexed, default is ‘true’
include:include option to be passed to the ActiveRecord find, used for including associated objects that need to be indexed with the parent object, accepts all formats ActiveRecord::Base.find does
first_id:The lowest possible ID for this class. Defaults to 0, which is fine for integer IDs; string primary keys will need to specify something reasonable here.

Examples

# index in batches of 500, commit after each
Post.index

# index all rows at once, then commit
Post.index(:batch_size => nil)

# index in batches of 500, commit when all batches complete
Post.index(:batch_commit => false)

# include the associated +author+ object when loading to index
Post.index(:include => :author)
[show source] 
# File lib/sunspot/rails/searchable.rb, line 224
        def solr_index(opts={})
          options = { :batch_size => 500, :batch_commit => true, :include => [], :first_id => 0}.merge(opts)
          unless options[:batch_size]
            Sunspot.index!(all(:include => options[:include]))
          else
            offset = 0
            counter = 1
            record_count = count
            last_id = options[:first_id]
            while(offset < record_count)
              solr_benchmark options[:batch_size], counter do
                records = all(:include => options[:include], :conditions => ["#{table_name}.#{primary_key} > ?", last_id], :limit => options[:batch_size], :order => primary_key)
                Sunspot.index(records)
                last_id = records.last.id
              end
              Sunspot.commit if options[:batch_commit]
              offset += options[:batch_size]
              counter += 1
            end
            Sunspot.commit unless options[:batch_commit]
          end
        end
solr_index_orphans ()

Return the IDs of records of this class that are indexed in Solr but do not exist in the database. Under normal circumstances, this should never happen, but this method is provided in case something goes wrong. Usually you will want to rectify the situation by calling clean_index_orphans or reindex

Returns

Array:Collection of IDs that exist in Solr but not in the database
[show source] 
# File lib/sunspot/rails/searchable.rb, line 257
        def solr_index_orphans
          count = self.count
          indexed_ids = solr_search_ids { paginate(:page => 1, :per_page => count) }.to_set
          all(:select => 'id').each do |object|
            indexed_ids.delete(object.id)
          end
          indexed_ids.to_a
        end
solr_reindex (options = {})

Completely rebuild the index for this class. First removes all instances from the index, then loads records and indexes them.

See index for information on options, etc.

[show source] 
# File lib/sunspot/rails/searchable.rb, line 181
        def solr_reindex(options = {})
          solr_remove_all_from_index
          solr_index(options)
        end
solr_remove_all_from_index ()

Remove instances of this class from the Solr index.

[show source] 
# File lib/sunspot/rails/searchable.rb, line 162
        def solr_remove_all_from_index
          Sunspot.remove_all(self)
        end
solr_remove_all_from_index! ()

Remove all instances of this class from the Solr index and immediately commit.

[show source] 
# File lib/sunspot/rails/searchable.rb, line 171
        def solr_remove_all_from_index!
          Sunspot.remove_all!(self)
        end
solr_search (options = {}, &block)

Search for instances of this class in Solr. The block is delegated to the Sunspot.search method - see the Sunspot documentation for the full API.

Example

Post.search(:include => [:blog]) do
  keywords 'best pizza'
  with :blog_id, 1
  order :updated_at, :desc
  facet :category_ids
end

Options

:include:Specify associations to eager load
:select:Specify columns to select from database when loading results

Returns

Sunspot::Search:Object containing results, totals, facets, etc.
[show source] 
# File lib/sunspot/rails/searchable.rb, line 129
        def solr_search(options = {}, &block)
          options.assert_valid_keys(:include, :select)
          search = Sunspot.new_search(self, &block)
          unless options.empty?
            search.build do |query|
              if options[:include]
                query.data_accessor_for(self).include = options[:include]
              end
              if options[:select]
                query.data_accessor_for(self).select = options[:select]
              end
            end
          end
          search.execute
        end
solr_search_ids (&block)

Get IDs of matching results without loading the result objects from the database. This method may be useful if search is used as an intermediate step in a larger find operation. The block is the same as the block provided to the search method.

Returns

Array:Array of IDs, in the order returned by the search
[show source] 
# File lib/sunspot/rails/searchable.rb, line 155
        def solr_search_ids(&block)
          solr_search(&block).raw_results.map { |raw_result| raw_result.primary_key.to_i }
        end

Protected instance methods

solr_benchmark (batch_size, counter) {|| ...}

Does some logging for benchmarking indexing performance

[show source] 
# File lib/sunspot/rails/searchable.rb, line 297
        def solr_benchmark(batch_size, counter,  &block)
          start = Time.now
          logger.info("[#{Time.now}] Start Indexing")
          yield
          elapsed = Time.now-start
          logger.info("[#{Time.now}] Completed Indexing. Rows indexed #{counter * batch_size}. Rows/sec: #{batch_size/elapsed.to_f} (Elapsed: #{elapsed} sec.)")
        end