module Sequel::Model::InstanceMethods
Sequel::Model
instance methods that implement basic model functionality.
-
All of the model before/after/around hooks are implemented as instance methods that are called by
Sequel
when the appropriate action occurs. For example, when destroying a model object,Sequel
will callaround_destroy
, which will callbefore_destroy
, do the destroy, and then callafter_destroy
. -
The following instance_methods all call the class method of the same name: columns, db, primary_key, db_schema.
-
The following accessor methods are defined via metaprogramming: raise_on_save_failure, raise_on_typecast_failure, require_modification, strict_param_setting, typecast_empty_string_to_nil, typecast_on_assignment, and use_transactions. The setter methods will change the setting for the instance, and the getter methods will check for an instance setting, then try the class setting if no instance setting has been set.
Constants
- EXISTS_SELECT_
Attributes
The hash of attribute values. Keys are symbols with the names of the underlying database columns. The returned hash is a reference to the receiver's values hash, and modifying it will also modify the receiver's values.
Artist.new(name: 'Bob').values # => {:name=>'Bob'} Artist[1].values # => {:id=>1, :name=>'Jim', ...}
The hash of attribute values. Keys are symbols with the names of the underlying database columns. The returned hash is a reference to the receiver's values hash, and modifying it will also modify the receiver's values.
Artist.new(name: 'Bob').values # => {:name=>'Bob'} Artist[1].values # => {:id=>1, :name=>'Jim', ...}
The hash of attribute values. Keys are symbols with the names of the underlying database columns. The returned hash is a reference to the receiver's values hash, and modifying it will also modify the receiver's values.
Artist.new(name: 'Bob').values # => {:name=>'Bob'} Artist[1].values # => {:id=>1, :name=>'Jim', ...}
Public Class Methods
Creates new instance and passes the given values to set. If a block is given, yield the instance to the block.
Arguments:
- values
-
should be a hash to pass to set.
Artist.new(name: 'Bob') Artist.new do |a| a.name = 'Bob' end
# File lib/sequel/model/base.rb 1112 def initialize(values = OPTS) 1113 @values = {} 1114 @new = true 1115 @modified = true 1116 initialize_set(values) 1117 _clear_changed_columns(:initialize) 1118 yield self if defined?(yield) 1119 end
Public Instance Methods
Alias of eql?
# File lib/sequel/model/base.rb 1149 def ==(obj) 1150 eql?(obj) 1151 end
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
# File lib/sequel/model/base.rb 1159 def ===(obj) 1160 case pkv = pk 1161 when nil 1162 return false 1163 when Array 1164 return false if pkv.any?(&:nil?) 1165 end 1166 1167 (obj.class == model) && (obj.pk == pkv) 1168 end
Returns value of the column's attribute.
Artist[1][:id] #=> 1
# File lib/sequel/model/base.rb 1124 def [](column) 1125 @values[column] 1126 end
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'}
# File lib/sequel/model/base.rb 1136 def []=(column, value) 1137 # If it is new, it doesn't have a value yet, so we should 1138 # definitely set the new value. 1139 # If the column isn't in @values, we can't assume it is 1140 # NULL in the database, so assume it has changed. 1141 v = typecast_value(column, value) 1142 vals = @values 1143 if new? || !vals.include?(column) || v != (c = vals[column]) || v.class != c.class 1144 change_column_value(column, v) 1145 end 1146 end
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.
# File lib/sequel/model/base.rb 1191 def autoincrementing_primary_key 1192 primary_key 1193 end
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.
# File lib/sequel/model/base.rb 1199 def cancel_action(msg=nil) 1200 raise_hook_failure(msg) 1201 end
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]
# File lib/sequel/model/base.rb 1210 def changed_columns 1211 _changed_columns 1212 end
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, ...}>
# File lib/sequel/model/base.rb 1219 def delete 1220 raise Sequel::Error, "can't delete frozen object" if frozen? 1221 _delete 1222 self 1223 end
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, ...}>
# File lib/sequel/model/base.rb 1231 def destroy(opts = OPTS) 1232 raise Sequel::Error, "can't destroy frozen object" if frozen? 1233 checked_save_failure(opts){checked_transaction(opts){_destroy(opts)}} 1234 end
Iterates through all of the current values using each.
Album[1].each{|k, v| puts "#{k} => #{v}"} # id => 1 # name => 'Bob'
# File lib/sequel/model/base.rb 1241 def each(&block) 1242 @values.each(&block) 1243 end
Compares model instances by values.
Artist[1] == Artist[1] # => true Artist.new == Artist.new # => true Artist[1].set(name: 'Bob') == Artist[1] # => false
# File lib/sequel/model/base.rb 1250 def eql?(obj) 1251 (obj.class == model) && (obj.values == @values) 1252 end
Returns the validation errors associated with this object. See Errors
.
# File lib/sequel/model/base.rb 1256 def errors 1257 @errors ||= errors_class.new 1258 end
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
# File lib/sequel/model/base.rb 1273 def exists? 1274 new? ? false : !this.get(EXISTS_SELECT_).nil? 1275 end
Ignore the model's setter method cache when this instances extends a module, as the module may contain setter methods.
# File lib/sequel/model/base.rb 1279 def extend(mod) 1280 @singleton_setter_added = true 1281 super 1282 end
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.
# File lib/sequel/model/base.rb 1287 def freeze 1288 unless errors.frozen? 1289 validate 1290 errors.freeze 1291 end 1292 values.freeze 1293 _changed_columns.freeze 1294 this if !new? && model.primary_key 1295 super 1296 end
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
# File lib/sequel/model/base.rb 1305 def hash 1306 case primary_key 1307 when Array 1308 [model, !pk.all? ? @values : pk].hash 1309 when Symbol 1310 [model, pk.nil? ? @values : pk].hash 1311 else 1312 [model, @values].hash 1313 end 1314 end
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
# File lib/sequel/model/base.rb 1320 def id 1321 @values[:id] 1322 end
Returns a string representation of the model instance including the class name and values.
# File lib/sequel/model/base.rb 1326 def inspect 1327 "#<#{inspect_prefix} @values=#{inspect_values}>" 1328 end
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]
# File lib/sequel/model/base.rb 1335 def keys 1336 @values.keys 1337 end
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
# File lib/sequel/model/base.rb 1362 def lock!(style=:update) 1363 _refresh(this.lock_style(style)) unless new? 1364 self 1365 end
Remove elements of the model object that make marshalling fail. Returns self.
a = Artist[1] a.marshallable! Marshal.dump(a)
# File lib/sequel/model/base.rb 1372 def marshallable! 1373 @this = nil 1374 self 1375 end
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')
# File lib/sequel/model/base.rb 1392 def modified!(column=nil) 1393 _add_changed_column(column) if column 1394 @modified = true 1395 end
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
# File lib/sequel/model/base.rb 1412 def modified?(column=nil) 1413 if column 1414 changed_columns.include?(column) 1415 else 1416 @modified || !changed_columns.empty? 1417 end 1418 end
Returns true if the current instance represents a new record.
Artist.new.new? # => true Artist[1].new? # => false
# File lib/sequel/model/base.rb 1424 def new? 1425 defined?(@new) ? @new : (@new = false) 1426 end
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]
# File lib/sequel/model/base.rb 1434 def pk 1435 raise(Error, "No primary key is associated with this model") unless key = primary_key 1436 if key.is_a?(Array) 1437 vals = @values 1438 key.map{|k| vals[k]} 1439 else 1440 @values[key] 1441 end 1442 end
If the receiver has a primary key value, returns true if the objects have the same class and primary key value. If the receiver's primary key value is nil or is an array containing nil, returns false.
Artist[1].pk_equal?(Artist[1]) # => true Artist.new.pk_equal?(Artist.new) # => false Artist[1].set(name: 'Bob').pk_equal?(Artist[1]) # => true
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}
# File lib/sequel/model/base.rb 1448 def pk_hash 1449 model.primary_key_hash(pk) 1450 end
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}
# File lib/sequel/model/base.rb 1458 def qualified_pk_hash(qualifier=model.table_name) 1459 model.qualified_primary_key_hash(pk, qualifier) 1460 end
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'
# File lib/sequel/model/base.rb 1470 def refresh 1471 raise Sequel::Error, "can't refresh frozen object" if frozen? 1472 _refresh(this) 1473 self 1474 end
Alias of refresh, but not aliased directly to make overriding in a plugin easier.
# File lib/sequel/model/base.rb 1477 def reload 1478 refresh 1479 end
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:
- :changed
-
save all changed columns, instead of all columns or the columns given
- :columns
-
array of specific columns that should be saved.
- :raise_on_failure
-
set to true or false to override the current
raise_on_save_failure
setting - :server
-
set the server/shard on the object before saving, and use that server/shard in any transaction.
- :transaction
-
set to true or false to override the current
use_transactions
setting - :validate
-
set to false to skip validation
# File lib/sequel/model/base.rb 1506 def save(opts=OPTS) 1507 raise Sequel::Error, "can't save frozen object" if frozen? 1508 set_server(opts[:server]) if opts[:server] 1509 unless _save_valid?(opts) 1510 raise(validation_failed_error) if raise_on_failure?(opts) 1511 return 1512 end 1513 checked_save_failure(opts){checked_transaction(opts){_save(opts)}} 1514 end
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', ...}
# File lib/sequel/model/base.rb 1525 def save_changes(opts=OPTS) 1526 save(Hash[opts].merge!(:changed=>true)) || false if modified? 1527 end
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'
# File lib/sequel/model/base.rb 1536 def set(hash) 1537 set_restricted(hash, :default) 1538 end
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:
- :missing
-
Can be set to :skip to skip missing entries or :raise to raise an
Error
for missing entries. The default behavior is not to check for missing entries, in which case the default value is used. To be friendly with most web frameworks, the missing check will also check for the string version of the argument in the hash if given a symbol.
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
# File lib/sequel/model/base.rb 1566 def set_fields(hash, fields, opts=nil) 1567 opts = if opts 1568 model.default_set_fields_options.merge(opts) 1569 else 1570 model.default_set_fields_options 1571 end 1572 1573 case missing = opts[:missing] 1574 when :skip, :raise 1575 do_raise = true if missing == :raise 1576 fields.each do |f| 1577 if hash.has_key?(f) 1578 set_column_value("#{f}=", hash[f]) 1579 elsif f.is_a?(Symbol) && hash.has_key?(sf = f.to_s) 1580 set_column_value("#{sf}=", hash[sf]) 1581 elsif do_raise 1582 raise(Sequel::Error, "missing field in hash: #{f.inspect} not in #{hash.inspect}") 1583 end 1584 end 1585 else 1586 fields.each{|f| set_column_value("#{f}=", hash[f])} 1587 end 1588 self 1589 end
Set the shard that this object is tied to. Returns self.
# File lib/sequel/model/base.rb 1592 def set_server(s) 1593 @server = s 1594 @this = @this.server(s) if @this 1595 self 1596 end
Clear the setter_methods
cache when a method is added
# File lib/sequel/model/base.rb 1599 def singleton_method_added(meth) 1600 @singleton_setter_added = true if meth.to_s.end_with?('=') 1601 super 1602 end
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
.
# File lib/sequel/model/base.rb 1609 def skip_validation_on_next_save! 1610 @skip_validation_on_next_save = true 1611 end
Returns (naked) dataset that should return only this instance.
Artist[1].this # SELECT * FROM artists WHERE (id = 1) LIMIT 1
# File lib/sequel/model/base.rb 1617 def this 1618 return @this if @this 1619 raise Error, "No dataset for model #{model}" unless ds = model.instance_dataset 1620 @this = use_server(ds.where(pk_hash)) 1621 end
Runs set
with the passed hash and then runs save_changes.
artist.update(name: 'Jim') # UPDATE artists SET name = 'Jim' WHERE (id = 1)
# File lib/sequel/model/base.rb 1626 def update(hash) 1627 update_restricted(hash, :default) 1628 end
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)
# File lib/sequel/model/base.rb 1638 def update_fields(hash, fields, opts=nil) 1639 set_fields(hash, fields, opts) 1640 save_changes 1641 end
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']
# File lib/sequel/model/base.rb 1657 def valid?(opts = OPTS) 1658 _valid?(opts) 1659 rescue HookFailed 1660 false 1661 end
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.
# File lib/sequel/model/base.rb 1649 def validate 1650 end
Private Instance Methods
Add a column as a changed column.
# File lib/sequel/model/base.rb 1666 def _add_changed_column(column) 1667 cc = _changed_columns 1668 cc << column unless cc.include?(column) 1669 end
Internal changed_columns
method that just returns stored array.
# File lib/sequel/model/base.rb 1672 def _changed_columns 1673 @changed_columns ||= [] 1674 end
Clear the changed columns. Reason is the reason for clearing the columns, and should be one of: :initialize, :refresh, :create or :update.
# File lib/sequel/model/base.rb 1679 def _clear_changed_columns(_reason) 1680 _changed_columns.clear 1681 end
Do the deletion of the object's dataset, and check that the row was actually deleted.
# File lib/sequel/model/base.rb 1685 def _delete 1686 n = _delete_without_checking 1687 raise(NoExistingObject, "Attempt to delete object did not result in a single row modification (Rows Deleted: #{n}, SQL: #{_delete_dataset.delete_sql})") if require_modification && n != 1 1688 n 1689 end
The dataset to use when deleting the object. The same as the object's dataset by default.
# File lib/sequel/model/base.rb 1693 def _delete_dataset 1694 this 1695 end
Actually do the deletion of the object's dataset. Return the number of rows modified.
# File lib/sequel/model/base.rb 1699 def _delete_without_checking 1700 if sql = (m = model).fast_instance_delete_sql 1701 sql = sql.dup 1702 ds = use_server(m.dataset) 1703 ds.literal_append(sql, pk) 1704 ds.with_sql_delete(sql) 1705 else 1706 _delete_dataset.delete 1707 end 1708 end
Internal destroy method, separted from destroy to allow running inside a transaction
# File lib/sequel/model/base.rb 1712 def _destroy(opts) 1713 called = false 1714 around_destroy do 1715 called = true 1716 before_destroy 1717 _destroy_delete 1718 after_destroy 1719 end 1720 raise_hook_failure(:around_destroy) unless called 1721 self 1722 end
Internal delete method to call when destroying an object, separated from delete to allow you to override destroy's version without affecting delete.
# File lib/sequel/model/base.rb 1727 def _destroy_delete 1728 delete 1729 end
Insert the record into the database, returning the primary key if the record should be refreshed from the database.
# File lib/sequel/model/base.rb 1733 def _insert 1734 ds = _insert_dataset 1735 if _use_insert_select?(ds) && !(h = _insert_select_raw(ds)).nil? 1736 _save_set_values(h) if h 1737 nil 1738 else 1739 iid = _insert_raw(ds) 1740 # if we have a regular primary key and it's not set in @values, 1741 # we assume it's the last inserted id 1742 if (pk = autoincrementing_primary_key) && pk.is_a?(Symbol) && !(vals = @values)[pk] 1743 vals[pk] = iid 1744 end 1745 pk 1746 end 1747 end
The dataset to use when inserting a new object. The same as the model's dataset by default.
# File lib/sequel/model/base.rb 1751 def _insert_dataset 1752 use_server(model.instance_dataset) 1753 end
Insert into the given dataset and return the primary key created (if any).
# File lib/sequel/model/base.rb 1756 def _insert_raw(ds) 1757 ds.insert(_insert_values) 1758 end
Insert into the given dataset and return the hash of column values.
# File lib/sequel/model/base.rb 1761 def _insert_select_raw(ds) 1762 ds.insert_select(_insert_values) 1763 end
Refresh using a particular dataset, used inside save to make sure the same server is used for reading newly inserted values from the database
# File lib/sequel/model/base.rb 1771 def _refresh(dataset) 1772 _refresh_set_values(_refresh_get(dataset) || raise(NoExistingObject, "Record not found")) 1773 _clear_changed_columns(:refresh) 1774 end
Get the row of column data from the database.
# File lib/sequel/model/base.rb 1777 def _refresh_get(dataset) 1778 if (sql = model.fast_pk_lookup_sql) && !dataset.opts[:lock] 1779 sql = sql.dup 1780 ds = use_server(dataset) 1781 ds.literal_append(sql, pk) 1782 ds.with_sql_first(sql) 1783 else 1784 dataset.first 1785 end 1786 end
Set the values to the given hash after refreshing.
# File lib/sequel/model/base.rb 1789 def _refresh_set_values(h) 1790 @values = h 1791 end
Internal version of save, split from save to allow running inside it's own transaction.
# File lib/sequel/model/base.rb 1795 def _save(opts) 1796 pk = nil 1797 called_save = false 1798 called_cu = false 1799 around_save do 1800 called_save = true 1801 before_save 1802 1803 if new? 1804 around_create do 1805 called_cu = true 1806 before_create 1807 pk = _insert 1808 @this = nil 1809 @new = false 1810 @modified = false 1811 pk ? _save_refresh : _clear_changed_columns(:create) 1812 after_create 1813 true 1814 end 1815 raise_hook_failure(:around_create) unless called_cu 1816 else 1817 around_update do 1818 called_cu = true 1819 before_update 1820 columns = opts[:columns] 1821 if columns.nil? 1822 columns_updated = if opts[:changed] 1823 _save_update_changed_colums_hash 1824 else 1825 _save_update_all_columns_hash 1826 end 1827 _clear_changed_columns(:update) 1828 else # update only the specified columns 1829 columns = Array(columns) 1830 columns_updated = @values.reject{|k, v| !columns.include?(k)} 1831 _changed_columns.reject!{|c| columns.include?(c)} 1832 end 1833 _update_columns(columns_updated) 1834 @this = nil 1835 @modified = false 1836 after_update 1837 true 1838 end 1839 raise_hook_failure(:around_update) unless called_cu 1840 end 1841 after_save 1842 true 1843 end 1844 raise_hook_failure(:around_save) unless called_save 1845 self 1846 end
Refresh the object after saving it, used to get default values of all columns. Separated from _save so it can be overridden to avoid the refresh.
# File lib/sequel/model/base.rb 1851 def _save_refresh 1852 _save_set_values(_refresh_get(this.server?(:default)) || raise(NoExistingObject, "Record not found")) 1853 _clear_changed_columns(:create) 1854 end
Set values to the provided hash. Called after a create, to set the full values from the database in the model instance.
# File lib/sequel/model/base.rb 1858 def _save_set_values(h) 1859 @values = h 1860 end
Return a hash of values used when saving all columns of an existing object (i.e. not passing specific columns to save or using update/save_changes). Defaults to all of the object's values except unmodified primary key columns, as some databases don't like you setting primary key values even to their existing values.
# File lib/sequel/model/base.rb 1868 def _save_update_all_columns_hash 1869 v = Hash[@values] 1870 cc = changed_columns 1871 Array(primary_key).each{|x| v.delete(x) unless cc.include?(x)} 1872 v 1873 end
Return a hash of values used when saving changed columns of an existing object. Defaults to all of the objects current values that are recorded as modified.
# File lib/sequel/model/base.rb 1878 def _save_update_changed_colums_hash 1879 cc = changed_columns 1880 @values.reject{|k,v| !cc.include?(k)} 1881 end
Validate the object if validating on save. Skips validation completely (including validation hooks) if skip_validation_on_save! has been called on the object, resetting the flag so that future saves will validate.
# File lib/sequel/model/base.rb 1887 def _save_valid?(opts) 1888 if @skip_validation_on_next_save 1889 @skip_validation_on_next_save = false 1890 return true 1891 end 1892 1893 checked_save_failure(opts){_valid?(opts)} 1894 end
Update this instance's dataset with the supplied column hash, checking that only a single row was modified.
# File lib/sequel/model/base.rb 1905 def _update(columns) 1906 n = _update_without_checking(columns) 1907 raise(NoExistingObject, "Attempt to update object did not result in a single row modification (SQL: #{_update_dataset.update_sql(columns)})") if require_modification && n != 1 1908 n 1909 end
Call _update with the given columns, if any are present. Plugins
can override this method in order to update with additional columns, even when the column hash is initially empty.
# File lib/sequel/model/base.rb 1899 def _update_columns(columns) 1900 _update(columns) unless columns.empty? 1901 end
The dataset to use when updating an object. The same as the object's dataset by default.
# File lib/sequel/model/base.rb 1913 def _update_dataset 1914 this 1915 end
Update this instances dataset with the supplied column hash.
# File lib/sequel/model/base.rb 1918 def _update_without_checking(columns) 1919 _update_dataset.update(columns) 1920 end
Whether to use insert_select when inserting a new row.
# File lib/sequel/model/base.rb 1923 def _use_insert_select?(ds) 1924 (!ds.opts[:select] || ds.opts[:returning]) && ds.supports_insert_select? 1925 end
Internal validation method, running validation hooks.
# File lib/sequel/model/base.rb 1928 def _valid?(opts) 1929 return errors.empty? if frozen? 1930 errors.clear 1931 called = false 1932 skip_validate = opts[:validate] == false 1933 around_validation do 1934 called = true 1935 before_validation 1936 validate unless skip_validate 1937 after_validation 1938 end 1939 1940 return true if skip_validate 1941 1942 if called 1943 errors.empty? 1944 else 1945 raise_hook_failure(:around_validation) 1946 end 1947 end
Change the value of the column to given value, recording the change.
# File lib/sequel/model/base.rb 1971 def change_column_value(column, value) 1972 _add_changed_column(column) 1973 @values[column] = value 1974 end
If not raising on failure, check for HookFailed
being raised by yielding and swallow it.
# File lib/sequel/model/base.rb 1951 def checked_save_failure(opts) 1952 if raise_on_failure?(opts) 1953 yield 1954 else 1955 begin 1956 yield 1957 rescue HookFailed 1958 nil 1959 end 1960 end 1961 end
If transactions should be used, wrap the yield in a transaction block.
# File lib/sequel/model/base.rb 1964 def checked_transaction(opts=OPTS, &block) 1965 h = {:server=>this_server}.merge!(opts) 1966 h[:skip_transaction] = true unless use_transaction?(opts) 1967 db.transaction(h, &block) 1968 end
Default error class used for errors.
# File lib/sequel/model/base.rb 1977 def errors_class 1978 Errors 1979 end
A HookFailed
exception for the given message tied to the current instance.
# File lib/sequel/model/base.rb 1982 def hook_failed_error(msg) 1983 HookFailed.new(msg, self) 1984 end
Clone constructor – freeze internal data structures if the original's are frozen.
# File lib/sequel/model/base.rb 1988 def initialize_clone(other) 1989 super 1990 freeze if other.frozen? 1991 self 1992 end
Copy constructor – Duplicate internal data structures.
# File lib/sequel/model/base.rb 1995 def initialize_copy(other) 1996 super 1997 @values = Hash[@values] 1998 @changed_columns = @changed_columns.dup if @changed_columns 1999 @errors = @errors.dup if @errors 2000 self 2001 end
Set the columns with the given hash. By default, the same as set
, but exists so it can be overridden. This is called only for new records, before changed_columns
is cleared.
# File lib/sequel/model/base.rb 2006 def initialize_set(h) 2007 set(h) unless h.empty? 2008 end
Default inspect output for the inspect, by default, just showing the class.
# File lib/sequel/model/base.rb 2011 def inspect_prefix 2012 model.name 2013 end
Default inspect output for the values hash, overwrite to change what inspect
displays.
# File lib/sequel/model/base.rb 2016 def inspect_values 2017 @values.inspect 2018 end
Raise an error appropriate to the hook type. May be swallowed by checked_save_failure
depending on the raise_on_failure? setting.
# File lib/sequel/model/base.rb 2030 def raise_hook_failure(type=nil) 2031 msg = case type 2032 when String 2033 type 2034 when Symbol 2035 "the #{type} hook failed" 2036 else 2037 "a hook failed" 2038 end 2039 2040 raise hook_failed_error(msg) 2041 end
Whether to raise or return false if this action fails. If the :raise_on_failure option is present in the hash, use that, otherwise, fallback to the object's raise_on_save_failure (if set), or class's default (if not).
# File lib/sequel/model/base.rb 2024 def raise_on_failure?(opts) 2025 opts.fetch(:raise_on_failure, raise_on_save_failure) 2026 end
Get the ruby class or classes related to the given column's type.
# File lib/sequel/model/base.rb 2044 def schema_type_class(column) 2045 if (sch = db_schema[column]) && (type = sch[:type]) 2046 db.schema_type_class(type) 2047 end 2048 end
Call setter methods based on keys in hash, with the appropriate values. Restrict which methods can be called based on the provided type.
# File lib/sequel/model/base.rb 2052 def set_restricted(hash, type) 2053 return self if hash.empty? 2054 meths = setter_methods(type) 2055 strict = strict_param_setting 2056 hash.each do |k,v| 2057 k = k.to_s 2058 m = "#{k}=" 2059 if meths.include?(m) 2060 set_column_value(m, v) 2061 elsif strict 2062 # Avoid using respond_to? or creating symbols from user input 2063 if public_methods.map(&:to_s).include?(m) 2064 if Array(model.primary_key).map(&:to_s).member?(k) && model.restrict_primary_key? 2065 raise MassAssignmentRestriction.create("#{k} is a restricted primary key", self, k) 2066 else 2067 raise MassAssignmentRestriction.create("#{k} is a restricted column", self, k) 2068 end 2069 else 2070 raise MassAssignmentRestriction.create("method #{m} doesn't exist", self, k) 2071 end 2072 end 2073 end 2074 self 2075 end
Returns all methods that can be used for attribute assignment (those that end with =), depending on the type:
- :default
-
Use the default methods allowed in the model class.
- :all
-
Allow setting all setters, except those specifically restricted (such as ==).
Array
-
Only allow setting of columns in the given array.
# File lib/sequel/model/base.rb 2083 def setter_methods(type) 2084 if type == :default && !@singleton_setter_added 2085 return model.setter_methods 2086 end 2087 2088 meths = methods.map(&:to_s).select{|l| l.end_with?('=')} - RESTRICTED_SETTER_METHODS 2089 meths -= Array(primary_key).map{|x| "#{x}="} if primary_key && model.restrict_primary_key? 2090 meths 2091 end
The server/shard that the model object's dataset uses, or :default if the model object's dataset does not have an associated shard.
# File lib/sequel/model/base.rb 2095 def this_server 2096 if (s = @server) 2097 s 2098 elsif (t = @this) 2099 t.opts[:server] || :default 2100 else 2101 model.dataset.opts[:server] || :default 2102 end 2103 end
Typecast the value to the column's type if typecasting. Calls the database's typecast_value
method, so database adapters can override/augment the handling for database specific column types.
# File lib/sequel/model/base.rb 2108 def typecast_value(column, value) 2109 return value unless typecast_on_assignment && db_schema && (col_schema = db_schema[column]) 2110 value = nil if '' == value and typecast_empty_string_to_nil and col_schema[:type] and ![:string, :blob].include?(col_schema[:type]) 2111 raise(InvalidValue, "nil/NULL is not allowed for the #{column} column") if raise_on_typecast_failure && value.nil? && (col_schema[:allow_null] == false) 2112 begin 2113 model.db.typecast_value(col_schema[:type], value) 2114 rescue InvalidValue 2115 raise_on_typecast_failure ? raise : value 2116 end 2117 end
Set the columns, filtered by the only and except arrays.
# File lib/sequel/model/base.rb 2120 def update_restricted(hash, type) 2121 set_restricted(hash, type) 2122 save_changes 2123 end
Set the given dataset to use the current object's shard.
# File lib/sequel/model/base.rb 2126 def use_server(ds) 2127 @server ? ds.server(@server) : ds 2128 end
Whether to use a transaction for this action. If the :transaction option is present in the hash, use that, otherwise, fallback to the object's default (if set), or class's default (if not).
# File lib/sequel/model/base.rb 2133 def use_transaction?(opts = OPTS) 2134 opts.fetch(:transaction, use_transactions) 2135 end
An ValidationFailed
exception instance to raise for this instance.
# File lib/sequel/model/base.rb 2138 def validation_failed_error 2139 ValidationFailed.new(self) 2140 end