X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FInflateColumn.pm;h=c16375d2d2e3ff792c26c5969dd12c2eb1091b9b;hb=HEAD;hp=84f86b89a37f425778e1652e49a5a500b2d3ef5f;hpb=ad5d0ee95a0b857e14c822818c3fe6059d022c40;p=dbsrgits%2FDBIx-Class.git diff --git a/lib/DBIx/Class/InflateColumn.pm b/lib/DBIx/Class/InflateColumn.pm index 84f86b8..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 @@ -25,12 +32,19 @@ 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 objects for your date and time fields. +L objects for your date and time fields. There's a +convenience component to actually do that though, try +L. + +It will handle all types of references except scalar references. It +will not handle scalar values, these are ignored and thus passed +through to L. This is to allow setting raw values to +"just work". Scalar references are passed through to the database to +deal with, to allow such settings as C< \'year + 1'> and C< \'DEFAULT' > +to work. -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. +If you want to filter plain scalar values and replace them with +something else, see L. =head1 METHODS @@ -48,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 >> on -it, 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; - $self->mk_group_accessors('inflated_column' => $col); + + $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 @@ -107,19 +148,24 @@ 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}; - return $self->{_inflated_column}{$col} = - $self->_inflated_column($col, $self->get_column($col)); + + my $val = $self->get_column($col); + + return $self->{_inflated_column}{$col} = $self->_inflated_column($col, $val); } =head2 set_inflated_column @@ -132,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 @@ -153,102 +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; - } - delete $self->{_column_data}{$col}; - return $self->{_inflated_column}{$col} = $inflated; -} - -=head2 get_column - -Gets a column value in the same way as L. 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. Handles inflation just -like L. - -=cut + my ($self, $col, $value) = @_; -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}; - } + if (! length ref $value or is_literal_value($value)) { + delete $self->{_inflated_column}{$col}; + $self->store_column($col => $value); } - return $self->next::method; -} - -=head2 has_column_loaded - -Like L, 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, 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}); - } + else { + delete $self->{_column_data}{$col}; + $self->{_inflated_column}{$col} = $value; } - return $class->next::method($attrs, @rest); -} - -=head2 new -Creates a row in the same way as L, 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; + return $value; } =head1 SEE ALSO @@ -256,24 +225,21 @@ sub new { =over 4 =item L - This component is loaded as part of the - "core" L components; generally there is no need to + C L components; generally there is no need to load it directly =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