NAME¶
DBIx::Class::Row - Basic row methods
SYNOPSIS¶
DESCRIPTION¶
This class is responsible for defining and doing basic operations on rows
derived from DBIx::Class::ResultSource objects.
Result 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 Result objects.
NOTE¶
All "Row objects" derived from a Schema-attached
DBIx::Class::ResultSet object (such as a typical "search-> next"
call) are actually Result instances, based on your application's Result Class.
DBIx::Class::Row implements most of the row-based communication with the
underlying storage, but a Result class
should not inherit from it
directly. Usually, Result classes inherit from DBIx::Class::Core, which in
turn combines the methods from several classes, one of them being
DBIx::Class::Row. Therefore, while many of the methods available to a
DBIx::Class::Core-derived Result class are described in the following
documentation, it does not detail all of the methods available to Result
objects. Refer to DBIx::Class::Manual::ResultClass for more info.
METHODS¶
new¶
my $result = My::Class->new(\%attrs);
my $result = $schema->resultset('MySource')->new(\%colsandvalues);
- Arguments: \%attrs or \%colsandvalues
- Return Value: $result
While you can create a new result object by calling "new" directly on
this class, you are better off calling it on a DBIx::Class::ResultSet object.
When calling it directly, you will not get a complete, usable row object until
you pass or set the "result_source" attribute, to a
DBIx::Class::ResultSource instance that is attached to a DBIx::Class::Schema
with a valid connection.
$attrs is a hashref of column name, value data. It can also contain some other
attributes such as the "result_source".
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.
Please note that if a value is not passed to new, no value will be sent in the
SQL INSERT call, and the column will therefore assume whatever default value
was specified in your database. While DBIC will retrieve the value of
autoincrement columns, it will never make an explicit database trip to
retrieve default values assigned by the RDBMS. You can explicitly request that
all values be fetched back from the database by calling
"discard_changes", or you can supply an explicit "undef"
to columns with NULL as the default, and save yourself a SELECT.
CAVEAT:
The behavior described above will backfire if you use a foreign key column
with a database-defined default. If you call the relationship accessor on
an object that doesn't have a set value for the FK column, DBIC will throw
an exception, as it has no way of knowing the PK of the related object (if
there is one).
$column_accessor¶
# Each pair does the same thing
# (un-inflated, regular column)
my $val = $result->get_column('first_name');
my $val = $result->first_name;
$result->set_column('first_name' => $val);
$result->first_name($val);
# (inflated column via DBIx::Class::InflateColumn::DateTime)
my $val = $result->get_inflated_column('last_modified');
my $val = $result->last_modified;
$result->set_inflated_column('last_modified' => $val);
$result->last_modified($val);
- Arguments: $value?
- Return Value: $value
A column accessor method is created for each column, which is used for
getting/setting the value for that column.
The actual method name is based on the accessor name given during the Result
Class column definition . Like "set_column", this will not store the
data in the database until "insert" or "update" is called
on the row.
insert¶
$result->insert;
- Arguments: none
- Return Value: $result
Inserts an object previously created by "new" into the database if it
isn't already in there. Returns the object itself. To insert an entirely new
row into the database, use "create" in DBIx::Class::ResultSet.
To fetch an uninserted result object, call new_result on a resultset.
This will also insert any uninserted, related objects held inside this one, see
"create" in DBIx::Class::ResultSet for more details.
in_storage¶
$result->in_storage; # Get value
$result->in_storage(1); # Set value
- Arguments: none or 1|0
- Return Value: 1|0
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::Row are invoked.
Creating a result object using "new_result" in DBIx::Class::ResultSet,
or calling "delete" on one, sets it to false.
update¶
$result->update(\%columns?)
- Arguments: none or a hashref
- Return Value: $result
Throws an exception if the result object is not yet in the database, according
to "in_storage". Returns the object itself.
This method issues an SQL UPDATE query to commit any changes to the object to
the database if required (see "get_dirty_columns"). It throws an
exception if a proper WHERE clause uniquely identifying the database row can
not be constructed (see significance of primary keys for more details).
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 } } )
If the values passed or any of the column values set on the object contain
scalar references, e.g.:
$result->last_modified(\'NOW()')->update();
# OR
$result->update({ last_modified => \'NOW()' });
The update will pass the values verbatim into SQL. (See SQL::Abstract docs). The
values in your Result 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.
$result->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.
delete¶
$result->delete
- Arguments: none
- Return Value: $result
Throws an exception if the object is not in the database according to
"in_storage". Also throws an exception if a proper WHERE clause
uniquely identifying the database row can not be constructed (see significance
of primary keys for more details).
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, since
DBIx-Class
deletes the main row first and only then attempts to
delete any remaining related rows.
If you delete an object within a
txn_do() (see "txn_do" in
DBIx::Class::Storage) and the transaction subsequently fails, the result
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.
See also "delete" in DBIx::Class::ResultSet.
get_column¶
my $val = $result->get_column($col);
- Arguments: $columnname
- Return Value: The value of the column
Throws an exception if the column name given doesn't exist according to
has_column.
Returns a raw column value from the result 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 $result was derived, and
did
not include $columnname in the list, this method will return
"undef" even if the database contains some value.
To retrieve all loaded column values as a hash, use "get_columns".
has_column_loaded¶
if ( $result->has_column_loaded($col) ) {
print "$col has been loaded from db";
}
- Arguments: $columnname
- Return Value: 0|1
Returns a true value if the column value has been loaded from the database (or
set locally).
get_columns¶
my %data = $result->get_columns;
- Arguments: none
- Return Value: A hash of columnname, value pairs.
Returns all loaded column data as a hash, containing raw values. To get just one
value for a particular column, use "get_column".
See "get_inflated_columns" to get the inflated values.
get_dirty_columns¶
my %data = $result->get_dirty_columns;
- Arguments: none
- Return Value: A hash of column, value pairs
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.
make_column_dirty¶
$result->make_column_dirty($col)
- Arguments: $columnname
- Return Value: not defined
Throws an exception if the column does not exist.
Marks a column as having been changed regardless of whether it has really
changed.
get_inflated_columns¶
my %inflated_data = $obj->get_inflated_columns;
- Arguments: none
- Return Value: A hash of column, object|value pairs
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.
set_column¶
$result->set_column($col => $val);
- Arguments: $columnname, $value
- Return Value: $value
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", or better yet, use
"$column_accessor".
set_columns¶
$result->set_columns({ $col => $val, ... });
- Arguments: \%columndata
- Return Value: $result
Sets multiple column, raw value pairs at once.
Works as "set_column".
set_inflated_columns¶
$result->set_inflated_columns({ $col => $val, $rel_name => $obj, ... });
- Arguments: \%columndata
- Return Value: $result
Sets more than one column value at once. Any inflated values are deflated and
the raw values stored.
Any related values passed as Result objects, using the relation name as a key,
are reduced to the appropriate foreign key values and stored. If instead of
related result 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 don't 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.
copy¶
my $copy = $orig->copy({ change => $to, ... });
- Arguments: \%replacementdata
- Return Value: $result copy
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. Also any columns which have the column info attribute
"is_auto_increment => 1" are explicitly removed before the copy,
so that the database can insert its own autoincremented values into the new
object.
Relationships will be followed by the copy procedure
only if the
relationship specifies a true value for its cascade_copy attribute.
"cascade_copy" is set by default on "has_many"
relationships and unset on all others.
store_column¶
$result->store_column($col => $val);
- Arguments: $columnname, $value
- Return Value: The value sent to storage
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 result object, extend this
method to catch all data setting methods.
inflate_result¶
Class->inflate_result($result_source, \%me, \%prefetch?)
- Arguments: $result_source, \%columndata, \%prefetcheddata
- Return Value: $result
All DBIx::Class::ResultSet methods that retrieve data from the database and turn
it into result 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.
Different types of results can also be created from a particular
DBIx::Class::ResultSet, see "result_class" in
DBIx::Class::ResultSet.
update_or_insert¶
$result->update_or_insert
- Arguments: none
- Return Value: Result of update or insert operation
"update"s the object if it's already in the database, according to
"in_storage", else "insert"s it.
insert_or_update¶
$obj->insert_or_update
Alias for "update_or_insert"
is_changed¶
my @changed_col_names = $result->is_changed();
if ($result->is_changed()) { ... }
- Arguments: none
- Return Value: 0|1 or @columnnames
In list context returns a list of columns with uncommited changes, or in scalar
context returns a true value if there are uncommitted changes.
is_column_changed¶
if ($result->is_column_changed('col')) { ... }
- Arguments: $columname
- Return Value: 0|1
Returns a true value if the column has uncommitted changes.
result_source¶
my $resultsource = $result->result_source;
- Arguments: $result_source?
- Return Value: $result_source
Accessor to the DBIx::Class::ResultSource this object was created from.
register_column¶
$column_info = { .... };
$class->register_column($column_name, $column_info);
- Arguments: $columnname, \%columninfo
- Return Value: not defined
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
get_from_storage¶
my $copy = $result->get_from_storage($attrs)
- Arguments: \%attrs
- Return Value: A Result object
Fetches a fresh copy of the Result object from the database and returns it.
Throws an exception if a proper WHERE clause identifying the database row can
not be constructed (i.e. if the original object does not contain its entire
primary key ). 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 result object, to determine
if any changes have been made in the database since it was created.
To just update your Result object with any latest changes from the database, use
"discard_changes" instead.
The \%attrs argument should be compatible with "ATTRIBUTES" in
DBIx::Class::ResultSet.
discard_changes¶
$result->discard_changes
- Arguments: none or $attrs
- Return Value: self (updates object in-place)
Re-selects the row from the database, losing any changes that had been made.
Throws an exception if a proper "WHERE" clause identifying the
database row can not be constructed (i.e. if the original object does not
contain its entire primary key).
This method can also be used to refresh from storage, retrieving any changes
made since the row was last read from storage.
$attrs, if supplied, is expected to be a hashref of attributes suitable for
passing as the second argument to "$resultset->search($cond,
$attrs)";
Note: If you are using DBIx::Class::Storage::DBI::Replicated as your storage, a
default of "{ force_pool => 'master' }"
is automatically set for you. Prior to "DBIx::Class 0.08109" (before
2010) one would have been required to explicitly wrap the entire operation in
a transaction to guarantee that up-to-date results are read from the master
database.
throw_exception¶
See "throw_exception" in DBIx::Class::Schema.
my @pk = $result->id;
- Arguments: none
- Returns: A list of primary key values
Returns the primary key(s) for a row. Can't be called as a class method.
Actually implemented in DBIx::Class::PK
FURTHER QUESTIONS?¶
Check the list of additional DBIC resources.
COPYRIGHT AND LICENSE¶
This module is free software copyright by the DBIx::Class (DBIC) authors. You
can redistribute it and/or modify it under the same terms as the DBIx::Class
library.