/ 
DBIx-Class-0.04999_03
River stage three • 349 direct dependents • 459 total dependents
/ DBIx::Class::Schema

NAME

DBIx::Class::Schema - composable schemas

SYNOPSIS

in My/Schema.pm

package My::Schema;

use base qw/DBIx::Class::Schema/;

__PACKAGE__->load_classes(qw/Foo Bar Baz/);

in My/Schema/Foo.pm

package My::Schema::Foo;

use base qw/DBIx::Class/;

__PACKAGE__->load_components(qw/PK::Auto::Pg Core/); # for example
__PACKAGE__->table('foo');
...

in My/DB.pm

use My::Schema;

My::Schema->compose_connection('My::DB', $dsn, $user, $pass, $attrs);

then in app code

my @obj = My::DB::Foo->search({}); # My::DB::Foo isa My::Schema::Foo My::DB

DESCRIPTION

Creates database classes based on a schema. This allows you to have more than one concurrent connection using the same database classes, by making subclasses under a new namespace for each connection. If you only need one class, you should probably use DBIx::Class::DB directly instead.

NB: If you're used to Class::DBI it's worth reading the "SYNOPSIS" carefully as DBIx::Class does things a little differently. Note in particular which module inherits off which.

METHODS

register_class <moniker> <component_class>

Registers a class which isa ResultSourceInstance; equivalent to calling

$schema->register_source($moniker, $class->result_source_instance);

register_source <moniker> <result source>

Registers the result source in the schema with the given moniker

class

my $class = $schema->class('Foo');

Retrieves the result class name for a given result source

source

my $source = $schema->source('Foo');

Returns the result source object for the registered name

sources

my @source_monikers = $schema->sources;

Returns the source monikers of all source registrations on this schema

resultset

my $rs = $schema->resultset('Foo');

Returns the resultset for the registered moniker

load_classes [<classes>, (<class>, <class>), {<namespace> => [<classes>]}]

Uses Module::Find to find all classes under the database class' namespace, or uses the classes you select. Then it loads the component (using use), and registers them (using 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.

compose_connection <target> <@db_info>

This is the most important method in this class. it takes a target namespace, as well as dbh connection info, and creates a DBIx::Class::DB class as well as subclasses for each of your database classes in this namespace, using this connection.

It will also setup a ->class method on the target class, which lets you resolve database classes based on the schema component name, for example

MyApp::DB->class('Foo') # returns MyApp::DB::Foo, 
                        # which ISA MyApp::Schema::Foo

This is the recommended API for accessing Schema generated classes, and using it might give you instant advantages with future versions of DBIC.

WARNING: Loading components into Schema classes after compose_connection may not cause them to be seen by the classes in your target namespace due to the dispatch table approach used by Class::C3. If you do this you may find you need to call Class::C3->reinitialize() afterwards to get the behaviour you expect.

setup_connection_class <$target> <@info>

Sets up a database connection class to inject between the schema and the subclasses the schema creates.

connection(@args)

Instantiates a new Storage object of type storage_type and passes the arguments to $storage->connection_info. Sets the connection in-place on the schema.

connect(@info)

Conveneience method, equivalent to $schema->clone->connection(@info)

clone

Clones the schema and its associated result_source objects and returns the copy.

AUTHORS

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

LICENSE

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