X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FRelationship%2FBase.pm;h=d6563f4ca7643bd9a18df3ca2bc43c4b4c5afb84;hb=fd323bf1046faa7de5a8c985268d80ec5b703361;hp=f07882b26682a220845493edf1812409d74e09e7;hpb=c00b00deb4354de9c59e46bd83f4a2b23b953425;p=dbsrgits%2FDBIx-Class.git diff --git a/lib/DBIx/Class/Relationship/Base.pm b/lib/DBIx/Class/Relationship/Base.pm index f07882b..d6563f4 100644 --- a/lib/DBIx/Class/Relationship/Base.pm +++ b/lib/DBIx/Class/Relationship/Base.pm @@ -5,6 +5,8 @@ use warnings; use Scalar::Util (); use base qw/DBIx::Class/; +use Try::Tiny; +use namespace::clean; =head1 NAME @@ -30,6 +32,8 @@ methods, for predefined ones, look in L. __PACKAGE__->add_relationship('relname', 'Foreign::Class', $cond, $attrs); +=head3 condition + The condition needs to be an L-style representation of the join between the tables. When resolving the condition for use in a C, keys using the pseudo-table C are resolved to mean "the Table on the @@ -67,9 +71,18 @@ Each key-value pair provided in a hashref will be used as Ced conditions. To add an Ced condition, use an arrayref of hashrefs. See the L documentation for more details. -In addition to the -L, -the following attributes are also valid: +=head3 attributes + +The L may +be used as relationship attributes. In particular, the 'where' attribute is +useful for filtering relationships: + + __PACKAGE__->has_many( 'valid_users', 'MyApp::Schema::User', + { 'foreign.user_id' => 'self.user_id' }, + { where => { valid => 1 } } + ); + +The following attributes are also valid: =over 4 @@ -83,18 +96,18 @@ command immediately before C. An arrayref containing a list of accessors in the foreign class to create in the main class. If, for example, you do the following: - + MyDB::Schema::CD->might_have(liner_notes => 'MyDB::Schema::LinerNotes', undef, { proxy => [ qw/notes/ ], }); - + Then, assuming MyDB::Schema::LinerNotes has an accessor named notes, you can do: my $cd = MyDB::Schema::CD->find(1); $cd->notes('Notes go here'); # set notes -- LinerNotes object is # created if it doesn't exist - + =item accessor Specifies the type of accessor that should be created for the relationship. @@ -107,21 +120,55 @@ created, which calls C for the relationship. =item is_foreign_key_constraint If you are using L to create SQL for you and you find that it -is creating constraints where it shouldn't, or not creating them where it +is creating constraints where it shouldn't, or not creating them where it should, set this attribute to a true or false value to override the detection of when to create constraints. +=item cascade_copy + +If C is true on a C relationship for an +object, then when you copy the object all the related objects will +be copied too. To turn this behaviour off, pass C<< cascade_copy => 0 >> +in the C<$attr> hashref. + +The behaviour defaults to C<< cascade_copy => 1 >> for C +relationships. + +=item cascade_delete + +By default, DBIx::Class cascades deletes across C, +C and C relationships. You can disable this +behaviour on a per-relationship basis by supplying +C<< cascade_delete => 0 >> in the relationship attributes. + +The cascaded operations are performed after the requested delete, +so if your database has a constraint on the relationship, it will +have deleted/updated the related records or raised an exception +before DBIx::Class gets to perform the cascaded operation. + +=item cascade_update + +By default, DBIx::Class cascades updates across C and +C relationships. You can disable this behaviour on a +per-relationship basis by supplying C<< cascade_update => 0 >> in +the relationship attributes. + +This is not a RDMS style cascade update - it purely means that when +an object has update called on it, all the related objects also +have update called. It will not change foreign keys automatically - +you must arrange to do this yourself. + =item on_delete / on_update If you are using L to create SQL for you, you can use these -attributes to explicitly set the desired C or C constraint -type. If not supplied the SQLT parser will attempt to infer the constraint type by +attributes to explicitly set the desired C or C constraint +type. If not supplied the SQLT parser will attempt to infer the constraint type by interrogating the attributes of the B relationship. For any 'multi' -relationship with C<< cascade_delete => 1 >>, the corresponding belongs_to -relationship will be created with an C constraint. For any +relationship with C<< cascade_delete => 1 >>, the corresponding belongs_to +relationship will be created with an C constraint. For any relationship bearing C<< cascade_copy => 1 >> the resulting belongs_to constraint will be C. If you wish to disable this autodetection, and just -use the RDBMS' default constraint type, pass C<< on_delete => undef >> or +use the RDBMS' default constraint type, pass C<< on_delete => undef >> or C<< on_delete => '' >>, and the same for C respectively. =item is_deferrable @@ -176,26 +223,37 @@ sub related_resultset { $self->throw_exception("Can't call *_related as class methods") unless ref $self; my $rel = shift; - my $rel_obj = $self->relationship_info($rel); + my $rel_info = $self->relationship_info($rel); $self->throw_exception( "No such relationship ${rel}" ) - unless $rel_obj; - + unless $rel_info; + return $self->{related_resultsets}{$rel} ||= do { my $attrs = (@_ > 1 && ref $_[$#_] eq 'HASH' ? pop(@_) : {}); - $attrs = { %{$rel_obj->{attrs} || {}}, %$attrs }; + $attrs = { %{$rel_info->{attrs} || {}}, %$attrs }; $self->throw_exception( "Invalid query: @_" ) if (@_ > 1 && (@_ % 2 == 1)); my $query = ((@_ > 1) ? {@_} : shift); my $source = $self->result_source; - my $cond = $source->resolve_condition( - $rel_obj->{cond}, $rel, $self - ); + + # condition resolution may fail if an incomplete master-object prefetch + # is encountered - that is ok during prefetch construction (not yet in_storage) + my $cond = try { + $source->_resolve_condition( $rel_info->{cond}, $rel, $self ) + } + catch { + if ($self->in_storage) { + $self->throw_exception ($_); + } + + $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION; # RV + }; + if ($cond eq $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION) { my $reverse = $source->reverse_relationship_info($rel); foreach my $rev_rel (keys %$reverse) { - if ($reverse->{$rev_rel}{attrs}{accessor} eq 'multi') { + if ($reverse->{$rev_rel}{attrs}{accessor} && $reverse->{$rev_rel}{attrs}{accessor} eq 'multi') { $attrs->{related_objects}{$rev_rel} = [ $self ]; Scalar::Util::weaken($attrs->{related_object}{$rev_rel}[0]); } else { @@ -209,7 +267,7 @@ sub related_resultset { if (ref $_ eq 'HASH') { my $hash; foreach my $key (keys %$_) { - my $newkey = $key =~ /\./ ? "me.$key" : $key; + my $newkey = $key !~ /\./ ? "me.$key" : $key; $hash->{$newkey} = $_->{$key}; } $hash; @@ -248,8 +306,8 @@ sub search_related { ( $objects_rs ) = $rs->search_related_rs('relname', $cond, $attrs); -This method works exactly the same as search_related, except that -it guarantees a restultset, even in list context. +This method works exactly the same as search_related, except that +it guarantees a resultset, even in list context. =cut @@ -278,9 +336,9 @@ sub count_related { my $new_obj = $obj->new_related('relname', \%col_data); Create a new item of the related foreign class. If called on a -L object, it will magically -set any foreign key columns of the new object to the related primary -key columns of the source object for you. The newly created item will +L object, it will magically +set any foreign key columns of the new object to the related primary +key columns of the source object for you. The newly created item will not be saved into your storage until you call L on it. @@ -381,7 +439,7 @@ example, to set the correct author for a book, find the Author object, then call set_from_related on the book. This is called internally when you pass existing objects as values to -L, or pass an object to a belongs_to acessor. +L, or pass an object to a belongs_to accessor. The columns are only set in the local copy of the object, call L to set them in the storage. @@ -390,24 +448,22 @@ set them in the storage. sub set_from_related { my ($self, $rel, $f_obj) = @_; - my $rel_obj = $self->relationship_info($rel); - $self->throw_exception( "No such relationship ${rel}" ) unless $rel_obj; - my $cond = $rel_obj->{cond}; + my $rel_info = $self->relationship_info($rel); + $self->throw_exception( "No such relationship ${rel}" ) unless $rel_info; + my $cond = $rel_info->{cond}; $self->throw_exception( "set_from_related can only handle a hash condition; the ". "condition for $rel is of type ". (ref $cond ? ref $cond : 'plain scalar') ) unless ref $cond eq 'HASH'; if (defined $f_obj) { - my $f_class = $self->result_source->schema->class($rel_obj->{class}); + my $f_class = $rel_info->{class}; $self->throw_exception( "Object $f_obj isn't a ".$f_class ) unless Scalar::Util::blessed($f_obj) and $f_obj->isa($f_class); } -# print STDERR "set_from_related: ", $rel, Data::Dumper::Dumper({$f_obj->get_columns}); $self->set_columns( - $self->result_source->resolve_condition( - $rel_obj->{cond}, $f_obj, $rel)); -# print STDERR "set_: ", Data::Dumper::Dumper({$self->get_columns}); + $self->result_source->_resolve_condition( + $rel_info->{cond}, $f_obj, $rel)); return 1; } @@ -472,17 +528,21 @@ B relationships.> =over 4 -=item Arguments: (\@hashrefs | \@objs) +=item Arguments: (\@hashrefs | \@objs), $link_vals? =back my $actor = $schema->resultset('Actor')->find(1); - my @roles = $schema->resultset('Role')->search({ role => + my @roles = $schema->resultset('Role')->search({ role => { '-in' => ['Fred', 'Barney'] } } ); $actor->set_roles(\@roles); # Replaces all of $actor's previous roles with the two named + $actor->set_roles(\@roles, { salary => 15_000_000 }); + # Sets a column in the link table for all roles + + Replace all the related objects with the given reference to a list of objects. This does a C B to remove the association between the current object and all related objects, then calls