X-Git-Url: https://git.dogcows.com/gitweb?p=chaz%2Fp5-DBIx-Class-ResultSet-RecursiveUpdate;a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FResultSet%2FRecursiveUpdate.pm;h=8193fb61c0de9a89909efa808cd3f7af0c96652e;hp=78a4bb261f40175cec39ac910f65961795134afa;hb=4ce61ffeb9482993f7c0fb5c09e39f04ec11dbea;hpb=8f5e0a3a71ba1dc147c876d94004cda0d07ec200 diff --git a/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm b/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm index 78a4bb2..8193fb6 100644 --- a/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm +++ b/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm @@ -2,8 +2,7 @@ use strict; use warnings; package DBIx::Class::ResultSet::RecursiveUpdate; - -our $VERSION = '0.013'; +# ABSTRACT: like update_or_create - but recursive use base qw(DBIx::Class::ResultSet); @@ -20,6 +19,7 @@ sub recursive_update { package DBIx::Class::ResultSet::RecursiveUpdate::Functions; use Carp; use Scalar::Util qw( blessed ); +use List::MoreUtils qw/ any /; sub recursive_update { my %params = @_; @@ -77,29 +77,56 @@ sub recursive_update { # warn 'columns: ' . Dumper( \%columns_by_accessor ); for my $name ( keys %$updates ) { my $source = $self->result_source; - if ( $columns_by_accessor{$name} + + # columns + if ( exists $columns_by_accessor{$name} && !( $source->has_relationship($name) && ref( $updates->{$name} ) ) ) { + + #warn "$name is a column\n"; $columns{$name} = $updates->{$name}; next; } - if ( !( $source->has_relationship($name) ) ) { + + # relationships + if ( $source->has_relationship($name) ) { + if ( _master_relation_cond( $self, $name ) ) { + + #warn "$name is a pre-update rel\n"; + $pre_updates{$name} = $updates->{$name}; + next; + } + else { + + #warn "$name is a post-update rel\n"; + $post_updates{$name} = $updates->{$name}; + next; + } + } + + # many-to-many helper accessors + if ( is_m2m( $self, $name ) ) { + + #warn "$name is a many-to-many helper accessor\n"; $other_methods{$name} = $updates->{$name}; next; } - my $info = $source->relationship_info($name); - if (_master_relation_cond( - $source, $info->{cond}, - _get_pk_for_related( $self, $name ) - ) - ) - { - $pre_updates{$name} = $updates->{$name}; - } - else { - $post_updates{$name} = $updates->{$name}; + + # accessors + if ( $object->can($name) && not $source->has_relationship($name) ) { + + #warn "$name is an accessor"; + $other_methods{$name} = $updates->{$name}; + next; } + + # unknown + # TODO: don't throw a warning instead of an exception to give users + # time to adapt to the new API + $self->throw_exception( + "No such column, relationship, many-to-many helper accessor or generic accessor '$name'" + ); } # warn 'other: ' . Dumper( \%other_methods ); use Data::Dumper; @@ -107,13 +134,19 @@ sub recursive_update { # first update columns and other accessors # so that later related records can be found for my $name ( keys %columns ) { + + #warn "update col $name\n"; $object->$name( $columns{$name} ); } for my $name ( keys %other_methods ) { - $object->$name( $updates->{$name} ) if $object->can($name); + + #warn "update other $name\n"; + $object->$name( $updates->{$name} ); } for my $name ( keys %pre_updates ) { - _update_relation( $self, $name, $updates->{$name}, $object, + + #warn "pre_update $name\n"; + _update_relation( $self, $name, $pre_updates{$name}, $object, $if_not_submitted ); } @@ -121,7 +154,10 @@ sub recursive_update { # don't allow insert to recurse to related objects # do the recursion ourselves # $object->{_rel_in_storage} = 1; + #warn "CHANGED: " . $object->is_changed . "\n": + #warn "IN STOR: " . $object->in_storage . "\n"; $object->update_or_insert if $object->is_changed; + $object->discard_changes; # updating many_to_many for my $name ( keys %$updates ) { @@ -129,6 +165,8 @@ sub recursive_update { my $value = $updates->{$name}; if ( is_m2m( $self, $name ) ) { + + #warn "update m2m $name\n"; my ($pk) = _get_pk_for_related( $self, $name ); my @rows; my $result_source = $object->$name->result_source; @@ -160,7 +198,9 @@ sub recursive_update { } } for my $name ( keys %post_updates ) { - _update_relation( $self, $name, $updates->{$name}, $object, + + #warn "post_update $name\n"; + _update_relation( $self, $name, $post_updates{$name}, $object, $if_not_submitted ); } return $object; @@ -179,10 +219,17 @@ sub _get_columns_by_accessor { return %columns; } -# Arguments: $name, $updates, $object, $if_not_submitted - +# Arguments: $rs, $name, $updates, $row, $if_not_submitted sub _update_relation { my ( $self, $name, $updates, $object, $if_not_submitted ) = @_; + + # this should never happen because we're checking the paramters passed to + # recursive_update, but just to be sure... + $object->throw_exception("No such relationship '$name'") + unless $object->has_relationship($name); + + #warn "_update_relation $name: OBJ: " . ref($object) . "\n"; + my $info = $object->result_source->relationship_info($name); # get a related resultset without a condition @@ -194,6 +241,10 @@ sub _update_relation { $self->result_source->_resolve_condition( $info->{cond}, $name, $object ); } + else { + $self->throw_exception( + "result_source must support _resolve_condition"); + } # warn "$name resolved: " . Dumper( $resolved ); use Data::Dumper; $resolved = {} @@ -201,41 +252,100 @@ sub _update_relation { && $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION == $resolved; - # an arrayref is only valid for has_many rels - if ( ref $updates eq 'ARRAY' ) { - my @updated_ids; + my @rel_cols = keys %{ $info->{cond} }; + map {s/^foreign\.//} @rel_cols; + + #warn "REL_COLS: " . Dumper(@rel_cols); use Data::Dumper; + #my $rel_col_cnt = scalar @rel_cols; + + # find out if all related columns are nullable + my $all_fks_nullable = 1; + for my $rel_col (@rel_cols) { + $all_fks_nullable = 0 + unless $related_resultset->result_source->column_info($rel_col) + ->{is_nullable}; + } + + $if_not_submitted = $all_fks_nullable ? 'nullify' : 'delete' + unless defined $if_not_submitted; + + #warn "\tNULLABLE: $all_fks_nullable ACTION: $if_not_submitted\n"; + + #warn "RELINFO for $name: " . Dumper($info); use Data::Dumper; + + # the only valid datatype for a has_many rels is an arrayref + if ( $info->{attrs}{accessor} eq 'multi' ) { + + # handle undef like empty arrayref + $updates = [] + unless defined $updates; + $self->throw_exception( + "data for has_many relationship '$name' must be an arrayref") + unless ref $updates eq 'ARRAY'; + + my @updated_objs; + + #warn "\tupdating has_many rel '$name' ($rel_col_cnt columns cols)\n"; for my $sub_updates ( @{$updates} ) { my $sub_object = recursive_update( resultset => $related_resultset, updates => $sub_updates, resolved => $resolved ); - push @updated_ids, $sub_object->id; + + push @updated_objs, $sub_object; } + + #warn "\tcreated and updated related rows\n"; + my @related_pks = $related_resultset->result_source->primary_columns; - if ( defined $if_not_submitted && $if_not_submitted eq 'delete' ) { - # only handles related result classes with single primary keys - if ( 1 == scalar @related_pks ) { - $object->$name->search( - { $related_pks[0] => { -not_in => \@updated_ids } } ) - ->delete; - } + my $rs_rel_delist = $object->$name; + + # foreign table has a single pk column + if ( scalar @related_pks == 1 ) { + $rs_rel_delist = $rs_rel_delist->search_rs( + { $related_pks[0] => + { -not_in => [ map ( $_->id, @updated_objs ) ] } + } + ); } - elsif ( defined $if_not_submitted - && $if_not_submitted eq 'set_to_null' ) - { - # only handles related result classes with single primary keys - if ( 1 == scalar @related_pks ) { - my @fk = keys %$resolved; - $object->$name->search( - { $related_pks[0] => { -not_in => \@updated_ids } } ) - ->update( { $fk[0] => undef } ); + # foreign table has multiple pk columns + else { + my @cond; + for my $obj (@updated_objs) { + my %cond_for_obj; + for my $col (@related_pks) { + $cond_for_obj{$col} = $obj->get_column($col); + } + push @cond, \%cond_for_obj; + } + # only limit resultset if there are related rows left + if (scalar @cond) { + $rs_rel_delist = $rs_rel_delist->search_rs( { -not => [@cond] } ); } } + + #warn "\tCOND: " . Dumper(\%cond); + #my $rel_delist_cnt = $rs_rel_delist->count; + if ( $if_not_submitted eq 'delete' ) { + + #warn "\tdeleting related rows: $rel_delist_cnt\n"; + $rs_rel_delist->delete; + } + elsif ( $if_not_submitted eq 'set_to_null' ) { + + #warn "\tnullifying related rows: $rel_delist_cnt\n"; + my %update = map { $_ => undef } @rel_cols; + $rs_rel_delist->update( \%update ); + } } - else { + elsif ($info->{attrs}{accessor} eq 'single' + || $info->{attrs}{accessor} eq 'filter' ) + { + + #warn "\tupdating rel '$name': $if_not_submitted\n"; my $sub_object; if ( ref $updates ) { @@ -257,7 +367,7 @@ sub _update_relation { ); } } - elsif ( !ref $updates ) { + else { $sub_object = $related_resultset->find($updates) unless ( !$updates @@ -273,6 +383,11 @@ sub _update_relation { && $info->{attrs}{join_type} eq 'LEFT' ) ); } + else { + $self->throw_exception( + "recursive_update doesn't now how to handle relationship '$name' with accessor " + . $info->{attrs}{accessor} ); + } } sub is_m2m { @@ -340,74 +455,97 @@ sub _get_pk_for_related { # after the row is inserted into the database # relationships before: belongs_to # relationships after: has_many, might_have and has_one +# true means before, false after sub _master_relation_cond { - my ( $source, $cond, @foreign_ids ) = @_; - my $foreign_ids_re = join '|', @foreign_ids; - if ( ref $cond eq 'HASH' ) { - for my $f_key ( keys %{$cond} ) { + my ( $self, $name ) = @_; + + my $source = $self->result_source; + my $info = $source->relationship_info($name); + + #warn "INFO: " . Dumper($info) . "\n"; + + # has_many rels are always after + return 0 + if $info->{attrs}->{accessor} eq 'multi'; + + my @foreign_ids = _get_pk_for_related( $self, $name ); + + #warn "IDS: " . join(', ', @foreign_ids) . "\n"; + + my $cond = $info->{cond}; + + sub _inner { + my ( $source, $cond, @foreign_ids ) = @_; + + while ( my ( $f_key, $col ) = each %{$cond} ) { # might_have is not master - my $col = $cond->{$f_key}; - $col =~ s/self\.//; + $col =~ s/^self\.//; + $f_key =~ s/^foreign\.//; if ( $source->column_info($col)->{is_auto_increment} ) { return 0; } - if ( $f_key =~ /^foreign\.$foreign_ids_re/ ) { + if ( any { $_ eq $f_key } @foreign_ids ) { return 1; } } + return 0; + } + + if ( ref $cond eq 'HASH' ) { + return _inner( $source, $cond, @foreign_ids ); } + + # arrayref of hashrefs elsif ( ref $cond eq 'ARRAY' ) { for my $new_cond (@$cond) { - return _master_relation_cond( $source, $new_cond, @foreign_ids ); + return _inner( $source, $new_cond, @foreign_ids ); } } + else { + $source->throw_exception( + "unhandled relation condition " . ref($cond) ); + } return; } 1; # Magic true value required at end of module __END__ -=head1 NAME - -DBIx::Class::ResultSet::RecursiveUpdate - like update_or_create - but recursive - =head1 SYNOPSIS -The functional interface: + # The functional interface: + my $schema = MyDB::Schema->connect(); my $new_item = DBIx::Class::ResultSet::RecursiveUpdate::Functions::recursive_update({ - resultset => $schema->resultset( 'Dvd' ), + resultset => $schema->resultset('User'), updates => { - id => 1, - owned_dvds => [ - { - title => 'One Flew Over the Cuckoo's Nest' - } - ] + id => 1, + owned_dvds => [ + { + title => "One Flew Over the Cuckoo's Nest" + } + ] } }); -As ResultSet subclass: + # As ResultSet subclass: __PACKAGE__->load_namespaces( default_resultset_class => '+DBIx::Class::ResultSet::RecursiveUpdate' ); -in the Schema file (see t/lib/DBSchema.pm). Or appriopriate 'use base' in the ResultSet classes. + # in the Schema file (see t/lib/DBSchema.pm). Or appriopriate 'use base' in the ResultSet classes. -Then: + my $user = $schema->resultset('User')->recursive_update({ + id => 1, + owned_dvds => [ + { + title => "One Flew Over the Cuckoo's Nest" + } + ] + }); - my $user = $user_rs->recursive_update( { - id => 1, - owned_dvds => [ - { - title => 'One Flew Over the Cuckoo's Nest' - } - ] - } - ); - =head1 DESCRIPTION This is still experimental. I've added a functional interface so that it can be used @@ -631,40 +769,3 @@ No bugs have been reported. Please report any bugs or feature requests to C, or through the web interface at L. - - -=head1 AUTHOR - -Zbigniew Lukasiak C<< >> -Influenced by code by Pedro Melo. - -=head1 LICENCE AND COPYRIGHT - -Copyright (c) 2008, Zbigniew Lukasiak C<< >>. All rights reserved. - -This module is free software; you can redistribute it and/or -modify it under the same terms as Perl itself. See L. - - -=head1 DISCLAIMER OF WARRANTY - -BECAUSE THIS SOFTWARE IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY -FOR THE SOFTWARE, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN -OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES -PROVIDE THE SOFTWARE "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER -EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE -ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE SOFTWARE IS WITH -YOU. SHOULD THE SOFTWARE PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL -NECESSARY SERVICING, REPAIR, OR CORRECTION. - -IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING -WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR -REDISTRIBUTE THE SOFTWARE AS PERMITTED BY THE ABOVE LICENCE, BE -LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL, -OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE -THE SOFTWARE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING -RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A -FAILURE OF THE SOFTWARE TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF -SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF -SUCH DAMAGES.