module Sequel::Model::InstanceMethods

Alias of eql?

Case equality. By default, checks equality of the primary key value, see pk_equal?.

Artist[1] === Artist[1] # => true
Artist.new === Artist.new # => false
Artist[1].set(name: 'Bob') === Artist[1] # => true

Returns value of the column’s attribute.

Artist[1][:id] #=> 1

Sets the value for the given column. If typecasting is enabled for this object, typecast the value based on the column’s type. If this is a new record or the typecasted value isn’t the same as the current value for the column, mark the column as changed.

a = Artist.new
a[:name] = 'Bob'
a.values #=> {:name=>'Bob'}

The autoincrementing primary key for this model object. Should be overridden if you have a composite primary key with one part of it being autoincrementing.

Cancel the current action. Should be called in before hooks to halt the processing of the action. If a msg argument is given and the model instance is configured to raise exceptions on failure, sets the message to use for the raised HookFailed exception.

The columns that have been updated. This isn’t completely accurate, as it could contain columns whose values have not changed.

a = Artist[1]
a.changed_columns # => []
a.name = 'Bob'
a.changed_columns # => [:name]

Deletes and returns self. Does not run destroy hooks. Look into using destroy instead.

Artist[1].delete # DELETE FROM artists WHERE (id = 1)
# => #<Artist {:id=>1, ...}>

Like delete but runs hooks before and after delete. Uses a transaction if use_transactions is true or if the :transaction option is given and true.

Artist[1].destroy # BEGIN; DELETE FROM artists WHERE (id = 1); COMMIT;
# => #<Artist {:id=>1, ...}>

Iterates through all of the current values using each.

Album[1].each{|k, v| puts "#{k} => #{v}"}
# id => 1
# name => 'Bob'

Compares model instances by values.

Artist[1] == Artist[1] # => true
Artist.new == Artist.new # => true
Artist[1].set(name: 'Bob') == Artist[1] # => false

Returns the validation errors associated with this object. See Errors.

Returns true when current instance exists, false otherwise. Generally an object that isn’t new will exist unless it has been deleted. Uses a database query to check for existence, unless the model object is new, in which case this is always false.

Artist[1].exists? # SELECT 1 AS one FROM artists WHERE (id = 1)
# => true
Artist.new.exists?
# => false

Ignore the model’s setter method cache when this instances extends a module, as the module may contain setter methods.

Freeze the object in such a way that it is still usable but not modifiable. Once an object is frozen, you cannot modify it’s values, changed_columns, errors, or dataset.

Value that should be unique for objects with the same class and pk (if pk is not nil), or the same class and values (if pk is nil).

Artist[1].hash == Artist[1].hash # true
Artist[1].set(name: 'Bob').hash == Artist[1].hash # true
Artist.new.hash == Artist.new.hash # true
Artist.new(name: 'Bob').hash == Artist.new.hash # false

Returns value for the :id attribute, even if the primary key is not id. To get the primary key value, use pk.

Artist[1].id # => 1

Returns a string representation of the model instance including the class name and values.

Returns the keys in values. May not include all column names.

Artist.new.keys # => []
Artist.new(name: 'Bob').keys # => [:name]
Artist[1].keys # => [:id, :name]

Refresh this record using for_update (by default, or the specified style when given) unless this is a new record. Returns self. This can be used to make sure no other process is updating the record at the same time.

If style is a string, it will be used directly. You should never pass a string to this method that is derived from user input, as that can lead to SQL injection.

A symbol may be used for database independent locking behavior, but all supported symbols have separate methods (e.g. for_update).

a = Artist[1]
Artist.db.transaction do
  a.lock!
  a.update(name: 'A')
end

a = Artist[2]
Artist.db.transaction do
  a.lock!('FOR NO KEY UPDATE')
  a.update(name: 'B')
end

Remove elements of the model object that make marshalling fail. Returns self.

a = Artist[1]
a.marshallable!
Marshal.dump(a)

Explicitly mark the object as modified, so save_changes/update will run callbacks even if no columns have changed.

a = Artist[1]
a.save_changes # No callbacks run, as no changes
a.modified!
a.save_changes # Callbacks run, even though no changes made

If a column is given, specifically marked that column as modified, so that save_changes/update will include that column in the update. This should be used if you plan on mutating the column value instead of assigning a new column value:

a.modified!(:name)
a.name.gsub!(/[aeou]/, 'i')

Whether this object has been modified since last saved, used by save_changes to determine whether changes should be saved. New values are always considered modified.

a = Artist[1]
a.modified? # => false
a.set(name: 'Jim')
a.modified? # => true

If a column is given, specifically check if the given column has been modified:

a.modified?(:num_albums) # => false
a.num_albums = 10
a.modified?(:num_albums) # => true

Returns true if the current instance represents a new record.

Artist.new.new? # => true
Artist[1].new? # => false

Returns the primary key value identifying the model instance. Raises an Error if this model does not have a primary key. If the model has a composite primary key, returns an array of values.

Artist[1].pk # => 1
Artist[[1, 2]].pk # => [1, 2]

Returns a hash mapping the receivers primary key column(s) to their values.

Artist[1].pk_hash # => {:id=>1}
Artist[[1, 2]].pk_hash # => {:id1=>1, :id2=>2}

Returns a hash mapping the receivers qualified primary key column(s) to their values.

Artist[1].qualified_pk_hash
# => {Sequel[:artists][:id]=>1}
Artist[[1, 2]].qualified_pk_hash
# => {Sequel[:artists][:id1]=>1, Sequel[:artists][:id2]=>2}

Reloads attributes from database and returns self. Also clears all changed_columns information. Raises an Error if the record no longer exists in the database.

a = Artist[1]
a.name = 'Jim'
a.refresh
a.name # => 'Bob'

Alias of refresh, but not aliased directly to make overriding in a plugin easier.

Creates or updates the record, after making sure the record is valid and before hooks execute successfully. Fails if:

• the record is not valid, or

• before_save calls cancel_action, or

• the record is new and before_create calls cancel_action, or

• the record is not new and before_update calls cancel_action.

If save fails and either raise_on_save_failure or the :raise_on_failure option is true, it raises ValidationFailed or HookFailed. Otherwise it returns nil.

If it succeeds, it returns self.

Takes the following options:

Saves only changed columns if the object has been modified. If the object has not been modified, returns nil. If unable to save, returns false unless raise_on_save_failure is true.

a = Artist[1]
a.save_changes # => nil
a.name = 'Jim'
a.save_changes # UPDATE artists SET name = 'Bob' WHERE (id = 1)
# => #<Artist {:id=>1, :name=>'Jim', ...}

Updates the instance with the supplied values with support for virtual attributes, raising an exception if a value is used that doesn’t have a setter method (or ignoring it if strict_param_setting = false). Does not save the record.

artist.set(name: 'Jim')
artist.name # => 'Jim'

For each of the fields in the given array fields, call the setter method with the value of that hash entry for the field. Returns self.

You can provide an options hash, with the following options currently respected:

Examples:

artist.set_fields({name: 'Jim'}, [:name])
artist.name # => 'Jim'

artist.set_fields({hometown: 'LA'}, [:name])
artist.name # => nil
artist.hometown # => 'Sac'

artist.name # => 'Jim'
artist.set_fields({}, [:name], missing: :skip)
artist.name # => 'Jim'

artist.name # => 'Jim'
artist.set_fields({}, [:name], missing: :raise)
# Sequel::Error raised

Set the shard that this object is tied to. Returns self.

Clear the setter_methods cache when a method is added

Skip all validation of the object on the next call to save, including the running of validation hooks. This is designed for and should only be used in cases where valid? is called before saving and the validate: false option cannot be passed to save.

Returns (naked) dataset that should return only this instance.

Artist[1].this
# SELECT * FROM artists WHERE (id = 1) LIMIT 1

Runs set with the passed hash and then runs save_changes.

artist.update(name: 'Jim') # UPDATE artists SET name = 'Jim' WHERE (id = 1)

Update the instance’s values by calling set_fields with the arguments, then calls save_changes.

artist.update_fields({name: 'Jim'}, [:name])
# UPDATE artists SET name = 'Jim' WHERE (id = 1)

artist.update_fields({hometown: 'LA'}, [:name])
# UPDATE artists SET name = NULL WHERE (id = 1)

Validates the object and returns true if no errors are reported.

artist.set(name: 'Valid').valid? # => true
artist.set(name: 'Invalid').valid? # => false
artist.errors.full_messages # => ['name cannot be Invalid']

Validates the object. If the object is invalid, errors should be added to the errors attribute. By default, does nothing, as all models are valid by default. See the “Model Validations” guide. for details about validation. Should not be called directly by user code, call valid? instead to check if an object is valid.