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=78a4bb261f40175cec39ac910f65961795134afa;hp=0997ff3a8bf854ea4412fcfe89487a9ead358fb6;hb=8f5e0a3a71ba1dc147c876d94004cda0d07ec200;hpb=4bb09f7fc7ffdb7adf715d4c42b9be6624809f7d diff --git a/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm b/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm index 0997ff3..78a4bb2 100644 --- a/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm +++ b/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm @@ -1,67 +1,99 @@ use strict; use warnings; + package DBIx::Class::ResultSet::RecursiveUpdate; -use version; our $VERSION = qv('0.005'); +our $VERSION = '0.013'; use base qw(DBIx::Class::ResultSet); sub recursive_update { my ( $self, $updates, $fixed_fields ) = @_; - return DBIx::Class::ResultSet::RecursiveUpdate::Functions::recursive_update( + 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 ) = @params{ qw/resultset updates fixed_fields object/ }; + 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'; + 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 ( $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, might_have and has_one my %post_updates; my %other_methods; - my %columns_by_accessor = _get_columns_by_accessor( $self ); + 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} - && !( $source->has_relationship($name) && ref( $updates->{$name} ) ) - ) + && !( $source->has_relationship($name) + && ref( $updates->{$name} ) ) ) { $columns{$name} = $updates->{$name}; 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}, _get_pk_for_related( $self, $name) + if (_master_relation_cond( + $source, $info->{cond}, + _get_pk_for_related( $self, $name ) + ) ) - ) { $pre_updates{$name} = $updates->{$name}; } @@ -69,47 +101,58 @@ sub recursive_update { $post_updates{$name} = $updates->{$name}; } } - # warn 'other: ' . Dumper( \%other_methods ); use Data::Dumper; - my @missing = - grep { !exists $columns{$_} && !exists $fixed_fields{$_} } $self->result_source->primary_columns; - if ( !$object && !scalar @missing ) { - $object = $self->find( \%columns, { key => 'primary' } ); - } - $object ||= $self->new( {} ); + # warn 'other: ' . Dumper( \%other_methods ); use Data::Dumper; - # 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 %other_methods ) { + $object->$name( $updates->{$name} ) if $object->can($name); } for my $name ( keys %pre_updates ) { - my $info = $object->result_source->relationship_info($name); - _update_relation( $self, $name, $updates, $object, $info ); + _update_relation( $self, $name, $updates->{$name}, $object, + $if_not_submitted ); } -# $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; + + # $self->_delete_empty_auto_increment($object); + # don't allow insert to recurse to related objects + # do the recursion ourselves + # $object->{_rel_in_storage} = 1; + $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}; - if ( is_m2m( $self, $name) ) { - my ($pk) = _get_pk_for_related( $self, $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, - $result_source->resultset->find( { $pk => $elem } ); + $result_source->resultset->find( { $pk => $elem } ); } } my $set_meth = 'set_' . $name; @@ -117,12 +160,13 @@ sub recursive_update { } } for my $name ( keys %post_updates ) { - my $info = $object->result_source->relationship_info($name); - _update_relation( $self, $name, $updates, $object, $info ); + _update_relation( $self, $name, $updates->{$name}, $object, + $if_not_submitted ); } return $object; } +# returns DBIx::Class::ResultSource::column_info as a hash indexed by column accessor || name sub _get_columns_by_accessor { my $self = shift; my $source = $self->result_source; @@ -135,45 +179,99 @@ sub _get_columns_by_accessor { return %columns; } +# Arguments: $name, $updates, $object, $if_not_submitted + sub _update_relation { - my ( $self, $name, $updates, $object, $info ) = @_; - my $related_result = - $self->related_resultset($name)->result_source->resultset; - my $resolved = - $self->result_source->resolve_condition( $info->{cond}, $name, $object ); - - # warn 'resolved: ' . Dumper( $resolved ); use Data::Dumper; - $resolved = undef - if defined $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION && $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION == $resolved; - if ( ref $updates->{$name} eq 'ARRAY' ) { - for my $sub_updates ( @{ $updates->{$name} } ) { - $sub_updates = { %$sub_updates, %$resolved } if $resolved && ref( $sub_updates ) eq 'HASH'; - my $sub_object = - recursive_update( resultset => $related_result, updates => $sub_updates ); + my ( $self, $name, $updates, $object, $if_not_submitted ) = @_; + my $info = $object->result_source->relationship_info($name); + + # get a related resultset without a condition + my $related_resultset = + $self->related_resultset($name)->result_source->resultset; + my $resolved; + if ( $self->result_source->can('_resolve_condition') ) { + $resolved = + $self->result_source->_resolve_condition( $info->{cond}, $name, + $object ); + } + + # warn "$name resolved: " . Dumper( $resolved ); use Data::Dumper; + $resolved = {} + if defined $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION + && $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION + == $resolved; + + # an arrayref is only valid for has_many rels + if ( ref $updates eq 'ARRAY' ) { + my @updated_ids; + for my $sub_updates ( @{$updates} ) { + my $sub_object = recursive_update( + resultset => $related_resultset, + updates => $sub_updates, + resolved => $resolved + ); + push @updated_ids, $sub_object->id; + } + 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; + } + } + 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 } ); + } } } else { - my $sub_updates = $updates->{$name}; my $sub_object; - if( ref $sub_updates ){ - $sub_updates = { %$sub_updates, %$resolved } if $resolved && ref( $sub_updates ) eq 'HASH'; + if ( ref $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 + if ( $info->{attrs}{accessor} eq 'single' + && defined $object->$name ) + { + $sub_object = recursive_update( + resultset => $related_resultset, + updates => $updates, + object => $object->$name ); } - else{ - $sub_object = - recursive_update( resultset => $related_result, updates => $sub_updates ); + else { + $sub_object = recursive_update( + resultset => $related_resultset, + updates => $updates, + resolved => $resolved + ); } } - elsif( ! ref $sub_updates ){ - $sub_object = $related_result->find( $sub_updates ); + elsif ( !ref $updates ) { + $sub_object = $related_resultset->find($updates) + unless ( + !$updates + && ( exists $info->{attrs}{join_type} + && $info->{attrs}{join_type} eq 'LEFT' ) + ); } - $object->set_from_related( $name, $sub_object ); + $object->set_from_related( $name, $sub_object ) + unless ( + !$sub_object + && !$updates + && ( exists $info->{attrs}{join_type} + && $info->{attrs}{join_type} eq 'LEFT' ) + ); } } @@ -203,7 +301,7 @@ sub get_m2m_source { if ( $rclass->can('_m2m_metadata') ) { return $self->result_source->related_source( $rclass->_m2m_metadata->{$relation}{relation} ) - ->related_source( + ->related_source( $rclass->_m2m_metadata->{$relation}{foreign_relation} ); } my $object = $self->new( {} ); @@ -214,11 +312,10 @@ sub get_m2m_source { sub _delete_empty_auto_increment { my ( $self, $object ) = @_; for my $col ( keys %{ $object->{_column_data} } ) { - if ( - $object->result_source->column_info($col)->{is_auto_increment} + if ($object->result_source->column_info($col)->{is_auto_increment} and ( !defined $object->{_column_data}{$col} or $object->{_column_data}{$col} eq '' ) - ) + ) { delete $object->{_column_data}{$col}; } @@ -233,12 +330,16 @@ sub _get_pk_for_related { } # many to many case - if ( is_m2m($self, $relation) ) { - $result_source = get_m2m_source($self, $relation); + if ( is_m2m( $self, $relation ) ) { + $result_source = get_m2m_source( $self, $relation ); } return $result_source->primary_columns; } +# This function determines wheter a relationship should be done before or +# after the row is inserted into the database +# relationships before: belongs_to +# relationships after: has_many, might_have and has_one sub _master_relation_cond { my ( $source, $cond, @foreign_ids ) = @_; my $foreign_ids_re = join '|', @foreign_ids; @@ -258,8 +359,7 @@ sub _master_relation_cond { } elsif ( ref $cond eq 'ARRAY' ) { for my $new_cond (@$cond) { - return 1 - if _master_relation_cond( $source, $new_cond, @foreign_ids ); + return _master_relation_cond( $source, $new_cond, @foreign_ids ); } } return; @@ -272,25 +372,21 @@ __END__ DBIx::Class::ResultSet::RecursiveUpdate - like update_or_create - but recursive - -=head1 VERSION - -This document describes DBIx::Class::ResultSet::RecursiveUpdate version 0.004 - - =head1 SYNOPSIS The functional interface: my $new_item = DBIx::Class::ResultSet::RecursiveUpdate::Functions::recursive_update({ - id => 1, - owned_dvds => [ - { - title => 'One Flew Over the Cuckoo's Nest' - } - ] - } - ); + resultset => $schema->resultset( 'Dvd' ), + updates => { + id => 1, + owned_dvds => [ + { + title => 'One Flew Over the Cuckoo's Nest' + } + ] + } + }); As ResultSet subclass: @@ -313,6 +409,7 @@ 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. @@ -360,18 +457,136 @@ in DBIx::Class::Schema. =head1 DESIGN CHOICES -=head2 Treatment of many to many pseudo relations +Columns and relationships which are excluded from the updates hashref aren't +touched at all. + +=head2 Treatment of belongs_to relations + +In case the relationship is included but undefined in the updates hashref, +all columns forming the relationship will be set to null. +If not all of them are nullable, DBIx::Class will throw an error. + +Updating the relationship: + + my $dvd = $dvd_rs->recursive_update( { + id => 1, + owner => $user->id, + }); + +Clearing the relationship (only works if cols are nullable!): + + my $dvd = $dvd_rs->recursive_update( { + id => 1, + owner => undef, + }); + +=head2 Treatment of might_have relationships + +In case the relationship is included but undefined in the updates hashref, +all columns forming the relationship will be set to null. + +Updating the relationship: + + my $user = $user_rs->recursive_update( { + id => 1, + address => { + street => "101 Main Street", + city => "Podunk", + state => "New York", + } + }); + +Clearing the relationship: + + my $user = $user_rs->recursive_update( { + id => 1, + address => undef, + }); + +=head2 Treatment of has_many relations + +If a relationship key is included in the data structure with a value of undef +or an empty array, all existing related rows will be deleted, or their foreign +key columns will be set to null. + +The exact behaviour depends on the nullability of the foreign key columns and +the value of the "if_not_submitted" parameter. The parameter defaults to +undefined which neither nullifies nor deletes. + +When the array contains elements they are updated if they exist, created when +not and deleted if not included. + +=head3 All foreign table columns are nullable + +In this case recursive_update defaults to nullifying the foreign columns. + +=head3 Not all foreign table columns are nullable + +In this case recursive_update deletes the foreign rows. + +Updating the relationship: + + Passing ids: + + my $dvd = $dvd_rs->recursive_update( { + id => 1, + tags => [1, 2], + }); + + Passing hashrefs: + + my $dvd = $dvd_rs->recursive_update( { + id => 1, + tags => [ + { + id => 1, + file => 'file0' + }, + { + id => 2, + file => 'file1', + }, + ], + }); + + Passing objects: + + TODO + + You can even mix them: + + my $dvd = $dvd_rs->recursive_update( { + id => 1, + tags => [ '2', { id => '3' } ], + }); + +Clearing the relationship: + + my $dvd = $dvd_rs->recursive_update( { + id => 1, + tags => undef, + }); + + This is the same as passing an empty array: + + my $dvd = $dvd_rs->recursive_update( { + id => 1, + tags => [], + }); + +=head2 Treatment of many-to-many pseudo relations 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 it isn't loaded in the ResultSource classes the code relies on the fact that: + if($object->can($name) and !$object->result_source->has_relationship($name) and $object->can( 'set_' . $name ) ) -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. +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. =head1 INTERFACE @@ -406,15 +621,11 @@ DBIx::Class::RecursiveUpdate requires no configuration files or environment vari =head1 INCOMPATIBILITIES -=for author to fill in: - None reported. =head1 BUGS AND LIMITATIONS -=for author to fill in: - No bugs have been reported. Please report any bugs or feature requests to