Module: Chewy::Type::Mapping::ClassMethods

Defined in:
lib/chewy/type/mapping.rb

Instance Method Summary collapse

Instance Method Details

#agg(name, &block) ⇒ Object Also known as: aggregation

Defines an aggregation that can be bound to a query or filter

Examples:

# Suppose that a user has posts and each post has ratings
# avg_post_rating is the mean of all ratings
class UsersIndex < Chewy::Index
  define_type User do
    field :posts do
      field :rating
    end

    agg :avg_rating do
      { avg: { field: 'posts.rating' } }
    end
  end
end


151
152
153
 
# File 'lib/chewy/type/mapping.rb', line 151

def agg(name, &block)
  self._agg_defs = _agg_defs.merge(name => block)
end

#field(*args, **options, &block) ⇒ Object

Defines mapping field for current type

The type is optional and defaults to string if not defined:

Also, multiple fields might be defined with one call and with the same options:

The only special option in the field definition is :value. If no :value specified then just corresponding method will be called for the indexed object. Also :value might be a proc or indexed object method name:

The proc evaluates inside the indexed object context if its arity is 0 and in present contexts if there is an argument:

If array was returned as value - it will be put in index as well.

Fields supports nesting in case of object field type. If user.quiz will return an array of objects, then result index content will be an array of hashes, if user.quiz is not a collection association then just values hash will be put in the index.

Nested fields are composed from nested objects:

Of course it is possible to define object fields contents dynamically but make sure evaluation proc returns hash:

The special case is multi_field. If type options and block are both present field is treated as a multi-field. In that case field composition changes satisfy elasticsearch rules:

Examples:

class UsersIndex < Chewy::Index
  define_type User do
    # passing all the options to field definition:
    field :full_name, analyzer: 'special'
  end
end
field :full_name
field :first_name, :last_name, analyzer: 'special'
class User < ActiveRecord::Base
  def user_full_name
    [first_name, last_name].join(' ')
  end
end

field :full_name, type: 'keyword', value: :user_full_name
field :full_name, type: 'keyword', value: -> { [first_name, last_name].join(' ') }

separator = ' '
field :full_name, type: 'keyword', value: ->(user) { [user.first_name, user.last_name].join(separator) }
field :tags, type: 'keyword', value: -> { tags.map(&:name) }
field :quiz do
  field :question, :answer
  field :score, type: 'integer'
end
field :name, value: -> { name_translations } do
  field :ru, value: ->(name) { name['ru'] }
  field :en, value: ->(name) { name['en'] }
end
field :name, type: 'object', value: -> { name_translations }
field :full_name, type: 'text', analyzer: 'name', value: ->{ full_name.try(:strip) } do
  field :sorted, analyzer: 'sorted'
end


127
128
129
130
131
132
133
 
# File 'lib/chewy/type/mapping.rb', line 127

def field(*args, **options, &block)
  if args.size > 1
    args.map { |name| field(name, options) }
  else
    expand_nested(Chewy::Fields::Base.new(args.first, options), &block)
  end
end

#mappings_hash ⇒ Object

Returns compiled mappings hash for current type



185
186
187
 
# File 'lib/chewy/type/mapping.rb', line 185

def mappings_hash
  root.mappings_hash[type_name.to_sym].present? ? root.mappings_hash : {}
end

#root(**options) ⇒ Object

Defines root object for mapping and is optional for type definition. Use it only if you need to pass options for root object mapping, such as date_detection or dynamic_date_formats

Examples:

class UsersIndex < Chewy::Index
  define_type User do
    # root object defined implicitly and optionless for current type
    field :full_name, type: 'keyword'
  end
end

class CarsIndex < Chewy::Index
  define_type Car do
    # explicit root definition with additional options
    root dynamic_date_formats: ['yyyy-MM-dd'] do
      field :model_name, type: 'keyword'
    end
  end
end


37
38
39
40
41
42
 
# File 'lib/chewy/type/mapping.rb', line 37

def root(**options)
  self.root_object ||= Chewy::Fields::Root.new(type_name, Chewy.default_root_options.merge(options))
  root_object.update_options!(options)
  yield if block_given?
  root_object
end

#supports_outdated_sync? ⇒ true, false

Check whether the type has outdated_sync_field defined with a simple value.

Returns:

  • (true, false) 


192
193
194
195
 
# File 'lib/chewy/type/mapping.rb', line 192

def supports_outdated_sync?
  updated_at_field = root.child_hash[outdated_sync_field] if outdated_sync_field
  !!updated_at_field && updated_at_field.value.nil?
end

#template(*args) ⇒ Object Also known as: dynamic_template

Defines dynamic template in mapping root objects

Name for each template is generated with the following rule: template_#!{dynamic_templates.size + 1}.

Examples:

class CarsIndex < Chewy::Index
  define_type Car do
    template 'model.*', type: 'text', analyzer: 'special'
    field 'model', type: 'object' # here we can put { de: 'Der Mercedes', en: 'Mercedes' }
                                  # and template will be applyed to this field
  end
end

Templates

template 'tit*', mapping_hash
template 'title.*', mapping_hash # dot in template causes "path_match" using
template /tit.+/, mapping_hash # using "match_pattern": "regexp"
template /title\..+/, mapping_hash # "\." - escaped dot causes "path_match" using
template /tit.+/, type: 'text', mapping_hash # "match_mapping_type" as the optionsl second argument
template template42: {match: 'hello*', mapping: {type: 'object'}} # or even pass a template as is


178
179
180
 
# File 'lib/chewy/type/mapping.rb', line 178

def template(*args)
  root.dynamic_template(*args)
end