chewy 0.0.1 → 0.1.0

data/Rakefile

@@ -1,5 +1,6 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'elasticsearch/extensions/test/cluster/tasks'
 
 RSpec::Core::RakeTask.new(:spec)
 

data/chewy.gemspec

@@ -18,13 +18,13 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rspec', '~> 2.14'
   spec.add_development_dependency 'sqlite3'
   spec.add_development_dependency 'kaminari'
   spec.add_development_dependency 'activerecord', '>= 3.2'
   spec.add_development_dependency 'database_cleaner'
+  spec.add_development_dependency 'elasticsearch-extensions'
   spec.add_development_dependency 'rubysl', '~> 2.0' if RUBY_ENGINE == 'rbx'
 
   spec.add_dependency 'activesupport', '>= 3.2'

data/filters

@@ -0,0 +1,76 @@
+term
+  name == 'value'
+  name != 'value'
+terms
+  name == ['value1', 'value2']   plain
+  name != ['value1', 'value2']
+
+  name(:&) == ['value1', 'value2']   or
+  name(:|) == ['value1', 'value2']   and
+  name(:b) == ['value1', 'value2']   bool
+  name(:f) == ['value1', 'value2']   fielddata
+regexp
+  name == /regexp/
+  name =~ /regexp/
+  name != /regexp/
+  name !~ /regexp/
+  name(:anystring, :intersection) == /regexp/
+prefix
+  name =~ 'pref'
+  name !~ 'pref'
+
+exists
+  name?
+missing
+  !name
+  !name?
+  name == nil
+
+numeric_range Numeric
+range Other
+  date >= Date.today
+  date > Date.today
+  date <= Date.today
+  date < Date.today
+
+  date == (2.days.ago..3.days.since)   ()
+  date == [2.days.ago..3.days.since]   []
+
+bool
+  must(name == 'name', email == 'email')
+    .should(name == 'name', email == 'email')
+    .must_not(name == 'name', email == 'email')
+and
+  (name == 'name') & (email == 'email')
+or
+  (name == 'name') | (email == 'email')
+not
+  !(name == 'name')
+  email != 'email'
+
+script s()
+query q()
+
+has child
+  has_child('type').query()
+  has_child('type').filter()
+has parent
+  has_parent('type').query()
+  has_parent('type').filter()
+nested
+  name.nested()
+match all
+  match_all
+
+geo bounding box
+geo distance
+geo distance range
+geo polygon
+geoshape
+geohash cell
+
+indices
+type
+ids
+
+limit

data/lib/chewy.rb

@@ -14,6 +14,8 @@ require 'chewy/fields/base'
 require 'chewy/fields/default'
 require 'chewy/fields/root'
 
+require 'chewy/railtie' if defined?(::Rails)
+
 ActiveSupport.on_load(:active_record) do
   extend Chewy::Type::Observe::ActiveRecordMethods
 end
@@ -39,9 +41,9 @@ module Chewy
     index = class_name.safe_constantize
     raise Chewy::UnderivableType.new("Can not find index named `#{class_name}`") unless index && index < Chewy::Index
     type = if type_name.present?
-      index.types[type_name] or raise Chewy::UnderivableType.new("Index `#{class_name}` doesn`t have type named `#{type_name}`")
-    elsif index.types.values.one?
-      index.types.values.first
+      index.type_hash[type_name] or raise Chewy::UnderivableType.new("Index `#{class_name}` doesn`t have type named `#{type_name}`")
+    elsif index.types.one?
+      index.types.first
     else
       raise Chewy::UnderivableType.new("Index `#{class_name}` has more than one type, please specify type via `#{index_name}#type_name`")
     end

data/lib/chewy/config.rb

@@ -2,46 +2,63 @@ module Chewy
   class Config
     include Singleton
 
-    attr_accessor :observing_enabled, :client_options
+    attr_accessor :client_options, :urgent_update, :query_mode, :filter_mode, :logger
 
     def self.delegated
       public_instance_methods - self.superclass.public_instance_methods - Singleton.public_instance_methods
     end
 
     def initialize
-      @observing_enabled = true
+      @urgent_update = false
       @client_options = {}
+      @query_mode = :must
+      @filter_mode = :and
     end
 
     def client_options
-      yaml_options = if defined? Rails
-        file = Rails.root.join(*%w(config chewy.yml))
-        YAML.load_file(file)[Rails.env].try(:deep_symbolize_keys) if File.exists?(file)
-      end
-      @client_options.merge(yaml_options || {})
+      options = @client_options.merge(yaml_options)
+      options.merge!(logger: logger) if logger
+      options
+    end
+
+    def client?
+      !!Thread.current[:chewy_client]
+    end
+
+    def client
+      Thread.current[:chewy_client] ||= ::Elasticsearch::Client.new client_options
     end
 
     def atomic?
-      atomic_stash.any?
+      stash.any?
     end
 
     def atomic
-      atomic_stash.push({})
-      result = yield
-      atomic_stash.last.each { |type, ids| type.import(ids) }
-      result
+      stash.push({})
+      yield
     ensure
-      atomic_stash.pop
+      stash.pop.each { |type, ids| type.import(ids) }
     end
 
-    def atomic_stash(type = nil, *ids)
-      if type
+    def stash *args
+      if args.any?
+        type, ids = *args
         raise ArgumentError.new('Only Chewy::Type::Base accepted as the first argument') unless type < Chewy::Type::Base
-        atomic_stash.push({}) unless atomic_stash.last
-        atomic_stash.last[type] ||= []
-        atomic_stash.last[type] |= ids.flatten
+        stash.last[type] ||= []
+        stash.last[type] |= ids
       else
-        Thread.current[:chewy_atomic] ||= []
+        Thread.current[:chewy_cache] ||= []
+      end
+    end
+
+  private
+
+    def yaml_options
+      @yaml_options ||= begin
+        if defined?(Rails)
+          file = Rails.root.join(*%w(config chewy.yml))
+          YAML.load_file(file)[Rails.env].try(:deep_symbolize_keys) if File.exists?(file)
+        end || {}
       end
     end
   end

data/lib/chewy/fields/base.rb

@@ -13,7 +13,11 @@ module Chewy
       end
 
       def compose(object)
-        result = value ? value.call(object) : object.send(name)
+        result = if value && value.is_a?(Proc)
+          value.arity == 0 ? object.instance_exec(&value) : value.call(object)
+        else
+          object.send(name)
+        end
 
         result = if result.is_a?(Enumerable)
           result.map { |object| nested_compose(object) }

data/lib/chewy/index.rb

@@ -1,30 +1,42 @@
 require 'chewy/index/actions'
-require 'chewy/index/client'
 require 'chewy/index/search'
 
 module Chewy
   class Index
     include Actions
-    include Client
     include Search
 
-    class_attribute :types
-    self.types = {}
+    singleton_class.delegate :client, to: 'Chewy'
+
+    class_attribute :type_hash
+    self.type_hash = {}
 
     class_attribute :_settings
     self._settings = {}
 
     def self.define_type(name_or_scope, &block)
       type_class = Chewy::Type.new(self, name_or_scope, &block)
-      self.types = types.merge(type_class.type_name => type_class)
+      self.type_hash = type_hash.merge(type_class.type_name => type_class)
 
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def self.#{type_class.type_name}
-          types['#{type_class.type_name}']
+          type_hash['#{type_class.type_name}']
         end
       RUBY
     end
 
+    def self.types *args
+      if args.any?
+        all.types *args
+      else
+        type_hash.values
+      end
+    end
+
+    def self.type_names
+      type_hash.keys
+    end
+
     def self.settings(params)
       self._settings = params
     end
@@ -43,7 +55,7 @@ module Chewy
     end
 
     def self.mappings_hash
-      mappings = types.values.map(&:mappings_hash).inject(:merge)
+      mappings = types.map(&:mappings_hash).inject(:merge)
       mappings.present? ? {mappings: mappings} : {}
     end
 
@@ -56,15 +68,15 @@ module Chewy
     end
 
     def self.search_type
-      types.keys
+      type_names
     end
 
     def self.import
-      types.values.all? { |t| t.import }
+      types.all? { |t| t.import }
     end
 
     def self.reset
-      index_purge!
+      purge!
       import
     end
   end

data/lib/chewy/index/actions.rb

@@ -4,38 +4,38 @@ module Chewy
       extend ActiveSupport::Concern
 
       module ClassMethods
-        def index_exists?
+        def exists?
           client.indices.exists(index: index_name)
         end
 
-        def index_create
-          index_create!
+        def create
+          create!
         rescue Elasticsearch::Transport::Transport::Errors::BadRequest
           false
         end
 
-        def index_create!
+        def create!
           client.indices.create(index: index_name, body: index_params)
         end
 
-        def index_delete
-          index_delete!
+        def delete
+          delete!
         rescue Elasticsearch::Transport::Transport::Errors::NotFound
           false
         end
 
-        def index_delete!
+        def delete!
           client.indices.delete(index: index_name)
         end
 
-        def index_purge
-          index_delete
-          index_create
+        def purge
+          delete
+          create
         end
 
-        def index_purge!
-          index_delete
-          index_create!
+        def purge!
+          delete
+          create!
         end
       end
     end

data/lib/chewy/index/search.rb

@@ -3,9 +3,14 @@ module Chewy
     module Search
       extend ActiveSupport::Concern
 
+      included do
+        singleton_class.delegate :explain, :limit, :offset, :facets, :query,
+          :filter, :order, :reorder, :only, :types, to: :all
+      end
+
       module ClassMethods
-        def search
-          Chewy::Query.new(search_index, type: search_type)
+        def all
+          Chewy::Query.new(search_index, types: search_type)
         end
 
         def search_string query, options = {}

data/lib/chewy/query.rb

@@ -1,132 +1,450 @@
+begin
+  require 'kaminari'
+rescue LoadError
+end
+
 require 'chewy/query/criteria'
+require 'chewy/query/context'
 require 'chewy/query/loading'
 require 'chewy/query/pagination'
 
 module Chewy
+  # Query allows you to create ES search requests with convenient
+  # chainable DSL. Queries are lazy evaluated and might be merged.
+  # The same DSL is used for whole index or individual types query build.
+  #
+  #   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 Loading
     include Pagination
 
-    DEFAULT_OPTIONS = {}
-
-    delegate :each, to: :_results
+    delegate :each, :count, :size, to: :_results
     alias_method :to_ary, :to_a
 
     attr_reader :index, :options, :criteria
 
-    def initialize(index, options = {})
-      @index, @options = index, DEFAULT_OPTIONS.merge(options)
+    def initialize index, options = {}
+      @index, @options = index, options
+      @types = Array.wrap(options.delete(:types))
       @criteria = Criteria.new
       reset
     end
 
-    def ==(other)
-      if other.is_a?(self.class)
+    # Comparation with other query or collection
+    # If other is collection - search request is executed and
+    # result is used for comparation
+    #
+    #   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
     end
 
-    def explain(value = nil)
-      chain { criteria.update_search explain: (value.nil? ? true : value) }
+    # Adds <tt>explain</tt> parameter to search request.
+    #
+    #   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>
+    # method
+    #
+    #   UsersIndex::User.filter(term: {name: 'Johny'}).explain.first._explanation # => {...}
+    #
+    def explain value = nil
+      chain { criteria.update_options explain: (value.nil? ? true : value) }
+    end
+
+    # Sets query compilation mode for search request.
+    # 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:
+    #
+    #     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:
+    #
+    #     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:
+    #
+    #     UsersIndex.query(text: {name: 'Johny'}).query(range: {age: {lte: 42}}).query_mode('50%')
+    #       # => {body: {
+    #              query: {bool: {
+    #                should: [{text: {name: 'Johny'}}, {range: {age: {lte: 42}}}],
+    #                minimum_should_match: '50%'
+    #              }}
+    #            }}
+    #
+    # * <tt>:dis_max</tt>
+    #   Query compiles into a <tt>dis_max</tt> query.
+    #
+    #   Ex:
+    #
+    #     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:
+    #
+    #     UsersIndex.query(text: {name: 'Johny'}).query(range: {age: {lte: 42}}).query_mode(0.7)
+    #       # => {body: {
+    #              query: {dis_max: {
+    #                queries: [{text: {name: 'Johny'}}, {range: {age: {lte: 42}}}],
+    #                tie_breaker: 0.7
+    #              }}
+    #            }}
+    #
+    # Default value for <tt>:query_mode</tt> might be changed
+    # with <tt>Chewy.query_mode</tt> config option.
+    #
+    #   Chewy.query_mode = :dis_max
+    #   Chewy.query_mode = '50%'
+    #
+    def query_mode value
+      chain { criteria.update_options query_mode: value }
     end
 
-    def limit(value)
-      chain { criteria.update_search size: Integer(value) }
+    # Sets query compilation mode for search request.
+    # 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:
+    #
+    #     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:
+    #
+    #     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:
+    #
+    #     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:
+    #
+    #     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:
+    #
+    #     UsersIndex.filter{ name == 'Johny' }.filter{ age <= 42 }.filter_mode('50%')
+    #       # => {body: {query: {filtered: {
+    #              query: {...},
+    #              filter: {bool: {
+    #                should: [{term: {name: 'Johny'}}, {range: {age: {lte: 42}}}],
+    #                minimum_should_match: '50%'
+    #              }}
+    #            }}}}
+    #
+    # Default value for <tt>:filter_mode</tt> might be changed
+    # with <tt>Chewy.filter_mode</tt> config option.
+    #
+    #   Chewy.filter_mode = :should
+    #   Chewy.filter_mode = '50%'
+    #
+    def filter_mode value
+      chain { criteria.update_options filter_mode: value }
     end
 
-    def offset(value)
-      chain { criteria.update_search from: Integer(value) }
+    # Sets elasticsearch <tt>size</tt> search request param
+    # Default value is set in the elasticsearch and is 10.
+    #
+    #  UsersIndex.filter{ name == 'Johny' }.limit(100)
+    #     # => {body: {
+    #            query: {...},
+    #            size: 100
+    #          }}
+    #
+    def limit value
+      chain { criteria.update_options size: Integer(value) }
     end
 
-    def query(params)
-      chain { criteria.update_query params }
+    # Sets elasticsearch <tt>from</tt> search request param
+    #
+    #  UsersIndex.filter{ name == 'Johny' }.offset(300)
+    #     # => {body: {
+    #            query: {...},
+    #            from: 300
+    #          }}
+    #
+    def offset value
+      chain { criteria.update_options from: Integer(value) }
     end
 
-    def facets(params)
+    # Adds facets section to the search request.
+    # All the chained facets a merged and added to the
+    # search request
+    #
+    #   UsersIndex.facets(tags: {terms: {field: 'tags'}}).facets(ages: {terms: {field: 'age'}})
+    #     # => {body: {
+    #            query: {...},
+    #            facets: {tags: {terms: {field: 'tags'}}, ages: {terms: {field: 'age'}}}
+    #          }}
+    #
+    def facets params
       chain { criteria.update_facets params }
     end
 
-    def filter(params)
+    # 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
+    #
+    # By default it joines inside <tt>must</tt> query
+    # See <tt>#query_mode</tt> chainable method for more info.
+    #
+    #   UsersIndex.query(text: {name: 'Johny'}).query(range: {age: {lte: 42}})
+    #   UsersIndex::User.query(text: {name: 'Johny'}).query(range: {age: {lte: 42}})
+    #     # => {body: {
+    #            query: {bool: {must: [{text: {name: 'Johny'}}, {range: {age: {lte: 42}}}]}}
+    #          }}
+    #
+    # If only one query was specified, it will become a result
+    # query as is, without joining.
+    #
+    #   UsersIndex.query(text: {name: 'Johny'})
+    #     # => {body: {
+    #            query: {text: {name: 'Johny'}}
+    #          }}
+    #
+    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
+    #
+    # By default it joines inside <tt>and</tt> filter
+    # See <tt>#filter_mode</tt> chainable method for more info.
+    #
+    # Also this method supports block DSL.
+    # See <tt>Chewy::Query::Context</tt> for more info.
+    #
+    #   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 }
+    #     # => {body: {query: {filtered: {
+    #            query: {...},
+    #            filter: {and: [{term: {name: 'Johny'}}, {range: {age: {lte: 42}}}]}
+    #          }}}}
+    #
+    # If only one filter was specified, it will become a result
+    # filter as is, without joining.
+    #
+    #   UsersIndex.filter(term: {name: 'Johny'})
+    #     # => {body: {query: {filtered: {
+    #            query: {...},
+    #            filter: {term: {name: 'Johny'}}
+    #          }}}}
+    #
+    def filter params = nil, &block
+      params = Context.new(&block).__render__ if block
       chain { criteria.update_filters params }
     end
 
-    def order(*params)
+    # Sets search request sorting
+    #
+    #   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
       chain { criteria.update_sort params }
     end
 
-    def reorder(*params)
+    # Cleans up previous search sorting and sets the new one
+    #
+    #   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
       chain { criteria.update_sort params, purge: true }
     end
 
-    def only(*params)
+    # Sets search request field list
+    #
+    #   UsersIndex.only(:first_name, :last_name).only(:age)
+    #     # => {body: {
+    #            query: {...},
+    #            fields: ['first_name', 'last_name', 'age']
+    #          }}
+    #
+    def only *params
       chain { criteria.update_fields params }
     end
 
-  protected
-
-    def initialize_clone(other)
-      @criteria = other.criteria.clone
-      reset
+    # Cleans up previous search field list and sets the new one
+    #
+    #   UsersIndex.only(:first_name, :last_name).only!(:age)
+    #     # => {body: {
+    #            query: {...},
+    #            fields: ['age']
+    #          }}
+    #
+    def only! *params
+      chain { criteria.update_fields params, purge: true }
     end
 
-  private
-
-    def chain &block
-      clone.tap { |q| q.instance_eval(&block) }
+    # Specify types participating in the search result
+    # Works via <tt>types</tt> filter. Always merged with another filters
+    # with the <tt>and</tt> filter.
+    #
+    #   UsersIndex.types(:admin, :manager).filters{ name == 'Johny' }.filters{ age <= 42 }
+    #     # => {body: {query: {filtered: {
+    #            query: {...},
+    #            filter: {and: [
+    #              {or: [
+    #                {type: {value: 'admin'}},
+    #                {type: {value: 'manager'}}
+    #              ]},
+    #              {term: {name: 'Johny'}},
+    #              {range: {age: {lte: 42}}}
+    #            ]}
+    #          }}}}
+    #
+    #   UsersIndex.types(:admin, :manager).filters{ name == 'Johny' }.filters{ age <= 42 }.filter_mode(:or)
+    #     # => {body: {query: {filtered: {
+    #            query: {...},
+    #            filter: {and: [
+    #              {or: [
+    #                {type: {value: 'admin'}},
+    #                {type: {value: 'manager'}}
+    #              ]},
+    #              {or: [
+    #                {term: {name: 'Johny'}},
+    #                {range: {age: {lte: 42}}}
+    #              ]}
+    #            ]}
+    #          }}}}
+    #
+    def types *params
+      if params.any?
+        chain { criteria.update_types params }
+      else
+        @types
+      end
     end
 
-    def reset
-      @_response, @_results = nil
+    # Acts the same way as <tt>types</tt>, but cleans up previously set types
+    #
+    #   UsersIndex.types(:admin).types!(:manager)
+    #     # => {body: {query: {filtered: {
+    #            query: {...},
+    #            filter: {type: {value: 'manager'}}
+    #          }}}}
+    #
+    def types! *params
+      chain { criteria.update_types params, purge: true }
     end
 
-    def types
-      @types ||= Array.wrap(options[:type] || options[:types])
+    # Merges two queries.
+    # Merges all the values in criteria with the same rules as values added manually.
+    #
+    #   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
+      chain { criteria.merge!(other.criteria) }
     end
 
-    def _filters
-      if criteria.filters.many?
-        {and: criteria.filters}
-      else
-        criteria.filters.first
-      end
-    end
+  protected
 
-    def _request_query
-      if criteria.filters?
-        {query: {
-          filtered: {
-            query: criteria.query? ? criteria.query : {match_all: {}},
-            filter: _filters
-          }
-        }}
-      elsif criteria.query?
-        {query: criteria.query}
-      else
-        {}
-      end
+    def initialize_clone other
+      @criteria = other.criteria.clone
+      reset
     end
 
-    def _request_body
-      body = _request_query
-      body = body.merge!(facets: criteria.facets) if criteria.facets?
-      body = body.merge!(sort: criteria.sort) if criteria.sort?
-      body = body.merge!(fields: criteria.fields) if criteria.fields?
-      {body: body}
+  private
+
+    def chain &block
+      clone.tap { |q| q.instance_eval(&block) }
     end
 
-    def _request_target
-      {index: index.index_name, type: types}
+    def reset
+      @_request, @_response, @_results = nil
     end
 
     def _request
-      [criteria.search, _request_target, _request_body].inject(:merge)
+      @_request ||= criteria.request_body.merge(index: index.index_name, type: types)
     end
 
     def _response
-      @_response ||= index.client.search(_request)
+      @_response ||= begin
+        ActiveSupport::Notifications.instrument 'search_query.chewy', request: _request, index: index do
+          index.client.search(_request)
+        end
+      end
     end
 
     def _results
@@ -134,7 +452,7 @@ module Chewy
         attributes = hit['_source'] || hit['fields'] || {}
         attributes.reverse_merge!(id: hit['_id']).merge!(_score: hit['_score'])
         attributes.merge!(_explain: hit['_explanation']) if hit['_explanation']
-        index.types[hit['_type']].new attributes
+        index.type_hash[hit['_type']].new attributes
       end
     end
   end