Catalyst::Model::DBIC::Schema man page on Pidora

Man page or keyword search:  
man Server   31170 pages
apropos Keyword Search (all sections)
Output format
Pidora logo
[printable version]

Catalyst::Model::DBIC:UsereContributed Perl DoCatalyst::Model::DBIC::Schema(3)

NAME
       Catalyst::Model::DBIC::Schema - DBIx::Class::Schema Model Class

SYNOPSIS
       First, prepare your database schema using DBIx::Class, see
       Catalyst::Helper::Model::DBIC::Schema for how to generate a
       DBIx::Class::Schema from your database using the Helper script, and
       DBIx::Class::Schema::Loader::Base.

       A typical usage of the helper script would be:

	   script/myapp_create.pl model FilmDB DBIC::Schema MyApp::Schema::FilmDB \
	       create=static dbi:mysql:filmdb dbusername dbpass \
	       quote_names=1

       If you are unfamiliar with DBIx::Class, see DBIx::Class::Manual::Intro
       first.

       These examples assume that you already have a schema called
       "MyApp::Schema::FilmDB", which defines some Result classes for tables
       in "MyApp::Schema::FilmDB::Result::Actor" and
       "MyApp::Schema::FilmDB::Result::Film". Either created by the helper
       script (as shown above) or manually.

       The helper also creates a Model in "lib/MyApp/Model/FilmDB.pm", if you
       already have a schema you can create just the Model using:

	   script/myapp_create.pl model FilmDB DBIC::Schema MyApp::Schema::FilmDB
	       dbi:mysql:filmdb dbusername dbpass

       The connect_info is optional and will be hardcoded into the Model if
       provided.  It's better to configure it in your Catalyst config file,
       which will also override any hardcoded config, see "connect_info" for
       examples.

       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 $db_model = $c->model('FilmDB');	     # a Catalyst::Model
	 my $dbic     = $c->model('FilmDB')->schema; # the actual DBIC object

       There is also a shortcut, which returns a DBIx::Class::ResultSet
       directly, instead of a Catalyst::Model:

	 my $rs = $c->model('FilmDB::Actor');

       See DBIx::Class::ResultSet to find out more about which methods can be
       called on ResultSets.

       You can also define your own ResultSet methods to encapsulate the
       database/business logic of your applications. These go into, for
       example, "lib/MyApp/Schema/FilmDB/ResultSet/Actor.pm". The class must
       inherit from DBIx::Class::ResultSet and is automatically loaded.

       Then call your methods like any other DBIx::Class::ResultSet method:

	   $c->model('FilmDB::Actor')->SAG_members

   Some examples:
	 # 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(...);

       To set up authentication, see "Setting up DBIC authentication" below.

DESCRIPTION
       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.

       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. This is just a matter of making a
       "lib/MyApp/Schema/ResultSet/Actor.pm" class that inherits from
       DBIx::Class::ResultSet, if you are using "load_namespaces" in
       DBIx::Class::Schema, the default for helper script generated schemas.

       See "Predefined searches" in DBIx::Class::Manual::Cookbook for
       information on definining your own DBIx::Class::ResultSet classes for
       use with "load_classes" in DBIx::Class::Schema, the old default.

CONFIG PARAMETERS
   schema_class
       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.

   connect_info
       This is a hashref or 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.

       This is not required if "schema_class" already has connection
       information defined inside itself (which isn't highly recommended, but
       can be done.)

       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_names 1
		   on_connect_do   some SQL statement
		   on_connect_do   another SQL statement
	       </connect_info>
	       user_defined_schema_accessor foo
	   </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
	     traits: Caching
	     connect_info:
		 dsn: dbi:Oracle:mydb
		 user: mtfnpy
		 password: mypass
		 LongReadLen: 1000000
		 LongTruncOk: 1
		 on_connect_call: 'datetime_setup'
		 quote_names: 1

       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',
	     ],
	   }
	 ]

   traits
       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.:

	   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.

       When writing a Trait, interesting points to modify are "BUILD", "setup"
       and "ACCEPT_CONTEXT".

       Traits that come with the distribution:

       Catalyst::TraitFor::Model::DBIC::Schema::Caching
       Catalyst::TraitFor::Model::DBIC::Schema::Replicated
       Catalyst::TraitFor::Model::DBIC::Schema::SchemaProxy

   storage_type
       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.

ATTRIBUTES
       The keys you pass in the model configuration are available as
       attributes.

       Other attributes available:

   connect_info
       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".

   model_name
       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".

   _default_cursor_class
       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.

ATTRIBUTES FROM MooseX::Traits::Pluggable
   _original_class_name
       The class name of your model before any "traits" are applied. E.g.
       "MyApp::Model::DB".

   _traits
       Unresolved arrayref of traits passed in the config.

   _resolved_traits
       Traits you used resolved to full class names.

CONFIGURING YOUR SCHEMA AND RESULTSETS
       See the documentation for
       Catalyst::TraitFor::Model::DBIC::Schema::SchemaProxy for instructions
       on how to pass config values from your Catalyst config to your
       DBIx::Class::Schema and/or DBIx::Class::ResultSet classes.

METHODS
   new
       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.

   schema
       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.

   composed_schema
       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

   clone
       Shortcut for ->composed_schema->clone

   connect
       Shortcut for ->composed_schema->connect

   source
       Shortcut for ->schema->source

   class
       Shortcut for ->schema->class

   resultset
       Shortcut for ->schema->resultset

   txn_do
       Shortcut for ->schema->txn_do

   txn_scope_guard
       Shortcut for ->schema->txn_scope_guard

   storage
       Provides an accessor for the connected schema's storage object.

       See DBIx::Class::Storage and DBIx::Class::Storage::DBI.

   setup
       Called at "BUILD" time before configuration, but after "connect_info"
       is set. To do something after configuuration use "after BUILD =>".

       Receives a hashref of args passed to "BUILD".

   ACCEPT_CONTEXT
       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.

ENVIRONMENT
       CMDS_NO_SOURCES
	   Set this variable if you will be using schemas with no sources
	   (Result classes) to disable the warning. The warning is there
	   because having no Result classes is usually a mistake.

Setting up DBIC authentication
       You can set this up with Catalyst::Authentication::Store::DBIx::Class
       in MyApp.pm:

	 package MyApp;

	 use Catalyst qw/... Authentication .../;

	 ...

	 __PACKAGE__->config('Plugin::Authentication' =>
		       {
			   default_realm => 'members',
			   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',
			       }
			   }
		       });

METHOD PROXYING
       The automatic proxying to the underlying DBIx::Class::Schema has been
       removed as of version 0.34, to enable this feature add "SchemaProxy" to
       "traits".

       See Catalyst::TraitFor::Model::DBIC::Schema::SchemaProxy.

SEE ALSO
       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, CatalystX::Component::Traits,
       MooseX::Traits::Pluggable

       Traits:

       Catalyst::TraitFor::Model::DBIC::Schema::Caching,
       Catalyst::TraitFor::Model::DBIC::Schema::Replicated,
       Catalyst::TraitFor::Model::DBIC::Schema::SchemaProxy,
       Catalyst::TraitFor::Model::DBIC::Schema::QueryLog

AUTHOR
       Brandon L Black "blblack at gmail.com"

CONTRIBUTORS
       caelum: Rafael Kitover "rkitover at cpan.org"

       dandv: Dan Dascalescu "dandv at cpan.org"

       bluefeet: Aran Deltac "bluefeet@cpan.org"

       t0m: Tomas Doran "bobtfish@bobtfish.net"

       osfameron: "osfameron@cpan.org"

       ozum: Ozum Eldogan "ozum@ozum.net"

       Pavel I. Shaydo "zwon@trinitum.org"

COPYRIGHT
       Copyright (c) 2006 - 2010 the Catalyst::Model::DBIC::Schema "AUTHOR"
       and "CONTRIBUTORS" as listed above.

LICENSE
       This program is free software. You can redistribute it and/or modify it
       under the same terms as Perl itself.

perl v5.14.1			  2011-05-20  Catalyst::Model::DBIC::Schema(3)
[top]

List of man pages available for Pidora

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net