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=2d3efb8dfd19a60157ec56d86bc6876749384389;hp=b9bf433e887f84928d3d715bf35b5bfd94201805;hb=11512e7c3673e8467fd7a743a455defcf1f71c41;hpb=5a9d5be123f2111da8344d102dcd143a222be2dd

diff --git a/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm b/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm
index b9bf433..2d3efb8 100644
--- a/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm
+++ b/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm
@@ -20,6 +20,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 +78,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 +135,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 +155,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 +166,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 +199,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 +220,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
@@ -195,9 +243,8 @@ sub _update_relation {
             $object );
     }
     else {
-        $resolved =
-            $self->result_source->resolve_condition( $info->{cond}, $name,
-            $object );
+        $self->throw_exception(
+            "result_source must support _resolve_condition");
     }
 
     # warn "$name resolved: " . Dumper( $resolved ); use Data::Dumper;
@@ -206,41 +253,97 @@ 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 @cond;
         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 {
+            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;
             }
+            $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 ) {
 
@@ -262,7 +365,7 @@ sub _update_relation {
                 );
             }
         }
-        elsif ( !ref $updates ) {
+        else {
             $sub_object = $related_resultset->find($updates)
                 unless (
                 !$updates
@@ -278,6 +381,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 {
@@ -345,28 +453,57 @@ 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;
 }