chewy 0.8.4 → 0.9.0

data/lib/chewy/journal/apply.rb

@@ -0,0 +1,31 @@
+module Chewy
+  class Journal
+    module Apply
+      # Applies all changes that were done since some moment
+      #
+      # @param time [Integer] timestamp from which changes will be applied
+      # @param options [Hash]
+      # @option options [Integer] :retries maximum number of attempts to make journal "empty". By default is set to 10
+      # @option options [Boolean] :once shows whether we should try until the journal is clean. If set to true, :retries is ignored
+      # @option options [Array<Chewy::Index>] :only filters the resulting set of records by index name
+      def since(time, options = {})
+        previous_entries = []
+        retries = options[:retries] || 10
+        stage = 0
+        while stage < retries
+          stage += 1
+          previous_entries.select { |entry| entry.created_at.to_i >= time }
+          entries = Entry.group(Entry.since(time, options[:only]))
+          Entry.subtract(entries, previous_entries)
+          break if entries.length.zero?
+          ActiveSupport::Notifications.instrument 'apply_journal.chewy', stage: stage
+          entries.each { |entry| entry.index.import(entry.object_ids, journal: false) }
+          break if options[:once]
+          time = Entry.recent_timestamp(entries)
+          previous_entries = entries
+        end
+      end
+      module_function :since
+    end
+  end
+end

data/lib/chewy/journal/clean.rb

@@ -0,0 +1,24 @@
+module Chewy
+  class Journal
+    module Clean
+      DELETE_BATCH_SIZE = 10_000
+
+      def until(time)
+        query = Query.new(time, :lte, nil, false).to_h
+        search_query = query.merge(fields: ['_id'], size: DELETE_BATCH_SIZE)
+        index_name = Journal.index_name
+
+        count = Chewy.client.count(index: index_name, body: query)['count']
+
+        (count.to_f / DELETE_BATCH_SIZE).ceil.times do
+          ids = Chewy.client.search(index: index_name, body: search_query)['hits']['hits'].map { |doc| doc['_id'] }
+          Chewy.client.bulk(body: ids.map { |id| { delete: { _index: index_name, _type: Journal.type_name, _id: id } } }, refresh: true)
+        end
+
+        Chewy.wait_for_status
+        count
+      end
+      module_function :until
+    end
+  end
+end

data/lib/chewy/journal/entry.rb

@@ -0,0 +1,83 @@
+module Chewy
+  class Journal
+    # Describes a journal entry and provides necessary assisting methods
+    class Entry
+      ATTRIBUTES = %w(index_name type_name action object_ids created_at).freeze
+
+      attr_accessor(*ATTRIBUTES)
+
+      def initialize(attributes = {})
+        attributes.slice(*ATTRIBUTES).each do |attr, value|
+          public_send("#{attr}=", value)
+        end
+      end
+
+      # Loads all entries since some time
+      # @param time [Integer] a timestamp from which we load a journal
+      # @param indices [Array<Chewy::Index>] journal records related to these indices will be loaded only
+      def self.since(time, indices = [])
+        query = Query.new(time, :gte, indices).to_h
+        parameters = { index: Journal.index_name, type: Journal.type_name, body: query }
+        size = Chewy.client.search(search_type: 'count', **parameters)['hits']['total']
+        if size > 0
+          Chewy.client
+            .search(size: size, sort: 'created_at', **parameters)['hits']['hits']
+            .map { |r| new(r['_source']) }
+        else
+          []
+        end
+      end
+
+      # Groups a list of entries by full type name to decrease
+      # a number of calls to Elasticsearch during journal apply
+      # @param entries [Array<Chewy::Journal::Entry>]
+      def self.group(entries)
+        entries.group_by(&:full_type_name)
+          .map { |_, grouped_entries| grouped_entries.reduce(:merge) }
+      end
+
+      # Allows to filter one list of entries from another
+      # If any records with the same full type name are found then their object_ids will be subtracted
+      # @param from [Array<Chewy::Journal::Entry>] from which list we subtract another
+      # @param what [Array<Chewy::Journal::Entry>] what we subtract
+      def self.subtract(from, what)
+        return from if what.empty?
+        from.each do |from_entry|
+          what.each do |what_entry|
+            from_entry.object_ids -= what_entry.object_ids if from_entry == what_entry
+          end
+        end
+        from.delete_if(&:empty?)
+      end
+
+      # Get the most recent timestamp from a list of entries
+      # @param entries [Array<Chewy::Journal::Entry>]
+      def self.recent_timestamp(entries)
+        entries.map { |entry| entry.created_at.to_i }.max
+      end
+
+      def index
+        @index ||= Chewy.derive_type(full_type_name)
+      end
+
+      def full_type_name
+        "#{index_name}##{type_name}"
+      end
+
+      def merge(other)
+        return self if other.nil? || full_type_name != other.full_type_name
+        self.object_ids |= other.object_ids
+        self.created_at = [created_at, other.created_at].compact.max
+        self
+      end
+
+      def ==(other)
+        full_type_name == other.try(:full_type_name)
+      end
+
+      def empty?
+        !object_ids || object_ids.empty?
+      end
+    end
+  end
+end

data/lib/chewy/journal/query.rb

@@ -0,0 +1,87 @@
+module Chewy
+  class Journal
+    class Query
+      # @param time [Integer]
+      # @param comparator [Symbol, String] lt, lte, gt, gte
+      # @param indices [Array<Chewy::Index>] which indices should only be selected in the resulting set
+      # @param use_filter [Boolean] should we use filter or query
+      def initialize(time, comparator, indices, use_filter = true)
+        @time = time
+        @comparator = comparator
+        @indices = indices || []
+        @use_filter = use_filter
+      end
+
+      # @return [Hash] ElasicSearch query
+      def to_h
+        @query ||= { query: { filtered: filtered } }
+      end
+
+    private
+
+      def filtered
+        if @use_filter
+          using_filter_query
+        else
+          using_query_query
+        end
+      end
+
+      def using_filter_query
+        if @indices.any?
+          {
+            filter: {
+              bool: {
+                must: [
+                  range_filter,
+                  bool: {
+                    should: @indices.collect { |i| index_filter(i) }
+                  }
+                ]
+              }
+            }
+          }
+        else
+          {
+            filter: range_filter
+          }
+        end
+      end
+
+      def using_query_query
+        if @indices.any?
+          {
+            query: range_filter,
+            filter: {
+              bool: {
+                should: @indices.collect { |i| index_filter(i) }
+              }
+            }
+          }
+        else
+          {
+            query: range_filter
+          }
+        end
+      end
+
+      def range_filter
+        {
+          range: {
+            created_at: {
+              @comparator => @time.to_i
+            }
+          }
+        }
+      end
+
+      def index_filter(index)
+        {
+          term: {
+            index_name: index.derivable_index_name
+          }
+        }
+      end
+    end
+  end
+end

data/lib/chewy/log_subscriber.rb

@@ -16,17 +16,17 @@ module Chewy
       render_action('Delete by Query', event) { |payload| payload[:request] }
     end
 
-    def render_action action, event, &block
+    def render_action(action, event)
       payload = event.payload
-      description = block.call(payload)
+      description = yield(payload)
 
-      if description.present?
-        subject = payload[:type].presence || payload[:index]
-        action = "#{subject} #{action} (#{event.duration.round(1)}ms)"
-        action = color(action, GREEN, true)
+      return if description.blank?
 
-        debug("  #{action} #{description}")
-      end
+      subject = payload[:type].presence || payload[:index]
+      action = "#{subject} #{action} (#{event.duration.round(1)}ms)"
+      action = color(action, GREEN, true)
+
+      debug("  #{action} #{description}")
     end
   end
 end

data/lib/chewy/minitest.rb

@@ -0,0 +1 @@
+require 'chewy/minitest/helpers'

data/lib/chewy/minitest/helpers.rb

@@ -0,0 +1,77 @@
+require_relative 'search_index_receiver'
+
+module Chewy
+  module Minitest
+    module Helpers
+      extend ActiveSupport::Concern
+
+      # Assert that an index *changes* during a block.
+      # @param (Chewy::Type) index the index / type to watch, eg EntitiesIndex::Entity.
+      # @param (Symbol) strategy the Chewy strategy to use around the block. See Chewy docs.
+      # @param (boolean) assert the index changes
+      # @param (boolean) bypass_actual_index
+      #   True to preempt the http call to Elastic, false otherwise.
+      #   Should be set to true unless actually testing search functionality.
+      #
+      # @return (SearchIndexReceiver) for optional further assertions on the nature of the index changes.
+      def assert_indexes(index, strategy: :atomic, bypass_actual_index: true)
+        type = Chewy.derive_type index
+        receiver = SearchIndexReceiver.new
+
+        bulk_method = type.method :bulk
+        # Manually mocking #bulk because we need to properly capture `self`
+        bulk_mock = lambda do |*bulk_args|
+          receiver.catch bulk_args, self
+
+          bulk_method.call(*bulk_args) unless bypass_actual_index
+
+          {}
+        end
+
+        type.define_singleton_method :bulk, bulk_mock
+
+        Chewy.strategy(strategy) do
+          yield
+        end
+
+        type.define_singleton_method :bulk, bulk_method
+
+        assert_includes receiver.updated_indexes, index, "Expected #{index} to be updated but it wasn't"
+
+        receiver
+      end
+
+      # Run indexing for the database changes during the block provided.
+      # By default, indexing is run at the end of the block.
+      # @param (Symbol) strategy the Chewy index update strategy see Chewy docs.
+      def run_indexing(strategy: :atomic)
+        Chewy.strategy strategy do
+          yield
+        end
+      end
+
+      module ClassMethods
+        # Declare that all tests in this file require real indexing, always.
+        # In my completely unscientific experiments, this roughly doubled test runtime.
+        # Use with trepidation.
+        def index_everything!
+          setup do
+            Chewy.strategy :urgent
+          end
+
+          teardown do
+            Chewy.strategy.pop
+          end
+        end
+      end
+
+      included do
+        teardown do
+          # always destroy indexes between tests
+          # Prevent croll pollution of test cases due to indexing
+          Chewy.massacre
+        end
+      end
+    end
+  end
+end

data/lib/chewy/minitest/search_index_receiver.rb

@@ -0,0 +1,80 @@
+# Test helper class to provide minitest hooks for Chewy::Index testing.
+#
+# @note Intended to be used in conjunction with a test helper which mocks over the #bulk
+#   method on a Chewy::Type class. (See SearchTestHelper)
+#
+# The class will capture the data from the *param on the Chewy::Type#bulk method and
+# aggregate the data for test analysis.
+class SearchIndexReceiver
+  def initialize
+    @mutations = {}
+  end
+
+  # @param bulk_params the bulk_params that should be sent to the Chewy::Type#bulk method.
+  # @param (Chewy::Type) type the Index::Type executing this query.
+  def catch(bulk_params, type)
+    Array.wrap(bulk_params).map { |y| y[:body] }.flatten.each do |update|
+      if update[:delete]
+        mutation_for(type).deletes << update[:delete][:_id]
+      elsif update[:index]
+        mutation_for(type).indexes << update[:index]
+      end
+    end
+  end
+
+  # @param index return only index requests to the specified Chewy::Type index.
+  # @return the index changes captured by the mock.
+  def indexes_for(index = nil)
+    if index
+      mutation_for(index).indexes
+    else
+      Hash[
+        @mutations.map { |a, b| [a, b.indexes] }
+      ]
+    end
+  end
+  alias_method :indexes, :indexes_for
+
+  # @param index return only delete requests to the specified Chewy::Type index.
+  # @return the index deletes captured by the mock.
+  def deletes_for(index = nil)
+    if index
+      mutation_for(index).deletes
+    else
+      Hash[
+        @mutations.map { |a, b| [a, b.deletes] }
+      ]
+    end
+  end
+  alias_method :deletes, :deletes_for
+
+  # Check to see if a given object has been indexed.
+  # @param (#id) obj the object to look for.
+  # @param Chewy::Type what type the object should be indexed as.
+  # @return bool if the object was indexed.
+  def indexed?(obj, type)
+    indexes_for(type).map { |i| i[:_id] }.include? obj.id
+  end
+
+  # Check to see if a given object has been deleted.
+  # @param (#id) obj the object to look for.
+  # @param Chewy::Type what type the object should have been deleted from.
+  # @return bool if the object was deleted.
+  def deleted?(obj, type)
+    deletes_for(type).include? obj.id
+  end
+
+  # @return a list of Chewy::Type indexes changed.
+  def updated_indexes
+    @mutations.keys
+  end
+
+private
+
+  # Get the mutation object for a given type.
+  # @param (Chewy::Type) type the index type to fetch.
+  # @return (#indexes, #deletes) an object with a list of indexes and a list of deletes.
+  def mutation_for(type)
+    @mutations[type] ||= OpenStruct.new(indexes: [], deletes: [])
+  end
+end

data/lib/chewy/query.rb

@@ -23,7 +23,7 @@ module Chewy
 
     attr_reader :_indexes, :_types, :options, :criteria
 
-    def initialize *indexes_or_types_and_options
+    def initialize(*indexes_or_types_and_options)
       @options = indexes_or_types_and_options.extract_options!
       @_types = indexes_or_types_and_options.select { |klass| klass < Chewy::Type }
       @_indexes = indexes_or_types_and_options.select { |klass| klass < Chewy::Index }
@@ -39,12 +39,8 @@ module Chewy
     #   UsersIndex.filter(term: {name: 'Johny'}) == UsersIndex.filter(term: {name: 'Johny'}).to_a # => true
     #   UsersIndex.filter(term: {name: 'Johny'}) == UsersIndex.filter(term: {name: 'Winnie'}) # => false
     #
-    def == other
-      super || if other.is_a?(self.class)
-        other.criteria == criteria
-      else
-        to_a == other
-      end
+    def ==(other)
+      super || other.is_a?(self.class) ? other.criteria == criteria : other == to_a
     end
 
     # Adds <tt>explain</tt> parameter to search request.
@@ -59,7 +55,7 @@ module Chewy
     #
     #   UsersIndex::User.filter(term: {name: 'Johny'}).explain.first._explanation # => {...}
     #
-    def explain value = nil
+    def explain(value = nil)
       chain { criteria.update_request_options explain: (value.nil? ? true : value) }
     end
 
@@ -73,7 +69,7 @@ module Chewy
     #      script: "doc['coordinates'].distanceInMiles(lat, lon)"
     #    }
     #  )
-    def script_fields value
+    def script_fields(value)
       chain { criteria.update_script_fields(value) }
     end
 
@@ -143,7 +139,7 @@ module Chewy
     #   Chewy.query_mode = :dis_max
     #   Chewy.query_mode = '50%'
     #
-    def query_mode value
+    def query_mode(value)
       chain { criteria.update_options query_mode: value }
     end
 
@@ -215,7 +211,7 @@ module Chewy
     #   Chewy.filter_mode = :should
     #   Chewy.filter_mode = '50%'
     #
-    def filter_mode value
+    def filter_mode(value)
       chain { criteria.update_options filter_mode: value }
     end
 
@@ -227,7 +223,7 @@ module Chewy
     #   UsersIndex.post_filter{ name == 'Johny' }.post_filter{ age <= 42 }.post_filter_mode(:should)
     #   UsersIndex.post_filter{ name == 'Johny' }.post_filter{ age <= 42 }.post_filter_mode('50%')
     #
-    def post_filter_mode value
+    def post_filter_mode(value)
       chain { criteria.update_options post_filter_mode: value }
     end
 
@@ -276,7 +272,7 @@ module Chewy
     # Use the timeout because it is important to your SLA, not because you want
     # to abort the execution of long running queries.
     #
-    def timeout value
+    def timeout(value)
       chain { criteria.update_request_options timeout: value }
     end
 
@@ -289,8 +285,8 @@ module Chewy
     #            size: 100
     #          }}
     #
-    def limit value
-      chain { criteria.update_request_options size: Integer(value) }
+    def limit(value = nil, &block)
+      chain { criteria.update_request_options size: block || Integer(value) }
     end
 
     # Sets elasticsearch <tt>from</tt> search request param
@@ -301,15 +297,15 @@ module Chewy
     #            from: 300
     #          }}
     #
-    def offset value
-      chain { criteria.update_request_options from: Integer(value) }
+    def offset(value = nil, &block)
+      chain { criteria.update_request_options from: block || Integer(value) }
     end
 
     # Elasticsearch highlight query option support
     #
     #   UsersIndex.query(...).highlight(fields: { ... })
     #
-    def highlight value
+    def highlight(value)
       chain { criteria.update_request_options highlight: value }
     end
 
@@ -317,7 +313,7 @@ module Chewy
     #
     #   UsersIndex.query(...).rescore(query: { ... })
     #
-    def rescore value
+    def rescore(value)
       chain { criteria.update_request_options rescore: value }
     end
 
@@ -325,10 +321,18 @@ module Chewy
     #
     # UsersIndex.query(...).min_score(0.5)
     #
-    def min_score value
+    def min_score(value)
       chain { criteria.update_request_options min_score: value }
     end
 
+    # Elasticsearch track_scores option support
+    #
+    # UsersIndex.query(...).track_scores(true)
+    #
+    def track_scores(value)
+      chain { criteria.update_request_options track_scores: value }
+    end
+
     # Adds facets section to the search request.
     # All the chained facets a merged and added to the
     # search request
@@ -342,7 +346,7 @@ module Chewy
     # If called parameterless - returns result facets from ES performing request.
     # Returns empty hash if no facets was requested or resulted.
     #
-    def facets params = nil
+    def facets(params = nil)
       raise RemovedFeature, 'removed in elasticsearch 2.0' if Runtime.version >= '2.0'
       if params
         chain { criteria.update_facets params }
@@ -395,6 +399,28 @@ module Chewy
       chain { criteria.update_scores scoring }
     end
 
+    # Add a weight scoring function to the search. All scores are
+    # added to the search request and combinded according to
+    # <tt>boost_mode</tt> and <tt>score_mode</tt>
+    #
+    # This probably only makes sense if you specify a filter
+    # for the weight as well.
+    #
+    #   UsersIndex.weight(23, filter: { term: { foo: :bar} })
+    #       # => {body:
+    #              query: {
+    #                function_score: {
+    #                  query: { ...},
+    #                  functions: [{
+    #                    weight: 23,
+    #                    filter: { term: { foo: :bar } }
+    #                  }]
+    #                } } }
+    def weight(factor, options = {})
+      scoring = options.merge(weight: factor.to_i)
+      chain { criteria.update_scores scoring }
+    end
+
     # Adds a random score to the search request. All scores are
     # added to the search request and combinded according to
     # <tt>boost_mode</tt> and <tt>score_mode</tt>
@@ -484,11 +510,20 @@ module Chewy
     def decay(function, field, options = {})
       field_options = options.extract!(:origin, :scale, :offset, :decay).delete_if { |_, v| v.nil? }
       scoring = options.merge(function => {
-        field => field_options
-      })
+                                field => field_options
+                              })
       chain { criteria.update_scores scoring }
     end
 
+    # Sets <tt>preference</tt> for request.
+    # For instance, one can use <tt>preference=_primary</tt> to execute only on the primary shards.
+    #
+    #   scope = UsersIndex.preference(:_primary)
+    #
+    def preference(value)
+      chain { criteria.update_search_options preference: value }
+    end
+
     # Sets elasticsearch <tt>aggregations</tt> search request param
     #
     #  UsersIndex.filter{ name == 'Johny' }.aggregations(category_id: {terms: {field: 'category_ids'}})
@@ -501,7 +536,7 @@ module Chewy
     #            }
     #          }}
     #
-    def aggregations params = nil
+    def aggregations(params = nil)
       @_named_aggs ||= _build_named_aggs
       @_fully_qualified_named_aggs ||= _build_fqn_aggs
       if params
@@ -512,7 +547,7 @@ module Chewy
         _response['aggregations'] || {}
       end
     end
-    alias :aggs :aggregations
+    alias_method :aggs, :aggregations
 
     # In this simplest of implementations each named aggregation must be uniquely named
     def _build_named_aggs
@@ -562,7 +597,7 @@ module Chewy
     #            }
     #          }}
     #
-    def suggest params = nil
+    def suggest(params = nil)
       if params
         chain { criteria.update_suggest params }
       else
@@ -595,7 +630,7 @@ module Chewy
     #            } }
     #          }}
     #
-    def strategy value = nil
+    def strategy(value = nil)
       chain { criteria.update_options strategy: value }
     end
 
@@ -621,7 +656,7 @@ module Chewy
     #            query: {text: {name: 'Johny'}}
     #          }}
     #
-    def query params
+    def query(params)
       chain { criteria.update_queries params }
     end
 
@@ -653,7 +688,7 @@ module Chewy
     #            filter: {term: {name: 'Johny'}}
     #          }}}}
     #
-    def filter params = nil, &block
+    def filter(params = nil, &block)
       params = Filters.new(&block).__render__ if block
       chain { criteria.update_filters params }
     end
@@ -684,7 +719,7 @@ module Chewy
     #            post_filter: {term: {name: 'Johny'}}
     #          }}
     #
-    def post_filter params = nil, &block
+    def post_filter(params = nil, &block)
       params = Filters.new(&block).__render__ if block
       chain { criteria.update_post_filters params }
     end
@@ -722,7 +757,7 @@ module Chewy
     #
     # Default value for <tt>:boost_mode</tt> might be changed
     # with <tt>Chewy.score_mode</tt> config option.
-    def boost_mode value
+    def boost_mode(value)
       chain { criteria.update_options boost_mode: value }
     end
 
@@ -762,7 +797,7 @@ module Chewy
     #
     #   Chewy.score_mode = :first
     #
-    def score_mode value
+    def score_mode(value)
       chain { criteria.update_options score_mode: value }
     end
 
@@ -774,7 +809,7 @@ module Chewy
     #            sort: ['first_name', 'last_name', {age: 'desc'}, {price: {order: 'asc', mode: 'avg'}}]
     #          }}
     #
-    def order *params
+    def order(*params)
       chain { criteria.update_sort params }
     end
 
@@ -786,7 +821,7 @@ module Chewy
     #            sort: [{price: {order: 'asc', mode: 'avg'}}]
     #          }}
     #
-    def reorder *params
+    def reorder(*params)
       chain { criteria.update_sort params, purge: true }
     end
 
@@ -798,7 +833,7 @@ module Chewy
     #            fields: ['first_name', 'last_name', 'age']
     #          }}
     #
-    def only *params
+    def only(*params)
       chain { criteria.update_fields params }
     end
 
@@ -810,7 +845,7 @@ module Chewy
     #            fields: ['age']
     #          }}
     #
-    def only! *params
+    def only!(*params)
       chain { criteria.update_fields params, purge: true }
     end
 
@@ -846,7 +881,7 @@ module Chewy
     #            ]}
     #          }}}}
     #
-    def types *params
+    def types(*params)
       chain { criteria.update_types params }
     end
 
@@ -858,7 +893,7 @@ module Chewy
     #            filter: {type: {value: 'manager'}}
     #          }}}}
     #
-    def types! *params
+    def types!(*params)
       chain { criteria.update_types params, purge: true }
     end
 
@@ -872,8 +907,8 @@ module Chewy
     #   scope = UsersIndex.aggs(max_age: { max: { field: 'age' } }).search_type(:count)
     #   max_age = scope.aggs['max_age']['value']
     #
-    def search_type val
-      chain { options.merge!(search_type: val) }
+    def search_type(value)
+      chain { criteria.update_search_options search_type: value }
     end
 
     # Merges two queries.
@@ -885,7 +920,7 @@ module Chewy
     #
     #   scope1.merge(scope2) == scope3 # => true
     #
-    def merge other
+    def merge(other)
       chain { criteria.merge!(other.criteria) }
     end
 
@@ -898,15 +933,15 @@ module Chewy
     #
     def delete_all
       if Runtime.version > '2.0'
-        plugins = Chewy.client.nodes.info(plugins: true)["nodes"].values.map { |item| item["plugins"] }.flatten
-        raise PluginMissing, "install delete-by-query plugin" unless plugins.find { |item| item["name"] == 'delete-by-query' }
+        plugins = Chewy.client.nodes.info(plugins: true)['nodes'].values.map { |item| item['plugins'] }.flatten
+        raise PluginMissing, 'install delete-by-query plugin' unless plugins.find { |item| item['name'] == 'delete-by-query' }
       end
       request = chain { criteria.update_options simple: true }.send(:_request)
       ActiveSupport::Notifications.instrument 'delete_query.chewy',
         request: request, indexes: _indexes, types: _types,
         index: _indexes.one? ? _indexes.first : _indexes,
         type: _types.one? ? _types.first : _types do
-          Chewy.client.delete_by_query(request)
+        Chewy.client.delete_by_query(request)
       end
     end
 
@@ -924,13 +959,31 @@ module Chewy
     #    UsersIndex::User.find([8, 13])  # array of objects with ids in [8, 13]
     #    UsersIndex::User.find([42])     # array of the object with id == 42
     #
-    def find *ids
+    def find(*ids)
       results = chain { criteria.update_options simple: true }.filter { _id == ids.flatten }.to_a
 
-      raise Chewy::DocumentNotFound.new("Could not find documents for ids #{ids.flatten}") if results.empty?
+      raise Chewy::DocumentNotFound, "Could not find documents for ids #{ids.flatten}" if results.empty?
       ids.one? && !ids.first.is_a?(Array) ? results.first : results
     end
 
+    # Returns true if there are at least one document that matches the query
+    #
+    #   PlacesIndex.query(...).filter(...).exists?
+    #
+    def exists?
+      search_type(:count).total > 0
+    end
+
+    # Sets limit to be equal to total documents count
+    #
+    #  PlacesIndex.query(...).filter(...).unlimited
+    #
+
+    def unlimited
+      count_query = search_type(:count)
+      offset(0).limit { count_query.total }
+    end
+
     # Returns request total time elapsed as reported by elasticsearch
     #
     #   UsersIndex.query(...).filter(...).took
@@ -955,14 +1008,14 @@ module Chewy
 
   protected
 
-    def initialize_clone other
+    def initialize_clone(other)
       @criteria = other.criteria.clone
       reset
     end
 
   private
 
-    def chain &block
+    def chain(&block)
       clone.tap { |q| q.instance_exec(&block) }
     end
 
@@ -973,8 +1026,8 @@ module Chewy
     def _request
       @_request ||= begin
         request = criteria.request_body
-        request.merge!(index: _indexes.map(&:index_name), type: _types.map(&:type_name))
-        request.merge!(search_type: options[:search_type]) if options[:search_type]
+        request[:index] = _indexes.map(&:index_name)
+        request[:type] = _types.map(&:type_name)
         request
       end
     end
@@ -984,12 +1037,12 @@ module Chewy
         request: _request, indexes: _indexes, types: _types,
         index: _indexes.one? ? _indexes.first : _indexes,
         type: _types.one? ? _types.first : _types do
-          begin
-            Chewy.client.search(_request)
-          rescue Elasticsearch::Transport::Transport::Errors::NotFound => e
-            raise e if e.message !~ /IndexMissingException/ && e.message !~ /index_not_found_exception/
-            {}
-          end
+        begin
+          Chewy.client.search(_request)
+        rescue Elasticsearch::Transport::Transport::Errors::NotFound => e
+          raise e if e.message !~ /IndexMissingException/ && e.message !~ /index_not_found_exception/
+          {}
+        end
       end
     end
 
@@ -1000,7 +1053,7 @@ module Chewy
           .merge!(_score: hit['_score'])
           .merge!(_explanation: hit['_explanation'])
 
-        wrapper = _derive_index(hit['_index']).type_hash[hit['_type']].new attributes
+        wrapper = _derive_index(hit['_index']).type(hit['_type']).new(attributes)
         wrapper._data = hit
         wrapper
       end
@@ -1009,12 +1062,15 @@ module Chewy
     def _collection
       @_collection ||= begin
         _load_objects! if criteria.options[:preload]
-        criteria.options[:preload] && criteria.options[:loaded_objects] ?
-          _results.map(&:_object) : _results
+        if criteria.options[:preload] && criteria.options[:loaded_objects]
+          _results.map(&:_object)
+        else
+          _results
+        end
       end
     end
 
-    def _derive_index index_name
+    def _derive_index(index_name)
       (@derive_index ||= {})[index_name] ||= _indexes_hash[index_name] ||
         _indexes_hash[_indexes_hash.keys.sort_by(&:length).reverse.detect { |name| index_name.start_with?(name) }]
     end