X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FRelationship.pm;h=3ee93ff09c427d32720476bf5a3248fe86f219e7;hb=5d62876f5fe86bc1b3a11a571074164bcce27e7b;hp=9420ab713c8672967ac89facad8523f8bfba2063;hpb=3bd6e3e0f621c4fe3d7562827a9b86ee5b91cbf2;p=dbsrgits%2FDBIx-Class-Historic.git diff --git a/lib/DBIx/Class/Relationship.pm b/lib/DBIx/Class/Relationship.pm index 9420ab7..3ee93ff 100644 --- a/lib/DBIx/Class/Relationship.pm +++ b/lib/DBIx/Class/Relationship.pm @@ -103,31 +103,140 @@ 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 - # 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); +=over 4 + +=item Arguments: $accessor_name, $related_class, $foreign_key_column|$cond?, $attr? + +=back 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. + +=over + +=item accessor_name + +This argument is the name of the method you can call on a +L object to retrieve the instance of the foreign +class matching this relationship. + +Use this accessor_name (relation name) in L +or L to join to the foreign table +indicated by this relationship. + +=item related_class + +This is the class name of the table referenced by the foreign key in +this class. + +=item foreign_key_column + +The column name on this class that contains the foreign key. + +OR + +=item cond -Cascading deletes are off per default on a C relationship, to turn -them on, pass C<< cascade_delete => 1 >> in the $attr hashref. +A hashref where the keys are C and +the values are C. This is useful for +relations that are across multiple columns. + +=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; # 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' } ); + +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 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 + +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. 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. + +=over + +=item accessor_name + +This argument is the name of the method you can call on a +L object to retrieve a resultset of the related +class restricted to the ones related to the row object. In list +context it returns the row objects. + +Use this accessor_name (relation name) in L +or L to join to the foreign table +indicated by this relationship. + +=item related_class + +This is the class name of the table which contains a foreign key +column containing PK values of this class. + +=item foreign_key_column + +The column name on the related class that contains the foreign key. + +OR + +=item cond + +A hashref where the keys are C and +the values are C. This is useful for +relations that are across multiple columns. + +=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 +248,113 @@ of C. $obj->add_to_books(\%col_data); -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. +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', + }); 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 + +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. + +=over + +=item accessor_name + +This argument is the name of the method you can call on a +L object to retrieve the instance of the foreign +class matching this relationship. + +Use this accessor_name (relation name) in L +or L to join to the foreign table +indicated by this relationship. + +=item related_class + +This is the class name of the table which contains a foreign key +column containing PK values of this class. + +=item foreign_key_column + +The column name on the related class that contains the foreign key. + +OR + +=item cond + +A hashref where the keys are C and +the values are C. This is useful for +relations that are across multiple columns. + +=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' } ); 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,89 +362,98 @@ 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 - My::DBIC::Schema::Actor->has_many( actor_roles => - 'My::DBIC::Schema::ActorRoles', - 'actor' ); - My::DBIC::Schema::ActorRoles->belongs_to( role => - 'My::DBIC::Schema::Role' ); - My::DBIC::Schema::ActorRoles->belongs_to( actor => - 'My::DBIC::Schema::Actor' ); +C 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 and similar methods which operate on true relationships. - My::DBIC::Schema::Actor->many_to_many( roles => 'actor_roles', - 'role' ); +=over -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. +=item accessor_name -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. +This argument is the name of the method you can call on a +L object to retrieve the rows matching this +relationship. -=head3 Created accessors +On a many_to_many, unlike other relationships, this cannot be used in +L to join tables. Use the relations +bridged across instead. -=head4 $rel +=item link_rel_name -=over 4 - -=item Arguments: $vals?, $attrs - -=back +This is the accessor_name from the has_many relationship we are +bridging from. - my $role_rs = $actor->roles; +=item foreign_rel_name - my $role1 = $actor->roles({ name => 'role1' })->first; +This is the accessor_name of the belongs_to relationship in the link +table that we are bridging across (which gives us the table we are +bridging to). -Returns a resultset for the foreign table on the right side of the -many-to-many relationship. (e.g., in the above example, a CD's -producers). Takes the same arguments as L. - -=head4 add_to_$rel +=back -=over 4 +To create a many_to_many relationship from Actor to Role: -=item Arguments: ($foreign_vals | $obj), $link_vals? + My::DBIC::Schema::Actor->has_many( actor_roles => + 'My::DBIC::Schema::ActorRoles', + 'actor' ); + My::DBIC::Schema::ActorRoles->belongs_to( role => + 'My::DBIC::Schema::Role' ); + My::DBIC::Schema::ActorRoles->belongs_to( actor => + 'My::DBIC::Schema::Actor' ); -=back + My::DBIC::Schema::Actor->many_to_many( roles => 'actor_roles', + 'role' ); - my $role = $schema->resultset('Role')->find(1); - $actor->add_to_roles($role); - # creates a My::DBIC::Schema::ActorRoles linking table row object +And, for the reverse relationship, from Role to Actor: - $actor->add_to_roles({ name => 'lead' }, { salary => 15_000_000 }); - # creates a new My::DBIC::Schema::Role row object and the linking table - # object with an extra column in the link + My::DBIC::Schema::Role->has_many( actor_roles => + 'My::DBIC::Schema::ActorRoles', + 'role' ); -Adds a linking table object for C<$obj> or C<$foreign_vals>. If the first -argument is a hash reference, the related object is created first with the -column values in the hash. If an object reference is given, just the linking -table object is created. In either case, any additional column values for the -linking table object can be specified in C<$link_vals>. + My::DBIC::Schema::Role->many_to_many( actors => 'actor_roles', 'actor' ); -=head4 remove_from_$rel +To add a role for your actor, and fill in the year of the role in the +actor_roles table: -=over 4 + $actor->add_to_roles($role, { year => 1995 }); -=item Arguments: $obj +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. -=back +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