X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FInflateColumn.pm;h=c16375d2d2e3ff792c26c5969dd12c2eb1091b9b;hb=d2308dde5718dc0f828584c3fa24d7417c484040;hp=5dec97d6d0bfb32f26becec0eed76a331b693f8f;hpb=b82c8a28bb4cb7d704496b8ce3966565d255d5b3;p=dbsrgits%2FDBIx-Class.git diff --git a/lib/DBIx/Class/InflateColumn.pm b/lib/DBIx/Class/InflateColumn.pm index 5dec97d..c16375d 100644 --- a/lib/DBIx/Class/InflateColumn.pm +++ b/lib/DBIx/Class/InflateColumn.pm @@ -2,9 +2,10 @@ package DBIx::Class::InflateColumn; use strict; use warnings; -use Scalar::Util qw/blessed/; -use base qw/DBIx::Class::Row/; +use base 'DBIx::Class::Row'; +use SQL::Abstract 'is_literal_value'; +use namespace::clean; =head1 NAME @@ -12,11 +13,17 @@ DBIx::Class::InflateColumn - Automatically create references from column data =head1 SYNOPSIS - # In your table classes - __PACKAGE__->inflate_column('column_name', { - inflate => sub { ... }, - deflate => sub { ... }, - }); + # In your table classes + __PACKAGE__->inflate_column('column_name', { + inflate => sub { + my ($raw_value_from_db, $result_object) = @_; + ... + }, + deflate => sub { + my ($inflated_value_from_user, $result_object) = @_; + ... + }, + }); =head1 DESCRIPTION @@ -26,7 +33,7 @@ for the database. It can be used, for example, to automatically convert to and from L objects for your date and time fields. There's a -conveniece component to actually do that though, try +convenience component to actually do that though, try L. It will handle all types of references except scalar references. It @@ -37,7 +44,7 @@ deal with, to allow such settings as C< \'year + 1'> and C< \'DEFAULT' > to work. If you want to filter plain scalar values and replace them with -something else, contribute a filtering component. +something else, see L. =head1 METHODS @@ -55,57 +62,84 @@ named C, you could inflate the column in the corresponding table class using something like: __PACKAGE__->inflate_column('insert_time', { - inflate => sub { DateTime::Format::Pg->parse_datetime(shift); }, - deflate => sub { DateTime::Format::Pg->format_datetime(shift); }, + inflate => sub { + my ($insert_time_raw_value, $event_result_object) = @_; + DateTime->from_epoch( epoch => $insert_time_raw_value ); + }, + deflate => sub { + my ($insert_time_dt_object, $event_result_object) = @_; + $insert_time_dt_object->epoch; + }, }); -(Replace L with the appropriate module for your -database, or consider L.) - The coderefs you set for inflate and deflate are called with two parameters, -the first is the value of the column to be inflated/deflated, the second is the -row object itself. Thus you can call C<< ->result_source->schema->storage->dbh >> in your inflate/defalte subs, to feed to L. +the first is the value of the column to be inflated/deflated, the second is +the result object itself. In this example, calls to an event's C accessor return a -L object. This L object is later "deflated" when -used in the database layer. +L object. This L object is later "deflated" back +to the integer epoch representation when used in the database layer. +For a much more thorough handling of the above example, please see +L =cut sub inflate_column { my ($self, $col, $attrs) = @_; - $self->throw_exception("No such column $col to inflate") - unless $self->has_column($col); + + my $colinfo = $self->result_source->columns_info([$col])->{$col}; + + $self->throw_exception("InflateColumn can not be used on a column with a declared FilterColumn filter") + if defined $colinfo->{_filter_info} and $self->isa('DBIx::Class::FilterColumn'); + $self->throw_exception("inflate_column needs attr hashref") unless ref $attrs eq 'HASH'; - $self->column_info($col)->{_inflate_info} = $attrs; - my $acc = $self->column_info($col)->{accessor}; + + $colinfo->{_inflate_info} = $attrs; + my $acc = $colinfo->{accessor}; $self->mk_group_accessors('inflated_column' => [ (defined $acc ? $acc : $col), $col]); return 1; } sub _inflated_column { my ($self, $col, $value) = @_; - return $value unless defined $value; # NULL is NULL is NULL - my $info = $self->column_info($col) - or $self->throw_exception("No column info for $col"); + + return $value if ( + ! defined $value # NULL is NULL is NULL + or + is_literal_value($value) #that would be a not-yet-reloaded literal update + ); + + my $info = $self->result_source->columns_info([$col])->{$col}; + return $value unless exists $info->{_inflate_info}; - my $inflate = $info->{_inflate_info}{inflate}; - $self->throw_exception("No inflator for $col") unless defined $inflate; - return $inflate->($value, $self); + + return ( + $info->{_inflate_info}{inflate} + || + $self->throw_exception("No inflator found for '$col'") + )->($value, $self); } sub _deflated_column { my ($self, $col, $value) = @_; -# 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"); + + ## Deflate any refs except for literals, pass through plain values + return $value if ( + ! length ref $value + or + is_literal_value($value) + ); + + my $info = $self->result_source->columns_info([$col])->{$col}; + return $value unless exists $info->{_inflate_info}; - my $deflate = $info->{_inflate_info}{deflate}; - $self->throw_exception("No deflator for $col") unless defined $deflate; - return $deflate->($value, $self); + + return ( + $info->{_inflate_info}{deflate} + || + $self->throw_exception("No deflator found for '$col'") + )->($value, $self); } =head2 get_inflated_column @@ -114,20 +148,22 @@ sub _deflated_column { Fetch a column value in its inflated state. This is directly analogous to L in that it only fetches a -column already retreived from the database, and then inflates it. +column already retrieved from the database, and then inflates it. Throws an exception if the column requested is not an inflated column. =cut sub get_inflated_column { my ($self, $col) = @_; + $self->throw_exception("$col is not an inflated column") - unless exists $self->column_info($col)->{_inflate_info}; + unless exists $self->result_source->columns_info->{$col}{_inflate_info}; + + # we take care of keeping things in sync return $self->{_inflated_column}{$col} if exists $self->{_inflated_column}{$col}; my $val = $self->get_column($col); - return $val if ref $val eq 'SCALAR'; #that would be a not-yet-reloaded sclarref update return $self->{_inflated_column}{$col} = $self->_inflated_column($col, $val); } @@ -142,15 +178,22 @@ analogous to L. =cut sub set_inflated_column { - 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}; + my ($self, $col, $value) = @_; + + # pass through deflated stuff + if (! length ref $value or is_literal_value($value)) { + $self->set_column($col, $value); + delete $self->{_inflated_column}{$col}; } - return $inflated; + # need to call set_column with the deflate cycle so that + # relationship caches are nuked if any + # also does the compare-for-dirtyness and change tracking dance + else { + $self->set_column($col, $self->_deflated_column($col, $value)); + $self->{_inflated_column}{$col} = $value; + } + + return $value; } =head2 store_inflated_column @@ -163,15 +206,18 @@ as dirty. This is directly analogous to L. =cut sub store_inflated_column { - my ($self, $col, $inflated) = @_; -# unless (blessed $inflated) { - unless (ref $inflated && ref($inflated) ne 'SCALAR') { - delete $self->{_inflated_column}{$col}; - $self->store_column($col => $inflated); - return $inflated; + my ($self, $col, $value) = @_; + + if (! length ref $value or is_literal_value($value)) { + delete $self->{_inflated_column}{$col}; + $self->store_column($col => $value); + } + else { + delete $self->{_column_data}{$col}; + $self->{_inflated_column}{$col} = $value; } - delete $self->{_column_data}{$col}; - return $self->{_inflated_column}{$col} = $inflated; + + return $value; } =head1 SEE ALSO @@ -184,19 +230,16 @@ sub store_inflated_column { =back -=head1 AUTHOR - -Matt S. Trout - -=head1 CONTRIBUTORS - -Daniel Westermann-Clark (documentation) +=head1 FURTHER QUESTIONS? -Jess Robinson +Check the list of L. -=head1 LICENSE +=head1 COPYRIGHT AND LICENSE -You may distribute this code under the same terms as Perl itself. +This module is free software L +by the L. You can +redistribute it and/or modify it under the same terms as the +L. =cut