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=cdfd1ffca61472f2c085eb638bdbcf7328a99b2c;hp=7275d1ef63844d5dad79d538e19b78a525e9142c;hb=9cf5eeae14f2216a27e18c67a03cefe787dcfc4a;hpb=c6ce25ccefcd1b746acd71bdaea2699931cd32b6 diff --git a/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm b/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm index 7275d1e..cdfd1ff 100644 --- a/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm +++ b/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm @@ -1,102 +1,221 @@ -package DBIx::Class::ResultSet::RecursiveUpdate; +use strict; +use warnings; -use version; $VERSION = qv('0.001'); +package DBIx::Class::ResultSet::RecursiveUpdate; -use warnings; -use strict; -use Carp; -use Scalar::Util qw( blessed ); +# ABSTRACT: like update_or_create - but recursive use base qw(DBIx::Class::ResultSet); sub recursive_update { - my ( $self, $updates, $fixed_fields ) = @_; - # warn 'entering: ' . $self->result_source->from(); + my ( $self, $updates, $attrs ) = @_; + + my $fixed_fields; + my $unknown_params_ok; + + # 0.21+ api + if ( defined $attrs && ref $attrs eq 'HASH' ) { + $fixed_fields = $attrs->{fixed_fields}; + $unknown_params_ok = $attrs->{unknown_params_ok}; + } + + # pre 0.21 api + elsif ( defined $attrs && ref $attrs eq 'ARRAY' ) { + $fixed_fields = $attrs; + } + + return + DBIx::Class::ResultSet::RecursiveUpdate::Functions::recursive_update( + resultset => $self, + updates => $updates, + fixed_fields => $fixed_fields, + unknown_params_ok => $unknown_params_ok, + ); +} + +package DBIx::Class::ResultSet::RecursiveUpdate::Functions; +use Carp::Clan qw/^DBIx::Class|^HTML::FormHandler|^Try::Tiny/; +use Scalar::Util qw( blessed ); +use List::MoreUtils qw/ any /; + +sub recursive_update { + my %params = @_; + my ( $self, $updates, $fixed_fields, $object, $resolved, + $if_not_submitted, $unknown_params_ok ) + = @params{ + qw/resultset updates fixed_fields object resolved if_not_submitted unknown_params_ok/ + }; + $resolved ||= {}; - 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; + # warn 'entering: ' . $self->result_source->from(); + carp 'fixed fields needs to be an array ref' + if defined $fixed_fields && ref $fixed_fields ne 'ARRAY'; if ( blessed($updates) && $updates->isa('DBIx::Class::Row') ) { return $updates; } + if ( $updates->{id} ) { + $object = $self->find( $updates->{id}, { key => 'primary' } ); + } + my %fixed_fields = map { $_ => 1 } @$fixed_fields + if $fixed_fields; + 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 %columns_by_accessor = $self->_get_columns_by_accessor; + 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} - && !( $source->has_relationship($name) && ref( $updates->{$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; } - 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}; + + # 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; + } } - else { - $post_updates{$name} = $updates->{$name}; + + # 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; } - } - # warn 'columns: ' . Dumper( \%columns ); use Data::Dumper; - my $object; - my @missing = - grep { !exists $columns{$_} && !exists $fixed_fields{$_} } $self->result_source->primary_columns; - if ( !scalar @missing ) { - $object = $self->find( \%columns, { key => 'primary' } ); + # accessors + if ( $object->can($name) && not $source->has_relationship($name) ) { + + #warn "$name is an accessor"; + $other_methods{$name} = $updates->{$name}; + next; + } + + # unknown + + # don't throw a warning instead of an exception to give users + # time to adapt to the new API + carp( + "No such column, relationship, many-to-many helper accessor or generic accessor '$name'" + ) unless $unknown_params_ok; + +#$self->throw_exception( +# "No such column, relationship, many-to-many helper accessor or generic accessor '$name'" +#); } - $object ||= $self->new( {} ); -# first update columns and other accessors - so that later related records can be found + # warn 'other: ' . Dumper( \%other_methods ); use Data::Dumper; + + # 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 ) { + + #warn "update other $name\n"; $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 ); + + #warn "pre_update $name\n"; + _update_relation( $self, $name, $pre_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; + #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 ) { next if exists $columns{$name}; my $value = $updates->{$name}; - if ( $self->is_m2m($name) ) { - my ($pk) = $self->_get_pk_for_related($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; - 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; @@ -104,12 +223,15 @@ sub recursive_update { } } for my $name ( keys %post_updates ) { - my $info = $object->result_source->relationship_info($name); - $self->_update_relation( $name, $updates, $object, $info ); + + #warn "post_update $name\n"; + _update_relation( $self, $name, $post_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; @@ -122,30 +244,176 @@ sub _get_columns_by_accessor { return %columns; } +# Arguments: $rs, $name, $updates, $row, $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 = - $related_result->recursive_update( $sub_updates ); + 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 + 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 ); + } + else { + $self->throw_exception( + "result_source must support _resolve_condition"); + } + + # warn "$name resolved: " . Dumper( $resolved ); use Data::Dumper; + $resolved = {} + if defined $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION + && $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION + == $resolved; + + 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_objs, $sub_object; + } + + #warn "\tcreated and updated related rows\n"; + + my @related_pks = $related_resultset->result_source->primary_columns; + + 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 ) ] } + } + ); + } + + # 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 ); } } + 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 ) { + + # for might_have relationship + 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_resultset, + updates => $updates, + resolved => $resolved + ); + } + } + else { + $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 ) + unless ( + !$sub_object + && !$updates + && ( exists $info->{attrs}{join_type} + && $info->{attrs}{join_type} eq 'LEFT' ) + ); + } else { - my $sub_updates = $updates->{$name}; - $sub_updates = { %$sub_updates, %$resolved } if $resolved && ref( $sub_updates ) eq 'HASH'; - my $sub_object = - $related_result->recursive_update( $sub_updates ); - $object->set_from_related( $name, $sub_object ); + $self->throw_exception( + "recursive_update doesn't now how to handle relationship '$name' with accessor " + . $info->{attrs}{accessor} ); } } @@ -175,7 +443,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( {} ); @@ -186,11 +454,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}; } @@ -205,83 +472,128 @@ 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; } +# 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 +# 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 1 - if _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: -=head1 VERSION + my $schema = MyDB::Schema->connect(); + my $new_item = DBIx::Class::ResultSet::RecursiveUpdate::Functions::recursive_update( + resultset => $schema->resultset('User'), + updates => { + id => 1, + owned_dvds => [ + { + title => "One Flew Over the Cuckoo's Nest" + } + ] + }, + unknown_params_ok => 1, + ); -This document describes DBIx::Class::ResultSet::RecursiveUpdate version 0.001 - -=head1 SYNOPSIS + # 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 appropriate '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" + } + ] + }, { + unknown_params_ok => 1, + }); - my $user = $user_rs->recursive_update( { - id => 1, - owned_dvds => [ - { - title => 'One Flew Over the Cuckoo's Nest' - } - ] - } - ); - =head1 DESCRIPTION -This is the first release - so treat it as experimental. -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. +This is still experimental. -It is a base class for ResultSets providing just one method: recursive_update +You can feed the ->create method of DBIx::Class 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 until L has an api itself. + +The functional interface can be used without modifications of the model, +for example by form processors like L. + +It is a base class for Ls providing the 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). -If not all colums comprising the primary key are specified - then a new row will be created, +If not all columns comprising the primary key are specified 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). @@ -291,43 +603,160 @@ 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: +then you need to inform recursive_update about the additional predicate with the fixed_fields attribute: - my $user = $restricted_rs->recursive_update( { - owned_dvds => [ - { - title => 'One Flew Over the Cuckoo's Nest' - } - ] - }, - [ 'id' ] + my $user = $restricted_rs->recursive_update( { + owned_dvds => [ + { + title => 'One Flew Over the Cuckoo's Nest' + } + ] + }, + { + fixed_fields => [ '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 +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 +forms with check boxes (or a select field with multiple choice) that lets you update such (pseudo) relations. -For a description how to set up base classes for ResultSets see load_namespaces -in DBIx::Class::Schema. +For a description how to set up base classes for ResultSets see L. =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 L. +If it isn't loaded in the ResultSource classes the code relies on the fact that: -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 ) ) -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 @@ -362,54 +791,13 @@ 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 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.