NAME

DBIO::Row - Basic row methods

VERSION

version 0.900000

SYNOPSIS

DESCRIPTION

DBIO::Row implements the basic row lifecycle for DBIO result objects: construction, column updates, inserts, deletes, refreshes, and related-object handling.

Result objects are returned from DBIO::ResultSet instances 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.

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 DBIO::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 DBIO::ResultSource instance that is attached to a DBIO::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 DBIO::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 DBIO::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 DBIO 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, DBIO will throw
an exception, as it has no way of knowing the PK of the related object (if
there is one).

new

Constructs a row object and initializes column/relationship data supplied in the attribute hashref.

The full constructor behavior and caveats are documented in the main new section above.

update_or_insert

Runs update for rows already in storage, otherwise runs insert.

TO_JSON

Returns a JSON-safe hashref of serializable column values.

_has_storage_value

Returns true if the given column opts in via keep_storage_value. Override on a Result class to enable snapshotting by other criteria (e.g. "all integer columns").

storage_value_columns

Arrayref of columns that will be snapshotted on this row.

store_storage_values

Refresh the snapshot from the current accessor values.

get_storage_value

$row->get_storage_value('title')

Returns the snapshotted value for a column.

before_column_change

__PACKAGE__->before_column_change(col => { method => ..., txn_wrap => 0 });

around_column_change

__PACKAGE__->around_column_change(col => { method => ..., txn_wrap => 0 });

after_column_change

__PACKAGE__->after_column_change(col => { method => ..., txn_wrap => 0 });

on_column_change_allow_override_args

Override and return true on your Result class if a before_column_change callback should be able to replace values passed to update($upd). Defaults to false to preserve historic behaviour.

proxy_resultset_method

__PACKAGE__->proxy_resultset_method($name, {
  slot             => $slot,             # defaults to $name
  resultset_method => $rs_method,        # defaults to "with_$name"
});

NOTE

All row objects produced from a schema-attached DBIO::ResultSet (for example via search->next) are actually instances of your application's Result Class.

DBIO::Row implements most of the row-level communication with the underlying storage, but a Result class should not inherit from it directly. Result classes normally inherit from DBIO::Core, which composes DBIO::Row together with other core behavior. Therefore, while many of the methods available to a DBIO::Core-derived Result class are described in the following documentation, it does not detail all of the methods available to Result objects. Refer to DBIO::Manual::ResultClass for more info.

$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 DBIO::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 DBIO::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 DBIO::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 DBIO::ResultSet, "create" in DBIO::ResultSet or "insert" in DBIO::Row are invoked.

Creating a result object using "new_result" in DBIO::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 DBIO::Relationship. Any database-level cascade or restrict will take precedence over a DBIO-based cascading delete, since DBIO 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 DBIO::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.

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 DBIO::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 DBIO::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 } } )

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 DBIO::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 DBIO::ResultSource.

Different types of results can also be created from a particular DBIO::ResultSet, see "result_class" in DBIO::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 DBIO::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 DBIO::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 DBIO::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 DBIO::Replicated::Storage as your storage, a default of { force_pool => 'master' } is automatically set for you. Prior to DBIO 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 DBIO::Schema.

TO_JSON

my $hashref = $row->TO_JSON;

Returns a hashref of the row's column values suitable for JSON serialization. Automatically excludes text, ntext, and blob columns unless is_serializable => 1 is set in the column info. Numeric columns are numified for correct JSON output.

self_rs

my $rs = $row->self_rs;

Returns a ResultSet containing only this row, useful for applying ResultSet methods to a single row.

StorageValues

Per-column opt-in snapshot of the values as last seen in storage. Mark a column with keep_storage_value => 1 and DBIO will record its current stored value at new, insert, update and inflate_result time. The snapshot uses the column accessor, so inflated / filtered values are captured rather than raw storage values.

__PACKAGE__->add_column(title => {
  data_type          => 'varchar',
  keep_storage_value => 1,
});

$row->title('New');
$row->get_storage_value('title'); # the old value
$row->update;
$row->get_storage_value('title'); # now 'New'

OnColumnChange

Register before_column_change, after_column_change, and around_column_change callbacks on a Result class. Callbacks fire from "update" only if the named column is actually dirty. The "old" value comes from "get_storage_value", so pair this with keep_storage_value => 1 on the column if you need a real previous value; otherwise it will be undef.

__PACKAGE__->before_column_change(
  amount => { method => 'bank_transfer', txn_wrap => 1 },
);

Callback signatures:

before: $self->$method($old, $new)
after:  $self->$method($old, $new)   # $old may now equal $new
around: $self->$method($next, $old, $new)

before callbacks fire in definition order, after callbacks fire in reverse order, around callbacks wrap in definition order (the innermost being the first declared). If any registered arg has txn_wrap => 1 the whole update is wrapped in a txn_scope_guard.

See "on_column_change_allow_override_args" in DBIx::Class::Helper::Row::OnColumnChange for on_column_change_allow_override_args semantics.

ProxyResultSetMethod

Expose a with_foo ResultSet method as a row accessor with a transparent fallback: if the column was already selected via the ResultSet method it is returned from the cached row data; otherwise the ResultSet method is re-run for this row.

package MyApp::Schema::ResultSet::Foo;
sub with_friend_count { ... }

package MyApp::Schema::Result::Foo;
__PACKAGE__->proxy_resultset_method('friend_count');

$foo_rs->first->friend_count;           # lazy fetch
$foo_rs->with_friend_count->first->friend_count;  # cached

The generated accessor stores the fetched value under the slot name in _column_data as a cache. Proxied slots are excluded from copy and update so they are never written as actual columns.

id

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 DBIO::PK

AUTHOR

DBIO & DBIx::Class Authors

COPYRIGHT AND LICENSE

This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.

To install DBIO, copy and paste the appropriate command in to your terminal.

cpanm

cpanm DBIO

CPAN shell

perl -MCPAN -e shell
install DBIO

For more information on module installation, please visit the detailed CPAN module installation guide.

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	Go to GitHub issues (only if GitHub is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)

NAME

VERSION

SYNOPSIS

DESCRIPTION

METHODS

new

new

update_or_insert

TO_JSON

_has_storage_value

storage_value_columns

store_storage_values

get_storage_value

before_column_change

around_column_change

after_column_change

on_column_change_allow_override_args

proxy_resultset_method

NOTE

$column_accessor

insert

in_storage

update

delete

get_column

has_column_loaded

get_columns

get_dirty_columns

make_column_dirty

get_inflated_columns

set_column

set_columns

set_inflated_columns

copy

store_column

inflate_result

update_or_insert

insert_or_update

is_changed

is_column_changed

result_source

register_column

get_from_storage

discard_changes

throw_exception

TO_JSON

self_rs

StorageValues

OnColumnChange

ProxyResultSetMethod

id

AUTHOR

COPYRIGHT AND LICENSE

Module Install Instructions

Keyboard Shortcuts