Class::DBI::Cascade::None(3pm) User Contributed Perl Documentation Class::DBI::Cascade::None(3pm)NAME
Class::DBI::Cascade::None - Do nothing upon deletion
DESCRIPTION
This is a Cascading Delete strategy that will do nothing, leaving orphaned records behind.
It is the base class for most ofther Cascade strategies, and so provides several important methods:
CONSTRUCTOR
new
my $strategy = Cascade::Class->new($Relationship);
This must be instantiated with a Class::DBI::Relationship object.
METHODS
foreign_for
my $iterator = $strategy->foreign_for($obj);
This will return all the objects which are foreign to $obj across the relationship. It's a normal Class::DBI search you can get the results
either as a list or as an iterator.
cascade
$strategy->cascade($obj);
Cascade across the related objects to $obj.
WRITING NEW STRATEGIES
Creating a Cascade strategy should be fairly simple. You usually just need to inherit from here, and then supply a cascade() method that
does the required thing with the results from foreign_for().
So, for example, Cascade::Delete is implemented simply as:
package Class::DBI::Cascade::Delete;
use base 'Class::DBI::Cascade::None';
sub cascade {
my ($self, $obj) = @_;
$self->foreign_for($obj)->delete_all;
}
perl v5.12.4 2005-09-14 Class::DBI::Cascade::None(3pm)
Check Out this Related Man Page
Class::DBI::Relationship(3pm) User Contributed Perl Documentation Class::DBI::Relationship(3pm)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.
perl v5.12.4 2005-09-16 Class::DBI::Relationship(3pm)