X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FRelationship.pm;h=b95867f01077542e150dcaf14d0526f15fe43850;hb=88262f96056323dd426285bd45fbe385168cd0d3;hp=dd3616678624c25c1273d0a57097ef843869fe15;hpb=303cf522b1c2841ecab3056cfbb4314fa05151a2;p=dbsrgits%2FDBIx-Class-Historic.git diff --git a/lib/DBIx/Class/Relationship.pm b/lib/DBIx/Class/Relationship.pm index dd36166..b95867f 100644 --- a/lib/DBIx/Class/Relationship.pm +++ b/lib/DBIx/Class/Relationship.pm @@ -103,31 +103,69 @@ All helper methods take the following arguments: Both C<$cond> and C<$attrs> are optional. Pass C for C<$cond> if you want to use the default value for it, but still want to set C<$attrs>. -See L for a list of valid attributes. + +See L for a list of valid attributes and valid +relationship attributes. =head2 belongs_to +=over 4 + +=item Arguments: $accessor_name, $related_class, $foreign_key_column|$cond?, $attr? + +=back + # in a Book class (where Author has many Books) - My::DBIC::Schema::Book->belongs_to(author => 'My::DBIC::Schema::Author'); - my $author_obj = $obj->author; - $obj->author($new_author_obj); + My::DBIC::Schema::Book->belongs_to( author => 'My::DBIC::Schema::Author' ); + + my $author_obj = $obj->author; # get author object + $obj->author( $new_author_obj ); # set author object + +The above belongs_to relationship could also have been specified as, + + My::DBIC::Schema::Book->belongs_to( author, + 'My::DBIC::Schema::Author', + { 'foreign.author' => 'self.author' } ); Creates a relationship where the calling class stores the foreign class's -primary key in one (or more) of its columns. If $cond is a column name -instead of a join condition hash, that is used as the name of the column -holding the foreign key. If $cond is not given, the relname is used as -the column name. +primary key in one (or more) of its columns. This relationship defaults to +using C<$accessor_name> as the foreign key in C<$related_class> to resolve the +join, unless C<$foreign_key_column> specifies the foreign key column in +C<$related_class> or C<$cond> specifies a reference to a join condition hash. + +If the relationship is optional -- i.e. the column containing the foreign key +can be NULL -- then the belongs_to relationship does the right thing. Thus, in +the example above C<$obj-Eauthor> would return C. However in this +case you would probably want to set the C attribute so that a C is done, which makes complex resultsets involving C or C +operations work correctly. The modified declaration is shown below: + + # in a Book class (where Author has_many Books) + __PACKAGE__->belongs_to(author => 'My::DBIC::Schema::Author', + 'author', {join_type => 'left'}); -Cascading deletes are off per default on a C relationship, to turn -them on, pass C<< cascade_delete => 1 >> in the $attr hashref. + +Cascading deletes are off by default on a C +relationship. To turn them on, pass C<< cascade_delete => 1 >> +in the $attr hashref. NOTE: If you are used to L relationships, this is the equivalent of C. +See L for documentation on relationship +methods and valid relationship attributes. + =head2 has_many - # in an Author class (where Author has many Books) +=over 4 + +=item Arguments: $accessor_name, $related_class, $foreign_key_column|$cond?, $attr? + +=back + + # in an Author class (where Author has_many Books) My::DBIC::Schema::Author->has_many(books => 'My::DBIC::Schema::Book', 'author'); + my $booklist = $obj->books; my $booklist = $obj->books({ name => { LIKE => '%macaroni%' }, @@ -139,44 +177,91 @@ of C. $obj->add_to_books(\%col_data); +The above C relationship could also have been specified with an +explicit join condition: + + My::DBIC::Schema::Author->has_many( books => 'My::DBIC::Schema::Book', { + 'foreign.author' => 'self.author', + }); + Creates a one-to-many relationship, where the corresponding elements of the foreign class store the calling class's primary key in one (or more) of its -columns. You should pass the name of the column in the foreign class as the -$cond argument, or specify a complete join condition. +columns. This relationship defaults to using C<$accessor_name> as the foreign +key in C<$related_class> to resolve the join, unless C<$foreign_key_column> +specifies the foreign key column in C<$related_class> or C<$cond> specifies a +reference to a join condition hash. Three methods are created when you create a has_many relationship. The first -method is the expected accessor method. The second is almost exactly the same -as the accessor method but "_rs" is added to the end of the method name. This -method works just like the normal accessor, except that it returns a resultset -no matter what, even in list context. The third method, named -C<< add_to_ >>, will also be added to your Row items, this allows -you to insert new related items, using the same mechanism as in +method is the expected accessor method, C<$accessor_name()>. The second is +almost exactly the same as the accessor method but "_rs" is added to the end of +the method name. This method works just like the normal accessor, except that +it returns a resultset no matter what, even in list context. The third method, +named C<< add_to_$relname >>, will also be added to your Row items; this +allows you to insert new related items, using the same mechanism as in L. If you delete an object in a class with a C relationship, all -the related objects will be deleted as well. However, any database-level -cascade or restrict will take precedence. To turn this behavior off, pass -C<< cascade_delete => 0 >> in the $attr hashref. +the related objects will be deleted as well. To turn this behaviour off, +pass C<< cascade_delete => 0 >> in the C<$attr> hashref. However, any +database-level cascade or restrict will take precedence over a +DBIx-Class-based cascading delete. + +See L for documentation on relationship +methods and valid relationship attributes. =head2 might_have - My::DBIC::Schema::Author->might_have(pseudonym => - 'My::DBIC::Schema::Pseudonyms'); +=over 4 + +=item Arguments: $accessor_name, $related_class, $foreign_key_column|$cond?, $attr? + +=back + + My::DBIC::Schema::Author->might_have( pseudonym => + 'My::DBIC::Schema::Pseudonym' ); + my $pname = $obj->pseudonym; # to get the Pseudonym object -Creates an optional one-to-one relationship with a class, where the foreign -class stores our primary key in one of its columns. Defaults to the primary -key of the foreign class unless $cond specifies a column or join condition. +The above might_have relationship could have been specified as: + + My::DBIC::Schema::Author->might_have( pseudonym => + 'My::DBIC::Schema::Pseudonym', + 'author' ); + +Or even: + + My::DBIC::Schema::Author->might_have( pseudonym => + 'My::DBIC::Schema::Pseudonym', + { 'foreign.author' => 'self.author' } ); + +Assuming the Pseudonym table has + +Creates an optional one-to-one relationship with a class. This relationship +defaults to using C<$accessor_name> as the foreign key in C<$related_class> to +resolve the join, unless C<$foreign_key_column> specifies the foreign key +column in C<$related_class> or C<$cond> specifies a reference to a join +condition hash. If you update or delete an object in a class with a C -relationship, the related object will be updated or deleted as well. -Any database-level update or delete constraints will override this behaviour. -To turn off this behavior, add C<< cascade_delete => 0 >> to the $attr hashref. +relationship, the related object will be updated or deleted as well. To +turn off this behavior, add C<< cascade_delete => 0 >> to the C<$attr> +hashref. Any database-level update or delete constraints will override +this behavior. + +See L for documentation on relationship +methods and valid relationship attributes. =head2 has_one +=over 4 + +=item Arguments: $accessor_name, $related_class_name, $join_condition?, $attr? + +=back + My::DBIC::Schema::Book->has_one(isbn => 'My::DBIC::Schema::ISBN'); - my $isbn_obj = $obj->isbn; + + my $isbn_obj = $obj->isbn; # to get the ISBN object Creates a one-to-one relationship with another class. This is just like C, except the implication is that the other object is always @@ -184,15 +269,26 @@ present. The only difference between C and C is that C uses an (ordinary) inner join, whereas C uses a left join. +The has_one relationship should be used when a row in the table has exactly one +related row in another table. If the related row might not exist in the foreign +table, use the L relationship. + +In the above example, each Book in the database is associated with exactly one +ISBN object. + +See L for documentation on relationship +methods and valid relationship attributes. =head2 many_to_many =over 4 -=item Arguments: $accessor_name, $link_rel_name, $foreign_rel_name +=item Arguments: $accessor_name, $link_rel_name, $foreign_rel_name, $attr? =back +To create a many_to_many relationship from Actor to Role: + My::DBIC::Schema::Actor->has_many( actor_roles => 'My::DBIC::Schema::ActorRoles', 'actor' ); @@ -204,48 +300,42 @@ left join. My::DBIC::Schema::Actor->many_to_many( roles => 'actor_roles', 'role' ); -Creates a accessors bridging two relationships; not strictly a relationship in -its own right, although the accessor will return a resultset or collection of -objects just as a has_many would. - -To use many_to_many, existing relationships from the original table to the link -table, and from the link table to the end table must already exist, these -relation names are then used in the many_to_many call. +And, for the reverse relationship, from Role to Actor: -=head3 Created accessors + My::DBIC::Schema::Role->has_many( actor_roles => + 'My::DBIC::Schema::ActorRoles', + 'role' ); -=head4 $rel + My::DBIC::Schema::Role->many_to_many( actors => 'actor_roles', 'actor' ); - my $role_rs = $actor->roles; +To add a role for your actor, and fill in the year of the role in the +actor_roles table: - my $role1 = $actor->roles({ name => 'role1' })->first; + $actor->add_to_roles($role, { year => 1995 }); -Returns a resultset for the table on the far-right side of the many-to-many -relationship. (e.g., in the above example, a CD's producers). +Many_to_many is not strictly a relationship in its own right. Instead, it is +a bridge between two resultsets which provide the same kind of convenience +accessors as true relationships provide. Although the accessor will return a +resultset or collection of objects just like has_many does, you cannot call +C<$related_resultset> and similar methods which operate on true relationships. -=head4 add_to_$rel +In the above example, ActorRoles is the link table class, and Role is the +foreign class. The C<$link_rel_name> parameter is the name of the accessor for +the has_many relationship from this table to the link table, and the +C<$foreign_rel_name> parameter is the accessor for the belongs_to relationship +from the link table to the foreign table. - my $role = $schema->resultset('Role')->find(1); - $actor->add_to_roles($role); - # creates a My::DBIC::Schema::ActorRoles linking table row object - - $actor->add_to_roles({ name => 'role1' }); - # creates a new My::DBIC::Schema::Role row object, as well as the - # linking table object - -Adds a linking table object for the specified object, or if a hash is given -instead the related object is created before the linking table object is -created. - -=head4 remove_from_$rel +To use many_to_many, existing relationships from the original table to the link +table, and from the link table to the end table must already exist, these +relation names are then used in the many_to_many call. - my $role = $schema->resultset('Role')->find(1); - $actor->remove_from_roles($role); - # removes $role's My::DBIC::Schema::ActorRoles linking table row object +In the above example, the Actor class will have 3 many_to_many accessor methods +set: C<$roles>, C<$add_to_roles>, C<$set_roles>, and similarly named accessors +will be created for the Role class for the C many_to_many +relationship. -Removes the link between the current object and the related object. Note that -the related object itself won't be deleted unless you call ->delete() on -it. This method just removes the link between the two objects. +See L for documentation on relationship +methods and valid relationship attributes. =cut