From: David Kamholz Date: Sat, 2 Dec 2006 06:06:15 +0000 (+0000) Subject: inline relationship and inflate code for new, update, get_column, set_column, etc. X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=61a622eec072005b2ef23c27d539d795e4bcf6b6;p=dbsrgits%2FDBIx-Class-Historic.git inline relationship and inflate code for new, update, get_column, set_column, etc. --- diff --git a/lib/DBIx/Class/InflateColumn.pm b/lib/DBIx/Class/InflateColumn.pm index 1168157..b88ec0c 100644 --- a/lib/DBIx/Class/InflateColumn.pm +++ b/lib/DBIx/Class/InflateColumn.pm @@ -155,93 +155,6 @@ sub store_inflated_column { return $self->{_inflated_column}{$col} = $obj; } -=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 - -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, 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}); - } - } - 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; -} - =head1 SEE ALSO =over 4 diff --git a/lib/DBIx/Class/Relationship/Accessor.pm b/lib/DBIx/Class/Relationship/Accessor.pm index b77ce00..b20eb16 100644 --- a/lib/DBIx/Class/Relationship/Accessor.pm +++ b/lib/DBIx/Class/Relationship/Accessor.pm @@ -62,39 +62,4 @@ sub add_relationship_accessor { } } -sub new { - my ($class, $attrs, @rest) = @_; - my ($related, $info); - foreach my $key (keys %{$attrs||{}}) { - next unless $info = $class->relationship_info($key); - $related->{$key} = delete $attrs->{$key} - if ref $attrs->{$key} - && $info->{attrs}{accessor} - && $info->{attrs}{accessor} eq 'single'; - } - my $obj = $class->next::method($attrs, @rest); - if ($related) { - $obj->{_relationship_data} = $related; - foreach my $rel (keys %$related) { - $obj->set_from_related($rel, $related->{$rel}); - } - } - return $obj; -} - -sub update { - my ($obj, $attrs, @rest) = @_; - my $info; - foreach my $key (keys %{$attrs||{}}) { - next unless $info = $obj->relationship_info($key); - if (ref $attrs->{$key} && $info->{attrs}{accessor} - && $info->{attrs}{accessor} eq 'single') { - my $rel = delete $attrs->{$key}; - $obj->set_from_related($key => $rel); - $obj->{_relationship_data}{$key} = $rel; - } - } - return $obj->next::method($attrs, @rest); -} - 1; diff --git a/lib/DBIx/Class/Row.pm b/lib/DBIx/Class/Row.pm index ae72e6f..baed842 100644 --- a/lib/DBIx/Class/Row.pm +++ b/lib/DBIx/Class/Row.pm @@ -42,11 +42,31 @@ sub new { if (my $source = delete $attrs->{-result_source}) { $new->result_source($source); } - foreach my $k (keys %$attrs) { - $new->throw_exception("No such column $k on $class") - unless $class->has_column($k); - $new->store_column($k => $attrs->{$k}); + + my ($related,$inflated); + foreach my $key (keys %$attrs) { + if (ref $attrs->{$key}) { + my $info = $class->relationship_info($key); + if ($info && $info->{attrs}{accessor} + && $info->{attrs}{accessor} eq 'single') + { + $new->set_from_related($key, $attrs->{$key}); + $related->{$key} = $attrs->{$key}; + next; + } + elsif ($class->has_column($key) + && exists $class->column_info($key)->{_inflate_info}) + { + $inflated->{$key} = $attrs->{$key}; + next; + } + } + $new->throw_exception("No such column $key on $class") + unless $class->has_column($key); + $new->store_column($key => $attrs->{$key}); } + $new->{_relationship_data} = $related if $related; + $new->{_inflated_column} = $inflated if $inflated; } return $new; @@ -111,7 +131,26 @@ sub update { my $ident_cond = $self->ident_condition; $self->throw_exception("Cannot safely update a row in a PK-less table") if ! keys %$ident_cond; - $self->set_columns($upd) if $upd; + if ($upd) { + foreach my $key (keys %$upd) { + if (ref $upd->{$key}) { + my $info = $self->relationship_info($key); + if ($info && $info->{attrs}{accessor} + && $info->{attrs}{accessor} eq 'single') + { + my $rel = delete $upd->{$key}; + $self->set_from_related($key => $rel); + $self->{_relationship_data}{$key} = $rel; + } + elsif ($self->has_column($key) + && exists $self->column_info($key)->{_inflate_info}) + { + $self->set_inflated_column($key, delete $upd->{$key}); + } + } + } + $self->set_columns($upd); + } my %to_update = $self->get_dirty_columns; return $self unless keys %to_update; my $rows = $self->result_source->storage->update( @@ -131,8 +170,8 @@ sub update { $obj->delete Deletes the object from the database. The object is still perfectly -usable, but C<-Ein_storage()> will now return 0 and the object must -reinserted using C<-Einsert()> before C<-E(update()> can be used +usable, but C<< ->in_storage() >> will now return 0 and the object must +reinserted using C<< ->insert() >> before C<< ->update() >> can be used on it. If you delete an object in a class with a C relationship, all the related objects will be deleted as well. To turn this behavior off, pass C 0> in the C<$attr> @@ -169,9 +208,10 @@ sub delete { my $val = $obj->get_column($col); -Gets a column value from a row object. Currently, does not do -any queries; the column must have already been fetched from -the database and stored in the object. +Gets a column value from a row object. Does not do any queries; the column +must have already been fetched from the database and stored in the object. If +there is an inflated value stored that has not yet been deflated, it is deflated +when the method is invoked. =cut @@ -179,6 +219,10 @@ sub get_column { my ($self, $column) = @_; $self->throw_exception( "Can't fetch data as class method" ) unless ref $self; return $self->{_column_data}{$column} if exists $self->{_column_data}{$column}; + if (exists $self->{_inflated_column}{$column}) { + return $self->store_column($column, + $self->_deflated_column($column, $self->{_inflated_column}{$column})); + } $self->throw_exception( "No such column '${column}'" ) unless $self->has_column($column); return undef; } @@ -190,13 +234,14 @@ sub get_column { } Returns a true value if the column value has been loaded from the -database (or set locally). +database (or set locally). =cut sub has_column_loaded { my ($self, $column) = @_; $self->throw_exception( "Can't call has_column data as class method" ) unless ref $self; + return 1 if exists $self->{_inflated_column}{$column}; return exists $self->{_column_data}{$column}; } @@ -210,6 +255,12 @@ Does C, for all column values at once. 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->{_column_data}}; }