DBIx::Class::Manual::FAQ - Frequently Asked Questions (in theory)
This document is intended as an anti-map of the documentation. If you know what you want to do, but not how to do it in DBIx::Class, then look here. It does not contain much code or examples, it just gives explanations and pointers to the correct pieces of documentation to read.
How Do I:
First, choose a database. For testing/experimenting, we recommend DBD::SQLite, which is a self-contained small database (i.e. all you need to do is to install DBD::SQLite from CPAN, and it works).
Next, spend some time defining which data you need to store, and how it relates to the other data you have. For some help on normalisation, go to http://b62.tripod.com/doc/dbbase.htm.
Now, decide whether you want to have the database itself be the definitive source of information about the data layout, or your DBIx::Class schema. If it's the former, look up the documentation for your database, eg. http://sqlite.org/lang_createtable.html, on how to create tables, and start creating them. For a nice universal interface to your database, you can try DBI::Shell. If you decided on the latter choice, read the FAQ on setting up your classes manually, and the one on creating tables from your schema.
Install Catalyst::Model::DBIC::Schema from CPAN. See its documentation, or below, for further details.
Install DBIx::Class::Schema::Loader from CPAN, and read its documentation.
Look at the DBIx::Class::Manual::Example and come back here if you get lost.
Create your classes manually, as above. Write a script that calls "deploy" in DBIx::Class::Schema. See there for details, or the DBIx::Class::Manual::Cookbook.
Make sure you database supports Unicode and set the connect attributes appropriately - see "Using Unicode" in DBIx::Class::Manual::Cookbook
Once you have created all the appropriate table/source classes, and an overall Schema class, you can start using them in an application. To do this, you need to create a central Schema object, which is used to access all the data in the various tables. See "connect" in DBIx::Class::Schema for details. The actual connection does not happen until you actually request data, so don't be alarmed if the error from incorrect connection details happens a lot later.
If your database server allows you to run querys across multiple databases at once, then so can DBIx::Class. All you need to do is make sure you write the database name as part of the "table" in DBIx::Class::ResultSource call. Eg:
__PACKAGE__->table('mydb.mytablename');
And load all the Result classes for both / all databases using one "load_namespaces" in DBIx::Class::Schema call.
Add the name of the schema to the "table" in DBIx::Class::ResultSource as part of the name, and make sure you give the one user you are going to connect with has permissions to read/write all the schemas/tables as necessary.
There are a variety of relationship types that come pre-defined for you to use. These are all listed in DBIx::Class::Relationship. If you need a non-standard type, or more information, look in DBIx::Class::Relationship::Base.
This is called a has_many relationship on the one side, and a belongs_to relationship on the many side. Currently these need to be set up individually on each side. See DBIx::Class::Relationship for details.
has_many
belongs_to
Create a belongs_to relationship for the field containing the foreign key. See "belongs_to" in DBIx::Class::Relationship.
Just create a belongs_to relationship, as above. If the column is NULL then the inflation to the foreign object will not happen. This has a side effect of not always fetching all the relevant data, if you use a nullable foreign-key relationship in a JOIN, then you probably want to set the join_type to left.
join_type
left
Instead of supplying a single column name, all relationship types also allow you to supply a hashref containing the condition across which the tables are to be joined. The condition may contain as many fields as you like. See DBIx::Class::Relationship::Base.
The term 'relationship' is used loosely with many_to_many as it is not considered a relationship in the fullest sense. For more info, read the documentation on "many_to_many" in DBIx::Class::Relationship.
By default, DBIx::Class cascades deletes and updates across has_many and might_have relationships. You can disable this behaviour on a per-relationship basis by supplying cascade_delete => 0 in the relationship attributes.
might_have
cascade_delete => 0
The cascaded operations are performed after the requested delete or update, so if your database has a constraint on the relationship, it will have deleted/updated the related records or raised an exception before DBIx::Class gets to perform the cascaded operation.
See DBIx::Class::Relationship.
Use its name. An accessor is created using the name. See examples in "Using relationships" in DBIx::Class::Manual::Cookbook.
Create a $schema object, as mentioned above in ".. connect to my database?". Find the ResultSet that you want to search in, by calling $schema->resultset('MySource') and call search on it. See "search" in DBIx::Class::ResultSet.
$schema
$schema->resultset('MySource')
search
Supplying something like:
->search({'mydatefield' => 'now()'})
to search, will probably not do what you expect. It will quote the text "now()", instead of trying to call the function. To provide literal, unquoted text you need to pass in a scalar reference, like so:
->search({'mydatefield' => \'now()'})
Supply a list of columns you want to sort by to the order_by attribute. See "order_by" in DBIx::Class::ResultSet.
order_by
as
You didn't alias anything, since as has nothing to do with the produced SQL. See "select" in DBIx::Class::ResultSet for details.
Supply a list of columns you want to group on, to the group_by attribute, see "group_by" in DBIx::Class::ResultSet.
group_by
You don't. See the explanation on ordering by an alias above.
The first argument to search is a hashref of accessor names and values to filter them by, for example:
->search({'created_time' => { '>=', '2006-06-01 00:00:00' } })
Note that to use a function here you need to make it a scalar reference:
->search({'created_time' => { '>=', \'yesterday()' } })
To search in two related tables, you first need to set up appropriate relationships between their respective classes. When searching you then supply the name of the relationship to the join attribute in your search, for example when searching in the Books table for all the books by the author "Fred Bloggs":
join
->search({'authors.name' => 'Fred Bloggs'}, { join => 'authors' })
The type of join created in your SQL depends on the type of relationship between the two tables, see DBIx::Class::Relationship for the join used by each relationship.
Currently, DBIx::Class can only create join conditions using equality, so you're probably better off creating a view in your database, and using that as your source. A view is a stored SQL query, which can be accessed similarly to a table, see your database documentation for details.
view
To use an SQL function on the left hand side of a comparison you currently need to resort to literal SQL:
->search( \[ 'YEAR(date_of_birth) = ?', [ plain_value => 1979 ] ] );
Note: the plain_value string in the [ plain_value => 1979 ] part should be either the same as the name of the column (do this if the type of the return value of the function is the same as the type of the column) or in the case of a function it's currently treated as a dummy string (it is a good idea to use plain_value or something similar to convey intent). The value is currently only significant when handling special column types (BLOBs, arrays, etc.), but this may change in the future.
plain_value
[ plain_value => 1979 ]
Behind the scenes, DBIx::Class uses SQL::Abstract to help construct its SQL searches. So if you fail to find help in the DBIx::Class::Manual::Cookbook, try looking in the SQL::Abstract documentation.
To make Oracle behave like most RDBMS use on_connect_do to issue alter session statements on database connection establishment:
->on_connect_do("ALTER SESSION SET NLS_COMP = 'LINGUISTIC'"); ->on_connect_do("ALTER SESSION SET NLS_SORT = '<NLS>_CI'"); e.g. ->on_connect_do("ALTER SESSION SET NLS_SORT = 'BINARY_CI'"); ->on_connect_do("ALTER SESSION SET NLS_SORT = 'GERMAN_CI'");
See the prefetch examples in the Cookbook.
Call get_column on a DBIx::Class::ResultSet. This returns a DBIx::Class::ResultSetColumn. See its documentation and the Cookbook for details.
get_column
In your table schema class, create a "private" column accessor with:
__PACKAGE__->add_columns(my_column => { accessor => '_hidden_my_column' });
Then, in the same class, implement a subroutine called "my_column" that fetches the real value and does the formatting you want.
See the Cookbook for more details.
Use the "rows" in DBIx::Class::ResultSet and "order_by" in DBIx::Class::ResultSet attributes to order your data and pick off a single row.
See also "Retrieve one and only one row from a resultset" in DBIx::Class::Manual::Cookbook.
A less readable way is to ask a regular search to return 1 row, using "slice" in DBIx::Class::ResultSet:
->search->(undef, { order_by => "id DESC" })->slice(0)
which (if supported by the database) will use LIMIT/OFFSET to hint to the database that we really only need one row. This can result in a significant speed improvement. The method using "single" in DBIx::Class::ResultSet mentioned in the cookbook can do the same if you pass a rows attribute to the search.
rows
Use "discard_changes" in DBIx::Class::Row.
$row->discard_changes
Discarding changes and refreshing from storage are two sides fo the same coin. When you want to discard your local changes, just re-fetch the row from storage. When you want to get a new, fresh copy of the row, just re-fetch the row from storage. "discard_changes" in DBIx::Class::Row does just that by re-fetching the row from storage using the row's primary key.
Pass the rows and page attributes to your search, eg:
page
->search({}, { rows => 10, page => 1});
Call pager on the paged resultset, it will return a Data::Page object. Calling total_entries on the pager will return the correct total.
pager
total_entries
count on the resultset will only return the total number in the page.
count
This happens automatically. After creating a result object, the primary key value created by your database can be fetched by calling id (or the access of your primary key column) on the object.
id
You need to create a trigger in your database that updates your primary key field from the sequence. To help PK::Auto find the next key value, you can tell it the name of the sequence in the column_info supplied with add_columns.
column_info
add_columns
->add_columns({ id => { sequence => 'mysequence', auto_nextval => 1 } });
The populate method in DBIx::Class::ResultSet provides efficient bulk inserts.
populate
DBIx::Class::Fixtures provides an alternative way to do this.
Create a resultset using a search, to filter the rows of data you would like to update, then call update on the resultset to change all the rows at once.
update
To stop the column name from being quoted, you'll need to tell DBIC that the right hand side is an SQL identifier (it will be quoted properly if you have quoting enabled):
->update({ somecolumn => { -ident => 'othercolumn' } })
This method will not retrieve the new value and put it in your Row object. To fetch the new value, use the discard_changes method on the Row.
discard_changes
# will return the scalar reference: $row->somecolumn() # issue a select using the PK to re-fetch the row data: $row->discard_changes(); # Now returns the correct new value: $row->somecolumn()
To update and refresh at once, chain your calls:
$row->update({ 'somecolumn' => { -ident => 'othercolumn' } })->discard_changes;
You can use DBIx::Class::InflateColumn to accomplish YAML/JSON storage transparently.
If you want to use JSON, then in your table schema class, do the following:
use JSON; __PACKAGE__->add_columns(qw/ ... my_column ../) __PACKAGE__->inflate_column('my_column', { inflate => sub { jsonToObj(shift) }, deflate => sub { objToJson(shift) }, });
For YAML, in your table schema class, do the following:
use YAML; __PACKAGE__->add_columns(qw/ ... my_column ../) __PACKAGE__->inflate_column('my_column', { inflate => sub { YAML::Load(shift) }, deflate => sub { YAML::Dump(shift) }, });
This technique is an easy way to store supplemental unstructured data in a table. Be careful not to overuse this capability, however. If you find yourself depending more and more on some data within the inflated column, then it may be time to factor that data out.
You can add custom methods that do arbitrary things, even to unrelated tables. For example, to provide a $book->foo() method which searches the cd table, you'd could add this to Book.pm:
$book->foo()
sub foo { my ($self, $col_data) = @_; return $self->result_source->schema->resultset('cd')->search($col_data); }
And invoke that on any Book Result object like so:
my $rs = $book->foo({ title => 'Down to Earth' });
When two tables ARE related, DBIx::Class::Relationship::Base provides many methods to find or create data in related tables for you. But if you want to write your own methods, you can.
For example, to provide a $book->foo() method to manually implement what create_related() from DBIx::Class::Relationship::Base does, you could add this to Book.pm:
sub foo { my ($self, $relname, $col_data) = @_; return $self->related_resultset($relname)->create($col_data); }
Invoked like this:
my $author = $book->foo('author', { name => 'Fred' });
You can add your own data accessors to your Result classes.
One method is to use the built in mk_group_accessors (via Class::Accessor::Grouped)
package App::Schema::Result::MyTable; use parent 'DBIx::Class::Core'; __PACKAGE__->table('foo'); #etc __PACKAGE__->mk_group_accessors('simple' => qw/non_column_data/); # must use simple group
An another method is to use Moose with your DBIx::Class package.
package App::Schema::Result::MyTable; use Moose; # import Moose use Moose::Util::TypeConstraint; # import Moose accessor type constraints extends 'DBIx::Class::Core'; # Moose changes the way we define our parent (base) package has 'non_column_data' => ( is => 'rw', isa => 'Str' ); # define a simple attribute __PACKAGE__->table('foo'); # etc
With either of these methods the resulting use of the accesssor would be
my $row; # assume that somewhere in here $row will get assigned to a MyTable row $row->non_column_data('some string'); # would set the non_column_data accessor # some other stuff happens here $row->update(); # would not inline the non_column_data accessor into the update
Like normal objects, mostly. However you need to watch out for TT calling methods in list context. When calling relationship accessors you will not get resultsets, but a list of all the related objects.
Use the "search_rs" in DBIx::Class::ResultSet method, or the relationship accessor methods ending with "_rs" to work around this issue.
See also "has_many" in DBIx::Class::Relationship.
Set the shell environment variable DBIC_TRACE to a true value.
DBIC_TRACE
For more info see DBIx::Class::Storage for details of how to turn on debugging in the environment, pass your own filehandle to save debug to, or create your own callback.
DBIx::Class runs the actual SQL statement as late as possible, thus if you create a resultset using search in scalar context, no query is executed. You can create further resultset refinements by calling search again or relationship accessors. The SQL query is only run when you ask the resultset for an actual result object.
If your table lacks a primary key, DBIx::Class can't work out which row it should operate on, for example to delete or update. However, a UNIQUE constraint on one or more columns allows DBIx::Class to uniquely identify the row, so you can tell DBIx::Class::ResultSource these columns act as a primary key, even if they don't from the database's point of view:
$resultset->set_primary_key(@column);
Look at the tips in "STARTUP SPEED" in DBIx::Class::Manual::Cookbook
You can reduce the overhead of object creation within DBIx::Class using the tips in "Skip result object creation for faster results" in DBIx::Class::Manual::Cookbook and "Get raw data for blindingly fast results" in DBIx::Class::Manual::Cookbook
If you need access to the original accessor, then you must "wrap around" the original method. You can do that either with Moose::Manual::MethodModifiers or Class::Method::Modifiers. The code example works for both modules:
package Your::Schema::Group; use Class::Method::Modifiers; # ... declare columns ... __PACKAGE__->has_many('group_servers', 'Your::Schema::GroupServer', 'group_id'); __PACKAGE__->many_to_many('servers', 'group_servers', 'server'); # if the server group is a "super group", then return all servers # otherwise return only servers that belongs to the given group around 'servers' => sub { my $orig = shift; my $self = shift; return $self->$orig(@_) unless $self->is_super_group; return $self->result_source->schema->resultset('Server')->all; };
If you just want to override the original method, and don't care about the data from the original accessor, then you have two options. Either use Method::Signatures::Simple that does most of the work for you, or do it the "dirty way".
Method::Signatures::Simple way:
package Your::Schema::Group; use Method::Signatures::Simple; # ... declare columns ... __PACKAGE__->has_many('group_servers', 'Your::Schema::GroupServer', 'group_id'); __PACKAGE__->many_to_many('servers', 'group_servers', 'server'); # The method keyword automatically injects the annoying my $self = shift; for you. method servers { return $self->result_source->schema->resultset('Server')->search({ ... }); }
The dirty way:
package Your::Schema::Group; use Sub::Name; # ... declare columns ... __PACKAGE__->has_many('group_servers', 'Your::Schema::GroupServer', 'group_id'); __PACKAGE__->many_to_many('servers', 'group_servers', 'server'); *servers = subname servers => sub { my $self = shift; return $self->result_source->schema->resultset('Server')->search({ ... }); };
See "Stringification" in DBIx::Class::Manual::Cookbook
If you get an error such as:
DBI connect('dbname=dbic','user',...) failed: could not connect to server: No such file or directory Is the server running locally and accepting connections on Unix domain socket "/var/run/postgresql/.s.PGSQL.5432"?
Likely you have/had two copies of postgresql installed simultaneously, the second one will use a default port of 5433, while DBD::Pg is compiled with a default port of 5432.
You can change the port setting in postgresql.conf.
postgresql.conf
Stop mysqld and restart it with the --skip-grant-tables option.
Issue the following statements in the mysql client.
UPDATE mysql.user SET Password=PASSWORD('MyNewPass') WHERE User='root'; FLUSH PRIVILEGES;
Restart mysql.
Taken from:
http://dev.mysql.com/doc/refman/5.1/en/resetting-permissions.html.
To install DBIx::Class, copy and paste the appropriate command in to your terminal.
cpanm
cpanm DBIx::Class
CPAN shell
perl -MCPAN -e shell install DBIx::Class
For more information on module installation, please visit the detailed CPAN module installation guide.