Marcus Ramberg > DBIx-Class-0.05999_04 > DBIx::Class::Relationship

Download:
DBIx-Class-0.05999_04.tar.gz

Dependencies

Annotate this POD (2)

CPAN RT

New  11
Open  18
Stalled  11
View/Report Bugs
Source   Latest Release: DBIx-Class-0.082810

NAME ^

DBIx::Class::Relationship - Inter-table relationships

SYNOPSIS ^

DESCRIPTION ^

This class handles relationships between the tables in your database model. It allows you to set up relationships and perform joins on them.

Only the helper methods for setting up standard relationship types are documented here. For the basic, lower-level methods, see DBIx::Class::Relationship::Base.

METHODS ^

All helper methods take the following arguments:

  __PACKAGE__>$method_name('relname', 'Foreign::Class', $cond, $attrs);

Both $cond and $attrs are optional. Pass undef for $cond if you want to use the default value for it, but still want to set $attrs. See DBIx::Class::Relationship::Base for a list of valid attributes.

belongs_to

  # in a Bar class (where Foo has many Bars)
  __PACKAGE__->belongs_to(foo => Foo);
  my $f_obj = $obj->foo;
  $obj->foo($new_f_obj);

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.

NOTE: If you are used to Class::DBI relationships, this is the equivalent of has_a.

has_many

  # in a Foo class (where Foo has many Bars)
  __PACKAGE__->has_many(bar => Bar, 'foo');
  my $f_resultset = $obj->foo;
  my $f_resultset = $obj->foo({ name => { LIKE => '%macaroni%' }, { prefetch => [qw/bar/] });
  my @f_obj = $obj->foo;

  $obj->add_to_foo(\%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.

If you delete an object in a class with a has_many relationship, all related objects will be deleted as well. However, any database-level cascade or restrict will take precedence.

might_have

  __PACKAGE__->might_have(baz => Baz);
  my $f_obj = $obj->baz; # to get the baz 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.

If you update or delete an object in a class with a might_have relationship, the related object will be updated or deleted as well. Any database-level update or delete constraints will override this behavior.

has_one

  __PACKAGE__->has_one(gorch => Gorch);
  my $f_obj = $obj->gorch;

Creates a one-to-one relationship with another class. This is just like might_have, except the implication is that the other object is always present. The only different between has_one and might_have is that has_one uses an (ordinary) inner join, whereas might_have uses a left join.

many_to_many

  __PACKAGE__->many_to_many( 'accessorname' => 'a_to_b', 'table_b' );
  my @f_objs = $obj_a->accessorname;

Creates an accessor 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.

AUTHORS ^

Matt S. Trout <mst@shadowcatsystems.co.uk>

LICENSE ^

You may distribute this code under the same terms as Perl itself.

syntax highlighting: