DBIx::Class::Row - Basic row methods
This class is responsible for defining and doing basic operations on rows derived from DBIx::Class::ResultSource objects.
Row objects are returned from DBIx::Class::ResultSets using the create, find, next and all methods, as well as invocations of 'single' ( belongs_to, has_one or might_have) relationship accessors of DBIx::Class::Row objects.
my $row = My::Class->new(\%attrs); my $row = $schema->resultset('MySource')->new(\%colsandvalues);
While you can create a new row object by calling new directly on this class, you are better off calling it on a DBIx::Class::ResultSet object.
new
When calling it directly, you will not get a complete, usable row object until you pass or set the source_handle attribute, to a DBIx::Class::ResultSource instance that is attached to a DBIx::Class::Schema with a valid connection.
source_handle
$attrs is a hashref of column name, value data. It can also contain some other attributes such as the source_handle.
$attrs
Passing an object, or an arrayref of objects as a value will call "set_from_related" in DBIx::Class::Relationship::Base for you. When passed a hashref or an arrayref of hashrefs as the value, these will be turned into objects via new_related, and treated as if you had passed objects.
For a more involved explanation, see "create" in DBIx::Class::ResultSet.
$row->insert;
Inserts an object previously created by "new" into the database if it isn't already in there. Returns the object itself. Requires the object's result source to be set, or the class to have a result_source_instance method. To insert an entirely new row into the database, use create (see "create" in DBIx::Class::ResultSet).
create
To fetch an uninserted row object, call new on a resultset.
This will also insert any uninserted, related objects held inside this one, see "create" in DBIx::Class::ResultSet for more details.
$row->in_storage; # Get value $row->in_storage(1); # Set value
Indicates whether the object exists as a row in the database or not. This is set to true when "find" in DBIx::Class::ResultSet, "create" in DBIx::Class::ResultSet or "insert" in DBIx::Class::ResultSet are used.
Creating a row object using "new" in DBIx::Class::ResultSet, or calling "delete" on one, sets it to false.
$row->update(\%columns?)
Throws an exception if the row object is not yet in the database, according to "in_storage".
This method issues an SQL UPDATE query to commit any changes to the object to the database if required.
Also takes an optional hashref of column_name => value> pairs to update on the object first. Be aware that the hashref will be passed to set_inflated_columns, which might edit it in place, so don't rely on it being the same after a call to update. If you need to preserve the hashref, it is sufficient to pass a shallow copy to update, e.g. ( { %{ $href } } )
column_name => value>
set_inflated_columns
update
If the values passed or any of the column values set on the object contain scalar references, eg:
$row->last_modified(\'NOW()'); # OR $row->update({ last_modified => \'NOW()' });
The update will pass the values verbatim into SQL. (See SQL::Abstract docs). The values in your Row object will NOT change as a result of the update call, if you want the object to be updated with the actual values from the database, call "discard_changes" after the update.
$row->update()->discard_changes();
To determine before calling this method, which column values have changed and will be updated, call "get_dirty_columns".
To check if any columns will be updated, call "is_changed".
To force a column to be updated, call "make_column_dirty" before this method.
$row->delete
Throws an exception if the object is not in the database according to "in_storage". Runs an SQL DELETE statement using the primary key values to locate the row.
The object is still perfectly usable, but "in_storage" will now return 0 and the object must be reinserted using "insert" before it can be used to "update" the row again.
If you delete an object in a class with a has_many relationship, an attempt is made to delete all the related objects as well. To turn this behaviour off, pass cascade_delete => 0 in the $attr hashref of the relationship, see DBIx::Class::Relationship. Any database-level cascade or restrict will take precedence over a DBIx-Class-based cascading delete.
has_many
cascade_delete => 0
$attr
If you delete an object within a txn_do() (see "txn_do" in DBIx::Class::Storage) and the transaction subsequently fails, the row object will remain marked as not being in storage. If you know for a fact that the object is still in storage (i.e. by inspecting the cause of the transaction's failure), you can use $obj->in_storage(1) to restore consistency between the object and the database. This would allow a subsequent $obj->delete to work as expected.
$obj->in_storage(1)
$obj->delete
See also "delete" in DBIx::Class::ResultSet.
my $val = $row->get_column($col);
Throws an exception if the column name given doesn't exist according to "has_column".
Returns a raw column value from the row object, if it has already been fetched from the database or set by an accessor.
If an inflated value has been set, it will be deflated and returned.
Note that if you used the columns or the select/as search attributes on the resultset from which $row was derived, and did not include $columnname in the list, this method will return undef even if the database contains some value.
columns
select/as
$row
$columnname
undef
To retrieve all loaded column values as a hash, use "get_columns".
if ( $row->has_column_loaded($col) ) { print "$col has been loaded from db"; }
Returns a true value if the column value has been loaded from the database (or set locally).
my %data = $row->get_columns;
Returns all loaded column data as a hash, containing raw values. To get just one value for a particular column, use "get_column".
my %data = $row->get_dirty_columns;
Only returns the column, value pairs for those columns that have been changed on this object since the last "update" or "insert" call.
See "get_columns" to fetch all column/value pairs.
$row->make_column_dirty($col)
Throws an exception if the column does not exist.
Marks a column as having been changed regardless of whether it has really changed.
my %inflated_data = $obj->get_inflated_columns;
Returns a hash of all column keys and associated values. Values for any columns set to use inflation will be inflated and returns as objects.
See "get_columns" to get the uninflated values.
See DBIx::Class::InflateColumn for how to setup inflation.
$row->set_column($col => $val);
Sets a raw column value. If the new value is different from the old one, the column is marked as dirty for when you next call "update".
If passed an object or reference as a value, this method will happily attempt to store it, and a later "insert" or "update" will try and stringify/numify as appropriate. To set an object to be deflated instead, see "set_inflated_columns".
$row->set_columns({ $col => $val, ... });
Sets multiple column, raw value pairs at once.
Works as "set_column".
$row->set_inflated_columns({ $col => $val, $relname => $obj, ... });
Sets more than one column value at once. Any inflated values are deflated and the raw values stored.
Any related values passed as Row objects, using the relation name as a key, are reduced to the appropriate foreign key values and stored. If instead of related row objects, a hashref of column, value data is passed, will create the related object first then store.
Will even accept arrayrefs of data as a value to a "has_many" in DBIx::Class::Relationship key, and create the related objects if necessary.
Be aware that the input hashref might be edited in place, so dont rely on it being the same after a call to set_inflated_columns. If you need to preserve the hashref, it is sufficient to pass a shallow copy to set_inflated_columns, e.g. ( { %{ $href } } )
See also "set_from_related" in DBIx::Class::Relationship::Base.
my $copy = $orig->copy({ change => $to, ... });
Inserts a new row into the database, as a copy of the original object. If a hashref of replacement data is supplied, these will take precedence over data in the original.
If the row has related objects in a "has_many" in DBIx::Class::Relationship then those objects may be copied too depending on the cascade_copy relationship attribute.
$row->store_column($col => $val);
Set a raw value for a column without marking it as changed. This method is used internally by "set_column" which you should probably be using.
This is the lowest level at which data is set on a row object, extend this method to catch all data setting methods.
Class->inflate_result($result_source, \%me, \%prefetch?)
All DBIx::Class::ResultSet methods that retrieve data from the database and turn it into row objects call this method.
Extend this method in your Result classes to hook into this process, for example to rebless the result into a different class.
Reblessing can also be done more easily by setting result_class in your Result class. See "result_class" in DBIx::Class::ResultSource.
result_class
$row->update_or_insert
"Update"s the object if it's already in the database, according to "in_storage", else "insert"s it.
$obj->insert_or_update
Alias for "update_or_insert"
my @changed_col_names = $row->is_changed(); if ($row->is_changed()) { ... }
In list context returns a list of columns with uncommited changes, or in scalar context returns a true value if there are uncommitted changes.
if ($row->is_column_changed('col')) { ... }
Returns a true value if the column has uncommitted changes.
my $resultsource = $row->result_source;
Accessor to the DBIx::Class::ResultSource this object was created from.
$column_info = { .... }; $class->register_column($column_name, $column_info);
Registers a column on the class. If the column_info has an 'accessor' key, creates an accessor named after the value if defined; if there is no such key, creates an accessor with the same name as the column
The column_info attributes are described in "add_columns" in DBIx::Class::ResultSource
my $copy = $row->get_from_storage($attrs)
Fetches a fresh copy of the Row object from the database and returns it.
If passed the \%attrs argument, will first apply these attributes to the resultset used to find the row.
This copy can then be used to compare to an existing row object, to determine if any changes have been made in the database since it was created.
To just update your Row object with any latest changes from the database, use "discard_changes" instead.
The \%attrs argument should be compatible with "ATTRIBUTES" in DBIx::Class::ResultSet.
See "throw_exception" in DBIx::Class::Schema.
my @pk = $row->id;
Returns the primary key(s) for a row. Can't be called as a class method. Actually implemented in DBIx::Class::PK
$row->discard_changes
Retrieves and sets the row object data from the database, losing any local changes made.
This method can also be used to refresh from storage, retrieving any changes made since the row was last read from storage. Actually implemented in DBIx::Class::PK
Matt S. Trout <mst@shadowcatsystems.co.uk>
You may distribute this code under the same terms as Perl itself.
To install DBIx::Class, copy and paste the appropriate command in to your terminal.
cpanm
cpanm DBIx::Class
CPAN shell
perl -MCPAN -e shell install DBIx::Class
For more information on module installation, please visit the detailed CPAN module installation guide.