# Class::DBI::Relationship - phpMan

## NAME
    [Class::DBI::Relationship] - base class for Relationships

## DESCRIPTION
    A [Class::DBI] class represents a database table. But merely being able to
    represent single tables isn't really that useful - databases are all
    about relationships.

    So, [Class::DBI] provides a variety of Relationship models to represent
    common database occurences (HasA, HasMany and MightHave), and provides a
    way to add others.

## SUBCLASSING
    Relationships should inherit from [Class::DBI::Relationship], and provide
    a variety of methods to represent the relationship. For examples of how
    these are used see [Class::DBI::Relationship::HasA],
    [Class::DBI::Relationship::HasMany] and
    [Class::DBI::Relationship::MightHave].

  remap_arguments
            sub remap_arguments {
                    my $self = shift;
                    # process @_;
                    return ($class, accessor, $foreign_class, $args)
            }

    Subclasses should define a 'remap_arguments' method that takes the
    arguments with which your relationship method will be called, and
    transforms them into the structure that the Relationship modules
    requires. If this method is not provided, then it is assumed that your
    method will be called with these 3 arguments in this order.

    This should return a list of 4 items:

    class
        The [Class::DBI] subclass to which this relationship applies. This
        will be passed in to you from the caller who actually set up the
        relationship, and is available for you to call methods on whilst
        performing this mapping. You should almost never need to change
        this.

        This usually an entire application base class (or [Class::DBI]
        itself), but could be a single class wishing to override a default
        relationship.

    accessor
        The method in the class which will provide access to the results of
        the relationship.

    foreign_class
        The class for the table with which the class has a relationship.

    args
        Any additional args that your relationship requires. It is
        recommended that you use this as a hashref to store any extra
        information your relationship needs rather than adding extra
        accessors, as this information will all be stored in the
        'meta_info'.

  triggers
            sub triggers {
                    return (
                            before_create => sub { ... },
                            after_create  => sub { ... },
                    );
            }

    Subclasses may define a 'triggers' method that returns a list of
    triggers that the relationship needs. This method can be omitted if
    there are no triggers to be set up.

  methods
            sub methods {
                    return (
                            method1 => sub { ... },
                            method2 => sub { ... },
                    );
            }

    Subclasses may define a 'methods' method that returns a list of methods
    to facilitate the relationship that should be created in the calling
    [Class::DBI] class. This method can be omitted if there are no methods to
    be set up.