Clarify

[dbsrgits/DBIx-Class.git] / lib / DBIx / Class / Manual / FAQ.pod

=head1 NAME

DBIx::Class::Manual::FAQ - Frequently Asked Questions (in theory)

=head1 DESCRIPTION

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 L<DBIx::Class>, then
look here. It does B<not> contain much code or examples, it just gives
explanations and pointers to the correct pieces of documentation to
read.

=head1 FAQs

How Do I:

=head2 Getting started

=over 4

=item .. create a database to use?

First, choose a database. For testing/experimenting, we reccommend
L<DBD::SQLite>, which is a self-contained small database (i.e. all you
need to do is to install L<DBD::SQLite> from CPAN, and it's usable).

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 L<http://b62.tripod.com/doc/dbbase.htm> or
L<http://209.197.234.36/db/simple.html>.

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

=item .. use DBIx::Class with L<Catalyst>?

Install L<Catalyst::Model::DBIC::Schema> from CPAN. See its
documentation, or below, for further details.

=item .. set up my DBIx::Class classes automatically from my database?

Install L<DBIx::Class::Schema::Loader> from CPAN, and read its documentation.

=item .. set up my DBIx::Class classes manually?

Look at the L<DBIx::Class::Manual::Example> and come back here if you get lost.

=item .. create my database tables from my DBIx::Class schema?

Create your classes manually, as above. Write a script that calls
L<DBIx::Class::Schema/deploy>. See there for details, or the
L<DBIx::Class::Manual::Cookbook>.

=item .. connect to my database?

Once you have created all the appropriate table/source classes, and an
overall L<Schema|DBIx::Class::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 L<DBIx::Class::Schema/connect> 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.

=item .. use DBIx::Class across multiple databases?

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
L<DBIx::Class::ResultSource/table> call. Eg:

  __PACKAGE__->table('mydb.mytablename');

And load all the Result classes for both / all databases using one
L<DBIx::Class::Schema/load_namespaces> call.

=item .. use DBIx::Class across PostgreSQL/DB2/Oracle schemas?

Add the name of the schema to the L<DBIx::Class::ResultSource/table>
as part of the name, and make sure you give the one user you are going
to connect with rights to read/write all the schemas/tables as
necessary.

=back

=head2 Relationships

=over 4

=item .. tell DBIx::Class about relationships between my tables?

There are a variety of relationship types that come pre-defined for
you to use.  These are all listed in L<DBIx::Class::Relationship>. If
you need a non-standard type, or more information, look in
L<DBIx::Class::Relationship::Base>.

=item .. define a one-to-many relationship?

This is called a C<has_many> relationship on the one side, and a
C<belongs_to> relationship on the many side. Currently these need to
be set up individually on each side. See L<DBIx::Class::Relationship>
for details.

=item .. define a relationship where this table contains another table's primary key? (foreign key)

Create a C<belongs_to> relationship for the field containing the
foreign key.  See L<DBIx::Class::Relationship/belongs_to>.

=item .. define a foreign key relationship where the key field may contain NULL?

Just create a C<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 C<join_type> to C<left>.

=item .. define a relationship where the key consists of more than one column?

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 L<DBIx::Class::Relationship::Base>.

=item .. define a relatiopnship across an intermediate table? (many-to-many)

Read the documentation on L<DBIx::Class::Relationship/many_to_many>.

=item .. stop DBIx::Class from attempting to cascade deletes on my has_many and might_have relationships?

By default, DBIx::Class cascades deletes and updates across
C<has_many> and C<might_have> relationships. You can disable this
behaviour on a per-relationship basis by supplying
C<< cascade_delete => 0 >> in the relationship attributes.

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 L<DBIx::Class::Relationship>.

=item .. use a relationship?

Use its name. An accessor is created using the name. See examples in
L<DBIx::Class::Manual::Cookbook/Using relationships>.

=back

=head2 Searching

=over 4

=item .. search for data?

Create a C<$schema> object, as mentioned above in ".. connect to my
database". Find the L<ResultSet|DBIx::Class::Manual::Glossary/ResultSet>
that you want to search in, and call C<search> on it. See
L<DBIx::Class::ResultSet/search>.

=item .. search using database functions?

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()'})

=item .. sort the results of my search?

Supply a list of columns you want to sort by to the C<order_by>
attribute. See L<DBIx::Class::ResultSet/order_by>.

=item .. sort my results based on fields I've aliased using C<as>?

You don't. You'll need to supply the same functions/expressions to
C<order_by>, as you did to C<select>.

To get "fieldname AS alias" in your SQL, you'll need to supply a
literal chunk of SQL in your C<select> attribute, such as:

 ->search({}, { select => [ \'now() AS currenttime'] })

Then you can use the alias in your C<order_by> attribute.

=item .. group the results of my search?

Supply a list of columns you want to group on, to the C<group_by>
attribute, see L<DBIx::Class::ResultSet/group_by>.

=item .. group my results based on fields I've aliased using C<as>?

You don't. You'll need to supply the same functions/expressions to
C<group_by>, as you did to C<select>.

To get "fieldname AS alias" in your SQL, you'll need to supply a
literal chunk of SQL in your C<select> attribute, such as:

 ->search({}, { select => [ \'now() AS currenttime'] })

Then you can use the alias in your C<group_by> attribute.

=item .. filter the results of my search?

The first argument to C<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 the whole value into
a scalar reference:

 ->search({'created_time' => \'>= yesterday()' })

=item .. search in several tables simultaneously?

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 C<join> attribute in
your search, for example when searching in the Books table for all the
books by the author "Fred Bloggs":

 ->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 L<DBIx::Class::Relationship>
for the join used by each relationship.

=item .. create joins with conditions other than column equality?

Currently, L<DBIx::Class> can only create join conditions using
equality, so you're probably better off creating a C<view> in your
database, and using that as your source. A C<view> is a stored SQL
query, which can be accessed similarly to a table, see your database
documentation for details.

=item .. search using greater-than or less-than and database functions?

To use functions or literal SQL with conditions other than equality
you need to supply the entire condition, for example:

 my $interval = "< now() - interval '12 hours'";
 ->search({last_attempt => \$interval})

and not:

 my $interval = "now() - interval '12 hours'";
 ->search({last_attempt => { '<' => \$interval } })

=item .. search with an SQL function on the left hand side?

To use an SQL function on the left hand side of a comparison:

 ->search({}, { where => \'YEAR(date_of_birth)=1979' });

=begin hidden

(When the bind arg ordering bug is fixed, the previous example can be
replaced with the following.)

 ->search({}, { where => \'YEAR(date_of_birth)=?', bind => [ 1979 ] });

=end hidden

Or, if you have quoting off:

 ->search({ 'YEAR(date_of_birth)' => 1979 });

=item .. find more help on constructing searches?

Behind the scenes, DBIx::Class uses L<SQL::Abstract> to help construct
its SQL searches. So if you fail to find help in the
L<DBIx::Class::Manual::Cookbook>, try looking in the SQL::Abstract
documentation.

=item .. make searches in Oracle (10gR2 and newer) case-insensitive?

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'");


=back

=head2 Fetching data

=over 4

=item .. fetch as much data as possible in as few select calls as possible?

See the prefetch examples in the L<Cookbook|DBIx::Class::Manual::Cookbook>.

=item .. fetch a whole column of data instead of a row?

Call C<get_column> on a L<DBIx::Class::ResultSet>. This returns a
L<DBIx::Class::ResultSetColumn>. See its documentation and the
L<Cookbook|DBIx::Class::Manual::Cookbook> for details.

=item .. fetch a formatted 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.

=item .. fetch a single (or topmost) row?

See L<DBIx::Class::Manual::Cookbook/Retrieve_one_and_only_one_row_from_a_resultset>.

A less readable way is to ask a regular search to return 1 row, using
L<DBIx::Class::ResultSet/slice>:

  ->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 L<DBIx::Class::ResultSet/single> mentioned
in the cookbook can do the same if you pass a C<rows> attribute to the search.

=item .. refresh a row from storage?

Use L<DBIx::Class::PK/discard_changes>.

  $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.
L<DBIx::Class::PK/discard_changes> does just that by re-fetching the row from storage
using the row's primary key.

=item .. fetch my data a "page" at a time?

Pass the C<rows> and C<page> attributes to your search, eg:

  ->search({}, { rows => 10, page => 1});

=item .. get a count of all rows even when paging?

Call C<pager> on the paged resultset, it will return a L<Data::Page>
object. Calling C<total_entries> on the pager will return the correct
total.

C<count> on the resultset will only return the total number in the page.

=back

=head2 Inserting and updating data

=over 4

=item .. insert a row with an auto incrementing primary key?

In versions of L<DBIx::Class> less than 0.07, you need to ensure your
table class loads the L<PK::Auto|DBIx::Class::PK::Auto>
component. This will attempt to fetch the value of your primary key
from the database after the insert has happened, and store it in the
created object. In versions 0.07 and above, this component is
automatically loaded.

=item .. insert a row with a primary key that uses a sequence?

You need to create a trigger in your database that updates your
primary key field from the sequence. To help PK::Auto find your
inserted key, you can tell it the name of the sequence in the
C<column_info> supplied with C<add_columns>.

 ->add_columns({ id => { sequence => 'mysequence', auto_nextval => 1 } });

=item .. insert many rows of data efficiently?

=item .. update a collection of rows at the same time?

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.

=item .. use database functions when updating rows?

=item .. update a column using data from another column?

To stop the column name from being quoted, you'll need to supply a
scalar reference:

 ->update({ somecolumn => \'othercolumn' })

But note that when using a scalar reference the column in the database
will be updated but when you read the value from the object with e.g.

 ->somecolumn()

you still get back the scalar reference to the string, B<not> the new
value in the database. To get that you must refresh the row from storage
using C<discard_changes()>. Or chain your function calls like this:

  ->update->discard_changes

to update the database and refresh the object in one step.

=item .. store JSON/YAML in a column and have it deflate/inflate automatically?

You can use L<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.

=back

=head2 Misc

=over 4

=item How do I store my own (non-db) data in my DBIx::Class objects?

You can add your own data accessors to your classes.

One method is to use the built in mk_group_accessors (via L<Class::Accessor::Grouped>)

	package MyTable;

	use parent 'DBIx::Class';

	__PACKAGE__->table('foo'); #etc
	__PACKAGE__->mk_group_accessors('simple' => qw/non_column_data/); # must use simple group

An another method is to use L<Moose> with your L<DBIx::Class> package.

	package MyTable;

	use Moose; # import Moose
	use Moose::Util::TypeConstraint; # import Moose accessor type constraints

	extends 'DBIx::Class'; # 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


=item How do I use DBIx::Class objects in my TT templates?

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.

Starting with version 0.07, you can use L<DBIx::Class::ResultSet/search_rs>
to work around this issue.

=item See the SQL statements my code is producing?

Turn on debugging! See L<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.

=item Why didn't my search run any SQL?

L<DBIx::Class> runs the actual SQL statement as late as possible, thus
if you create a resultset using C<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 row object.

=item How do I deal with tables that lack a primary key?

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 L<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);

=item How do I make my program start faster?

Look at the tips in L<DBIx::Class::Manual::Cookbook/"STARTUP SPEED">

=item How do I reduce the overhead of database queries?

You can reduce the overhead of object creation within L<DBIx::Class>
using the tips in L<DBIx::Class::Manual::Cookbook/"Skip row object creation for faster results">
and L<DBIx::Class::Manual::Cookbook/"Get raw data for blindingly fast results">

=back

=head2 Notes for CDBI users

=over 4

=item Is there a way to make an object auto-stringify itself as a
particular column or group of columns (a-la cdbi Stringfy column
group, or stringify_self method) ?

See L<DBIx::Class::Manual::Cookbook/Stringification>

=back

=head2 Troubleshooting

=over 4

=item Help, I can't connect to postgresql!

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 L<DBD::Pg> is compiled with a
default port of 5432.

You can chance the port setting in C<postgresql.conf>.

=item I've lost or forgotten my mysql password

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:

L<http://dev.mysql.com/doc/refman/5.1/en/resetting-permissions.html>.

=back