X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FRelationship.pm;h=cdb35811c573d9a5c30358e064e3de077c05fd1c;hb=9ce9ec1036c3a67b4087b3f4a90bca09463c1e03;hp=fc48fdc998e760e2f90c858174f9a3d5c5aa5ea6;hpb=c687b87e860c97257542dda2b14c0137f6fbc583;p=dbsrgits%2FDBIx-Class.git diff --git a/lib/DBIx/Class/Relationship.pm b/lib/DBIx/Class/Relationship.pm index fc48fdc..cdb3581 100644 --- a/lib/DBIx/Class/Relationship.pm +++ b/lib/DBIx/Class/Relationship.pm @@ -3,102 +3,116 @@ package DBIx::Class::Relationship; use strict; use warnings; -use base qw/Class::Data::Inheritable/; - -__PACKAGE__->mk_classdata('_relationships', { } ); - -sub add_relationship { - my ($class, $rel, $f_class, $cond, $attrs) = @_; - my %rels = %{ $class->_relationships }; - $rels{$rel} = { class => $f_class, - cond => $cond, - attrs => $attrs }; - $class->_relationships(\%rels); -} - -sub _cond_key { - my ($self, $attrs, $key) = @_; - my $action = $attrs->{_action} || ''; - if ($action eq 'convert') { - unless ($key =~ s/^foreign\.//) { - die "Unable to convert relationship to WHERE clause: invalid key ${key}"; - } - return $key; - } elsif ($action eq 'join') { - my ($type, $field) = split(/\./, $key); - if ($attrs->{_aliases}{$type}) { - return join('.', $attrs->{_aliases}{$type}, $field); - } else { - die "Unable to resolve type ${type}: only have aliases for ". - join(', ', keys %{$attrs->{_aliases}{$type} || {}}); - } - } - return $self->NEXT::ACTUAL::_cond_key($attrs, $key); -} - -sub _cond_value { - my ($self, $attrs, $key, $value) = @_; - my $action = $attrs->{_action} || ''; - if ($action eq 'convert') { - unless ($value =~ s/^self\.//) { - die "Unable to convert relationship to WHERE clause: invalid value ${value}"; - } - unless ($self->_columns->{$value}) { - die "Unable to convert relationship to WHERE clause: no such accessor ${value}"; - } - push(@{$attrs->{bind}}, $self->get_column($value)); - return '?'; - } elsif ($action eq 'join') { - my ($type, $field) = split(/\./, $value); - if ($attrs->{_aliases}{$type}) { - return join('.', $attrs->{_aliases}{$type}, $field); - } else { - die "Unable to resolve type ${type}: only have aliases for ". - join(', ', keys %{$attrs->{_aliases}{$type} || {}}); - } - } - - return $self->NEXT::ACTUAL::_cond_value($attrs, $key, $value) -} - -sub search_related { - my $self = shift; - my $rel = shift; - my $attrs = { }; - if (@_ > 1 && ref $_[$#_] eq 'HASH') { - $attrs = { %{ pop(@_) } }; - } - my $rel_obj = $self->_relationships->{$rel}; - die "No such relationship ${rel}" unless $rel; - $attrs = { %{$rel_obj->{attrs}}, %{$attrs || {}} }; - my $s_cond; - if (@_) { - die "Invalid query: @_" if (@_ > 1 && (@_ % 2 == 1)); - my $query = ((@_ > 1) ? {@_} : shift); - $s_cond = $self->_cond_resolve($query, $attrs); - } - $attrs->{_action} = 'convert'; - my ($cond) = $self->_cond_resolve($rel_obj->{cond}, $attrs); - $cond = "${s_cond} AND ${cond}" if $s_cond; - return $rel_obj->{class}->retrieve_from_sql($cond, @{$attrs->{bind} || []}, - $attrs); -} - -sub create_related { - my ($self, $rel, $values, $attrs) = @_; - die "Can't call create_related as class method" unless ref $self; - die "create_related needs a hash" unless (ref $values eq 'HASH'); - my $rel_obj = $self->_relationships->{$rel}; - die "No such relationship ${rel}" unless $rel; - die "Can't abstract implicit create for ${rel}, condition not a hash" - unless ref $rel_obj->{cond} eq 'HASH'; - $attrs = { %{$rel_obj->{attrs}}, %{$attrs || {}}, _action => 'convert' }; - my %fields = %$values; - while (my ($k, $v) = each %{$rel_obj->{cond}}) { - $self->_cond_value($attrs, $k => $v); - $fields{$self->_cond_key($attrs, $k)} = (@{delete $attrs->{bind}})[0]; - } - return $rel_obj->{class}->create(\%fields); -} +use base qw/DBIx::Class/; + +__PACKAGE__->load_own_components(qw/ + Helpers + Accessor + CascadeActions + ProxyMethods + Base +/); + +=head1 NAME + +DBIx::Class::Relationship - Inter-table relationships + +=head1 SYNOPSIS + +=head1 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 +L. + +=head1 METHODS + +All helper methods take the following arguments: + + __PACKAGE__>$method_name('relname', 'Foreign::Class', $cond, $attrs); + +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. + +=head2 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 L relationships, this is the equivalent +of C. + +=head2 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 C relationship, all +related objects will be deleted as well. However, any database-level +cascade or restrict will take precedence. + +=head2 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 C relationship, +the related object will be updated or deleted as well. Any database-level update +or delete constraints will override this behavior. + +=head2 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 C, +except the implication is that the other object is always present. The only different +between C and C is that C uses an (ordinary) inner join, +whereas C uses a left join. + + +=head2 many_to_many + + __PACKAGE__->many_to_many( 'accessorname' => 'a_to_b', 'table_b' ); + my @f_objs = $obj_a->accessorname; + +=cut 1; + +=head1 AUTHORS + +Matt S. Trout + +=head1 LICENSE + +You may distribute this code under the same terms as Perl itself. + +=cut +