chewy 5.0.0 → 7.0.1

data/lib/chewy/search/parameters/none.rb

@@ -12,14 +12,12 @@ module Chewy
         include BoolStorage
 
         # Renders `match_none` query if the values is set to true.
-        # Well, we can't really use match none because we need to support
-        # ES2, so we are simulating it with `match_all` negation.
         #
         # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-match-all-query.html#query-dsl-match-none-query
         # @see Chewy::Search::Request
         # @see Chewy::Search::Request#response
         def render
-          {query: {bool: {filter: {bool: {must_not: {match_all: {}}}}}}} if value.present?
+          {query: {match_none: {}}} if value.present?
         end
       end
     end

data/lib/chewy/search/request.rb

@@ -1,7 +1,7 @@
 module Chewy
   module Search
-    # The main requset DSL class. Supports multiple index requests.
-    # Supports ES2 and ES5 search API and query DSL.
+    # The main request DSL class. Supports multiple index requests.
+    # Supports ES5 search API and query DSL.
     #
     # @note The class tries to be as immutable as possible,
     #   so most of the methods return a new instance of the class.
@@ -26,8 +26,9 @@ module Chewy
         timeout min_score source stored_fields search_after
         load script_fields suggest aggs aggregations none
         indices_boost rescore highlight total total_count
-        total_entries types delete_all count exists? exist? find pluck
-        scroll_batches scroll_hits scroll_results scroll_wrappers
+        total_entries indices types delete_all count exists?
+        exist? find pluck scroll_batches scroll_hits
+        scroll_results scroll_wrappers
       ].to_set.freeze
       DEFAULT_BATCH_SIZE = 1000
       DEFAULT_PLUCK_BATCH_SIZE = 10_000
@@ -51,24 +52,32 @@ module Chewy
       alias_method :total_count, :total
       alias_method :total_entries, :total
 
-      attr_reader :_indexes, :_types
-
       # The class is initialized with the list of chewy indexes and/or
       # types, which are later used to compose requests.
+      # Any symbol/string passed is treated as an index identifier.
       #
       # @example
+      #   Chewy::Search::Request.new(:places)
+      #   # => <Chewy::Search::Request {:index=>["places"]}>
       #   Chewy::Search::Request.new(PlacesIndex)
       #   # => <Chewy::Search::Request {:index=>["places"], :type=>["city", "country"]}>
       #   Chewy::Search::Request.new(PlacesIndex::City)
       #   # => <Chewy::Search::Request {:index=>["places"], :type=>["city"]}>
       #   Chewy::Search::Request.new(UsersIndex, PlacesIndex::City)
       #   # => <Chewy::Search::Request {:index=>["users", "places"], :type=>["city", "user"]}>
-      # @param indexes_or_types [Array<Chewy::Index, Chewy::Type>] indexes and types in any combinations
-      def initialize(*indexes_or_types)
-        @_types = indexes_or_types.select { |klass| klass < Chewy::Type }
-        @_indexes = indexes_or_types.select { |klass| klass < Chewy::Index }
-        @_types |= @_indexes.flat_map(&:types)
-        @_indexes |= @_types.map(&:index)
+      # @param indexes_or_types [Array<Chewy::Index, Chewy::Type, String, Symbol>] indices and types in any combinations
+      def initialize(*indices_or_types)
+        indices = indices_or_types.reject do |klass|
+          klass.is_a?(Class) && klass < Chewy::Type
+        end
+
+        types = indices_or_types.select do |klass|
+          klass.is_a?(Class) && klass < Chewy::Type
+        end
+
+        parameters.modify!(:indices) do
+          replace!(indices: indices, types: types)
+        end
       end
 
       # Underlying parameter storage collection.
@@ -103,14 +112,23 @@ module Chewy
       # @see Chewy::Search::Response
       # @return [Chewy::Search::Response] a response object instance
       def response
-        @response ||= Response.new(perform, loader, collection_paginator)
+        @response ||= build_response(perform)
+      end
+
+      # Wraps and sets the raw Elasticsearch response to provide access
+      # to convenience methods.
+      #
+      # @see Chewy::Search::Response
+      # @param from_elasticsearch [Hash] An Elasticsearch response
+      def response=(from_elasticsearch)
+        @response = build_response(from_elasticsearch)
       end
 
       # ES request body
       #
       # @return [Hash] request body
       def render
-        @render ||= render_base.merge(parameters.render)
+        @render ||= parameters.render
       end
 
       # Includes the class name and the result of rendering.
@@ -281,21 +299,39 @@ module Chewy
       #   @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-request-docvalue-fields.html
       #   @param values [Array<String, Symbol>] field names
       #   @return [Chewy::Search::Request]
+      %i[order docvalue_fields].each do |name|
+        define_method name do |value, *values|
+          modify(name) { update!([value, *values]) }
+        end
+      end
+
+      # @!method indices(*values)
+      #   Modifies `index` request parameter. Updates the storage on every call.
+      #   Added passed indexes to the parameter list.
+      #
+      #   @example
+      #     UsersIndex.indices(CitiesIndex).indices(:another)
+      #     # => <UsersIndex::Query {:index=>["another", "cities", "users"], :type=>["city", "user"]}>
+      #   @see Chewy::Search::Parameters::Indices
+      #   @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-search.html
+      #   @param values [Array<Chewy::Index, String, Symbol>] index names
+      #   @return [Chewy::Search::Request]
       #
       # @!method types(*values)
-      #   Modifies `types` request parameter. Updates the storage on every call.
-      #   Constrains types passed on the request initialization.
+      #   Modifies `type` request parameter. Updates the storage on every call.
+      #   Constrains types passed on the request initialization or adds them
+      #   to the list depending on circumstances.
       #
       #   @example
-      #     PlacesIndex.types(:city).types(:unexistent)
-      #     # => <PlacesIndex::Query {:index=>["places"], :type=>["city"]}>
-      #   @see Chewy::Search::Parameters::Types
+      #     UsersIndex.types(CitiesIndex::City).types(:unexistent)
+      #     # => <UsersIndex::Query {:index=>["cities", "users"], :type=>["city", "user"]}>
+      #   @see Chewy::Search::Parameters::Indices
       #   @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-search.html
-      #   @param values [Array<String, Symbol>] type names
+      #   @param values [Array<Chewy::Type, String, Symbol>] type names
       #   @return [Chewy::Search::Request]
-      %i[order docvalue_fields types].each do |name|
+      %i[indices types].each do |name|
         define_method name do |value, *values|
-          modify(name) { update!([value, *values]) }
+          modify(:indices) { update!(name => [value, *values]) }
         end
       end
 
@@ -759,7 +795,7 @@ module Chewy
       # @param values [Array<String, Symbol>]
       # @return [Chewy::Search::Request] new scope
       def only(*values)
-        chain { parameters.only!(values.flatten(1)) }
+        chain { parameters.only!(values.flatten(1) + [:indices]) }
       end
 
       # Returns a new scope containing all the storages except specified.
@@ -901,28 +937,28 @@ module Chewy
       end
 
       # Deletes all the documents from the specified scope it uses
-      # `delete_by_query` API. For ES < 5.0 it uses `delete_by_query`
-      # plugin, which requires additional installation effort.
+      # `delete_by_query`
       #
       # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-delete-by-query.html
-      # @see https://www.elastic.co/guide/en/elasticsearch/plugins/2.0/plugins-delete-by-query.html
       # @note The result hash is different for different API used.
       # @param refresh [true, false] field names
       # @return [Hash] the result of query execution
       def delete_all(refresh: true)
         request_body = only(WHERE_STORAGES).render.merge(refresh: refresh)
         ActiveSupport::Notifications.instrument 'delete_query.chewy',
-          request: request_body, indexes: _indexes, types: _types,
-          index: _indexes.one? ? _indexes.first : _indexes,
-          type: _types.one? ? _types.first : _types do
-            if Runtime.version < '5.0'
-              delete_by_query_plugin(request_body)
-            else
-              Chewy.client.delete_by_query(request_body)
-            end
+          notification_payload(request: request_body) do
+            request_body[:body] = {query: {match_all: {}}} if request_body[:body].empty?
+            Chewy.client.delete_by_query(request_body)
           end
       end
 
+      # Returns whether or not the query has been performed.
+      #
+      # @return [true, false]
+      def performed?
+        !@response.nil?
+      end
+
     protected
 
       def initialize_clone(origin)
@@ -932,10 +968,12 @@ module Chewy
 
     private
 
+      def build_response(raw_response)
+        Response.new(raw_response, loader, collection_paginator)
+      end
+
       def compare_internals(other)
-        _indexes.sort_by(&:derivable_name) == other._indexes.sort_by(&:derivable_name) &&
-          _types.sort_by(&:derivable_name) == other._types.sort_by(&:derivable_name) &&
-          parameters == other.parameters
+        parameters == other.parameters
       end
 
       def modify(name, &block)
@@ -947,58 +985,51 @@ module Chewy
       end
 
       def reset
-        @response, @render, @render_base, @type_names, @index_names, @loader = nil
+        @response, @render, @loader = nil
       end
 
       def perform(additional = {})
         request_body = render.merge(additional)
+        request_body[:rest_total_hits_as_int] = true if Chewy::Runtime::Version.new(Chewy.client.info['version']['number']) >= '7.0.0'
         ActiveSupport::Notifications.instrument 'search_query.chewy',
-          request: request_body, indexes: _indexes, types: _types,
-          index: _indexes.one? ? _indexes.first : _indexes,
-          type: _types.one? ? _types.first : _types do
-          begin
-            Chewy.client.search(request_body)
-          rescue Elasticsearch::Transport::Transport::Errors::NotFound
-            {}
+          notification_payload(request: request_body) do
+            begin
+              Chewy.client.search(request_body)
+            rescue Elasticsearch::Transport::Transport::Errors::NotFound
+              {}
+            end
           end
-        end
       end
 
-      def raw_limit_value
-        parameters[:limit].value
-      end
-
-      def raw_offset_value
-        parameters[:offset].value
+      def notification_payload(additional)
+        {
+          indexes: _indices, types: _types,
+          index: _indices.one? ? _indices.first : _indices,
+          type: _types.one? ? _types.first : _types
+        }.merge(additional)
       end
 
-      def index_names
-        @index_names ||= _indexes.map(&:index_name).uniq
+      def _indices
+        parameters[:indices].indices
       end
 
-      def type_names
-        @type_names ||= if parameters[:types].value.present?
-          _types.map(&:type_name).uniq & parameters[:types].value
-        else
-          _types.map(&:type_name).uniq
-        end
+      def _types
+        parameters[:indices].types
       end
 
-      def render_base
-        @render_base ||= {index: index_names, type: type_names, body: {}}
+      def raw_limit_value
+        parameters[:limit].value
       end
 
-      def delete_by_query_plugin(request)
-        path = Elasticsearch::API::Utils.__pathify(
-          Elasticsearch::API::Utils.__listify(request[:index]),
-          Elasticsearch::API::Utils.__listify(request[:type]),
-          '_query'
-        )
-        Chewy.client.perform_request(Elasticsearch::API::HTTP_DELETE, path, {}, request[:body]).body
+      def raw_offset_value
+        parameters[:offset].value
       end
 
       def loader
-        @loader ||= Loader.new(indexes: @_indexes, **parameters[:load].value)
+        @loader ||= Loader.new(
+          indexes: parameters[:indices].indices,
+          **parameters[:load].value
+        )
       end
 
       def fetch_field(hit, field)
@@ -1009,10 +1040,6 @@ module Chewy
         end
       end
 
-      def performed?
-        !@response.nil?
-      end
-
       def collection_paginator
         method(:paginated_collection).to_proc if respond_to?(:paginated_collection, true)
       end

data/lib/chewy/search/scrolling.rb

@@ -31,16 +31,19 @@ module Chewy
         total = [raw_limit_value, result.fetch('hits', {}).fetch('total', 0)].compact.min
         last_batch_size = total % batch_size
         fetched = 0
+        scroll_id = nil
 
         loop do
           hits = result.fetch('hits', {}).fetch('hits', [])
           fetched += hits.size
           hits = hits.first(last_batch_size) if last_batch_size != 0 && fetched >= total
           yield(hits) if hits.present?
-          break if fetched >= total
           scroll_id = result['_scroll_id']
+          break if fetched >= total
           result = perform_scroll(scroll: scroll, scroll_id: scroll_id)
         end
+      ensure
+        Chewy.client.clear_scroll(scroll_id: scroll_id) if scroll_id
       end
 
       # @!method scroll_hits(batch_size: 1000, scroll: '1m')
@@ -125,11 +128,9 @@ module Chewy
 
       def perform_scroll(body)
         ActiveSupport::Notifications.instrument 'search_query.chewy',
-          request: body, indexes: _indexes, types: _types,
-          index: _indexes.one? ? _indexes.first : _indexes,
-          type: _types.one? ? _types.first : _types do
-          Chewy.client.scroll(body)
-        end
+          notification_payload(request: body) do
+            Chewy.client.scroll(body)
+          end
       end
     end
   end

data/lib/chewy/stash.rb

@@ -24,7 +24,7 @@ module Chewy
       # @param since_time [Time, DateTime] a timestamp from which we load a journal
       # @param only [Chewy::Index, Array<Chewy::Index>] journal entries related to these indices will be loaded only
       def self.entries(since_time, only: [])
-        self.for(only).filter(range: {created_at: {gt: since_time}})
+        self.for(only).filter(range: {created_at: {gt: since_time}}).filter.minimum_should_match(1)
       end
 
       # Cleans up all the journal entries until the specified time. If nothing is

data/lib/chewy/strategy/active_job.rb

@@ -11,7 +11,7 @@ module Chewy
     #
     class ActiveJob < Atomic
       class Worker < ::ActiveJob::Base
-        queue_as :chewy
+        queue_as { Chewy.settings.dig(:active_job, :queue) || 'chewy' }
 
         def perform(type, ids, options = {})
           options[:refresh] = !Chewy.disable_refresh_async if Chewy.disable_refresh_async

data/lib/chewy/strategy/sidekiq.rb

@@ -33,7 +33,7 @@ module Chewy
     private
 
       def sidekiq_queue
-        Chewy.settings.fetch(:sidekiq, {})[:queue] || 'chewy'
+        Chewy.settings.dig(:sidekiq, :queue) || 'chewy'
       end
     end
   end

data/lib/chewy/type.rb

@@ -14,7 +14,10 @@ require 'chewy/type/witchcraft'
 
 module Chewy
   class Type
-    IMPORT_OPTIONS_KEYS = %i[batch_size bulk_size refresh consistency replication raw_import journal pipeline].freeze
+    IMPORT_OPTIONS_KEYS = %i[
+      batch_size bulk_size consistency direct_import journal
+      pipeline raw_import refresh replication
+    ].freeze
 
     include Search
     include Mapping

data/lib/chewy/type/adapter/active_record.rb

@@ -22,7 +22,7 @@ module Chewy
         end
 
         def import_scope(scope, options)
-          pluck_in_batches(scope, options.slice(:batch_size)).inject(true) do |result, ids|
+          pluck_in_batches(scope, **options.slice(:batch_size)).inject(true) do |result, ids|
             objects = if options[:raw_import]
               raw_default_scope_where_ids_in(ids, options[:raw_import])
             else

data/lib/chewy/type/adapter/mongoid.rb

@@ -25,7 +25,7 @@ module Chewy
         end
 
         def import_scope(scope, options)
-          pluck_in_batches(scope, options.slice(:batch_size)).map do |ids|
+          pluck_in_batches(scope, **options.slice(:batch_size)).map do |ids|
             yield grouped_objects(default_scope_where_ids_in(ids))
           end.all?
         end

data/lib/chewy/type/adapter/orm.rb

@@ -45,6 +45,7 @@ module Chewy
         # Import options:
         #
         #   <tt>:batch_size</tt> - import batch size, 1000 objects by default
+        #   <tt>:direct_import</tt> - import objects without reloading
         #
         # Method handles destroyed objects as well. In case of objects ORM scope
         # or array passed, objects, responding with true to `destroyed?` method will be deleted
@@ -75,10 +76,10 @@ module Chewy
         def import(*args, &block)
           collection, options = import_args(*args)
 
-          if collection.is_a?(relation_class)
-            import_scope(collection, options, &block)
-          else
+          if !collection.is_a?(relation_class) || options[:direct_import]
             import_objects(collection, options, &block)
+          else
+            import_scope(collection, options, &block)
           end
         end
 
@@ -89,7 +90,7 @@ module Chewy
 
           if options[:fields].present? || collection.is_a?(relation_class)
             collection = all_scope_where_ids_in(identify(collection)) unless collection.is_a?(relation_class)
-            pluck_in_batches(collection, options.slice(:fields, :batch_size, :typecast), &block)
+            pluck_in_batches(collection, **options.slice(:fields, :batch_size, :typecast), &block)
           else
             identify(collection).each_slice(options[:batch_size]) do |batch|
               yield batch
@@ -119,6 +120,8 @@ module Chewy
           indexed = collection_ids.each_slice(options[:batch_size]).map do |ids|
             batch = if options[:raw_import]
               raw_default_scope_where_ids_in(ids, options[:raw_import])
+            elsif options[:direct_import]
+              hash.values_at(*ids.map(&:to_s))
             else
               default_scope_where_ids_in(ids)
             end