use warnings;
use Carp::Clan qw/^DBIx::Class/;
+use Scalar::Util qw/weaken/;
use base qw/DBIx::Class/;
with your classes.
NB: If you're used to L<Class::DBI> it's worth reading the L</SYNOPSIS>
-carefully as DBIx::Class does things a little differently. Note in
+carefully, as DBIx::Class does things a little differently. Note in
particular which module inherits off which.
=head1 METHODS
=head2 register_class
-=head3 Arguments: ($moniker, $component_class)
+=over 4
+
+=item Arguments: $moniker, $component_class
+
+=back
-Registers a class which isa L<DBIx::Class::ResultSourceProxy>. Equivalent to
-calling
+Registers a class which isa DBIx::Class::ResultSourceProxy. Equivalent to
+calling:
$schema->register_source($moniker, $component_class->result_source_instance);
=head2 register_source
-=head3 Arguments: ($moniker, $result_source)
+=over 4
+
+=item Arguments: $moniker, $result_source
+
+=back
Registers the L<DBIx::Class::ResultSource> in the schema with the given
moniker.
$reg{$moniker} = $source;
$self->source_registrations(\%reg);
$source->schema($self);
+ weaken($source->{schema}) if ref($self);
if ($source->result_class) {
my %map = %{$self->class_mappings};
$map{$source->result_class} = $moniker;
$self->class_mappings(\%map);
}
-}
+}
=head2 class
-=head3 Arguments: ($moniker)
+=over 4
+
+=item Arguments: $moniker
-=head3 Returns: $classname
+=item Return Value: $classname
-Retrieves the result class name for the given moniker.
+=back
-e.g.,
+Retrieves the result class name for the given moniker. For example:
my $class = $schema->class('CD');
=head2 source
-=head3 Arguments: ($moniker)
+=over 4
+
+=item Arguments: $moniker
-=head3 Returns: $result_source
+=item Return Value: $result_source
+
+=back
my $source = $schema->source('Book');
=head2 sources
-=head3 Returns: @source_monikers
+=over 4
-Returns the source monikers of all source registrations on this schema.
+=item Return Value: @source_monikers
+
+=back
-e.g.,
+Returns the source monikers of all source registrations on this schema.
+For example:
my @source_monikers = $schema->sources;
=head2 resultset
-=head3 Arguments: ($moniker)
+=over 4
+
+=item Arguments: $moniker
-=head3 Returns: $result_set
+=item Return Value: $result_set
+
+=back
my $rs = $schema->resultset('DVD');
=head2 load_classes
-=head3 Arguments: @classes?, { $namespace => [ @classes ] }+
+=over 4
+
+=item Arguments: @classes?, { $namespace => [ @classes ] }+
+
+=back
With no arguments, this method uses L<Module::Find> to find all classes under
the schema's namespace. Otherwise, this method loads the classes you specify
(using L<use>), and registers them (using L</"register_class">).
-It is possible to comment out classes with a leading '#', but note that perl
-will think it's a mistake (trying to use a comment in a qw list) so you'll
-need to add "no warnings 'qw';" before your load_classes call.
+It is possible to comment out classes with a leading C<#>, but note that perl
+will think it's a mistake (trying to use a comment in a qw list), so you'll
+need to add C<no warnings 'qw';> before your load_classes call.
-e.g.,
+Example:
My::Schema->load_classes(); # loads My::Schema::CD, My::Schema::Artist,
- # etc. (anything under the My::Schema namespace)
+ # etc. (anything under the My::Schema namespace)
# loads My::Schema::CD, My::Schema::Artist, Other::Namespace::Producer but
# not Other::Namespace::LinerNotes nor My::Schema::Track
my $comp_class = "${prefix}::${comp}";
eval "use $comp_class"; # If it fails, assume the user fixed it
if ($@) {
- $comp_class =~ s/::/\//g;
+ $comp_class =~ s/::/\//g;
die $@ unless $@ =~ /Can't locate.+$comp_class\.pm\sin\s\@INC/;
- warn $@ if $@;
+ warn $@ if $@;
}
push(@to_register, [ $comp, $comp_class ]);
}
=head2 compose_connection
-=head3 Arguments: ($target_namespace, @db_info)
+=over 4
+
+=item Arguments: $target_namespace, @db_info
-=head3 Returns: $new_schema
+=item Return Value: $new_schema
-Calls L<DBIx::Class::schema/"compose_namespace"> to the target namespace,
-calls L<DBIx::Class::Schema/connection>(@db_info) on the new schema, then
-injects the L<DBix::Class::ResultSetProxy> component and a resultset_instance
-classdata entry on all the new classes in order to support
+=back
+
+Calls L<DBIx::Class::Schema/"compose_namespace"> to the target namespace,
+calls L<DBIx::Class::Schema/connection> with @db_info on the new schema,
+then injects the L<DBix::Class::ResultSetProxy> component and a
+resultset_instance classdata entry on all the new classes, in order to support
$target_namespaces::$class->search(...) method calls.
This is primarily useful when you have a specific need for class method access
=head2 compose_namespace
-=head3 Arguments: $target_namespace, $additional_base_class?
+=over 4
+
+=item Arguments: $target_namespace, $additional_base_class?
-=head3 Returns: $new_schema
+=item Return Value: $new_schema
+
+=back
For each L<DBIx::Class::ResultSource> in the schema, this method creates a
class in the target namespace (e.g. $target_namespace::CD,
classes will inherit from first the corresponding classe from the current
schema then the base class.
-e.g. (for a schema with My::Schema::CD and My::Schema::Artist classes),
+For example, for a schema with My::Schema::CD and My::Schema::Artist classes,
$schema->compose_namespace('My::DB', 'Base::Class');
print join (', ', @My::DB::CD::ISA) . "\n";
print join (', ', @My::DB::Artist::ISA) ."\n";
-Will produce the output
+will produce the output
My::Schema::CD, Base::Class
My::Schema::Artist, Base::Class
=head2 setup_connection_class
-=head3 Arguments: ($target, @info)
+=over 4
+
+=item Arguments: $target, @info
+
+=back
Sets up a database connection class to inject between the schema and the
subclasses that the schema creates.
=head2 connection
-=head3 Arguments: (@args)
+=over 4
+
+=item Arguments: @args
-=head3 Returns: $new_schema
+=item Return Value: $new_schema
+
+=back
Instantiates a new Storage object of type
L<DBIx::Class::Schema/"storage_type"> and passes the arguments to
=head2 connect
-=head3 Arguments: (@info)
+=over 4
+
+=item Arguments: @info
-=head3 Returns: $new_schema
+=item Return Value: $new_schema
+
+=back
This is a convenience method. It is equivalent to calling
$schema->clone->connection(@info). See L</connection> and L</clone> for more
=head2 txn_do
-=head3 Arguments: (C<$coderef>, @coderef_args?)
+=over 4
+
+=item Arguments: C<$coderef>, @coderef_args?
-=head3 Returns: (C<$return_value> | C<@return_values> | C<undef>) for scalar,
-list and void contexts, respectively
+=item Return Value: The return value of $coderef
+
+=back
Executes C<$coderef> with (optional) arguments C<@coderef_args> atomically,
returning its result (if any). If an exception is caught, a rollback is issued
$self->txn_begin; # If this throws an exception, no rollback is needed
my $wantarray = wantarray; # Need to save this since the context
- # inside the eval{} block is independent
- # of the context that called txn_do()
+ # inside the eval{} block is independent
+ # of the context that called txn_do()
eval {
# Need to differentiate between scalar/list context to allow for
my $rollback_error = $@;
my $exception_class = "DBIx::Class::Storage::NESTED_ROLLBACK_EXCEPTION";
$self->throw_exception($error) # propagate nested rollback
- if $rollback_error =~ /$exception_class/;
+ if $rollback_error =~ /$exception_class/;
$self->throw_exception(
"Transaction aborted: $error. Rollback failed: ${rollback_error}"
=head2 clone
-=head3 Returns: $new_schema
+=over 4
+
+=item Return Value: $new_schema
+
+=back
Clones the schema and its associated result_source objects and returns the
copy.
=head2 populate
-=head3 Arguments: ($moniker, \@data);
+=over 4
+
+=item Arguments: $moniker, \@data;
+
+=back
Populates the source registered with the given moniker with the supplied data.
@data should be a list of listrefs -- the first containing column names, the
=head2 throw_exception
-=over 4
+=over 4
-=item Arguments: ($message)
+=item Arguments: $message
=back
=over 4
-=item Arguments: ($sqlt_args)
+=item Arguments: $sqlt_args
=back
projects / dbsrgits/DBIx-Class.git / blobdiff