Catalyst::Model::DBIC::Schema - DBIx::Class::Schema Model Class
Manual creation of a DBIx::Class::Schema and a Catalyst::Model::DBIC::Schema:
Create the DBIx:Class schema in MyApp/Schema/FilmDB.pm:
package MyApp::Schema::FilmDB; use base qw/DBIx::Class::Schema/; __PACKAGE__->load_classes(qw/Actor Role/);
Create some classes for the tables in the database, for example an Actor in MyApp/Schema/FilmDB/Actor.pm:
package MyApp::Schema::FilmDB::Actor; use base qw/DBIx::Class/ __PACKAGE__->load_components(qw/Core/); __PACKAGE__->table('actor'); ...
and a Role in MyApp/Schema/FilmDB/Role.pm:
package MyApp::Schema::FilmDB::Role; use base qw/DBIx::Class/ __PACKAGE__->load_components(qw/Core/); __PACKAGE__->table('role'); ...
Notice that the schema is in MyApp::Schema, not in MyApp::Model. This way it's usable as a standalone module and you can test/run it without Catalyst.
To expose it to Catalyst as a model, you should create a DBIC Model in MyApp/Model/FilmDB.pm:
package MyApp::Model::FilmDB; use base qw/Catalyst::Model::DBIC::Schema/; __PACKAGE__->config( schema_class => 'MyApp::Schema::FilmDB', connect_info => { dsn => "DBI:...", user => "username", password => "password", } );
See below for a full list of the possible config parameters.
Now you have a working Model which accesses your separate DBIC Schema. This can be used/accessed in the normal Catalyst manner, via $c->model():
my $actor = $c->model('FilmDB::Actor')->find(1);
You can also use it to set up DBIC authentication with Catalyst::Authentication::Store::DBIx::Class in MyApp.pm:
package MyApp; use Catalyst qw/... Authentication .../; ... __PACKAGE__->config->{authentication} = { default_realm => 'members', realms => { members => { credential => { class => 'Password', password_field => 'password', password_type => 'hashed' password_hash_type => 'SHA-256' }, store => { class => 'DBIx::Class', user_model => 'DB::User', role_relation => 'roles', role_field => 'rolename', } } } };
$c->model('Schema::Source') returns a DBIx::Class::ResultSet for the source name parameter passed. To find out more about which methods can be called on a ResultSet, or how to add your own methods to it, please see the ResultSet documentation in the DBIx::Class distribution.
$c->model('Schema::Source')
Some examples are given below:
# to access schema methods directly: $c->model('FilmDB')->schema->source(...); # to access the source object, resultset, and class: $c->model('FilmDB')->source(...); $c->model('FilmDB')->resultset(...); $c->model('FilmDB')->class(...); # For resultsets, there's an even quicker shortcut: $c->model('FilmDB::Actor') # is the same as $c->model('FilmDB')->resultset('Actor') # To get the composed schema for making new connections: my $newconn = $c->model('FilmDB')->composed_schema->connect(...); # Or the same thing via a convenience shortcut: my $newconn = $c->model('FilmDB')->connect(...); # or, if your schema works on different storage drivers: my $newconn = $c->model('FilmDB')->composed_schema->clone(); $newconn->storage_type('::LDAP'); $newconn->connection(...); # and again, a convenience shortcut my $newconn = $c->model('FilmDB')->clone(); $newconn->storage_type('::LDAP'); $newconn->connection(...);
This is a Catalyst Model for DBIx::Class::Schema-based Models. See the documentation for Catalyst::Helper::Model::DBIC::Schema for information on generating these Models via Helper scripts.
When your Catalyst app starts up, a thin Model layer is created as an interface to your DBIC Schema. It should be clearly noted that the model object returned by $c->model('FilmDB') is NOT itself a DBIC schema or resultset object, but merely a wrapper proving methods to access the underlying schema.
$c->model('FilmDB')
In addition to this model class, a shortcut class is generated for each source in the schema, allowing easy and direct access to a resultset of the corresponding type. These generated classes are even thinner than the model class, providing no public methods but simply hooking into Catalyst's model() accessor via the ACCEPT_CONTEXT mechanism. The complete contents of each generated class is roughly equivalent to the following:
package MyApp::Model::FilmDB::Actor sub ACCEPT_CONTEXT { my ($self, $c) = @_; $c->model('FilmDB')->resultset('Actor'); }
In short, there are three techniques available for obtaining a DBIC resultset object:
# the long way my $rs = $c->model('FilmDB')->schema->resultset('Actor'); # using the shortcut method on the model object my $rs = $c->model('FilmDB')->resultset('Actor'); # using the generated class directly my $rs = $c->model('FilmDB::Actor');
In order to add methods to a DBIC resultset, you cannot simply add them to the source (row, table) definition class; you must define a separate custom resultset class. See "Predefined searches" in DBIx::Class::Manual::Cookbook for more info.
This is the classname of your DBIx::Class::Schema Schema. It needs to be findable in @INC, but it does not need to be inside the Catalyst::Model:: namespace. This parameter is required.
@INC
Catalyst::Model::
This is an arrayref of connection parameters, which are specific to your storage_type (see your storage type documentation for more details). If you only need one parameter (e.g. the DSN), you can just pass a string instead of an arrayref.
storage_type
This is not required if schema_class already has connection information defined inside itself (which isn't highly recommended, but can be done)
schema_class
For DBIx::Class::Storage::DBI, which is the only supported storage_type in DBIx::Class at the time of this writing, the parameters are your dsn, username, password, and connect options hashref.
See "connect_info" in DBIx::Class::Storage::DBI for a detailed explanation of the arguments supported.
Examples:
connect_info => { dsn => 'dbi:Pg:dbname=mypgdb', user => 'postgres', password => '' } connect_info => { dsn => 'dbi:SQLite:dbname=foo.db', on_connect_do => [ 'PRAGMA synchronous = OFF', ] } connect_info => { dsn => 'dbi:Pg:dbname=mypgdb', user => 'postgres', password => '', pg_enable_utf8 => 1, on_connect_do => [ 'some SQL statement', 'another SQL statement', ], }
Or using Config::General:
<Model::FilmDB> schema_class MyApp::Schema::FilmDB traits Caching <connect_info> dsn dbi:Pg:dbname=mypgdb user postgres password "" auto_savepoint 1 quote_char """ on_connect_do some SQL statement on_connect_do another SQL statement </connect_info> </Model::FilmDB>
or
<Model::FilmDB> schema_class MyApp::Schema::FilmDB connect_info dbi:SQLite:dbname=foo.db </Model::FilmDB>
Or using YAML:
Model::MyDB: schema_class: MyDB connect_info: dsn: dbi:Oracle:mydb user: mtfnpy password: mypass LongReadLen: 1000000 LongTruncOk: 1 on_connect_do: [ "alter session set nls_date_format = 'YYYY-MM-DD HH24:MI:SS'" ] cursor_class: 'DBIx::Class::Cursor::Cached' quote_char: '"'
The old arrayref style with hashrefs for DBI then DBIx::Class options is also supported:
connect_info => [ 'dbi:Pg:dbname=mypgdb', 'postgres', '', { pg_enable_utf8 => 1, }, { auto_savepoint => 1, on_connect_do => [ 'some SQL statement', 'another SQL statement', ], } ]
Array of Traits to apply to the instance. Traits are Moose::Roles.
They are relative to the MyApp::TraitFor::Model::DBIC::Schema::, then the Catalyst::TraitFor::Model::DBIC::Schema:: namespaces, unless prefixed with + in which case they are taken to be a fully qualified name. E.g.:
MyApp::TraitFor::Model::DBIC::Schema::
Catalyst::TraitFor::Model::DBIC::Schema::
+
traits Caching traits +MyApp::TraitFor::Model::Foo
A new instance is created at application time, so any consumed required attributes, coercions and modifiers will work.
Traits are applied at "COMPONENT" in Catalyst::Component time using CatalystX::Component::Traits.
ref $self will be an anon class if any traits are applied, $self->_original_class_name will be the original class.
ref $self
$self->_original_class_name
When writing a Trait, interesting points to modify are BUILD, "setup" and "ACCEPT_CONTEXT".
BUILD
Traits that come with the distribution:
Allows the use of a different storage_type than what is set in your schema_class (which in turn defaults to ::DBI if not set in current DBIx::Class). Completely optional, and probably unnecessary for most people until other storage backends become available for DBIx::Class.
::DBI
The keys you pass in the model configuration are available as attributes.
Other attributes available:
Your connect_info args normalized to hashref form (with dsn/user/password.) See "connect_info" in DBIx::Class::Storage::DBI for more info on the hashref form of "connect_info".
The model name Catalyst uses to resolve this model, the part after ::Model:: or ::M:: in your class name. E.g. if your class name is MyApp::Model::DB the "model_name" will be DB.
::Model::
::M::
MyApp::Model::DB
DB
What to reset your "cursor_class" in DBIx::Class::Storage::DBI to if a custom one doesn't work out. Defaults to DBIx::Class::Storage::DBI::Cursor.
The class name of your model before any "traits" are applied. E.g. MyApp::Model::DB.
Unresolved arrayref of traits passed in the config.
Traits you used resolved to full class names.
Instantiates the Model based on the above-documented ->config parameters. The only required parameter is schema_class. connect_info is required in the case that schema_class does not already have connection information defined for it.
connect_info
Accessor which returns the connected schema being used by the this model. There are direct shortcuts on the model class itself for schema->resultset, schema->source, and schema->class.
Accessor which returns the composed schema, which has no connection info, which was used in constructing the schema above. Useful for creating new connections based on the same schema/model. There are direct shortcuts from the model object for composed_schema->clone and composed_schema->connect
schema
Shortcut for ->composed_schema->clone
Shortcut for ->composed_schema->connect
Shortcut for ->schema->source
Shortcut for ->schema->class
Shortcut for ->schema->resultset
Provides an accessor for the connected schema's storage object. Used often for debugging and controlling transactions.
Called at BUILD> time before configuration, but after "connect_info" is set. To do something after configuuration use after BUILD =>.
after BUILD =>
Point of extension for doing things at $c->model time with context, returns the model instance, see "ACCEPT_CONTEXT" in Catalyst::Manual::Intro for more information.
$c->model
General Catalyst Stuff:
Catalyst::Manual, Catalyst::Test, Catalyst::Request, Catalyst::Response, Catalyst::Helper, Catalyst,
Stuff related to DBIC and this Model style:
DBIx::Class, DBIx::Class::Schema, DBIx::Class::Schema::Loader, Catalyst::Helper::Model::DBIC::Schema, MooseX::Object::Pluggable
Traits:
Catalyst::TraitFor::Model::DBIC::Schema::Caching, Catalyst::TraitFor::Model::DBIC::Schema::Replicated
Brandon L Black, blblack at gmail.com
blblack at gmail.com
Contributors:
Rafael Kitover, rkitover at cpan.org
rkitover at cpan.org
This program is free software, you can redistribute it and/or modify it under the same terms as Perl itself.
To install Catalyst::Model::DBIC::Schema, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Catalyst::Model::DBIC::Schema
CPAN shell
perl -MCPAN -e shell install Catalyst::Model::DBIC::Schema
For more information on module installation, please visit the detailed CPAN module installation guide.