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=8baa6dd3aa7f212d3acef5d269f712bc226fd358;hp=5934bc4936957a5c2e85fb6514cc3583271cf74d;hb=26af922f6508d7731f52be6fbb09b3c4bd44b58d;hpb=424363ed169eae916480670bea2363322285855a diff --git a/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm b/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm index 5934bc4..8baa6dd 100644 --- a/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm +++ b/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm @@ -1,153 +1,242 @@ package DBIx::Class::ResultSet::RecursiveUpdate; -use version; $VERSION = qv('0.0.1'); +use version; $VERSION = qv('0.001'); use warnings; use strict; use Carp; +use Scalar::Util qw( blessed ); use base qw(DBIx::Class::ResultSet); -sub recursive_update { - my( $self, $updates ) = @_; - my $object; - # this is a workaround for a bug in the svn version 4794 - if ( ref $self->{cond} eq 'ARRAY' and ref $self->{cond}[0] eq 'SCALAR' ){ - $self->{cond} = {}; - $object = $self->new( {} ); +sub recursive_update { + my ( $self, $updates, $fixed_fields ) = @_; + + # warn 'entering: ' . $self->result_source->from(); + if ( blessed($updates) && $updates->isa('DBIx::Class::Row') ) { + return $updates; } - else { - $object = $self->find( $updates, { key => 'primary' } ) || $self->new( {} ); + if ($fixed_fields) { + carp if !( ref($fixed_fields) eq 'HASH' ); + $updates = { %$updates, %$fixed_fields }; } - for my $name ( keys %$updates ){ if($object->can($name)){ - my $value = $updates->{$name}; - # updating relations that that should be done before the row is inserted into the database - # like belongs_to - if( $object->result_source->has_relationship($name) - and - ref $value - ){ - my $info = $object->result_source->relationship_info( $name ); - if( $info and not $info->{attrs}{accessor} eq 'multi' - and - _master_relation_cond( $object, $info->{cond}, _get_pk_for_related( $object, $name ) ) - ){ - my $related_result = $object->related_resultset( $name ); - $DB::single = 1; - my $sub_object = $related_result->recursive_update( $value ); - $object->set_from_related( $name, $sub_object ); - } - } - # columns and other accessors - elsif( $object->result_source->has_column($name) - or - !$object->can( 'set_' . $name ) - ) { - $object->$name($value); - } + # direct column accessors + my %columns; + +# 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 + my %post_updates; + my %columns_by_accessor = $self->_get_columns_by_accessor; + +# warn 'columns_by_accessor: ' . Dumper( \%columns_by_accessor ); use Data::Dumper; + for my $name ( keys %$updates ) { + my $source = $self->result_source; + if ( $columns_by_accessor{$name} + && !( $source->has_relationship($name) && ref( $updates->{$name} ) ) + ) + { + $columns{$name} = $updates->{$name}; + next; + } + next if !$source->has_relationship($name); + my $info = $source->relationship_info($name); + if ( + _master_relation_cond( + $source, $info->{cond}, $self->_get_pk_for_related($name) + ) + ) + { + $pre_updates{$name} = $updates->{$name}; + } + else { + $post_updates{$name} = $updates->{$name}; } - #warn Dumper($object->{_column_data}); use Data::Dumper; } - _delete_empty_auto_increment($object); + + # 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 + for my $name ( keys %columns ) { + $object->$name( $updates->{$name} ); + } + for my $name ( keys %pre_updates ) { + my $info = $object->result_source->relationship_info($name); + $self->_update_relation( $name, $updates, $object, $info ); + } + $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; - # updating relations that can be done only after the row is inserted into the database - # like has_many and many_to_many - for my $name ( keys %$updates ){ + # updating many_to_many + for my $name ( keys %$updates ) { + next if exists $columns{$name}; my $value = $updates->{$name}; + # many to many case - if($object->can($name) and - !$object->result_source->has_relationship($name) and - $object->can( 'set_' . $name ) - ) { - my ( $pk ) = _get_pk_for_related( $object, $name ); - my @values = @{$updates->{$name}}; - my @rows; - my $result_source = $object->$name->result_source; - @rows = $result_source->resultset->search({ $pk => [ @values ] } ) if @values; - my $set_meth = 'set_' . $name; - $object->$set_meth( \@rows ); - } - elsif( $object->result_source->has_relationship($name) ){ - my $info = $object->result_source->relationship_info( $name ); - # has many case - if( ref $updates->{$name} eq 'ARRAY' ){ - for my $sub_updates ( @{$updates->{$name}} ) { - my $sub_object = $object->search_related( $name )->recursive_update( $sub_updates ); + if ( $self->is_m2m($name) ) { + my ($pk) = $self->_get_pk_for_related($name); + my @rows; + my $result_source = $object->$name->result_source; + for my $elem ( @{ $updates->{$name} } ) { + if ( ref $elem ) { + push @rows, $result_source->resultset->find($elem); + } + else { + push @rows, + $result_source->resultset->find( { $pk => $elem } ); } } - # might_have and has_one case - elsif ( ! _master_relation_cond( $object, $info->{cond}, _get_pk_for_related( $object, $name ) ) ){ - my $sub_object = $object->search_related( $name )->recursive_update( $value ); - #$object->set_from_related( $name, $sub_object ); - } + my $set_meth = 'set_' . $name; + $object->$set_meth( \@rows ); } } + for my $name ( keys %post_updates ) { + my $info = $object->result_source->relationship_info($name); + $self->_update_relation( $name, $updates, $object, $info ); + } return $object; } -sub _delete_empty_auto_increment { - my ( $object ) = @_; - for my $col ( keys %{$object->{_column_data}}){ - 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} +sub _get_columns_by_accessor { + my $self = shift; + my $source = $self->result_source; + my %columns; + for my $name ( $source->columns ) { + my $info = $source->column_info($name); + $info->{name} = $name; + $columns{ $info->{accessor} || $name } = $info; + } + return %columns; +} + +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 $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION == $resolved; + if ( ref $updates->{$name} eq 'ARRAY' ) { + for my $sub_updates ( @{ $updates->{$name} } ) { + my $sub_object = + $related_result->recursive_update( $sub_updates, $resolved ); } } + else { + my $sub_object = + $related_result->recursive_update( $updates->{$name}, $resolved ); + $object->set_from_related( $name, $sub_object ); + } } -sub _get_pk_for_related { - my ( $object, $relation ) = @_; +sub is_m2m { + my ( $self, $relation ) = @_; + my $rclass = $self->result_class; - my $rs = $object->result_source->resultset; - my $result_source = _get_related_source( $rs, $relation ); - return $result_source->primary_columns; + # DBIx::Class::IntrospectableM2M + if ( $rclass->can('_m2m_metadata') ) { + return $rclass->_m2m_metadata->{$relation}; + } + my $object = $self->new( {} ); + if ( $object->can($relation) + and !$self->result_source->has_relationship($relation) + and $object->can( 'set_' . $relation ) ) + { + return 1; + } + return; +} + +sub get_m2m_source { + my ( $self, $relation ) = @_; + my $rclass = $self->result_class; + + # DBIx::Class::IntrospectableM2M + if ( $rclass->can('_m2m_metadata') ) { + return $self->result_source->related_source( + $rclass->_m2m_metadata->{$relation}{relation} ) + ->related_source( + $rclass->_m2m_metadata->{$relation}{foreign_relation} ); + } + my $object = $self->new( {} ); + my $r = $object->$relation; + return $r->result_source; } -sub _get_related_source { - my ( $rs, $name ) = @_; - if( $rs->result_source->has_relationship( $name ) ){ - return $rs->result_source->related_source( $name ); +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} + and ( !defined $object->{_column_data}{$col} + or $object->{_column_data}{$col} eq '' ) + ) + { + delete $object->{_column_data}{$col}; + } } +} + +sub _get_pk_for_related { + my ( $self, $relation ) = @_; + my $result_source; + if ( $self->result_source->has_relationship($relation) ) { + $result_source = $self->result_source->related_source($relation); + } + # many to many case - my $row = $rs->new({}); - if ( $row->can( $name ) and $row->can( 'add_to_' . $name ) and $row->can( 'set_' . $name ) ){ - my $r = $row->$name; - return $r->result_source; + if ( $self->is_m2m($relation) ) { + $result_source = $self->get_m2m_source($relation); } - return; + return $result_source->primary_columns; } sub _master_relation_cond { - my ( $object, $cond, @foreign_ids ) = @_; + my ( $source, $cond, @foreign_ids ) = @_; my $foreign_ids_re = join '|', @foreign_ids; - if ( ref $cond eq 'HASH' ){ + if ( ref $cond eq 'HASH' ) { for my $f_key ( keys %{$cond} ) { + # might_have is not master my $col = $cond->{$f_key}; $col =~ s/self\.//; - if( $object->column_info( $col )->{is_auto_increment} ){ + if ( $source->column_info($col)->{is_auto_increment} ) { return 0; } - if( $f_key =~ /^foreign\.$foreign_ids_re/ ){ + if ( $f_key =~ /^foreign\.$foreign_ids_re/ ) { return 1; } } - }elsif ( ref $cond eq 'ARRAY' ){ - for my $new_cond ( @$cond ) { - return 1 if _master_relation_cond( $object, $new_cond, @foreign_ids ); + } + elsif ( ref $cond eq 'ARRAY' ) { + for my $new_cond (@$cond) { + return 1 + if _master_relation_cond( $source, $new_cond, @foreign_ids ); } } return; } -# Module implementation here - - -1; # Magic true value required at end of module +1; # Magic true value required at end of module __END__ =head1 NAME @@ -157,19 +246,17 @@ DBIx::Class::ResultSet::RecursiveUpdate - like update_or_create - but recursive =head1 VERSION -This document describes DBIx::Class::ResultSet::RecursiveUpdate version 0.0.1 +This document describes DBIx::Class::ResultSet::RecursiveUpdate version 0.001 =head1 SYNOPSIS - __PACKAGE__->load_namespaces( default_resultset_class => '+DBIx::Class::ResultSet::RecursiveUpdate' ); + __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. Then: -=for author to fill in: - my $user = $user_rs->recursive_update( { id => 1, owned_dvds => [ @@ -184,51 +271,98 @@ Then: =head1 DESCRIPTION -=for author to fill in: - 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 - tries to fill that void. - It is a base class for ResultSets providing just one method: recursive_update - 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. - - For a description how to set up base classes for ResultSets see load_namespaces - in DBIx::Class::Schema. +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 +tries to fill that void. -=head1 INTERFACE +It is a base class for ResultSets providing just one method: recursive_update +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. -=for author to fill in: +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. + +For a description how to set up base classes for ResultSets see load_namespaces +in DBIx::Class::Schema. + +=head1 DESIGN CHOICES + +=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 + !$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. + +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 =head1 METHODS =head2 recursive_update -The only method here. +The method that does the work here. + +=head2 is_m2m + +$self->is_m2m( 'name ' ) - answers the question if 'name' is a many to many +(pseudo) relation on $self. + +=head2 get_m2m_source + +$self->get_m2m_source( 'name' ) - returns the ResultSource linked to by the many +to many (pseudo) relation 'name' from $self. + =head1 DIAGNOSTICS =head1 CONFIGURATION AND ENVIRONMENT -=for author to fill in: - DBIx::Class::RecursiveUpdate requires no configuration files or environment variables. - =head1 DEPENDENCIES -=for author to fill in: - DBIx::Class -None. - - =head1 INCOMPATIBILITIES =for author to fill in: