Module: Elasticsearch::Persistence::Model::Store::InstanceMethods

Defined in:
lib/elasticsearch/persistence/model/store.rb

Instance Method Summary collapse

Instance Method Details

#becomes(klass) ⇒ Object 



253
254
255
256
257
258
259
260
261
262
263
264
265
266
 
# File 'lib/elasticsearch/persistence/model/store.rb', line 253

def becomes(klass)
  became = klass.new(attributes)
  changed_attributes = @changed_attributes if defined?(@changed_attributes)
  became.instance_variable_set("@changed_attributes", changed_attributes || {})
  became.instance_variable_set("@new_record", new_record?)
  became.instance_variable_set("@destroyed", destroyed?)
  became.instance_variable_set("@errors", errors)
  became.instance_variable_set("@persisted", persisted?)
  became.instance_variable_set("@_id", _id)
  became.instance_variable_set("@_version", _version)
  became.instance_variable_set("@_index", _index)
  became.instance_variable_set("@_type", _type)
  became
end

#decrement(attribute, value = 1, options = {}) ⇒ Hash

Decrements a numeric attribute (via Elasticsearch’s “Update” API) and returns the response

Examples:

Decrement the ‘salary` attribute by 1


p.decrement :salary

Decrement the ‘salary` attribute by 100


p.decrement :salary, 100

Returns:

  • (Hash) —

    The Elasticsearch response as a Hash

Raises:



180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
 
# File 'lib/elasticsearch/persistence/model/store.rb', line 180

def decrement(attribute, value = 1, options = {})
  raise DocumentNotPersisted, "Object not persisted: #{self.inspect}" unless persisted?

  options.update index: self._index if self._index
  options.update type: self._type if self._type

  response = self.class.gateway.update(self.id, { script: "ctx._source.#{attribute} = ctx._source.#{attribute} - #{value}" }.merge(options))
  self[attribute] -= value

  @_index = response["_index"]
  @_type = response["_type"]
  @_version = response["_version"]

  response
end

#destroy(options = {}) ⇒ Hash Also known as: delete

Deletes the model from Elasticsearch (if it’s persisted), freezes it, and returns the response

Examples:

Delete a model instance


p.destroy
=> {"_index"=>"people", ... "_id"=>"RzFSXFR0R8u1CZIWNs2Gvg", "_version"=>2 ...}

Returns:

  • (Hash) —

    The Elasticsearch response as a Hash

Raises:



90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/elasticsearch/persistence/model/store.rb', line 90

def destroy(options = {})
  raise DocumentNotPersisted, "Object not persisted: #{self.inspect}" unless persisted?

  run_callbacks :destroy do
    options.update index: self._index if self._index
    options.update type: self._type if self._type

    response = self.class.gateway.delete(self.id, options)

    @destroyed = true
    @persisted = false
    self.freeze
    response
  end
end

#destroyed? ⇒ TrueClass, FalseClass

Returns true when the model has been destroyed, false otherwise

Returns:

  • (TrueClass, FalseClass) 


233
234
235
 
# File 'lib/elasticsearch/persistence/model/store.rb', line 233

def destroyed?
  !!@destroyed
end

#increment(attribute, value = 1, options = {}) ⇒ Hash

Increments a numeric attribute (via Elasticsearch’s “Update” API) and returns the response

Examples:

Increment the ‘salary` attribute by 1


p.increment :salary

Increment the ‘salary` attribute by 100


p.increment :salary, 100

Returns:

  • (Hash) —

    The Elasticsearch response as a Hash

Raises:



151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
 
# File 'lib/elasticsearch/persistence/model/store.rb', line 151

def increment(attribute, value = 1, options = {})
  raise DocumentNotPersisted, "Object not persisted: #{self.inspect}" unless persisted?

  options.update index: self._index if self._index
  options.update type: self._type if self._type

  response = self.class.gateway.update(self.id, { script: "ctx._source.#{attribute} += #{value}" }.merge(options))

  self[attribute] += value

  @_index = response["_index"]
  @_type = response["_type"]
  @_version = response["_version"]

  response
end

#new_record? ⇒ TrueClass, FalseClass

Returns true when the model has not been saved yet, false otherwise

Returns:

  • (TrueClass, FalseClass) 


249
250
251
 
# File 'lib/elasticsearch/persistence/model/store.rb', line 249

def new_record?
  !persisted? && !destroyed?
end

#persisted? ⇒ TrueClass, FalseClass

Returns true when the model has been already saved to the database, false otherwise

Returns:

  • (TrueClass, FalseClass) 


241
242
243
 
# File 'lib/elasticsearch/persistence/model/store.rb', line 241

def persisted?
  !!@persisted && !destroyed?
end

#save(options = {}) ⇒ Hash, FalseClass

Saves the model (if validations pass) and returns the response (or ‘false`)

Examples:

Save a valid model instance


p = Person.new(name: 'John')
p.save
=> {"_index"=>"people", ... "_id"=>"RzFSXFR0R8u1CZIWNs2Gvg", "_version"=>1, "created"=>true}

Save an invalid model instance


p = Person.new(name: nil)
p.save
# => false

Returns:

  • (Hash, FalseClass) —

    The Elasticsearch response as a Hash or ‘false`



44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/elasticsearch/persistence/model/store.rb', line 44

def save(options = {})
  return false unless valid?

  run_callbacks :save do
    options.update id: self.id
    options.update index: self._index if self._index
    options.update type: self._type if self._type

    if new_record?
      response = run_callbacks :create do
        response = self.class.gateway.save(self, options)
        self[:updated_at] = Time.now.utc

        @_id = response["_id"]
        @_index = response["_index"]
        @_type = response["_type"]
        @_version = response["_version"]
        @persisted = true

        response
      end
    else
      response = self.class.gateway.save(self, options)

      self[:updated_at] = Time.now.utc

      @_id = response["_id"]
      @_index = response["_index"]
      @_type = response["_type"]
      @_version = response["_version"]
      @persisted = true

      response
    end
  end
end

#touch(attribute = :updated_at, options = {}) ⇒ Hash

Updates the ‘updated_at` attribute, saves the model and returns the response

Examples:

Update the ‘updated_at` attribute (default)


p.touch

Update a custom attribute: ‘saved_on`


p.touch :saved_on

Returns:

  • (Hash) —

    The Elasticsearch response as a Hash

Raises:



208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
 
# File 'lib/elasticsearch/persistence/model/store.rb', line 208

def touch(attribute = :updated_at, options = {})
  raise DocumentNotPersisted, "Object not persisted: #{self.inspect}" unless persisted?
  raise ArgumentError, "Object does not have '#{attribute}' attribute" unless respond_to?(attribute)

  run_callbacks :touch do
    options.update index: self._index if self._index
    options.update type: self._type if self._type

    value = Time.now.utc
    response = self.class.gateway.update(self.id, { doc: { attribute => value.iso8601 } }.merge(options))

    self[attribute] = value

    @_index = response["_index"]
    @_type = response["_type"]
    @_version = response["_version"]

    response
  end
end

#update(attributes = {}, options = {}) ⇒ Hash Also known as: update_attributes

Updates the model (via Elasticsearch’s “Update” API) and returns the response

Examples:

Update a model with partial attributes


p.update name: 'UPDATED'
=> {"_index"=>"people", ... "_version"=>2}

Returns:

  • (Hash) —

    The Elasticsearch response as a Hash

Raises:



117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/elasticsearch/persistence/model/store.rb', line 117

def update(attributes = {}, options = {})
  raise DocumentNotPersisted, "Object not persisted: #{self.inspect}" unless persisted?

  run_callbacks :update do
    options.update index: self._index if self._index
    options.update type: self._type if self._type

    attributes.update({ updated_at: Time.now.utc })

    response = self.class.gateway.update(self.id, { doc: attributes }.merge(options))

    self.attributes = self.attributes.merge(attributes)
    @_index = response["_index"]
    @_type = response["_type"]
    @_version = response["_version"]

    response
  end
end