Class: Chewy::Search::QueryProxy

Inherits:

Object

• Object
• Chewy::Search::QueryProxy

Defined in:

lib/chewy/search/query_proxy.rb

Overview

This specialized proxy class is used to provide an ability of query, filter, post_filter parameters additional modification.

See Also:

• Parameters::Query
• Parameters::Filter
• Parameters::PostFilter
• Parameters::QueryStorage

Instance Method Summary

• #and(query_hash_or_scope = nil, &block) ⇒ Chewy::Search::Request

  Executes Parameters::QueryStorage#and in the scope of newly created request object.

• #initialize(parameter_name, request) ⇒ QueryProxy constructor

  A new instance of QueryProxy.

• #minimum_should_match(value) ⇒ Chewy::Search::Request

  Executes Parameters::QueryStorage#minimum_should_match in the scope of newly created request object.

• #must(query_hash = nil, &block) ⇒ Chewy::Search::Request

  Executes Parameters::QueryStorage#must in the scope of newly created request object.

• #must_not(query_hash = nil, &block) ⇒ Chewy::Search::Request

  Executes Parameters::QueryStorage#must_not in the scope of newly created request object.

• #not(query_hash_or_scope = nil, &block) ⇒ Chewy::Search::Request

  Executes Parameters::QueryStorage#not in the scope of newly created request object.

• #or(query_hash_or_scope = nil, &block) ⇒ Chewy::Search::Request

  Executes Parameters::QueryStorage#or in the scope of newly created request object.

• #should(query_hash = nil, &block) ⇒ Chewy::Search::Request

  Executes Parameters::QueryStorage#should in the scope of newly created request object.

Constructor Details

#initialize(parameter_name, request) ⇒ QueryProxy

Returns a new instance of QueryProxy.

Parameters:

• parameter_name (Symbol) —

  modified parameter name

• request (Chewy::Search::Request) —

  request instance for modification

# File 'lib/chewy/search/query_proxy.rb', line 14

def initialize(parameter_name, request)
  @parameter_name = parameter_name
  @request = request
end

Instance Method Details

#and(query_hash) ⇒ Chewy::Search::Request #and(scope) ⇒ Chewy::Search::Request #and { ... } ⇒ Chewy::Search::Request

Executes Parameters::QueryStorage#and in the scope of newly created request object.

Overloads:

• #and(query_hash) ⇒ Chewy::Search::Request

  If pure hash is passed, the current root bool query and the passed one are joined into a single must array of the new root query.

  Examples:

  scope = PlacesIndex.query.must_not(match: {name: 'Moscow'})
  scope.query.and(match: {name: 'London'})
  # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
  #      :must=>[{:bool=>{:must_not=>{:match=>{:name=>"Moscow"}}}}, {:match=>{:name=>"London"}}]}}}}>
  scope = PlacesIndex.query(match: {name: 'Moscow'})
  scope.query.and(match: {name: 'London'})
  # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
  #      :must=>[{:match=>{:name=>"Moscow"}}, {:match=>{:name=>"London"}}]}}}}>

  Parameters:

  • query_hash (Hash) —

    pure query hash

  See Also:

  • https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html
• #and(scope) ⇒ Chewy::Search::Request

  If a scope is passed, the appropriate parameter storage value will be extracted from it and used as a second query.

  Examples:

  scope1 = PlacesIndex.query.must_not(match: {name: 'Moscow'})
  scope2 = PlacesIndex.query(match: {name: 'London'})
  scope1.query.and(scope2)
  # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
  #      :must=>[{:bool=>{:must_not=>{:match=>{:name=>"Moscow"}}}}, {:match=>{:name=>"London"}}]}}}}>

  Parameters:

  • scope (Chewy::Search::Request) —

    other scope

• #and { ... } ⇒ Chewy::Search::Request

  If block is passed instead of a pure hash, `elasticsearch-dsl” gem will be used to process it.

  Examples:

  scope = PlacesIndex.query.must_not(match: {name: 'Moscow'})
  scope.query.and { match name: 'London' }
  # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
  #      :must=>[{:bool=>{:must_not=>{:match=>{:name=>"Moscow"}}}}, {:match=>{:name=>"London"}}]}}}}>

  Yields:

  • the block is processed by elasticsearch-dsl gem

  See Also:

  • https://github.com/elastic/elasticsearch-ruby/tree/master/elasticsearch-dsl

Returns:

• (Chewy::Search::Request)

See Also:

• Parameters::QueryStorage#and

# File 'lib/chewy/search/query_proxy.rb', line 239

%i[and or not].each do |method|
  define_method method do |query_hash_or_scope = nil, &block|
    unless query_hash_or_scope || block
      raise ArgumentError,
            "Please provide a parameter or a block to `#{method}`"
    end

    if !block && query_hash_or_scope.is_a?(Chewy::Search::Request)
      query_hash_or_scope = query_hash_or_scope.parameters[@parameter_name].value
    end
    @request.send(:modify, @parameter_name) { send(method, block || query_hash_or_scope) }
  end
end

#minimum_should_match(value) ⇒ Chewy::Search::Request

Executes Parameters::QueryStorage#minimum_should_match in the scope of newly created request object.

Parameters:

• value (String, Integer, nil)

Returns:

• (Chewy::Search::Request)

See Also:

• Parameters::QueryStorage#minimum_should_match

# File 'lib/chewy/search/query_proxy.rb', line 259

def minimum_should_match(value)
  @request.send(:modify, @parameter_name) { minimum_should_match(value) }
end

#must(query_hash) ⇒ Chewy::Search::Request #must { ... } ⇒ Chewy::Search::Request

Executes Parameters::QueryStorage#must in the scope of newly created request object.

Overloads:

• #must(query_hash) ⇒ Chewy::Search::Request

  If pure hash is passed it is added to must array of the bool query.

  Examples:

  PlacesIndex.query.must(match: {name: 'Moscow'}).query.must(match: {name: 'London'})
  # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
  #      :must=>[{:match=>{:name=>"Moscow"}}, {:match=>{:name=>"London"}}]}}}}>

  Parameters:

  • query_hash (Hash) —

    pure query hash

  See Also:

  • https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html
• #must { ... } ⇒ Chewy::Search::Request

  If block is passed instead of a pure hash, `elasticsearch-dsl” gem will be used to process it.

  Examples:

  PlacesIndex.query.must { match name: 'Moscow' }.query.must { match name: 'London' }
  # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
  #      :must=>[{:match=>{:name=>"Moscow"}}, {:match=>{:name=>"London"}}]}}}}>

  Yields:

  • the block is processed by elasticsearch-dsl gem

  See Also:

  • https://github.com/elastic/elasticsearch-ruby/tree/master/elasticsearch-dsl

Returns:

• (Chewy::Search::Request)

See Also:

• Parameters::QueryStorage#must

# File 'lib/chewy/search/query_proxy.rb', line 102

%i[must should must_not].each do |method|
  define_method method do |query_hash = nil, &block|
    raise ArgumentError, "Please provide a parameter or a block to `#{method}`" unless query_hash || block

    @request.send(:modify, @parameter_name) { send(method, block || query_hash) }
  end
end

#must_not(query_hash) ⇒ Chewy::Search::Request #must_not { ... } ⇒ Chewy::Search::Request

Executes Parameters::QueryStorage#must_not in the scope of newly created request object.

Overloads:

• #must_not(query_hash) ⇒ Chewy::Search::Request

  If pure hash is passed it is added to must_not array of the bool query.

  Examples:

  PlacesIndex.query.must_not(match: {name: 'Moscow'}).query.must_not(match: {name: 'London'})
  # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
  #      :must_not=>[{:match=>{:name=>"Moscow"}}, {:match=>{:name=>"London"}}]}}}}>

  Parameters:

  • query_hash (Hash) —

    pure query hash

  See Also:

  • https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html
• #must_not { ... } ⇒ Chewy::Search::Request

  If block is passed instead of a pure hash, `elasticsearch-dsl” gem will be used to process it.

  Examples:

  PlacesIndex.query.must_not { match name: 'Moscow' }.query.must_not { match name: 'London' }
  # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
  #      :must_not=>[{:match=>{:name=>"Moscow"}}, {:match=>{:name=>"London"}}]}}}}>

  Yields:

  • the block is processed by elasticsearch-dsl gem

  See Also:

  • https://github.com/elastic/elasticsearch-ruby/tree/master/elasticsearch-dsl

Returns:

• (Chewy::Search::Request)

See Also:

• Parameters::QueryStorage#must_not

# File 'lib/chewy/search/query_proxy.rb', line 102

%i[must should must_not].each do |method|
  define_method method do |query_hash = nil, &block|
    raise ArgumentError, "Please provide a parameter or a block to `#{method}`" unless query_hash || block

    @request.send(:modify, @parameter_name) { send(method, block || query_hash) }
  end
end

#not(query_hash) ⇒ Chewy::Search::Request #not(scope) ⇒ Chewy::Search::Request #not { ... } ⇒ Chewy::Search::Request

Executes Parameters::QueryStorage#not in the scope of newly created request object. The only difference from #must_not is that is accepts another scope additionally.

Overloads:

• #not(query_hash) ⇒ Chewy::Search::Request

  If pure hash is passed it is added to must_not array of the bool query.

  Examples:

  scope = PlacesIndex.query.must_not(match: {name: 'Moscow'})
  scope.query.not(match: {name: 'London'})
  # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
  #      :must_not=>[{:match=>{:name=>"Moscow"}}, {:match=>{:name=>"London"}}]}}}}>

  Parameters:

  • query_hash (Hash) —

    pure query hash

  See Also:

  • https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html
• #not(scope) ⇒ Chewy::Search::Request

  If a scope is passed, the appropriate parameter storage value will be extracted from it and used as a second query.

  Examples:

  scope1 = PlacesIndex.query.must_not(match: {name: 'Moscow'})
  scope2 = PlacesIndex.query(match: {name: 'London'})
  scope1.query.not(scope2)
  # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
  #      :must_not=>[{:match=>{:name=>"Moscow"}}, {:match=>{:name=>"London"}}]}}}}>

  Parameters:

  • scope (Chewy::Search::Request) —

    other scope

• #not { ... } ⇒ Chewy::Search::Request

  If block is passed instead of a pure hash, `elasticsearch-dsl” gem will be used to process it.

  Examples:

  scope = PlacesIndex.query.must_not(match: {name: 'Moscow'})
  scope.query.not { match name: 'London' }
  # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
  #      :must_not=>[{:match=>{:name=>"Moscow"}}, {:match=>{:name=>"London"}}]}}}}>

  Yields:

  • the block is processed by elasticsearch-dsl gem

  See Also:

  • https://github.com/elastic/elasticsearch-ruby/tree/master/elasticsearch-dsl

Returns:

• (Chewy::Search::Request)

See Also:

• Parameters::QueryStorage#not

# File 'lib/chewy/search/query_proxy.rb', line 239

%i[and or not].each do |method|
  define_method method do |query_hash_or_scope = nil, &block|
    unless query_hash_or_scope || block
      raise ArgumentError,
            "Please provide a parameter or a block to `#{method}`"
    end

    if !block && query_hash_or_scope.is_a?(Chewy::Search::Request)
      query_hash_or_scope = query_hash_or_scope.parameters[@parameter_name].value
    end
    @request.send(:modify, @parameter_name) { send(method, block || query_hash_or_scope) }
  end
end

#or(query_hash) ⇒ Chewy::Search::Request #or(scope) ⇒ Chewy::Search::Request #or { ... } ⇒ Chewy::Search::Request

Executes Parameters::QueryStorage#or in the scope of newly created request object.

Overloads:

• #or(query_hash) ⇒ Chewy::Search::Request

  If pure hash is passed, the current root bool query and the passed one are joined into a single should array of the new root query.

  Examples:

  scope = PlacesIndex.query.must_not(match: {name: 'Moscow'})
  scope.query.or(match: {name: 'London'})
  # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
  #      :should=>[{:bool=>{:must_not=>{:match=>{:name=>"Moscow"}}}}, {:match=>{:name=>"London"}}]}}}}>
  scope = PlacesIndex.query(match: {name: 'Moscow'})
  scope.query.or(match: {name: 'London'})
  # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
  #      :should=>[{:match=>{:name=>"Moscow"}}, {:match=>{:name=>"London"}}]}}}}>

  Parameters:

  • query_hash (Hash) —

    pure query hash

  See Also:

  • https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html
• #or(scope) ⇒ Chewy::Search::Request

  If a scope is passed, the appropriate parameter storage value will be extracted from it and used as a second query.

  Examples:

  scope1 = PlacesIndex.query.must_not(match: {name: 'Moscow'})
  scope2 = PlacesIndex.query(match: {name: 'London'})
  scope1.query.or(scope2)
  # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
  #      :should=>[{:bool=>{:must_not=>{:match=>{:name=>"Moscow"}}}}, {:match=>{:name=>"London"}}]}}}}>

  Parameters:

  • scope (Chewy::Search::Request) —

    other scope

• #or { ... } ⇒ Chewy::Search::Request

  If block is passed instead of a pure hash, `elasticsearch-dsl” gem will be used to process it.

  Examples:

  scope = PlacesIndex.query.must_not(match: {name: 'Moscow'})
  scope.query.or { match name: 'London' }
  # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
  #      :should=>[{:bool=>{:must_not=>{:match=>{:name=>"Moscow"}}}}, {:match=>{:name=>"London"}}]}}}}>

  Yields:

  • the block is processed by elasticsearch-dsl gem

  See Also:

  • https://github.com/elastic/elasticsearch-ruby/tree/master/elasticsearch-dsl

Returns:

• (Chewy::Search::Request)

See Also:

• Parameters::QueryStorage#or

# File 'lib/chewy/search/query_proxy.rb', line 239

%i[and or not].each do |method|
  define_method method do |query_hash_or_scope = nil, &block|
    unless query_hash_or_scope || block
      raise ArgumentError,
            "Please provide a parameter or a block to `#{method}`"
    end

    if !block && query_hash_or_scope.is_a?(Chewy::Search::Request)
      query_hash_or_scope = query_hash_or_scope.parameters[@parameter_name].value
    end
    @request.send(:modify, @parameter_name) { send(method, block || query_hash_or_scope) }
  end
end

#should(query_hash) ⇒ Chewy::Search::Request #should { ... } ⇒ Chewy::Search::Request

Executes Parameters::QueryStorage#should in the scope of newly created request object.

Overloads:

• #should(query_hash) ⇒ Chewy::Search::Request

  If pure hash is passed it is added to should array of the bool query.

  Examples:

  PlacesIndex.query.should(match: {name: 'Moscow'}).query.should(match: {name: 'London'})
  # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
  #      :should=>[{:match=>{:name=>"Moscow"}}, {:match=>{:name=>"London"}}]}}}}>

  Parameters:

  • query_hash (Hash) —

    pure query hash

  See Also:

  • https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html
• #should { ... } ⇒ Chewy::Search::Request

  If block is passed instead of a pure hash, `elasticsearch-dsl” gem will be used to process it.

  Examples:

  PlacesIndex.query.should { match name: 'Moscow' }.query.should { match name: 'London' }
  # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
  #      :should=>[{:match=>{:name=>"Moscow"}}, {:match=>{:name=>"London"}}]}}}}>

  Yields:

  • the block is processed by elasticsearch-dsl gem

  See Also:

  • https://github.com/elastic/elasticsearch-ruby/tree/master/elasticsearch-dsl

Returns:

• (Chewy::Search::Request)

See Also:

• Parameters::QueryStorage#should

# File 'lib/chewy/search/query_proxy.rb', line 102

%i[must should must_not].each do |method|
  define_method method do |query_hash = nil, &block|
    raise ArgumentError, "Please provide a parameter or a block to `#{method}`" unless query_hash || block

    @request.send(:modify, @parameter_name) { send(method, block || query_hash) }
  end
end