searchkick 4.6.3 → 5.0.1

data/lib/searchkick/reindex_queue.rb

@@ -5,11 +5,30 @@ module Searchkick
     def initialize(name)
       @name = name
 
-      raise Searchkick::Error, "Searchkick.redis not set" unless Searchkick.redis
+      raise Error, "Searchkick.redis not set" unless Searchkick.redis
     end
 
-    def push(record_id)
-      Searchkick.with_redis { |r| r.lpush(redis_key, record_id) }
+    # supports single and multiple ids
+    def push(record_ids)
+      Searchkick.with_redis { |r| r.lpush(redis_key, record_ids) }
+    end
+
+    def push_records(records)
+      record_ids =
+        records.map do |record|
+          # always pass routing in case record is deleted
+          # before the queue job runs
+          if record.respond_to?(:search_routing)
+            routing = record.search_routing
+          end
+
+          # escape pipe with double pipe
+          value = escape(record.id.to_s)
+          value = "#{value}|#{escape(routing)}" if routing
+          value
+        end
+
+      push(record_ids)
     end
 
     # TODO use reliable queuing
@@ -48,5 +67,9 @@ module Searchkick
     def redis_version
       @redis_version ||= Searchkick.with_redis { |r| Gem::Version.new(r.info["redis_version"]) }
     end
+
+    def escape(value)
+      value.gsub("|", "||")
+    end
   end
 end

data/lib/searchkick/reindex_v2_job.rb

@@ -1,41 +1,17 @@
 module Searchkick
   class ReindexV2Job < ActiveJob::Base
-    RECORD_NOT_FOUND_CLASSES = [
-      "ActiveRecord::RecordNotFound",
-      "Mongoid::Errors::DocumentNotFound",
-      "NoBrainer::Error::DocumentNotFound",
-      "Cequel::Record::RecordNotFound"
-    ]
-
     queue_as { Searchkick.queue_name }
 
-    def perform(klass, id, method_name = nil, routing: nil)
-      model = klass.constantize
-      record =
-        begin
-          if model.respond_to?(:unscoped)
-            model.unscoped.find(id)
-          else
-            model.find(id)
-          end
-        rescue => e
-          # check by name rather than rescue directly so we don't need
-          # to determine which classes are defined
-          raise e unless RECORD_NOT_FOUND_CLASSES.include?(e.class.name)
-          nil
-        end
-
-      unless record
-        record = model.new
-        record.id = id
-        if routing
-          record.define_singleton_method(:search_routing) do
-            routing
-          end
-        end
-      end
-
-      RecordIndexer.new(record).reindex(method_name, mode: :inline)
+    def perform(class_name, id, method_name = nil, routing: nil, index_name: nil)
+      model = Searchkick.load_model(class_name, allow_child: true)
+      index = model.searchkick_index(name: index_name)
+      # use should_index? to decide whether to index (not default scope)
+      # just like saving inline
+      # could use Searchkick.scope() in future
+      # but keep for now for backwards compatibility
+      model = model.unscoped if model.respond_to?(:unscoped)
+      items = [{id: id, routing: routing}]
+      RecordIndexer.new(index).reindex_items(model, items, method_name: method_name, single: true)
     end
   end
 end

data/lib/searchkick/relation.rb

@@ -0,0 +1,36 @@
+module Searchkick
+  class Relation
+    # note: modifying body directly is not supported
+    # and has no impact on query after being executed
+    # TODO freeze body object?
+    delegate :body, :params, to: :@query
+    delegate_missing_to :private_execute
+
+    def initialize(model, term = "*", **options)
+      @query = Query.new(model, term, **options)
+    end
+
+    # same as Active Record
+    def inspect
+      entries = results.first(11).map!(&:inspect)
+      entries[10] = "..." if entries.size == 11
+      "#<#{self.class.name} [#{entries.join(', ')}]>"
+    end
+
+    def execute
+      Searchkick.warn("The execute method is no longer needed")
+      private_execute
+      self
+    end
+
+    private
+
+    def private_execute
+      @execute ||= @query.execute
+    end
+
+    def query
+      @query
+    end
+  end
+end

data/lib/searchkick/relation_indexer.rb

@@ -0,0 +1,150 @@
+module Searchkick
+  class RelationIndexer
+    attr_reader :index
+
+    def initialize(index)
+      @index = index
+    end
+
+    def reindex(relation, mode:, method_name: nil, full: false, resume: false, scope: nil)
+      # apply scopes
+      if scope
+        relation = relation.send(scope)
+      elsif relation.respond_to?(:search_import)
+        relation = relation.search_import
+      end
+
+      # remove unneeded loading for async
+      if mode == :async
+        if relation.respond_to?(:primary_key)
+          relation = relation.select(relation.primary_key).except(:includes, :preload)
+        elsif relation.respond_to?(:only)
+          relation = relation.only(:_id)
+        end
+      end
+
+      if mode == :async && full
+        return full_reindex_async(relation)
+      end
+
+      relation = resume_relation(relation) if resume
+
+      reindex_options = {
+        mode: mode,
+        method_name: method_name,
+        full: full
+      }
+      record_indexer = RecordIndexer.new(index)
+
+      in_batches(relation) do |items|
+        record_indexer.reindex(items, **reindex_options)
+      end
+    end
+
+    def batches_left
+      Searchkick.with_redis { |r| r.scard(batches_key) }
+    end
+
+    def batch_completed(batch_id)
+      Searchkick.with_redis { |r| r.srem(batches_key, batch_id) }
+    end
+
+    private
+
+    def resume_relation(relation)
+      if relation.respond_to?(:primary_key)
+        # use total docs instead of max id since there's not a great way
+        # to get the max _id without scripting since it's a string
+        where = relation.arel_table[relation.primary_key].gt(index.total_docs)
+        relation = relation.where(where)
+      else
+        raise Error, "Resume not supported for Mongoid"
+      end
+    end
+
+    def in_batches(relation)
+      if relation.respond_to?(:find_in_batches)
+        klass = relation.klass
+        # remove order to prevent possible warnings
+        relation.except(:order).find_in_batches(batch_size: batch_size) do |batch|
+          # prevent scope from affecting search_data as well as inline jobs
+          # Active Record runs relation calls in scoping block
+          # https://github.com/rails/rails/blob/main/activerecord/lib/active_record/relation/delegation.rb
+          # note: we could probably just call klass.current_scope = nil
+          # anywhere in reindex method (after initial all call),
+          # but this is more cautious
+          previous_scope = klass.current_scope(true)
+          if previous_scope
+            begin
+              klass.current_scope = nil
+              yield batch
+            ensure
+              klass.current_scope = previous_scope
+            end
+          else
+            yield batch
+          end
+        end
+      else
+        klass = relation.klass
+        each_batch(relation, batch_size: batch_size) do |batch|
+          # prevent scope from affecting search_data as well as inline jobs
+          # note: Model.with_scope doesn't always restore scope, so use custom logic
+          previous_scope = Mongoid::Threaded.current_scope(klass)
+          if previous_scope
+            begin
+              Mongoid::Threaded.set_current_scope(nil, klass)
+              yield batch
+            ensure
+              Mongoid::Threaded.set_current_scope(previous_scope, klass)
+            end
+          else
+            yield batch
+          end
+        end
+      end
+    end
+
+    def each_batch(relation, batch_size:)
+      # https://github.com/karmi/tire/blob/master/lib/tire/model/import.rb
+      # use cursor for Mongoid
+      items = []
+      relation.all.each do |item|
+        items << item
+        if items.length == batch_size
+          yield items
+          items = []
+        end
+      end
+      yield items if items.any?
+    end
+
+    def batch_size
+      @batch_size ||= index.options[:batch_size] || 1000
+    end
+
+    def full_reindex_async(relation)
+      batch_id = 1
+      class_name = relation.searchkick_options[:class_name]
+
+      in_batches(relation) do |items|
+        batch_job(class_name, batch_id, items.map(&:id))
+        batch_id += 1
+      end
+    end
+
+    def batch_job(class_name, batch_id, record_ids)
+      Searchkick.with_redis { |r| r.sadd(batches_key, batch_id) }
+      Searchkick::BulkReindexJob.perform_later(
+        class_name: class_name,
+        index_name: index.name,
+        batch_id: batch_id,
+        record_ids: record_ids.map { |v| v.instance_of?(Integer) ? v : v.to_s }
+      )
+    end
+
+    def batches_key
+      "searchkick:reindex:#{index.name}:batches"
+    end
+  end
+end

data/lib/searchkick/results.rb

@@ -1,5 +1,3 @@
-require "forwardable"
-
 module Searchkick
   class Results
     include Enumerable
@@ -19,13 +17,11 @@ module Searchkick
       @results ||= with_hit.map(&:first)
     end
 
-    # TODO return enumerator like with_score
     def with_hit
-      @with_hit ||= begin
-        if missing_records.any?
-          Searchkick.warn("Records in search index do not exist in database: #{missing_records.map { |v| v[:id] }.join(", ")}")
-        end
-        with_hit_and_missing_records[0]
+      return enum_for(:with_hit) unless block_given?
+
+      build_hits.each do |result|
+        yield result
       end
     end
 
@@ -145,7 +141,7 @@ module Searchkick
 
     def hits
       if error
-        raise Searchkick::Error, "Query error - use the error method to view it"
+        raise Error, "Query error - use the error method to view it"
       else
         @response["hits"]["hits"]
       end
@@ -157,10 +153,11 @@ module Searchkick
       end
     end
 
-    # TODO return enumerator like with_score
     def with_highlights(multiple: false)
-      with_hit.map do |result, hit|
-        [result, hit_highlights(hit, multiple: multiple)]
+      return enum_for(:with_highlights, multiple: multiple) unless block_given?
+
+      with_hit.each do |result, hit|
+        yield result, hit_highlights(hit, multiple: multiple)
       end
     end
 
@@ -181,7 +178,7 @@ module Searchkick
     end
 
     def scroll
-      raise Searchkick::Error, "Pass `scroll` option to the search method for scrolling" unless scroll_id
+      raise Error, "Pass `scroll` option to the search method for scrolling" unless scroll_id
 
       if block_given?
         records = self
@@ -194,10 +191,10 @@ module Searchkick
       else
         begin
           # TODO Active Support notifications for this scroll call
-          Searchkick::Results.new(@klass, Searchkick.client.scroll(scroll: options[:scroll], body: {scroll_id: scroll_id}), @options)
+          Results.new(@klass, Searchkick.client.scroll(scroll: options[:scroll], body: {scroll_id: scroll_id}), @options)
         rescue => e
           if Searchkick.not_found_error?(e) && e.message =~ /search_context_missing_exception/i
-            raise Searchkick::Error, "Scroll id has expired"
+            raise Error, "Scroll id has expired"
           else
             raise e
           end
@@ -235,7 +232,7 @@ module Searchkick
                 index_alias = index.split("_")[0..-2].join("_")
                 Array((options[:index_mapping] || {})[index_alias])
               end
-            raise Searchkick::Error, "Unknown model for index: #{index}. Pass the `models` option to the search method." unless models.any?
+            raise Error, "Unknown model for index: #{index}. Pass the `models` option to the search method." unless models.any?
             index_models[index] = models
           end
 
@@ -287,7 +284,7 @@ module Searchkick
                 end
 
               if hit["highlight"] || options[:highlight]
-                highlight = Hash[hit["highlight"].to_a.map { |k, v| [base_field(k), v.first] }]
+                highlight = hit["highlight"].to_a.to_h { |k, v| [base_field(k), v.first] }
                 options[:highlighted_fields].map { |k| base_field(k) }.each do |k|
                   result["highlighted_#{k}"] ||= (highlight[k] || result[k])
                 end
@@ -302,23 +299,25 @@ module Searchkick
       end
     end
 
+    def build_hits
+      @build_hits ||= begin
+        if missing_records.any?
+          Searchkick.warn("Records in search index do not exist in database: #{missing_records.map { |v| v[:id] }.join(", ")}")
+        end
+        with_hit_and_missing_records[0]
+      end
+    end
+
     def results_query(records, hits)
+      records = Searchkick.scope(records)
+
       ids = hits.map { |hit| hit["_id"] }
       if options[:includes] || options[:model_includes]
         included_relations = []
         combine_includes(included_relations, options[:includes])
         combine_includes(included_relations, options[:model_includes][records]) if options[:model_includes]
 
-        records =
-          if defined?(NoBrainer::Document) && records < NoBrainer::Document
-            if Gem.loaded_specs["nobrainer"].version >= Gem::Version.new("0.21")
-              records.eager_load(included_relations)
-            else
-              records.preload(included_relations)
-            end
-          else
-            records.includes(included_relations)
-          end
+        records = records.includes(included_relations)
       end
 
       if options[:scope_results]
@@ -344,7 +343,7 @@ module Searchkick
 
     def hit_highlights(hit, multiple: false)
       if hit["highlight"]
-        Hash[hit["highlight"].map { |k, v| [(options[:json] ? k : k.sub(/\.#{@options[:match_suffix]}\z/, "")).to_sym, multiple ? v : v.first] }]
+        hit["highlight"].to_h { |k, v| [(options[:json] ? k : k.sub(/\.#{@options[:match_suffix]}\z/, "")).to_sym, multiple ? v : v.first] }
       else
         {}
       end

data/lib/searchkick/version.rb

@@ -1,3 +1,3 @@
 module Searchkick
-  VERSION = "4.6.3"
+  VERSION = "5.0.1"
 end