Dogcows Code - chaz/p5-DBIx-Class-ResultSet-RecursiveUpdate/blob - lib/DBIx/Class/ResultSet/RecursiveUpdate.pm

   1 use strict;
   2 use warnings;
   3
   4 package DBIx::Class::ResultSet::RecursiveUpdate;
   5
   6 our $VERSION = '0.013';
   7
   8 use base qw(DBIx::Class::ResultSet);
   9
  10 sub recursive_update {
  11     my ( $self, $updates, $fixed_fields ) = @_;
  12     return
  13         DBIx::Class::ResultSet::RecursiveUpdate::Functions::recursive_update(
  14         resultset    => $self,
  15         updates      => $updates,
  16         fixed_fields => $fixed_fields
  17         );
  18 }
  19
  20 package DBIx::Class::ResultSet::RecursiveUpdate::Functions;
  21 use Carp;
  22 use Scalar::Util qw( blessed );
  23 use List::MoreUtils qw/ any /;
  24
  25 sub recursive_update {
  26     my %params = @_;
  27     my ( $self, $updates, $fixed_fields, $object, $resolved,
  28         $if_not_submitted )
  29         = @params{
  30         qw/resultset updates fixed_fields object resolved if_not_submitted/};
  31     $resolved ||= {};
  32
  33     # warn 'entering: ' . $self->result_source->from();
  34     carp 'fixed fields needs to be an array ref'
  35         if $fixed_fields && ref($fixed_fields) ne 'ARRAY';
  36     my %fixed_fields;
  37     %fixed_fields = map { $_ => 1 } @$fixed_fields if $fixed_fields;
  38     if ( blessed($updates) && $updates->isa('DBIx::Class::Row') ) {
  39         return $updates;
  40     }
  41     if ( $updates->{id} ) {
  42         $object = $self->find( $updates->{id}, { key => 'primary' } );
  43     }
  44     my @missing =
  45         grep { !exists $updates->{$_} && !exists $fixed_fields{$_} }
  46         $self->result_source->primary_columns;
  47     if ( !$object && !scalar @missing ) {
  48
  49         # warn 'finding by: ' . Dumper( $updates ); use Data::Dumper;
  50         $object = $self->find( $updates, { key => 'primary' } );
  51     }
  52     $updates = { %$updates, %$resolved };
  53     @missing =
  54         grep { !exists $resolved->{$_} } @missing;
  55     if ( !$object && !scalar @missing ) {
  56
  57        # warn 'finding by +resolved: ' . Dumper( $updates ); use Data::Dumper;
  58         $object = $self->find( $updates, { key => 'primary' } );
  59     }
  60     $object ||= $self->new( {} );
  61
  62     # warn Dumper( $updates ); use Data::Dumper;
  63     # direct column accessors
  64     my %columns;
  65
  66     # relations that that should be done before the row is inserted into the
  67     # database like belongs_to
  68     my %pre_updates;
  69
  70     # relations that that should be done after the row is inserted into the
  71     # database like has_many, might_have and has_one
  72     my %post_updates;
  73     my %other_methods;
  74     my %columns_by_accessor = _get_columns_by_accessor($self);
  75
  76     #    warn 'resolved: ' . Dumper( $resolved );
  77     #    warn 'updates: ' . Dumper( $updates ); use Data::Dumper;
  78     #    warn 'columns: ' . Dumper( \%columns_by_accessor );
  79     for my $name ( keys %$updates ) {
  80         my $source = $self->result_source;
  81
  82         # columns
  83         if ( exists $columns_by_accessor{$name}
  84             && !( $source->has_relationship($name)
  85                 && ref( $updates->{$name} ) ) )
  86         {
  87
  88             #warn "$name is a column\n";
  89             $columns{$name} = $updates->{$name};
  90             next;
  91         }
  92
  93         # relationships
  94         if ( $source->has_relationship($name) ) {
  95             if ( _master_relation_cond( $self, $name ) ) {
  96
  97                 #warn "$name is a pre-update rel\n";
  98                 $pre_updates{$name} = $updates->{$name};
  99                 next;
 100             }
 101             else {
 102
 103                 #warn "$name is a post-update rel\n";
 104                 $post_updates{$name} = $updates->{$name};
 105                 next;
 106             }
 107         }
 108
 109         # many-to-many helper accessors
 110         if ( is_m2m( $self, $name ) ) {
 111
 112             #warn "$name is a many-to-many helper accessor\n";
 113             $other_methods{$name} = $updates->{$name};
 114             next;
 115         }
 116
 117         # accessors
 118         if ( $object->can($name) && not $source->has_relationship($name) ) {
 119
 120             #warn "$name is an accessor";
 121             $other_methods{$name} = $updates->{$name};
 122             next;
 123         }
 124
 125         # unknown
 126         # TODO: don't throw a warning instead of an exception to give users
 127         #       time to adapt to the new API
 128         $self->throw_exception(
 129             "No such column, relationship, many-to-many helper accessor or generic accessor '$name'"
 130         );
 131     }
 132
 133     # warn 'other: ' . Dumper( \%other_methods ); use Data::Dumper;
 134
 135     # first update columns and other accessors
 136     # so that later related records can be found
 137     for my $name ( keys %columns ) {
 138
 139         #warn "update col $name\n";
 140         $object->$name( $columns{$name} );
 141     }
 142     for my $name ( keys %other_methods ) {
 143
 144         #warn "update other $name\n";
 145         $object->$name( $updates->{$name} );
 146     }
 147     for my $name ( keys %pre_updates ) {
 148
 149         #warn "pre_update $name\n";
 150         _update_relation( $self, $name, $pre_updates{$name}, $object,
 151             $if_not_submitted );
 152     }
 153
 154     # $self->_delete_empty_auto_increment($object);
 155     # don't allow insert to recurse to related objects
 156     # do the recursion ourselves
 157     # $object->{_rel_in_storage} = 1;
 158     #warn "CHANGED: " . $object->is_changed . "\n":
 159     #warn "IN STOR: " .  $object->in_storage . "\n";
 160     $object->update_or_insert if $object->is_changed;
 161     $object->discard_changes;
 162
 163     # updating many_to_many
 164     for my $name ( keys %$updates ) {
 165         next if exists $columns{$name};
 166         my $value = $updates->{$name};
 167
 168         if ( is_m2m( $self, $name ) ) {
 169
 170             #warn "update m2m $name\n";
 171             my ($pk) = _get_pk_for_related( $self, $name );
 172             my @rows;
 173             my $result_source = $object->$name->result_source;
 174             my @updates;
 175             if ( !defined $value ) {
 176                 next;
 177             }
 178             elsif ( ref $value ) {
 179                 @updates = @{$value};
 180             }
 181             else {
 182                 @updates = ($value);
 183             }
 184             for my $elem (@updates) {
 185                 if ( ref $elem ) {
 186                     push @rows,
 187                         recursive_update(
 188                         resultset => $result_source->resultset,
 189                         updates   => $elem
 190                         );
 191                 }
 192                 else {
 193                     push @rows,
 194                         $result_source->resultset->find( { $pk => $elem } );
 195                 }
 196             }
 197             my $set_meth = 'set_' . $name;
 198             $object->$set_meth( \@rows );
 199         }
 200     }
 201     for my $name ( keys %post_updates ) {
 202
 203         #warn "post_update $name\n";
 204         _update_relation( $self, $name, $post_updates{$name}, $object,
 205             $if_not_submitted );
 206     }
 207     return $object;
 208 }
 209
 210 # returns DBIx::Class::ResultSource::column_info as a hash indexed by column accessor || name
 211 sub _get_columns_by_accessor {
 212     my $self   = shift;
 213     my $source = $self->result_source;
 214     my %columns;
 215     for my $name ( $source->columns ) {
 216         my $info = $source->column_info($name);
 217         $info->{name} = $name;
 218         $columns{ $info->{accessor} || $name } = $info;
 219     }
 220     return %columns;
 221 }
 222
 223 # Arguments: $rs, $name, $updates, $row, $if_not_submitted
 224 sub _update_relation {
 225     my ( $self, $name, $updates, $object, $if_not_submitted ) = @_;
 226
 227     # this should never happen because we're checking the paramters passed to
 228     # recursive_update, but just to be sure...
 229     $object->throw_exception("No such relationship '$name'")
 230         unless $object->has_relationship($name);
 231
 232     #warn "_update_relation $name: OBJ: " . ref($object) . "\n";
 233
 234     my $info = $object->result_source->relationship_info($name);
 235
 236     # get a related resultset without a condition
 237     my $related_resultset =
 238         $self->related_resultset($name)->result_source->resultset;
 239     my $resolved;
 240     if ( $self->result_source->can('_resolve_condition') ) {
 241         $resolved =
 242             $self->result_source->_resolve_condition( $info->{cond}, $name,
 243             $object );
 244     }
 245     else {
 246         $self->throw_exception(
 247             "result_source must support _resolve_condition");
 248     }
 249
 250     # warn "$name resolved: " . Dumper( $resolved ); use Data::Dumper;
 251     $resolved = {}
 252         if defined $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION
 253             && $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION
 254             == $resolved;
 255
 256     my @rel_cols = keys %{ $info->{cond} };
 257     map {s/^foreign\.//} @rel_cols;
 258
 259     #warn "REL_COLS: " . Dumper(@rel_cols); use Data::Dumper;
 260     my $rel_col_cnt = scalar @rel_cols;
 261
 262     # find out if all related columns are nullable
 263     my $all_fks_nullable = 1;
 264     for my $rel_col (@rel_cols) {
 265         $all_fks_nullable = 0
 266             unless $related_resultset->result_source->column_info($rel_col)
 267                 ->{is_nullable};
 268     }
 269
 270     $if_not_submitted = $all_fks_nullable ? 'nullify' : 'delete'
 271         unless defined $if_not_submitted;
 272
 273     #warn "\tNULLABLE: $all_fks_nullable ACTION: $if_not_submitted\n";
 274
 275     #warn "RELINFO for $name: " . Dumper($info); use Data::Dumper;
 276
 277     # the only valid datatype for a has_many rels is an arrayref
 278     if ( $info->{attrs}{accessor} eq 'multi' ) {
 279
 280         # handle undef like empty arrayref
 281         $updates = []
 282             unless defined $updates;
 283         $self->throw_exception(
 284             "data for has_many relationship '$name' must be an arrayref")
 285             unless ref $updates eq 'ARRAY';
 286
 287         my @updated_objs;
 288
 289         #warn "\tupdating has_many rel '$name' ($rel_col_cnt columns cols)\n";
 290         for my $sub_updates ( @{$updates} ) {
 291             my $sub_object = recursive_update(
 292                 resultset => $related_resultset,
 293                 updates   => $sub_updates,
 294                 resolved  => $resolved
 295             );
 296
 297             push @updated_objs, $sub_object;
 298         }
 299
 300         #warn "\tcreated and updated related rows\n";
 301
 302         my @related_pks = $related_resultset->result_source->primary_columns;
 303
 304         my $rs_rel_delist = $object->$name;
 305
 306         # foreign table has a single pk column
 307         if ( scalar @related_pks == 1 ) {
 308             $rs_rel_delist = $rs_rel_delist->search_rs(
 309                 {   $related_pks[0] =>
 310                         { -not_in => [ map ( $_->id, @updated_objs ) ] }
 311                 }
 312             );
 313         }
 314
 315         # foreign table has multiple pk columns
 316         else {
 317             my @cond;
 318             for my $obj (@updated_objs) {
 319                 my %cond_for_obj;
 320                 for my $col (@related_pks) {
 321                     $cond_for_obj{$col} = $obj->get_column($col);
 322                 }
 323                 push @cond, \%cond_for_obj;
 324             }
 325             # only limit resultset if there are related rows left
 326             if (scalar @cond) {
 327                 $rs_rel_delist = $rs_rel_delist->search_rs( { -not => [@cond] } );
 328             }
 329         }
 330
 331         #warn "\tCOND: " . Dumper(\%cond);
 332         #my $rel_delist_cnt = $rs_rel_delist->count;
 333         if ( $if_not_submitted eq 'delete' ) {
 334
 335             #warn "\tdeleting related rows: $rel_delist_cnt\n";
 336             $rs_rel_delist->delete;
 337         }
 338         elsif ( $if_not_submitted eq 'set_to_null' ) {
 339
 340             #warn "\tnullifying related rows: $rel_delist_cnt\n";
 341             my %update = map { $_ => undef } @rel_cols;
 342             $rs_rel_delist->update( \%update );
 343         }
 344     }
 345     elsif ($info->{attrs}{accessor} eq 'single'
 346         || $info->{attrs}{accessor} eq 'filter' )
 347     {
 348
 349         #warn "\tupdating rel '$name': $if_not_submitted\n";
 350         my $sub_object;
 351         if ( ref $updates ) {
 352
 353             # for might_have relationship
 354             if ( $info->{attrs}{accessor} eq 'single'
 355                 && defined $object->$name )
 356             {
 357                 $sub_object = recursive_update(
 358                     resultset => $related_resultset,
 359                     updates   => $updates,
 360                     object    => $object->$name
 361                 );
 362             }
 363             else {
 364                 $sub_object = recursive_update(
 365                     resultset => $related_resultset,
 366                     updates   => $updates,
 367                     resolved  => $resolved
 368                 );
 369             }
 370         }
 371         else {
 372             $sub_object = $related_resultset->find($updates)
 373                 unless (
 374                 !$updates
 375                 && ( exists $info->{attrs}{join_type}
 376                     && $info->{attrs}{join_type} eq 'LEFT' )
 377                 );
 378         }
 379         $object->set_from_related( $name, $sub_object )
 380             unless (
 381                !$sub_object
 382             && !$updates
 383             && ( exists $info->{attrs}{join_type}
 384                 && $info->{attrs}{join_type} eq 'LEFT' )
 385             );
 386     }
 387     else {
 388         $self->throw_exception(
 389             "recursive_update doesn't now how to handle relationship '$name' with accessor "
 390                 . $info->{attrs}{accessor} );
 391     }
 392 }
 393
 394 sub is_m2m {
 395     my ( $self, $relation ) = @_;
 396     my $rclass = $self->result_class;
 397
 398     # DBIx::Class::IntrospectableM2M
 399     if ( $rclass->can('_m2m_metadata') ) {
 400         return $rclass->_m2m_metadata->{$relation};
 401     }
 402     my $object = $self->new( {} );
 403     if (    $object->can($relation)
 404         and !$self->result_source->has_relationship($relation)
 405         and $object->can( 'set_' . $relation ) )
 406     {
 407         return 1;
 408     }
 409     return;
 410 }
 411
 412 sub get_m2m_source {
 413     my ( $self, $relation ) = @_;
 414     my $rclass = $self->result_class;
 415
 416     # DBIx::Class::IntrospectableM2M
 417     if ( $rclass->can('_m2m_metadata') ) {
 418         return $self->result_source->related_source(
 419             $rclass->_m2m_metadata->{$relation}{relation} )
 420             ->related_source(
 421             $rclass->_m2m_metadata->{$relation}{foreign_relation} );
 422     }
 423     my $object = $self->new( {} );
 424     my $r = $object->$relation;
 425     return $r->result_source;
 426 }
 427
 428 sub _delete_empty_auto_increment {
 429     my ( $self, $object ) = @_;
 430     for my $col ( keys %{ $object->{_column_data} } ) {
 431         if ($object->result_source->column_info($col)->{is_auto_increment}
 432             and ( !defined $object->{_column_data}{$col}
 433                 or $object->{_column_data}{$col} eq '' )
 434             )
 435         {
 436             delete $object->{_column_data}{$col};
 437         }
 438     }
 439 }
 440
 441 sub _get_pk_for_related {
 442     my ( $self, $relation ) = @_;
 443     my $result_source;
 444     if ( $self->result_source->has_relationship($relation) ) {
 445         $result_source = $self->result_source->related_source($relation);
 446     }
 447
 448     # many to many case
 449     if ( is_m2m( $self, $relation ) ) {
 450         $result_source = get_m2m_source( $self, $relation );
 451     }
 452     return $result_source->primary_columns;
 453 }
 454
 455 # This function determines wheter a relationship should be done before or
 456 # after the row is inserted into the database
 457 # relationships before: belongs_to
 458 # relationships after: has_many, might_have and has_one
 459 # true means before, false after
 460 sub _master_relation_cond {
 461     my ( $self, $name ) = @_;
 462
 463     my $source = $self->result_source;
 464     my $info   = $source->relationship_info($name);
 465
 466     #warn "INFO: " . Dumper($info) . "\n";
 467
 468     # has_many rels are always after
 469     return 0
 470         if $info->{attrs}->{accessor} eq 'multi';
 471
 472     my @foreign_ids = _get_pk_for_related( $self, $name );
 473
 474     #warn "IDS: " . join(', ', @foreign_ids) . "\n";
 475
 476     my $cond = $info->{cond};
 477
 478     sub _inner {
 479         my ( $source, $cond, @foreign_ids ) = @_;
 480
 481         while ( my ( $f_key, $col ) = each %{$cond} ) {
 482
 483             # might_have is not master
 484             $col   =~ s/^self\.//;
 485             $f_key =~ s/^foreign\.//;
 486             if ( $source->column_info($col)->{is_auto_increment} ) {
 487                 return 0;
 488             }
 489             if ( any { $_ eq $f_key } @foreign_ids ) {
 490                 return 1;
 491             }
 492         }
 493         return 0;
 494     }
 495
 496     if ( ref $cond eq 'HASH' ) {
 497         return _inner( $source, $cond, @foreign_ids );
 498     }
 499
 500     # arrayref of hashrefs
 501     elsif ( ref $cond eq 'ARRAY' ) {
 502         for my $new_cond (@$cond) {
 503             return _inner( $source, $new_cond, @foreign_ids );
 504         }
 505     }
 506     else {
 507         $source->throw_exception(
 508             "unhandled relation condition " . ref($cond) );
 509     }
 510     return;
 511 }
 512
 513 1;    # Magic true value required at end of module
 514 __END__
 515
 516 =head1 NAME
 517
 518 DBIx::Class::ResultSet::RecursiveUpdate - like update_or_create - but recursive
 519
 520 =head1 SYNOPSIS
 521
 522 The functional interface:
 523
 524     my $new_item = DBIx::Class::ResultSet::RecursiveUpdate::Functions::recursive_update({
 525         resultset => $schema->resultset( 'Dvd' ),
 526         updates => {
 527             id => 1,
 528             owned_dvds => [
 529                 {
 530                   title => 'One Flew Over the Cuckoo's Nest'
 531                 }
 532             ]
 533         }
 534     });
 535
 536
 537 As ResultSet subclass:
 538
 539     __PACKAGE__->load_namespaces( default_resultset_class => '+DBIx::Class::ResultSet::RecursiveUpdate' );
 540
 541 in the Schema file (see t/lib/DBSchema.pm).  Or appriopriate 'use base' in the ResultSet classes.
 542
 543 Then:
 544
 545     my $user = $user_rs->recursive_update( {
 546         id => 1,
 547         owned_dvds => [
 548         {
 549           title => 'One Flew Over the Cuckoo's Nest'
 550         }
 551         ]
 552       }
 553     );
 554
 555
 556 =head1 DESCRIPTION
 557
 558 This is still experimental. I've added a functional interface so that it can be used
 559 in Form Processors and not require modification of the model.
 560
 561 You can feed the ->create method with a recursive datastructure and have the related records
 562 created.  Unfortunately you cannot do a similar thing with update_or_create - this module
 563 tries to fill that void.
 564
 565 It is a base class for ResultSets providing just one method: recursive_update
 566 which works just like update_or_create but can recursively update or create
 567 data objects composed of multiple rows. All rows need to be identified by primary keys
 568 - so you need to provide them in the update structure (unless they can be deduced from
 569 the parent row - for example when you have a belongs_to relationship).
 570 If not all colums comprising the primary key are specified - then a new row will be created,
 571 with the expectation that the missing columns will be filled by it (as in the case of auto_increment
 572 primary keys).
 573
 574
 575 If the resultset itself stores an assignement for the primary key,
 576 like in the case of:
 577
 578     my $restricted_rs = $user_rs->search( { id => 1 } );
 579
 580 then you need to inform recursive_update about additional predicate with a second argument:
 581
 582     my $user = $restricted_rs->recursive_update( {
 583         owned_dvds => [
 584         {
 585           title => 'One Flew Over the Cuckoo's Nest'
 586         }
 587         ]
 588       },
 589       [ 'id' ]
 590     );
 591
 592 This will work with a new DBIC release.
 593
 594 For a many_to_many (pseudo) relation you can supply a list of primary keys
 595 from the other table - and it will link the record at hand to those and
 596 only those records identified by them.  This is convenient for handling web
 597 forms with check boxes (or a SELECT box with multiple choice) that let you
 598 update such (pseudo) relations.
 599
 600 For a description how to set up base classes for ResultSets see load_namespaces
 601 in DBIx::Class::Schema.
 602
 603 =head1 DESIGN CHOICES
 604
 605 Columns and relationships which are excluded from the updates hashref aren't
 606 touched at all.
 607
 608 =head2 Treatment of belongs_to relations
 609
 610 In case the relationship is included but undefined in the updates hashref,
 611 all columns forming the relationship will be set to null.
 612 If not all of them are nullable, DBIx::Class will throw an error.
 613
 614 Updating the relationship:
 615
 616     my $dvd = $dvd_rs->recursive_update( {
 617         id    => 1,
 618         owner => $user->id,
 619     });
 620
 621 Clearing the relationship (only works if cols are nullable!):
 622
 623     my $dvd = $dvd_rs->recursive_update( {
 624         id    => 1,
 625         owner => undef,
 626     });
 627
 628 =head2 Treatment of might_have relationships
 629
 630 In case the relationship is included but undefined in the updates hashref,
 631 all columns forming the relationship will be set to null.
 632
 633 Updating the relationship:
 634
 635     my $user = $user_rs->recursive_update( {
 636         id => 1,
 637         address => {
 638             street => "101 Main Street",
 639             city   => "Podunk",
 640             state  => "New York",
 641         }
 642     });
 643
 644 Clearing the relationship:
 645
 646     my $user = $user_rs->recursive_update( {
 647         id => 1,
 648         address => undef,
 649     });
 650
 651 =head2 Treatment of has_many relations
 652
 653 If a relationship key is included in the data structure with a value of undef
 654 or an empty array, all existing related rows will be deleted, or their foreign
 655 key columns will be set to null.
 656
 657 The exact behaviour depends on the nullability of the foreign key columns and
 658 the value of the "if_not_submitted" parameter. The parameter defaults to
 659 undefined which neither nullifies nor deletes.
 660
 661 When the array contains elements they are updated if they exist, created when
 662 not and deleted if not included.
 663
 664 =head3 All foreign table columns are nullable
 665
 666 In this case recursive_update defaults to nullifying the foreign columns.
 667
 668 =head3 Not all foreign table columns are nullable
 669
 670 In this case recursive_update deletes the foreign rows.
 671
 672 Updating the relationship:
 673
 674     Passing ids:
 675
 676     my $dvd = $dvd_rs->recursive_update( {
 677         id   => 1,
 678         tags => [1, 2],
 679     });
 680
 681     Passing hashrefs:
 682
 683     my $dvd = $dvd_rs->recursive_update( {
 684         id   => 1,
 685         tags => [
 686             {
 687                 id   => 1,
 688                 file => 'file0'
 689             },
 690             {
 691                 id   => 2,
 692                 file => 'file1',
 693             },
 694         ],
 695     });
 696
 697     Passing objects:
 698
 699     TODO
 700
 701     You can even mix them:
 702
 703     my $dvd = $dvd_rs->recursive_update( {
 704         id   => 1,
 705         tags => [ '2', { id => '3' } ],
 706     });
 707
 708 Clearing the relationship:
 709
 710     my $dvd = $dvd_rs->recursive_update( {
 711         id   => 1,
 712         tags => undef,
 713     });
 714
 715     This is the same as passing an empty array:
 716
 717     my $dvd = $dvd_rs->recursive_update( {
 718         id   => 1,
 719         tags => [],
 720     });
 721
 722 =head2 Treatment of many-to-many pseudo relations
 723
 724 The function gets the information about m2m relations from DBIx::Class::IntrospectableM2M.
 725 If it isn't loaded in the ResultSource classes the code relies on the fact that:
 726
 727     if($object->can($name) and
 728              !$object->result_source->has_relationship($name) and
 729              $object->can( 'set_' . $name )
 730          )
 731
 732 Then $name must be a many to many pseudo relation.
 733 And that in a similarly ugly was I find out what is the ResultSource of
 734 objects from that many to many pseudo relation.
 735
 736
 737 =head1 INTERFACE
 738
 739 =head1 METHODS
 740
 741 =head2 recursive_update
 742
 743 The method that does the work here.
 744
 745 =head2 is_m2m
 746
 747 $self->is_m2m( 'name ' ) - answers the question if 'name' is a many to many
 748 (pseudo) relation on $self.
 749
 750 =head2 get_m2m_source
 751
 752 $self->get_m2m_source( 'name' ) - returns the ResultSource linked to by the many
 753 to many (pseudo) relation 'name' from $self.
 754
 755
 756 =head1 DIAGNOSTICS
 757
 758
 759 =head1 CONFIGURATION AND ENVIRONMENT
 760
 761 DBIx::Class::RecursiveUpdate requires no configuration files or environment variables.
 762
 763 =head1 DEPENDENCIES
 764
 765     DBIx::Class
 766
 767 =head1 INCOMPATIBILITIES
 768
 769 None reported.
 770
 771
 772 =head1 BUGS AND LIMITATIONS
 773
 774 No bugs have been reported.
 775
 776 Please report any bugs or feature requests to
 777 C<bug-dbix-class-recursiveput@rt.cpan.org>, or through the web interface at
 778 L<http://rt.cpan.org>.
 779
 780
 781 =head1 AUTHOR
 782
 783 Zbigniew Lukasiak  C<< <zby@cpan.org> >>
 784 Influenced by code by Pedro Melo.
 785
 786 =head1 LICENCE AND COPYRIGHT
 787
 788 Copyright (c) 2008, Zbigniew Lukasiak C<< <zby@cpan.org> >>. All rights reserved.
 789
 790 This module is free software; you can redistribute it and/or
 791 modify it under the same terms as Perl itself. See L<perlartistic>.
 792
 793
 794 =head1 DISCLAIMER OF WARRANTY
 795
 796 BECAUSE THIS SOFTWARE IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
 797 FOR THE SOFTWARE, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
 798 OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
 799 PROVIDE THE SOFTWARE "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
 800 EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 801 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE
 802 ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE SOFTWARE IS WITH
 803 YOU. SHOULD THE SOFTWARE PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
 804 NECESSARY SERVICING, REPAIR, OR CORRECTION.
 805
 806 IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
 807 WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
 808 REDISTRIBUTE THE SOFTWARE AS PERMITTED BY THE ABOVE LICENCE, BE
 809 LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL,
 810 OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE
 811 THE SOFTWARE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
 812 RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
 813 FAILURE OF THE SOFTWARE TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
 814 SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
 815 SUCH DAMAGES.