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=ce89f3863cb7ed45f8a5ccdb4065f71bd18ba92b;hp=8baa6dd3aa7f212d3acef5d269f712bc226fd358;hb=8cc7f86b76634bbae9ec36aca0cb2669ebe78a18;hpb=26af922f6508d7731f52be6fbb09b3c4bd44b58d diff --git a/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm b/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm index 8baa6dd..ce89f38 100644 --- a/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm +++ b/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm @@ -1,39 +1,69 @@ +use strict; +use warnings; package DBIx::Class::ResultSet::RecursiveUpdate; -use version; $VERSION = qv('0.001'); - -use warnings; -use strict; -use Carp; -use Scalar::Util qw( blessed ); +our $VERSION = '0.012'; use base qw(DBIx::Class::ResultSet); sub recursive_update { my ( $self, $updates, $fixed_fields ) = @_; + return DBIx::Class::ResultSet::RecursiveUpdate::Functions::recursive_update( + resultset => $self, + updates => $updates, + fixed_fields => $fixed_fields + ); +} +package DBIx::Class::ResultSet::RecursiveUpdate::Functions; +use Carp; +use Scalar::Util qw( blessed ); + + +sub recursive_update { + my %params = @_; + my ( $self, $updates, $fixed_fields, $object, $resolved, $if_not_submitted ) = @params{ qw/resultset updates fixed_fields object resolved if_not_submitted/ }; + $resolved ||= {}; # warn 'entering: ' . $self->result_source->from(); + carp 'fixed fields needs to be an array ref' if $fixed_fields && ref($fixed_fields) ne 'ARRAY'; + my %fixed_fields; + %fixed_fields = map { $_ => 1 } @$fixed_fields if $fixed_fields; if ( blessed($updates) && $updates->isa('DBIx::Class::Row') ) { return $updates; } - if ($fixed_fields) { - carp if !( ref($fixed_fields) eq 'HASH' ); - $updates = { %$updates, %$fixed_fields }; + if ( $updates->{id} ){ + $object = $self->find( $updates->{id}, { key => 'primary' } ); } - + my @missing = + grep { !exists $updates->{$_} && !exists $fixed_fields{$_} } $self->result_source->primary_columns; + if ( !$object && !scalar @missing ) { +# warn 'finding by: ' . Dumper( $updates ); use Data::Dumper; + $object = $self->find( $updates, { key => 'primary' } ); + } + $updates = { %$updates, %$resolved }; + @missing = + grep { !exists $resolved->{$_} } @missing; + if ( !$object && !scalar @missing ) { +# warn 'finding by +resolved: ' . Dumper( $updates ); use Data::Dumper; + $object = $self->find( $updates, { key => 'primary' } ); + } + $object ||= $self->new( {} ); + # warn Dumper( $updates ); use Data::Dumper; # direct column accessors my %columns; -# relations that that should be done before the row is inserted into the database -# like belongs_to + # relations that that should be done before the row is inserted into the database + # like belongs_to my %pre_updates; -# relations that that should be done after the row is inserted into the database -# like has_many and might_have + # relations that that should be done after the row is inserted into the database + # like has_many and might_have my %post_updates; - my %columns_by_accessor = $self->_get_columns_by_accessor; - -# warn 'columns_by_accessor: ' . Dumper( \%columns_by_accessor ); use Data::Dumper; + my %other_methods; + my %columns_by_accessor = _get_columns_by_accessor( $self ); +# warn 'resolved: ' . Dumper( $resolved ); +# warn 'updates: ' . Dumper( $updates ); use Data::Dumper; +# warn 'columns: ' . Dumper( \%columns_by_accessor ); for my $name ( keys %$updates ) { my $source = $self->result_source; if ( $columns_by_accessor{$name} @@ -43,11 +73,14 @@ sub recursive_update { $columns{$name} = $updates->{$name}; next; } - next if !$source->has_relationship($name); + if( !( $source->has_relationship($name) ) ){ + $other_methods{$name} = $updates->{$name}; + next; + } my $info = $source->relationship_info($name); if ( _master_relation_cond( - $source, $info->{cond}, $self->_get_pk_for_related($name) + $source, $info->{cond}, _get_pk_for_related( $self, $name) ) ) { @@ -57,44 +90,47 @@ sub recursive_update { $post_updates{$name} = $updates->{$name}; } } + # warn 'other: ' . Dumper( \%other_methods ); use Data::Dumper; - # warn 'columns: ' . Dumper( \%columns ); use Data::Dumper; - - my $object; - my @missing = - grep { !exists $columns{$_} } $self->result_source->primary_columns; - if ( !scalar @missing ) { - $object = $self->find( \%columns, { key => 'primary' } ); - } - $object ||= $self->new( {} ); - -# first update columns and other accessors - so that later related records can be found + # first update columns and other accessors - so that later related records can be found for my $name ( keys %columns ) { - $object->$name( $updates->{$name} ); + $object->$name( $columns{$name} ); + } + for my $name ( keys %other_methods) { + $object->$name( $updates->{$name} ) if $object->can( $name ); } for my $name ( keys %pre_updates ) { my $info = $object->result_source->relationship_info($name); - $self->_update_relation( $name, $updates, $object, $info ); + _update_relation( $self, $name, $updates, $object, $info, $if_not_submitted ); } - $self->_delete_empty_auto_increment($object); - +# $self->_delete_empty_auto_increment($object); # don't allow insert to recurse to related objects - we do the recursion ourselves # $object->{_rel_in_storage} = 1; - $object->update_or_insert; + + $object->update_or_insert if $object->is_changed; # updating many_to_many for my $name ( keys %$updates ) { next if exists $columns{$name}; my $value = $updates->{$name}; - # many to many case - if ( $self->is_m2m($name) ) { - my ($pk) = $self->_get_pk_for_related($name); + if ( is_m2m( $self, $name) ) { + my ($pk) = _get_pk_for_related( $self, $name); my @rows; my $result_source = $object->$name->result_source; - for my $elem ( @{ $updates->{$name} } ) { + my @updates; + if( ! defined $value ){ + next; + } + elsif( ref $value ){ + @updates = @{ $value }; + } + else{ + @updates = ( $value ); + } + for my $elem ( @updates ) { if ( ref $elem ) { - push @rows, $result_source->resultset->find($elem); + push @rows, recursive_update( resultset => $result_source->resultset, updates => $elem ); } else { push @rows, @@ -107,7 +143,7 @@ sub recursive_update { } for my $name ( keys %post_updates ) { my $info = $object->result_source->relationship_info($name); - $self->_update_relation( $name, $updates, $object, $info ); + _update_relation( $self, $name, $updates, $object, $info, $if_not_submitted ); } return $object; } @@ -125,26 +161,63 @@ sub _get_columns_by_accessor { } sub _update_relation { - my ( $self, $name, $updates, $object, $info ) = @_; - + my ( $self, $name, $updates, $object, $info, $if_not_submitted ) = @_; my $related_result = $self->related_resultset($name)->result_source->resultset; - my $resolved = - $self->result_source->resolve_condition( $info->{cond}, $name, $object ); + my $resolved; + if( $self->result_source->can( '_resolve_condition' ) ){ + $resolved = $self->result_source->_resolve_condition( $info->{cond}, $name, $object ); + } + else{ + $resolved = $self->result_source->resolve_condition( $info->{cond}, $name, $object ); + } # warn 'resolved: ' . Dumper( $resolved ); use Data::Dumper; - $resolved = undef - if $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION == $resolved; + $resolved = {} + if defined $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION && $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION == $resolved; if ( ref $updates->{$name} eq 'ARRAY' ) { + my @updated_ids; for my $sub_updates ( @{ $updates->{$name} } ) { my $sub_object = - $related_result->recursive_update( $sub_updates, $resolved ); + recursive_update( resultset => $related_result, updates => $sub_updates, resolved => $resolved ); + push @updated_ids, $sub_object->id; + } + my @related_pks = $related_result->result_source->primary_columns; + if( defined $if_not_submitted && $if_not_submitted eq 'delete' ){ + if ( 1 == scalar @related_pks ){ + $object->$name->search( { $related_pks[0] => { -not_in => \@updated_ids } } )->delete; + } + } + elsif( defined $if_not_submitted && $if_not_submitted eq 'set_to_null' ){ + if ( 1 == scalar @related_pks ){ + my @fk = keys %$resolved; + $object->$name->search( { $related_pks[0] => { -not_in => \@updated_ids } } )->update( { $fk[0] => undef } ); + } } } else { - my $sub_object = - $related_result->recursive_update( $updates->{$name}, $resolved ); - $object->set_from_related( $name, $sub_object ); + my $sub_updates = $updates->{$name}; + my $sub_object; + if( ref $sub_updates ){ + # for might_have relationship + if( $info->{attrs}{accessor} eq 'single' && defined $object->$name ){ + $sub_object = recursive_update( + resultset => $related_result, + updates => $sub_updates, + object => $object->$name + ); + } + else{ + $sub_object = + recursive_update( resultset => $related_result, updates => $sub_updates, resolved => $resolved ); + } + } + elsif( ! ref $sub_updates ){ + $sub_object = $related_result->find( $sub_updates ) + unless (!$sub_updates && ($info->{attrs}{join_type} eq 'LEFT')); + } + $object->set_from_related( $name, $sub_object ) + unless (!$sub_object && !$sub_updates && ($info->{attrs}{join_type} eq 'LEFT')); } } @@ -204,8 +277,8 @@ sub _get_pk_for_related { } # many to many case - if ( $self->is_m2m($relation) ) { - $result_source = $self->get_m2m_source($relation); + if ( is_m2m($self, $relation) ) { + $result_source = get_m2m_source($self, $relation); } return $result_source->primary_columns; } @@ -241,16 +314,33 @@ __END__ =head1 NAME -DBIx::Class::ResultSet::RecursiveUpdate - like update_or_create - but recursive +DBIx::Class::ResultSet::RecursiveUpdate - like update_or_create - but recursive =head1 VERSION -This document describes DBIx::Class::ResultSet::RecursiveUpdate version 0.001 +This document describes DBIx::Class::ResultSet::RecursiveUpdate version 0.006 =head1 SYNOPSIS +The functional interface: + + my $new_item = DBIx::Class::ResultSet::RecursiveUpdate::Functions::recursive_update({ + resultset => $schema->resultset( 'Dvd' ), + updates => { + id => 1, + owned_dvds => [ + { + title => 'One Flew Over the Cuckoo's Nest' + } + ] + } + }); + + +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. @@ -261,7 +351,6 @@ Then: id => 1, owned_dvds => [ { - id => undef, title => 'One Flew Over the Cuckoo's Nest' } ] @@ -270,6 +359,8 @@ Then: =head1 DESCRIPTION +This is still experimental. I've added a functional interface so that it can be used +in Form Processors and not require modification of the model. You can feed the ->create method with a recursive datastructure and have the related records created. Unfortunately you cannot do a similar thing with update_or_create - this module @@ -280,15 +371,35 @@ which works just like update_or_create but can recursively update or create data objects composed of multiple rows. All rows need to be identified by primary keys - so you need to provide them in the update structure (unless they can be deduced from the parent row - for example when you have a belongs_to relationship). -When creating new rows in a table with auto_increment primary keys you need to -put 'undef' for the key value - this is then removed -and a correct INSERT statement is generated. +If not all colums comprising the primary key are specified - then a new row will be created, +with the expectation that the missing columns will be filled by it (as in the case of auto_increment +primary keys). + + +If the resultset itself stores an assignement for the primary key, +like in the case of: + + my $restricted_rs = $user_rs->search( { id => 1 } ); + +then you need to inform recursive_update about additional predicate with a second argument: + + my $user = $restricted_rs->recursive_update( { + owned_dvds => [ + { + title => 'One Flew Over the Cuckoo's Nest' + } + ] + }, + [ 'id' ] + ); + +This will work with a new DBIC release. For a many_to_many (pseudo) relation you can supply a list of primary keys from the other table - and it will link the record at hand to those and only those records identified by them. This is convenient for handling web forms with check boxes (or a SELECT box with multiple choice) that let you -update such (pseudo) relations. +update such (pseudo) relations. For a description how to set up base classes for ResultSets see load_namespaces in DBIx::Class::Schema. @@ -297,14 +408,9 @@ in DBIx::Class::Schema. =head2 Treatment of many to many pseudo relations -Matt Trout expressed following criticism of the support for many to many in -RecursiveUpdate and since this is an extension of his DBIx::Class I feel obliged to -reply to it. It is about two points leading in his opinion to 'fragile and -implicitely broken code'. - -1. That I rely on the fact that - - if($object->can($name) and +The function gets the information about m2m relations from DBIx::Class::IntrospectableM2M. +If it is not loaded in the ResultSource classes - then the code relies on the fact that: + if($object->can($name) and !$object->result_source->has_relationship($name) and $object->can( 'set_' . $name ) ) @@ -313,25 +419,6 @@ then $name must be a many to many pseudo relation. And that in a similarly ugly was I find out what is the ResultSource of objects from that many to many pseudo relation. -2. That I treat uniformly relations and many to many (which are -different from relations because they require traversal of the bridge -table). - -To answer 1) I've refactored that 'dirty' code into is_m2m and get_m2m_source so -that it can be easily overridden. I agree that this code is not too nice - but -currenlty it is the only way to do what I need - and I'll replace it as soon as -there is a more clean way. I don't think it is extremely brittle - sure it will -break if many to many (pseudo) relations don't get 'set_*' methods anymore - but -I would say it is rather justified for this kind of change in underlying library -to break it. - - -Ad 2) - first this is not strictly true - RecursiveUpdate does have -different code to cope with m2m and other cases (see the point above for -example) - but it let's the user to treat m2m and 'normal' relations in a -uniform way. I consider this a form of abstraction - it is the work that -RecursiveUpdate does for the programmer. - =head1 INTERFACE