chewy 0.8.4 → 5.1.0

data/lib/chewy/query.rb

@@ -1,6 +1,5 @@
 require 'chewy/query/criteria'
 require 'chewy/query/filters'
-require 'chewy/query/scoping'
 require 'chewy/query/loading'
 require 'chewy/query/pagination'
 
@@ -9,21 +8,31 @@ module Chewy
   # chainable DSL. Queries are lazy evaluated and might be merged.
   # The same DSL is used for whole index or individual types query build.
   #
+  # @example
   #   UsersIndex.filter{ age < 42 }.query(text: {name: 'Alex'}).limit(20)
   #   UsersIndex::User.filter{ age < 42 }.query(text: {name: 'Alex'}).limit(20)
   #
   class Query
     include Enumerable
-    include Scoping
     include Loading
     include Pagination
+    include Chewy::Search::Scoping
+
+    DELEGATED_METHODS = %i[
+      explain query_mode filter_mode post_filter_mode
+      timeout limit offset highlight min_score rescore facets script_score
+      boost_factor weight random_score field_value_factor decay aggregations
+      suggest none strategy query filter post_filter boost_mode
+      score_mode order reorder only types delete_all find total
+      total_count total_entries unlimited script_fields track_scores preference
+    ].to_set.freeze
 
     delegate :each, :count, :size, to: :_collection
     alias_method :to_ary, :to_a
 
     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 }
@@ -31,39 +40,45 @@ module Chewy
       @criteria = Criteria.new
     end
 
+    # A compatibility layer with the new request DSL.
+    def render
+      _request
+    end
+
     # Comparation with other query or collection
     # If other is collection - search request is executed and
     # result is used for comparation
     #
+    # @example
     #   UsersIndex.filter(term: {name: 'Johny'}) == UsersIndex.filter(term: {name: 'Johny'}) # => true
     #   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.
+    # Adds `explain` parameter to search request.
     #
+    # @example
     #   UsersIndex.filter(term: {name: 'Johny'}).explain
     #   UsersIndex.filter(term: {name: 'Johny'}).explain(true)
     #   UsersIndex.filter(term: {name: 'Johny'}).explain(false)
     #
     # Calling explain without any arguments sets explanation flag to true.
-    # With <tt>explain: true</tt>, every result object has <tt>_explanation</tt>
+    # With `explain: true`, every result object has `_explanation`
     # method
     #
+    # @example
     #   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
 
-    # Adds <tt>script_fields</tt> parameter to search request.
+    # Adds `script_fields` parameter to search request.
+    #
+    # @example
     #  UsersIndex.script_fields(
     #    distance: {
     #      params: {
@@ -73,7 +88,7 @@ module Chewy
     #      script: "doc['coordinates'].distanceInMiles(lat, lon)"
     #    }
     #  )
-    def script_fields value
+    def script_fields(value)
       chain { criteria.update_script_fields(value) }
     end
 
@@ -81,31 +96,28 @@ module Chewy
     # Not used if only one filter for search is specified.
     # Possible values:
     #
-    # * <tt>:must</tt>
-    #   Default value. Query compiles into a bool <tt>must</tt> query.
-    #
-    #   Ex:
+    # * `:must`
+    #   Default value. Query compiles into a bool `must` query.
     #
+    # @example
     #     UsersIndex.query(text: {name: 'Johny'}).query(range: {age: {lte: 42}})
     #       # => {body: {
     #              query: {bool: {must: [{text: {name: 'Johny'}}, {range: {age: {lte: 42}}}]}}
     #            }}
     #
-    # * <tt>:should</tt>
-    #   Query compiles into a bool <tt>should</tt> query.
-    #
-    #   Ex:
+    # * `:should`
+    #   Query compiles into a bool `should` query.
     #
+    # @example
     #     UsersIndex.query(text: {name: 'Johny'}).query(range: {age: {lte: 42}}).query_mode(:should)
     #       # => {body: {
     #              query: {bool: {should: [{text: {name: 'Johny'}}, {range: {age: {lte: 42}}}]}}
     #            }}
     #
-    # * Any acceptable <tt>minimum_should_match</tt> value (1, '2', '75%')
-    #   Query compiles into a bool <tt>should</tt> query with <tt>minimum_should_match</tt> set.
-    #
-    #   Ex:
+    # * Any acceptable `minimum_should_match` value (1, '2', '75%')
+    #   Query compiles into a bool `should` query with `minimum_should_match` set.
     #
+    # @example
     #     UsersIndex.query(text: {name: 'Johny'}).query(range: {age: {lte: 42}}).query_mode('50%')
     #       # => {body: {
     #              query: {bool: {
@@ -114,21 +126,19 @@ module Chewy
     #              }}
     #            }}
     #
-    # * <tt>:dis_max</tt>
-    #   Query compiles into a <tt>dis_max</tt> query.
-    #
-    #   Ex:
+    # * `:dis_max`
+    #   Query compiles into a `dis_max` query.
     #
+    # @example
     #     UsersIndex.query(text: {name: 'Johny'}).query(range: {age: {lte: 42}}).query_mode(:dis_max)
     #       # => {body: {
     #              query: {dis_max: {queries: [{text: {name: 'Johny'}}, {range: {age: {lte: 42}}}]}}
     #            }}
     #
     # * Any Float value (0.0, 0.7, 1.0)
-    #   Query compiles into a <tt>dis_max</tt> query with <tt>tie_breaker</tt> option set.
-    #
-    #   Ex:
+    #   Query compiles into a `dis_max` query with `tie_breaker` option set.
     #
+    # @example
     #     UsersIndex.query(text: {name: 'Johny'}).query(range: {age: {lte: 42}}).query_mode(0.7)
     #       # => {body: {
     #              query: {dis_max: {
@@ -137,13 +147,14 @@ module Chewy
     #              }}
     #            }}
     #
-    # Default value for <tt>:query_mode</tt> might be changed
-    # with <tt>Chewy.query_mode</tt> config option.
+    # Default value for `:query_mode` might be changed
+    # with `Chewy.query_mode` config option.
     #
+    # @example
     #   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
 
@@ -151,55 +162,50 @@ module Chewy
     # Not used if only one filter for search is specified.
     # Possible values:
     #
-    # * <tt>:and</tt>
-    #   Default value. Filter compiles into an <tt>and</tt> filter.
-    #
-    #   Ex:
+    # * `:and`
+    #   Default value. Filter compiles into an `and` filter.
     #
+    # @example
     #     UsersIndex.filter{ name == 'Johny' }.filter{ age <= 42 }
     #       # => {body: {query: {filtered: {
     #              query: {...},
     #              filter: {and: [{term: {name: 'Johny'}}, {range: {age: {lte: 42}}}]}
     #            }}}}
     #
-    # * <tt>:or</tt>
-    #   Filter compiles into an <tt>or</tt> filter.
-    #
-    #   Ex:
+    # * `:or`
+    #   Filter compiles into an `or` filter.
     #
+    # @example
     #     UsersIndex.filter{ name == 'Johny' }.filter{ age <= 42 }.filter_mode(:or)
     #       # => {body: {query: {filtered: {
     #              query: {...},
     #              filter: {or: [{term: {name: 'Johny'}}, {range: {age: {lte: 42}}}]}
     #            }}}}
     #
-    # * <tt>:must</tt>
-    #   Filter compiles into a bool <tt>must</tt> filter.
-    #
-    #   Ex:
+    # * `:must`
+    #   Filter compiles into a bool `must` filter.
     #
+    # @example
     #     UsersIndex.filter{ name == 'Johny' }.filter{ age <= 42 }.filter_mode(:must)
     #       # => {body: {query: {filtered: {
     #              query: {...},
     #              filter: {bool: {must: [{term: {name: 'Johny'}}, {range: {age: {lte: 42}}}]}}
     #            }}}}
     #
-    # * <tt>:should</tt>
-    #   Filter compiles into a bool <tt>should</tt> filter.
-    #
-    #   Ex:
+    # * `:should`
+    #   Filter compiles into a bool `should` filter.
     #
+    # @example
     #     UsersIndex.filter{ name == 'Johny' }.filter{ age <= 42 }.filter_mode(:should)
     #       # => {body: {query: {filtered: {
     #              query: {...},
     #              filter: {bool: {should: [{term: {name: 'Johny'}}, {range: {age: {lte: 42}}}]}}
     #            }}}}
     #
-    # * Any acceptable <tt>minimum_should_match</tt> value (1, '2', '75%')
-    #   Filter compiles into bool <tt>should</tt> filter with <tt>minimum_should_match</tt> set.
-    #
-    #   Ex:
+    # * Any acceptable `minimum_should_match` value (1, '2', '75%')
+    #   Filter compiles into bool `should` filter with `minimum_should_match` set.
     #
+    # @example
     #     UsersIndex.filter{ name == 'Johny' }.filter{ age <= 42 }.filter_mode('50%')
     #       # => {body: {query: {filtered: {
     #              query: {...},
@@ -209,13 +215,14 @@ module Chewy
     #              }}
     #            }}}}
     #
-    # Default value for <tt>:filter_mode</tt> might be changed
-    # with <tt>Chewy.filter_mode</tt> config option.
+    # Default value for `:filter_mode` might be changed
+    # with `Chewy.filter_mode` config option.
     #
+    # @example
     #   Chewy.filter_mode = :should
     #   Chewy.filter_mode = '50%'
     #
-    def filter_mode value
+    def filter_mode(value)
       chain { criteria.update_options filter_mode: value }
     end
 
@@ -223,11 +230,12 @@ module Chewy
     # Note that it fallbacks by default to `Chewy.filter_mode` if
     # `Chewy.post_filter_mode` is nil.
     #
+    # @example
     #   UsersIndex.post_filter{ name == 'Johny' }.post_filter{ age <= 42 }.post_filter_mode(:and)
     #   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
 
@@ -246,6 +254,7 @@ module Chewy
     # The response to a search request will indicate whether the search timed
     # out and how many shards responded successfully:
     #
+    # @example
     #   ...
     #   "timed_out":     true,
     #   "_shards": {
@@ -263,6 +272,7 @@ module Chewy
     # responding with an error. The timeout parameter can be used to explicitly
     # specify how long it waits.
     #
+    # @example
     #   UsersIndex.timeout("5000ms")
     #
     # Timeout is not a circuit breaker.
@@ -276,63 +286,78 @@ 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
 
-    # Sets elasticsearch <tt>size</tt> search request param
+    # Sets elasticsearch `size` search request param
     # Default value is set in the elasticsearch and is 10.
     #
+    # @example
     #  UsersIndex.filter{ name == 'Johny' }.limit(100)
     #     # => {body: {
     #            query: {...},
     #            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
+    # Sets elasticsearch `from` search request param
     #
+    # @example
     #  UsersIndex.filter{ name == 'Johny' }.offset(300)
     #     # => {body: {
     #            query: {...},
     #            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
     #
+    # @example
     #   UsersIndex.query(...).highlight(fields: { ... })
     #
-    def highlight value
+    def highlight(value)
       chain { criteria.update_request_options highlight: value }
     end
 
     # Elasticsearch rescore query option support
     #
+    # @example
     #   UsersIndex.query(...).rescore(query: { ... })
     #
-    def rescore value
+    def rescore(value)
       chain { criteria.update_request_options rescore: value }
     end
 
     # Elasticsearch minscore option support
     #
-    # UsersIndex.query(...).min_score(0.5)
+    # @example
+    #   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
+    #
+    # @example
+    #   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
     #
+    # @example
     #   UsersIndex.facets(tags: {terms: {field: 'tags'}}).facets(ages: {terms: {field: 'age'}})
     #     # => {body: {
     #            query: {...},
@@ -342,7 +367,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 }
@@ -353,8 +378,9 @@ module Chewy
 
     # Adds a script function to score the search request. All scores are
     # added to the search request and combinded according to
-    # <tt>boost_mode</tt> and <tt>score_mode</tt>
+    # `boost_mode` and `score_mode`
     #
+    # @example
     #   UsersIndex.script_score("doc['boost'].value", params: { modifier: 2 })
     #       # => {body:
     #              query: {
@@ -369,17 +395,18 @@ module Chewy
     #                  }]
     #                } } }
     def script_score(script, options = {})
-      scoring = { script_score: { script: script }.merge(options) }
+      scoring = {script_score: {script: script}.merge(options)}
       chain { criteria.update_scores scoring }
     end
 
     # Adds a boost factor 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>
+    # `boost_mode` and `score_mode`
     #
     # This probably only makes sense if you specify a filter
     # for the boost factor as well
     #
+    # @example
     #   UsersIndex.boost_factor(23, filter: { term: { foo: :bar} })
     #       # => {body:
     #              query: {
@@ -395,15 +422,39 @@ 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
+    # `boost_mode` and `score_mode`
+    #
+    # This probably only makes sense if you specify a filter
+    # for the weight as well.
+    #
+    # @example
+    #   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>
+    # `boost_mode` and `score_mode`
     #
     # This probably only makes sense if you specify a filter
     # for the random score as well.
     #
     # If you do not pass in a seed value, Time.now will be used
     #
+    # @example
     #   UsersIndex.random_score(23, filter: { foo: :bar})
     #       # => {body:
     #              query: {
@@ -415,17 +466,18 @@ module Chewy
     #                  }]
     #                } } }
     def random_score(seed = Time.now, options = {})
-      scoring = options.merge(random_score: { seed: seed.to_i })
+      scoring = options.merge(random_score: {seed: seed.to_i})
       chain { criteria.update_scores scoring }
     end
 
     # Add a field value scoring to the search. All scores are
     # added to the search request and combinded according to
-    # <tt>boost_mode</tt> and <tt>score_mode</tt>
+    # `boost_mode` and `score_mode`
     #
     # This function is only available in Elasticsearch 1.2 and
     # greater
     #
+    # @example
     #   UsersIndex.field_value_factor(
     #                {
     #                  field: :boost,
@@ -452,11 +504,12 @@ module Chewy
 
     # Add a decay scoring to the search. All scores are
     # added to the search request and combinded according to
-    # <tt>boost_mode</tt> and <tt>score_mode</tt>
+    # `boost_mode` and `score_mode`
     #
     # The parameters have default values, but those may not
     # be very useful for most applications.
     #
+    # @example
     #   UsersIndex.decay(
     #                :gauss,
     #                :field,
@@ -489,8 +542,19 @@ module Chewy
       chain { criteria.update_scores scoring }
     end
 
-    # Sets elasticsearch <tt>aggregations</tt> search request param
+    # Sets `preference` for request.
+    # For instance, one can use `preference=_primary` to execute only on the primary shards.
+    #
+    # @example
+    #   scope = UsersIndex.preference(:_primary)
     #
+    def preference(value)
+      chain { criteria.update_search_options preference: value }
+    end
+
+    # Sets elasticsearch `aggregations` search request param
+    #
+    # @example
     #  UsersIndex.filter{ name == 'Johny' }.aggregations(category_id: {terms: {field: 'category_ids'}})
     #     # => {body: {
     #            query: {...},
@@ -501,18 +565,18 @@ module Chewy
     #            }
     #          }}
     #
-    def aggregations params = nil
+    def aggregations(params = nil)
       @_named_aggs ||= _build_named_aggs
       @_fully_qualified_named_aggs ||= _build_fqn_aggs
       if params
-        params = { params => @_named_aggs[params] } if params.is_a?(Symbol)
-        params = { params => _get_fully_qualified_named_agg(params) } if params.is_a?(String) && params =~ /\A\S+#\S+\.\S+\z/
+        params = {params => @_named_aggs[params]} if params.is_a?(Symbol)
+        params = {params => _get_fully_qualified_named_agg(params)} if params.is_a?(String) && params =~ /\A\S+#\S+\.\S+\z/
         chain { criteria.update_aggregations params }
       else
         _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
@@ -549,8 +613,9 @@ module Chewy
       @_fully_qualified_named_aggs[idx][type][agg_name]
     end
 
-    # Sets elasticsearch <tt>suggest</tt> search request param
+    # Sets elasticsearch `suggest` search request param
     #
+    # @example
     #  UsersIndex.suggest(name: {text: 'Joh', term: {field: 'name'}})
     #     # => {body: {
     #            query: {...},
@@ -562,7 +627,7 @@ module Chewy
     #            }
     #          }}
     #
-    def suggest params = nil
+    def suggest(params = nil)
       if params
         chain { criteria.update_suggest params }
       else
@@ -570,10 +635,11 @@ module Chewy
       end
     end
 
-    # Marks the criteria as having zero records. This scope  always returns empty array
+    # Marks the criteria as having zero documents. This scope  always returns empty array
     # without touching the elasticsearch server.
     # All the chained calls of methods don't affect the result
     #
+    # @example
     #   UsersIndex.none.to_a
     #     # => []
     #   UsersIndex.query(text: {name: 'Johny'}).none.to_a
@@ -587,6 +653,7 @@ module Chewy
 
     # Setups strategy for top-level filtered query
     #
+    # @example
     #    UsersIndex.filter { name == 'Johny'}.strategy(:leap_frog)
     #     # => {body: {
     #            query: { filtered: {
@@ -595,18 +662,19 @@ module Chewy
     #            } }
     #          }}
     #
-    def strategy value = nil
+    def strategy(value = nil)
       chain { criteria.update_options strategy: value }
     end
 
     # Adds one or more query to the search request
     # Internally queries are stored as an array
     # While the full query compilation this array compiles
-    # according to <tt>:query_mode</tt> option value
+    # according to `:query_mode` option value
     #
-    # By default it joines inside <tt>must</tt> query
-    # See <tt>#query_mode</tt> chainable method for more info.
+    # By default it joines inside `must` query
+    # See `#query_mode` chainable method for more info.
     #
+    # @example
     #   UsersIndex.query(text: {name: 'Johny'}).query(range: {age: {lte: 42}})
     #   UsersIndex::User.query(text: {name: 'Johny'}).query(range: {age: {lte: 42}})
     #     # => {body: {
@@ -616,26 +684,28 @@ module Chewy
     # If only one query was specified, it will become a result
     # query as is, without joining.
     #
+    # @example
     #   UsersIndex.query(text: {name: 'Johny'})
     #     # => {body: {
     #            query: {text: {name: 'Johny'}}
     #          }}
     #
-    def query params
+    def query(params)
       chain { criteria.update_queries params }
     end
 
     # Adds one or more filter to the search request
     # Internally filters are stored as an array
     # While the full query compilation this array compiles
-    # according to <tt>:filter_mode</tt> option value
+    # according to `:filter_mode` option value
     #
-    # By default it joins inside <tt>and</tt> filter
-    # See <tt>#filter_mode</tt> chainable method for more info.
+    # By default it joins inside `and` filter
+    # See `#filter_mode` chainable method for more info.
     #
     # Also this method supports block DSL.
-    # See <tt>Chewy::Query::Filters</tt> for more info.
+    # See `Chewy::Query::Filters` for more info.
     #
+    # @example
     #   UsersIndex.filter(term: {name: 'Johny'}).filter(range: {age: {lte: 42}})
     #   UsersIndex::User.filter(term: {name: 'Johny'}).filter(range: {age: {lte: 42}})
     #   UsersIndex.filter{ name == 'Johny' }.filter{ age <= 42 }
@@ -647,13 +717,14 @@ module Chewy
     # If only one filter was specified, it will become a result
     # filter as is, without joining.
     #
+    # @example
     #   UsersIndex.filter(term: {name: 'Johny'})
     #     # => {body: {query: {filtered: {
     #            query: {...},
     #            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
@@ -661,14 +732,15 @@ module Chewy
     # Adds one or more post_filter to the search request
     # Internally post_filters are stored as an array
     # While the full query compilation this array compiles
-    # according to <tt>:post_filter_mode</tt> option value
+    # according to `:post_filter_mode` option value
     #
-    # By default it joins inside <tt>and</tt> filter
-    # See <tt>#post_filter_mode</tt> chainable method for more info.
+    # By default it joins inside `and` filter
+    # See `#post_filter_mode` chainable method for more info.
     #
     # Also this method supports block DSL.
-    # See <tt>Chewy::Query::Filters</tt> for more info.
+    # See `Chewy::Query::Filters` for more info.
     #
+    # @example
     #   UsersIndex.post_filter(term: {name: 'Johny'}).post_filter(range: {age: {lte: 42}})
     #   UsersIndex::User.post_filter(term: {name: 'Johny'}).post_filter(range: {age: {lte: 42}})
     #   UsersIndex.post_filter{ name == 'Johny' }.post_filter{ age <= 42 }
@@ -679,12 +751,13 @@ module Chewy
     # If only one post_filter was specified, it will become a result
     # post_filter as is, without joining.
     #
+    # @example
     #   UsersIndex.post_filter(term: {name: 'Johny'})
     #     # => {body: {
     #            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
@@ -693,11 +766,10 @@ module Chewy
     # Not used if no score functions are specified
     # Possible values:
     #
-    # * <tt>:multiply</tt>
+    # * `:multiply`
     #   Default value. Query score and function result are multiplied.
     #
-    #   Ex:
-    #
+    # @example
     #     UsersIndex.boost_mode('multiply').script_score('doc['boost'].value')
     #       # => {body: {query: function_score: {
     #         query: {...},
@@ -705,24 +777,24 @@ module Chewy
     #         functions: [ ... ]
     #       }}}
     #
-    # * <tt>:replace</tt>
+    # * `:replace`
     #   Only function result is used, query score is ignored.
     #
-    # * <tt>:sum</tt>
+    # * `:sum`
     #   Query score and function score are added.
     #
-    # * <tt>:avg</tt>
+    # * `:avg`
     #   Average of query and function score.
     #
-    # * <tt>:max</tt>
+    # * `:max`
     #   Max of query and function score.
     #
-    # * <tt>:min</tt>
+    # * `:min`
     #   Min of query and function score.
     #
-    # Default value for <tt>:boost_mode</tt> might be changed
-    # with <tt>Chewy.score_mode</tt> config option.
-    def boost_mode value
+    # Default value for `:boost_mode` might be changed
+    # with `Chewy.score_mode` config option.
+    def boost_mode(value)
       chain { criteria.update_options boost_mode: value }
     end
 
@@ -730,11 +802,10 @@ module Chewy
     # Not used if no score functions are specified.
     # Possible values:
     #
-    # * <tt>:multiply</tt>
+    # * `:multiply`
     #   Default value. Scores are multiplied.
     #
-    #   Ex:
-    #
+    # @example
     #     UsersIndex.score_mode('multiply').script_score('doc['boost'].value')
     #       # => {body: {query: function_score: {
     #         query: {...},
@@ -742,82 +813,88 @@ module Chewy
     #         functions: [ ... ]
     #       }}}
     #
-    # * <tt>:sum</tt>
+    # * `:sum`
     #   Scores are summed.
     #
-    # * <tt>:avg</tt>
+    # * `:avg`
     #   Scores are averaged.
     #
-    # * <tt>:first</tt>
+    # * `:first`
     #   The first function that has a matching filter is applied.
     #
-    # * <tt>:max</tt>
+    # * `:max`
     #   Maximum score is used.
     #
-    # * <tt>:min</tt>
+    # * `:min`
     #   Minimum score is used
     #
-    # Default value for <tt>:score_mode</tt> might be changed
-    # with <tt>Chewy.score_mode</tt> config option.
+    # Default value for `:score_mode` might be changed
+    # with `Chewy.score_mode` config option.
     #
+    # @example
     #   Chewy.score_mode = :first
     #
-    def score_mode value
+    def score_mode(value)
       chain { criteria.update_options score_mode: value }
     end
 
     # Sets search request sorting
     #
+    # @example
     #   UsersIndex.order(:first_name, :last_name).order(age: :desc).order(price: {order: :asc, mode: :avg})
     #     # => {body: {
     #            query: {...},
     #            sort: ['first_name', 'last_name', {age: 'desc'}, {price: {order: 'asc', mode: 'avg'}}]
     #          }}
     #
-    def order *params
+    def order(*params)
       chain { criteria.update_sort params }
     end
 
     # Cleans up previous search sorting and sets the new one
     #
+    # @example
     #   UsersIndex.order(:first_name, :last_name).order(age: :desc).reorder(price: {order: :asc, mode: :avg})
     #     # => {body: {
     #            query: {...},
     #            sort: [{price: {order: 'asc', mode: 'avg'}}]
     #          }}
     #
-    def reorder *params
+    def reorder(*params)
       chain { criteria.update_sort params, purge: true }
     end
 
     # Sets search request field list
     #
+    # @example
     #   UsersIndex.only(:first_name, :last_name).only(:age)
     #     # => {body: {
     #            query: {...},
     #            fields: ['first_name', 'last_name', 'age']
     #          }}
     #
-    def only *params
+    def only(*params)
       chain { criteria.update_fields params }
     end
 
     # Cleans up previous search field list and sets the new one
     #
+    # @example
     #   UsersIndex.only(:first_name, :last_name).only!(:age)
     #     # => {body: {
     #            query: {...},
     #            fields: ['age']
     #          }}
     #
-    def only! *params
+    def only!(*params)
       chain { criteria.update_fields params, purge: true }
     end
 
     # Specify types participating in the search result
-    # Works via <tt>types</tt> filter. Always merged with another filters
-    # with the <tt>and</tt> filter.
+    # Works via `types` filter. Always merged with another filters
+    # with the `and` filter.
     #
+    # @example
     #   UsersIndex.types(:admin, :manager).filters{ name == 'Johny' }.filters{ age <= 42 }
     #     # => {body: {query: {filtered: {
     #            query: {...},
@@ -846,72 +923,88 @@ module Chewy
     #            ]}
     #          }}}}
     #
-    def types *params
+    def types(*params)
       chain { criteria.update_types params }
     end
 
-    # Acts the same way as <tt>types</tt>, but cleans up previously set types
+    # Acts the same way as `types`, but cleans up previously set types
     #
+    # @example
     #   UsersIndex.types(:admin).types!(:manager)
     #     # => {body: {query: {filtered: {
     #            query: {...},
     #            filter: {type: {value: 'manager'}}
     #          }}}}
     #
-    def types! *params
+    def types!(*params)
       chain { criteria.update_types params, purge: true }
     end
 
-    # Sets <tt>search_type</tt> for request.
-    # For instance, one can use <tt>search_type=count</tt> to fetch only total count of records or to fetch only aggregations without fetching records.
+    # Sets `search_type` for request.
+    # For instance, one can use `search_type=count` to fetch only total count of documents or to fetch only aggregations without fetching documents.
     #
+    # @example
     #   scope = UsersIndex.search_type(:count)
-    #   scope.count == 0  # no records actually fetched
+    #   scope.count == 0  # no documents actually fetched
     #   scope.total == 10 # but we know a total count of them
     #
     #   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.
     # Merges all the values in criteria with the same rules as values added manually.
     #
+    # @example
     #   scope1 = UsersIndex.filter{ name == 'Johny' }
     #   scope2 = UsersIndex.filter{ age <= 42 }
     #   scope3 = UsersIndex.filter{ name == 'Johny' }.filter{ age <= 42 }
     #
     #   scope1.merge(scope2) == scope3 # => true
     #
-    def merge other
+    def merge(other)
       chain { criteria.merge!(other.criteria) }
     end
 
-    # Deletes all records matching a query.
+    # Deletes all documents matching a query.
     #
+    # @example
     #   UsersIndex.delete_all
     #   UsersIndex.filter{ age <= 42 }.delete_all
     #   UsersIndex::User.delete_all
     #   UsersIndex::User.filter{ age <= 42 }.delete_all
     #
     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' }
+      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' }
       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)
-      end
+          if Runtime.version >= '2.0'
+            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
+          else
+            Chewy.client.delete_by_query(request)
+          end
+        end
     end
 
-    # Find all records matching a query.
+    # Find all documents matching a query.
     #
+    # @example
     #   UsersIndex.find(42)
     #   UsersIndex.filter{ age <= 42 }.find(42)
     #   UsersIndex::User.find(42)
@@ -920,19 +1013,41 @@ module Chewy
     # In all the previous examples find will return a single object.
     # To get a collection - pass an array of ids.
     #
+    # @example
     #    UsersIndex::User.find(42, 7, 3) # array of objects with ids in [42, 7, 3]
     #    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
+    #
+    # @example
+    #   PlacesIndex.query(...).filter(...).exists?
+    #
+    def exists?
+      search_type(:count).total > 0
+    end
+
+    # Sets limit to be equal to total documents count
+    #
+    # @example
+    #  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
     #
+    # @example
     #   UsersIndex.query(...).filter(...).took
     #
     def took
@@ -947,6 +1062,7 @@ module Chewy
     # important to you than complete results, you can specify a timeout as 10 or
     # "10ms" (10 milliseconds), or "1s" (1 second). See #timeout method.
     #
+    # @example
     #   UsersIndex.query(...).filter(...).timed_out
     #
     def timed_out
@@ -955,14 +1071,14 @@ module Chewy
 
   protected
 
-    def initialize_clone other
-      @criteria = other.criteria.clone
+    def initialize_clone(origin)
+      @criteria = origin.criteria.clone
       reset
     end
 
   private
 
-    def chain &block
+    def chain(&block)
       clone.tap { |q| q.instance_exec(&block) }
     end
 
@@ -973,8 +1089,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_hash.keys
+        request[:type] = _types.map(&:type_name)
         request
       end
     end
@@ -984,37 +1100,37 @@ 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
 
     def _results
       @_results ||= (criteria.none? || _response == {} ? [] : _response['hits']['hits']).map do |hit|
-        attributes = (hit['_source'] || {})
-          .reverse_merge(id: hit['_id'])
-          .merge!(_score: hit['_score'])
-          .merge!(_explanation: hit['_explanation'])
-
-        wrapper = _derive_index(hit['_index']).type_hash[hit['_type']].new attributes
-        wrapper._data = hit
-        wrapper
+        _derive_type(hit['_index'], hit['_type']).build(hit)
       end
     end
 
     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_type(index, type)
+      (@types_cache ||= {})[[index, type]] ||= _derive_index(index).type(type)
+    end
+
+    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