class ChewyQuery::Builder::Filters

Context provides simplified DSL functionality for filters declaring. You can use logic operations & and | to concat expressions.

builder.filter{ (article.title =~ /Honey/) & (age < 42) & !rate }

Public Class Methods

new(outer = nil, &block) click to toggle source
# File lib/chewy_query/builder/filters.rb, line 31
def initialize(outer = nil, &block)
  @block = block
  @outer = outer || eval('self', block.binding)
end

Public Instance Methods

__render__() click to toggle source

Renders evaluated filters. For internal usage.

# File lib/chewy_query/builder/filters.rb, line 222
def __render__
  __result__.__render__ # haha, wtf?
end
__result__() click to toggle source

Evaluates context block, returns top node. For internal usage.

# File lib/chewy_query/builder/filters.rb, line 215
def __result__
  instance_exec(&@block)
end
f(name = nil, *args, &block) click to toggle source

Returns field node Used if method_missing is not working by some reason. Additional expression options might be passed as second argument hash.

builder.filter{ f(:name) == 'Name' } == builder.filter{ name == 'Name' } # => true
builder.filter{ f(:name, execution: :bool) == ['Name1', 'Name2'] } ==
  builder.filter{ name(execution: :bool) == ['Name1', 'Name2'] } # => true

Supports block for getting field name from the outer scope

def field
  :name
end

builder.filter{ f{ field } == 'Name' } == builder.filter{ name == 'Name' } # => true
# File lib/chewy_query/builder/filters.rb, line 65
def f(name = nil, *args, &block)
  name = block ? o(&block) : name
  Nodes::Field.new(name, *args)
end
has_child(type) click to toggle source

Initializes has_child filter. Chainable interface acts the same as main query interface. You can pass plain filters or plain queries or filter with DSL block.

builder.filter{ has_child('user').filter(term: {role: 'Admin'}) }
builder.filter{ has_child('user').filter{ role == 'Admin' } }
builder.filter{ has_child('user').query(match: {name: 'borogoves'}) }

Filters and queries might be combined and filter_mode and query_mode are configurable:

builder.filter do
  has_child('user')
    .filter{ name: 'Peter' }
    .query(match: {name: 'Peter'})
    .filter{ age > 42 }
    .filter_mode(:or)
end
# File lib/chewy_query/builder/filters.rb, line 158
def has_child(type)
  Nodes::HasChild.new(type, @outer)
end
has_parent(type) click to toggle source

Initializes has_parent filter. Chainable interface acts the same as main query interface. You can pass plain filters or plain queries or filter with DSL block.

builder.filter{ has_parent('user').filter(term: {role: 'Admin'}) }
builder.filter{ has_parent('user').filter{ role == 'Admin' } }
builder.filter{ has_parent('user').query(match: {name: 'borogoves'}) }

Filters and queries might be combined and filter_mode and query_mode are configurable:

builder.filter do
  has_parent('user')
    .filter{ name: 'Peter' }
    .query(match: {name: 'Peter'})
    .filter{ age > 42 }
    .filter_mode(:or)
end
# File lib/chewy_query/builder/filters.rb, line 180
def has_parent(type)
  Nodes::HasParent.new(type, @outer)
end
match_all() click to toggle source

Just simple match_all filter.

# File lib/chewy_query/builder/filters.rb, line 186
def match_all
  Nodes::MatchAll.new
end
method_missing(method, *args, &block) click to toggle source

Creates field or exists node Additional options for further expression might be passed as hash

builder.filter{ name == 'Name' } == builder.filter(term: {name: 'Name'}) # => true
builder.filter{ name? } == builder.filter(exists: {term: 'name'}) # => true
builder.filter{ name(execution: :bool) == ['Name1', 'Name2'] } ==
  builder.filter(terms: {name: ['Name1', 'Name2'], execution: :bool}) # => true

Also field names might be chained to use dot-notation for ES field names

builder.filter{ article.title =~ 'Hello' }
builder.filter{ article.tags? }
# File lib/chewy_query/builder/filters.rb, line 203
def method_missing(method, *args, &block)
  method = method.to_s
  if method =~ /\?\Z/
    Nodes::Exists.new(method.gsub(/\?\Z/, ''))
  else
    f(method, *args)
  end
end
o(&block) click to toggle source

Outer scope call Block evaluates in the external context

def name
  'Friend'
end

builder.filter{ name == o{ name } } # => {filter: {term: {name: 'Friend'}}}
# File lib/chewy_query/builder/filters.rb, line 45
def o(&block)
  @outer.instance_exec(&block)
end
q(query = nil, &block) click to toggle source

Returns query filter

builder.filter{ q(query_string: {query: 'name: hello'}) }

Supports block for getting query from the outer scope

def query
  {query_string: {query: 'name: hello'}}
end

builder.filter{ q{ query } } == builder.filter{ q(query_string: {query: 'name: hello'}) } # => true
# File lib/chewy_query/builder/filters.rb, line 103
def q(query = nil, &block)
  Nodes::Query.new(block ? o(&block) : query)
end
r(raw = nil, &block) click to toggle source

Returns raw expression Same as filter with arguments instead of block, but can participate in expressions

builder.filter{ r(term: {name: 'Name'}) }
builder.filter{ r(term: {name: 'Name'}) & (age < 42) }

Supports block for getting raw filter from the outer scope

def filter
  {term: {name: 'Name'}}
end

builder.filter{ r{ filter } } == builder.filter{ r(term: {name: 'Name'}) } # => true
builder.filter{ r{ filter } } == builder.filter(term: {name: 'Name'}) # => true
# File lib/chewy_query/builder/filters.rb, line 122
def r(raw = nil, &block)
  Nodes::Raw.new(block ? o(&block) : raw)
end
s(*args, &block) click to toggle source

Returns script filter Just script filter. Supports additional params.

builder.filter{ s('doc["num1"].value > 1') }
builder.filter{ s('doc["num1"].value > param1', param1: 42) }

Supports block for getting script from the outer scope

def script
  'doc["num1"].value > param1 || 1'
end

builder.filter{ s{ script } } == builder.filter{ s('doc["num1"].value > 1') } # => true
builder.filter{ s(param1: 42) { script } } == builder.filter{ s('doc["num1"].value > 1', param1: 42) } # => true
# File lib/chewy_query/builder/filters.rb, line 85
def s(*args, &block)
  params = args.extract_options!
  script = block ? o(&block) : args.first
  Nodes::Script.new(script, params)
end