=head1 NAME
- DBIx::Class::InflateColumn - Automatically create objects from column data
+ DBIx::Class::InflateColumn - Automatically create references from column data
=head1 SYNOPSIS
=head1 DESCRIPTION
- This component translates column data into objects, i.e. "inflating"
- the column data. It also "deflates" objects into an appropriate format
+ This component translates column data into references, i.e. "inflating"
+ the column data. It also "deflates" references into an appropriate format
for the database.
It can be used, for example, to automatically convert to and from
L<DateTime> objects for your date and time fields.
+ It will accept arrayrefs, hashrefs and blessed references (objects),
+ but not scalarrefs. Scalar references are passed through to the
+ database to deal with, to allow such settings as C< \'year + 1'> and
+ C< \'DEFAULT' > to work.
+
=head1 METHODS
=head2 inflate_column
sub _deflated_column {
my ($self, $col, $value) = @_;
- return $value unless ref $value && blessed($value); # If it's not an object, don't touch it
+ # return $value unless ref $value && blessed($value); # If it's not an object, don't touch it
+ ## Leave scalar refs (ala SQL::Abstract literal SQL), untouched, deflate all other refs
+ return $value unless (ref $value && ref($value) ne 'SCALAR');
my $info = $self->column_info($col) or
$self->throw_exception("No column info for $col");
return $value unless exists $info->{_inflate_info};
=cut
sub set_inflated_column {
- my ($self, $col, $obj) = @_;
- $self->set_column($col, $self->_deflated_column($col, $obj));
- if (blessed $obj) {
- $self->{_inflated_column}{$col} = $obj;
+ my ($self, $col, $inflated) = @_;
+ $self->set_column($col, $self->_deflated_column($col, $inflated));
+ # if (blessed $inflated) {
+ if (ref $inflated && ref($inflated) ne 'SCALAR') {
+ $self->{_inflated_column}{$col} = $inflated;
} else {
delete $self->{_inflated_column}{$col};
}
- return $obj;
+ return $inflated;
}
=head2 store_inflated_column
=cut
sub store_inflated_column {
- my ($self, $col, $obj) = @_;
- unless (blessed $obj) {
+ my ($self, $col, $inflated) = @_;
+ # unless (blessed $inflated) {
+ unless (ref $inflated && ref($inflated) ne 'SCALAR') {
delete $self->{_inflated_column}{$col};
- $self->store_column($col => $obj);
- return $obj;
+ $self->store_column($col => $inflated);
+ return $inflated;
}
delete $self->{_column_data}{$col};
- return $self->{_inflated_column}{$col} = $obj;
+ return $self->{_inflated_column}{$col} = $inflated;
}
-=head2 get_column
-
-Gets a column value in the same way as L<DBIx::Class::Row/get_column>. If there
-is an inflated value stored that has not yet been deflated, it is deflated
-when the method is invoked.
-
-=cut
-
-sub get_column {
- my ($self, $col) = @_;
- if (exists $self->{_inflated_column}{$col}
- && !exists $self->{_column_data}{$col}) {
- $self->store_column($col, $self->_deflated_column($col, $self->{_inflated_column}{$col}));
- }
- return $self->next::method($col);
-}
-
-=head2 get_columns
-
-Returns the get_column info for all columns as a hash,
-just like L<DBIx::Class::Row/get_columns>. Handles inflation just
-like L</get_column>.
-
-=cut
-
-sub get_columns {
- my $self = shift;
- if (exists $self->{_inflated_column}) {
- foreach my $col (keys %{$self->{_inflated_column}}) {
- $self->store_column($col, $self->_deflated_column($col, $self->{_inflated_column}{$col}))
- unless exists $self->{_column_data}{$col};
- }
- }
- return $self->next::method;
-}
-
-=head2 has_column_loaded
-
-Like L<DBIx::Class::Row/has_column_loaded>, but also returns true if there
-is an inflated value stored.
-
-=cut
-
-sub has_column_loaded {
- my ($self, $col) = @_;
- return 1 if exists $self->{_inflated_column}{$col};
- return $self->next::method($col);
-}
-
-=head2 update
-
-Updates a row in the same way as L<DBIx::Class::Row/update>, handling
-inflation and deflation of columns appropriately.
-
-=cut
-
-sub update {
- my ($class, $attrs, @rest) = @_;
- foreach my $key (keys %{$attrs||{}}) {
- if (ref $attrs->{$key} && $class->has_column($key)
- && exists $class->column_info($key)->{_inflate_info}) {
- $class->set_inflated_column($key, delete $attrs->{$key});
- }
- }
- return $class->next::method($attrs, @rest);
-}
-
-=head2 new
-
-Creates a row in the same way as L<DBIx::Class::Row/new>, handling
-inflation and deflation of columns appropriately.
-
-=cut
-
-sub new {
- my ($class, $attrs, @rest) = @_;
- my $inflated;
- foreach my $key (keys %{$attrs||{}}) {
- $inflated->{$key} = delete $attrs->{$key}
- if ref $attrs->{$key} && $class->has_column($key)
- && exists $class->column_info($key)->{_inflate_info};
- }
- my $obj = $class->next::method($attrs, @rest);
- $obj->{_inflated_column} = $inflated if $inflated;
- return $obj;
-}
-
=head1 SEE ALSO
=over 4
Daniel Westermann-Clark <danieltwc@cpan.org> (documentation)
+ Jess Robinson <cpan@desert-island.demon.co.uk>
+
=head1 LICENSE
You may distribute this code under the same terms as Perl itself.
use lib qw(t/lib);
use DBICTest;
-DBICTest::Schema::CD->add_column('year');
my $schema = DBICTest->init_schema();
eval { require DateTime };
plan skip_all => "Need DateTime for inflation tests" if $@;
- plan tests => 4;
+ plan tests => 20;
-DBICTest::Schema::CD->inflate_column( 'year',
+$schema->class('CD')
+#DBICTest::Schema::CD
+->inflate_column( 'year',
{ inflate => sub { DateTime->new( year => shift ) },
deflate => sub { shift->year } }
);
is( $cd->year->month, 1, 'inflated month ok' );
+ eval { $cd->year(\'year +1'); };
+ ok(!$@, 'updated year using a scalarref');
+ $cd->update();
+ $cd->discard_changes();
+
+ is( ref($cd->year), 'DateTime', 'year is still a DateTime, ok' );
+
+ is( $cd->year->year, 1998, 'updated year, bypassing inflation' );
+
+ is( $cd->year->month, 1, 'month is still 1' );
+
+ # get_inflated_column test
+
+ is( ref($cd->get_inflated_column('year')), 'DateTime', 'get_inflated_column produces a DateTime');
+
# deflate test
my $now = DateTime->now;
$cd->year( $now );
$cd->update;
- ($cd) = $schema->resultset("CD")->search( year => $now->year );
+ $cd = $schema->resultset("CD")->find(3);
is( $cd->year->year, $now->year, 'deflate ok' );
+ # set_inflated_column test
+ eval { $cd->set_inflated_column('year', $now) };
+ ok(!$@, 'set_inflated_column with DateTime object');
+ $cd->update;
+
+ $cd = $schema->resultset("CD")->find(3);
+ is( $cd->year->year, $now->year, 'deflate ok' );
+
+ $cd = $schema->resultset("CD")->find(3);
+ my $before_year = $cd->year->year;
+ eval { $cd->set_inflated_column('year', \'year + 1') };
+ ok(!$@, 'set_inflated_column to "year + 1"');
+ $cd->update;
+
+ $cd = $schema->resultset("CD")->find(3);
+ is( $cd->year->year, $before_year+1, 'deflate ok' );
+
+ # store_inflated_column test
+ $cd = $schema->resultset("CD")->find(3);
+ eval { $cd->store_inflated_column('year', $now) };
+ ok(!$@, 'store_inflated_column with DateTime object');
+ $cd->update;
+
+ is( $cd->year->year, $now->year, 'deflate ok' );
+
+ # update tests
+ $cd = $schema->resultset("CD")->find(3);
+ eval { $cd->update({'year' => $now}) };
+ ok(!$@, 'update using DateTime object ok');
+ is($cd->year->year, $now->year, 'deflate ok');
+
+ $cd = $schema->resultset("CD")->find(3);
+ $before_year = $cd->year->year;
+ eval { $cd->update({'year' => \'year + 1'}) };
+ ok(!$@, 'update using scalarref ok');
+
+ $cd = $schema->resultset("CD")->find(3);
+ is($cd->year->year, $before_year + 1, 'deflate ok');
+
+ # discard_changes test
+ $cd = $schema->resultset("CD")->find(3);
+ # inflate the year
+ $before_year = $cd->year->year;
+ $cd->update({ year => \'year + 1'});
+ $cd->discard_changes;
+
+ is($cd->year->year, $before_year + 1, 'discard_changes clears the inflated value');
+
+ # eval { $cd->store_inflated_column('year', \'year + 1') };
+ # print STDERR "ERROR: $@" if($@);
+ # ok(!$@, 'store_inflated_column to "year + 1"');
+
+ # is_deeply( $cd->year, \'year + 1', 'deflate ok' );
+
projects / dbsrgits/DBIx-Class.git / commitdiff