Proper fix for RETURNING with default insert
[dbsrgits/DBIx-Class.git] / lib / DBIx / Class / Manual / FAQ.pod
1 =head1 NAME
2
3 DBIx::Class::Manual::FAQ - Frequently Asked Questions (in theory)
4
5 =head1 DESCRIPTION
6
7 This document is intended as an anti-map of the documentation. If you
8 know what you want to do, but not how to do it in L<DBIx::Class>, then
9 look here. It does B<not> contain much code or examples, it just gives
10 explanations and pointers to the correct pieces of documentation to
11 read.
12
13 =head1 FAQs
14
15 How Do I:
16
17 =head2 Getting started
18
19 =over 4
20
21 =item .. create a database to use?
22
23 First, choose a database. For testing/experimenting, we reccommend
24 L<DBD::SQLite>, which is a self-contained small database (i.e. all you
25 need to do is to install L<DBD::SQLite> from CPAN, and it's usable).
26
27 Next, spend some time defining which data you need to store, and how
28 it relates to the other data you have. For some help on normalisation,
29 go to L<http://b62.tripod.com/doc/dbbase.htm>.
30
31 Now, decide whether you want to have the database itself be the
32 definitive source of information about the data layout, or your
33 DBIx::Class schema. If it's the former, look up the documentation for
34 your database, eg. L<http://sqlite.org/lang_createtable.html>, on how
35 to create tables, and start creating them. For a nice universal
36 interface to your database, you can try L<DBI::Shell>. If you decided
37 on the latter choice, read the FAQ on setting up your classes
38 manually, and the one on creating tables from your schema.
39
40 =item .. use DBIx::Class with L<Catalyst>?
41
42 Install L<Catalyst::Model::DBIC::Schema> from CPAN. See its
43 documentation, or below, for further details.
44
45 =item .. set up my DBIx::Class classes automatically from my database?
46
47 Install L<DBIx::Class::Schema::Loader> from CPAN, and read its documentation.
48
49 =item .. set up my DBIx::Class classes manually?
50
51 Look at the L<DBIx::Class::Manual::Example> and come back here if you get lost.
52
53 =item .. create my database tables from my DBIx::Class schema?
54
55 Create your classes manually, as above. Write a script that calls
56 L<DBIx::Class::Schema/deploy>. See there for details, or the
57 L<DBIx::Class::Manual::Cookbook>.
58
59 =item .. connect to my database?
60
61 Once you have created all the appropriate table/source classes, and an
62 overall L<Schema|DBIx::Class::Schema> class, you can start using
63 them in an application. To do this, you need to create a central
64 Schema object, which is used to access all the data in the various
65 tables. See L<DBIx::Class::Schema/connect> for details. The actual
66 connection does not happen until you actually request data, so don't
67 be alarmed if the error from incorrect connection details happens a
68 lot later.
69
70 =item .. use DBIx::Class across multiple databases?
71
72 If your database server allows you to run querys across multiple
73 databases at once, then so can DBIx::Class. All you need to do is make
74 sure you write the database name as part of the
75 L<DBIx::Class::ResultSource/table> call. Eg:
76
77   __PACKAGE__->table('mydb.mytablename');
78
79 And load all the Result classes for both / all databases using one
80 L<DBIx::Class::Schema/load_namespaces> call.
81
82 =item .. use DBIx::Class across PostgreSQL/DB2/Oracle schemas?
83
84 Add the name of the schema to the L<DBIx::Class::ResultSource/table>
85 as part of the name, and make sure you give the one user you are going
86 to connect with rights to read/write all the schemas/tables as
87 necessary.
88
89 =back
90
91 =head2 Relationships
92
93 =over 4
94
95 =item .. tell DBIx::Class about relationships between my tables?
96
97 There are a variety of relationship types that come pre-defined for
98 you to use.  These are all listed in L<DBIx::Class::Relationship>. If
99 you need a non-standard type, or more information, look in
100 L<DBIx::Class::Relationship::Base>.
101
102 =item .. define a one-to-many relationship?
103
104 This is called a C<has_many> relationship on the one side, and a
105 C<belongs_to> relationship on the many side. Currently these need to
106 be set up individually on each side. See L<DBIx::Class::Relationship>
107 for details.
108
109 =item .. define a relationship where this table contains another table's primary key? (foreign key)
110
111 Create a C<belongs_to> relationship for the field containing the
112 foreign key.  See L<DBIx::Class::Relationship/belongs_to>.
113
114 =item .. define a foreign key relationship where the key field may contain NULL?
115
116 Just create a C<belongs_to> relationship, as above. If the column is
117 NULL then the inflation to the foreign object will not happen. This
118 has a side effect of not always fetching all the relevant data, if you
119 use a nullable foreign-key relationship in a JOIN, then you probably
120 want to set the C<join_type> to C<left>.
121
122 =item .. define a relationship where the key consists of more than one column?
123
124 Instead of supplying a single column name, all relationship types also
125 allow you to supply a hashref containing the condition across which
126 the tables are to be joined. The condition may contain as many fields
127 as you like. See L<DBIx::Class::Relationship::Base>.
128
129 =item .. define a relationship across an intermediate table? (many-to-many)
130
131 Read the documentation on L<DBIx::Class::Relationship/many_to_many>.
132
133 =item .. stop DBIx::Class from attempting to cascade deletes on my has_many and might_have relationships?
134
135 By default, DBIx::Class cascades deletes and updates across
136 C<has_many> and C<might_have> relationships. You can disable this
137 behaviour on a per-relationship basis by supplying
138 C<< cascade_delete => 0 >> in the relationship attributes.
139
140 The cascaded operations are performed after the requested delete or
141 update, so if your database has a constraint on the relationship, it
142 will have deleted/updated the related records or raised an exception
143 before DBIx::Class gets to perform the cascaded operation.
144
145 See L<DBIx::Class::Relationship>.
146
147 =item .. use a relationship?
148
149 Use its name. An accessor is created using the name. See examples in
150 L<DBIx::Class::Manual::Cookbook/Using relationships>.
151
152 =back
153
154 =head2 Searching
155
156 =over 4
157
158 =item .. search for data?
159
160 Create a C<$schema> object, as mentioned above in ".. connect to my
161 database". Find the L<ResultSet|DBIx::Class::Manual::Glossary/ResultSet>
162 that you want to search in, and call C<search> on it. See
163 L<DBIx::Class::ResultSet/search>.
164
165 =item .. search using database functions?
166
167 Supplying something like:
168
169  ->search({'mydatefield' => 'now()'})
170
171 to search, will probably not do what you expect. It will quote the
172 text "now()", instead of trying to call the function. To provide
173 literal, unquoted text you need to pass in a scalar reference, like
174 so:
175
176  ->search({'mydatefield' => \'now()'})
177
178 =item .. sort the results of my search?
179
180 Supply a list of columns you want to sort by to the C<order_by>
181 attribute. See L<DBIx::Class::ResultSet/order_by>.
182
183 =item .. sort my results based on fields I've aliased using C<as>?
184
185 You didn't alias anything, since L<as|DBIx::Class::ResultSet/as>
186 B<has nothing to do> with the produced SQL. See
187 L<DBIx::Class::ResultSet/select> for details.
188
189 =item .. group the results of my search?
190
191 Supply a list of columns you want to group on, to the C<group_by>
192 attribute, see L<DBIx::Class::ResultSet/group_by>.
193
194 =item .. group my results based on fields I've aliased using C<as>?
195
196 You don't. See the explanation on ordering by an alias above.
197
198 =item .. filter the results of my search?
199
200 The first argument to C<search> is a hashref of accessor names and
201 values to filter them by, for example:
202
203  ->search({'created_time' => { '>=', '2006-06-01 00:00:00' } })
204
205 Note that to use a function here you need to make it a scalar
206 reference:
207
208  ->search({'created_time' => { '>=', \'yesterday()' } })
209
210 =item .. search in several tables simultaneously?
211
212 To search in two related tables, you first need to set up appropriate
213 relationships between their respective classes. When searching you
214 then supply the name of the relationship to the C<join> attribute in
215 your search, for example when searching in the Books table for all the
216 books by the author "Fred Bloggs":
217
218  ->search({'authors.name' => 'Fred Bloggs'}, { join => 'authors' })
219
220 The type of join created in your SQL depends on the type of
221 relationship between the two tables, see L<DBIx::Class::Relationship>
222 for the join used by each relationship.
223
224 =item .. create joins with conditions other than column equality?
225
226 Currently, L<DBIx::Class> can only create join conditions using
227 equality, so you're probably better off creating a C<view> in your
228 database, and using that as your source. A C<view> is a stored SQL
229 query, which can be accessed similarly to a table, see your database
230 documentation for details.
231
232 =item .. search with an SQL function on the left hand side?
233
234 To use an SQL function on the left hand side of a comparison:
235
236  ->search({ -nest => \[ 'YEAR(date_of_birth) = ?', [ plain_value => 1979 ] ] });
237
238 Note: the C<plain_value> string in the C<< [ plain_value => 1979 ] >> part
239 should be either the same as the name of the column (do this if the type of the
240 return value of the function is the same as the type of the column) or
241 otherwise it's essentially a dummy string currently (use C<plain_value> as a
242 habit). It is used by L<DBIx::Class> to handle special column types.
243
244 Or, if you have quoting off:
245
246  ->search({ 'YEAR(date_of_birth)' => 1979 });
247
248 =item .. find more help on constructing searches?
249
250 Behind the scenes, DBIx::Class uses L<SQL::Abstract> to help construct
251 its SQL searches. So if you fail to find help in the
252 L<DBIx::Class::Manual::Cookbook>, try looking in the SQL::Abstract
253 documentation.
254
255 =item .. make searches in Oracle (10gR2 and newer) case-insensitive?
256
257 To make Oracle behave like most RDBMS use on_connect_do to issue
258 alter session statements on database connection establishment:
259
260  ->on_connect_do("ALTER SESSION SET NLS_COMP = 'LINGUISTIC'");
261  ->on_connect_do("ALTER SESSION SET NLS_SORT = '<NLS>_CI'");
262  e.g.
263  ->on_connect_do("ALTER SESSION SET NLS_SORT = 'BINARY_CI'");
264  ->on_connect_do("ALTER SESSION SET NLS_SORT = 'GERMAN_CI'");
265
266
267 =back
268
269 =head2 Fetching data
270
271 =over 4
272
273 =item .. fetch as much data as possible in as few select calls as possible?
274
275 See the prefetch examples in the L<Cookbook|DBIx::Class::Manual::Cookbook>.
276
277 =item .. fetch a whole column of data instead of a row?
278
279 Call C<get_column> on a L<DBIx::Class::ResultSet>. This returns a
280 L<DBIx::Class::ResultSetColumn>. See its documentation and the
281 L<Cookbook|DBIx::Class::Manual::Cookbook> for details.
282
283 =item .. fetch a formatted column?
284
285 In your table schema class, create a "private" column accessor with:
286
287   __PACKAGE__->add_columns(my_column => { accessor => '_hidden_my_column' });
288
289 Then, in the same class, implement a subroutine called "my_column" that
290 fetches the real value and does the formatting you want.
291
292 See the Cookbook for more details.
293
294 =item .. fetch a single (or topmost) row?
295
296 See L<DBIx::Class::Manual::Cookbook/Retrieve_one_and_only_one_row_from_a_resultset>.
297
298 A less readable way is to ask a regular search to return 1 row, using
299 L<DBIx::Class::ResultSet/slice>:
300
301   ->search->(undef, { order_by => "id DESC" })->slice(0)
302
303 which (if supported by the database) will use LIMIT/OFFSET to hint to the
304 database that we really only need one row. This can result in a significant
305 speed improvement. The method using L<DBIx::Class::ResultSet/single> mentioned
306 in the cookbook can do the same if you pass a C<rows> attribute to the search.
307
308 =item .. refresh a row from storage?
309
310 Use L<DBIx::Class::PK/discard_changes>.
311
312   $row->discard_changes
313
314 Discarding changes and refreshing from storage are two sides fo the same coin.  When you
315 want to discard your local changes, just re-fetch the row from storage.  When you want
316 to get a new, fresh copy of the row, just re-fetch the row from storage.
317 L<DBIx::Class::PK/discard_changes> does just that by re-fetching the row from storage
318 using the row's primary key.
319
320 =item .. fetch my data a "page" at a time?
321
322 Pass the C<rows> and C<page> attributes to your search, eg:
323
324   ->search({}, { rows => 10, page => 1});
325
326 =item .. get a count of all rows even when paging?
327
328 Call C<pager> on the paged resultset, it will return a L<Data::Page>
329 object. Calling C<total_entries> on the pager will return the correct
330 total.
331
332 C<count> on the resultset will only return the total number in the page.
333
334 =back
335
336 =head2 Inserting and updating data
337
338 =over 4
339
340 =item .. insert a row with an auto incrementing primary key?
341
342 In versions of L<DBIx::Class> less than 0.07, you need to ensure your
343 table class loads the L<PK::Auto|DBIx::Class::PK::Auto>
344 component. This will attempt to fetch the value of your primary key
345 from the database after the insert has happened, and store it in the
346 created object. In versions 0.07 and above, this component is
347 automatically loaded.
348
349 =item .. insert a row with a primary key that uses a sequence?
350
351 You need to create a trigger in your database that updates your
352 primary key field from the sequence. To help PK::Auto find your
353 inserted key, you can tell it the name of the sequence in the
354 C<column_info> supplied with C<add_columns>.
355
356  ->add_columns({ id => { sequence => 'mysequence', auto_nextval => 1 } });
357
358 =item .. insert many rows of data efficiently?
359
360 The C<populate> method in L<DBIx::Class::ResultSet> provides
361 efficient bulk inserts.
362
363 =item .. update a collection of rows at the same time?
364
365 Create a resultset using a search, to filter the rows of data you
366 would like to update, then call update on the resultset to change all
367 the rows at once.
368
369 =item .. use database functions when updating rows?
370
371 =item .. update a column using data from another column?
372
373 To stop the column name from being quoted, you'll need to supply a
374 scalar reference:
375
376  ->update({ somecolumn => \'othercolumn' })
377
378 But note that when using a scalar reference the column in the database
379 will be updated but when you read the value from the object with e.g.
380
381  ->somecolumn()
382
383 you still get back the scalar reference to the string, B<not> the new
384 value in the database. To get that you must refresh the row from storage
385 using C<discard_changes()>. Or chain your function calls like this:
386
387   ->update->discard_changes
388
389 to update the database and refresh the object in one step.
390
391 =item .. store JSON/YAML in a column and have it deflate/inflate automatically?
392
393 You can use L<DBIx::Class::InflateColumn> to accomplish YAML/JSON storage transparently.
394
395 If you want to use JSON, then in your table schema class, do the following:
396
397  use JSON;
398
399  __PACKAGE__->add_columns(qw/ ... my_column ../)
400  __PACKAGE__->inflate_column('my_column', {
401      inflate => sub { jsonToObj(shift) },
402      deflate => sub { objToJson(shift) },
403  });
404
405 For YAML, in your table schema class, do the following:
406
407  use YAML;
408
409  __PACKAGE__->add_columns(qw/ ... my_column ../)
410  __PACKAGE__->inflate_column('my_column', {
411      inflate => sub { YAML::Load(shift) },
412      deflate => sub { YAML::Dump(shift) },
413  });
414
415 This technique is an easy way to store supplemental unstructured data in a table. Be
416 careful not to overuse this capability, however. If you find yourself depending more
417 and more on some data within the inflated column, then it may be time to factor that
418 data out.
419
420 =back
421
422 =head2 Custom methods in Result classes
423
424 You can add custom methods that do arbitrary things, even to unrelated tables. 
425 For example, to provide a C<< $book->foo() >> method which searches the 
426 cd table, you'd could add this to Book.pm:
427
428   sub foo {
429     my ($self, $col_data) = @_;
430     return $self->result_source->schema->resultset('cd')->search($col_data);
431   }
432
433 And invoke that on any Book Result object like so:
434
435   my $rs = $book->foo({ title => 'Down to Earth' });
436
437 When two tables ARE related, L<DBIx::Class::Relationship::Base> provides many
438 methods to find or create data in related tables for you. But if you want to
439 write your own methods, you can.
440
441 For example, to provide a C<< $book->foo() >> method to manually implement
442 what create_related() from L<DBIx::Class::Relationship::Base> does, you could 
443 add this to Book.pm:
444
445   sub foo {
446     my ($self, $relname, $col_data) = @_;
447     return $self->related_resultset($relname)->create($col_data);
448   }
449
450 Invoked like this:
451
452   my $author = $book->foo('author', { name => 'Fred' });
453
454 =head2 Misc
455
456 =over 4
457
458 =item How do I store my own (non-db) data in my DBIx::Class objects?
459
460 You can add your own data accessors to your classes.
461
462 One method is to use the built in mk_group_accessors (via L<Class::Accessor::Grouped>)
463
464         package MyTable;
465
466         use parent 'DBIx::Class';
467
468         __PACKAGE__->table('foo'); #etc
469         __PACKAGE__->mk_group_accessors('simple' => qw/non_column_data/); # must use simple group
470
471 An another method is to use L<Moose> with your L<DBIx::Class> package.
472
473         package MyTable;
474
475         use Moose; # import Moose
476         use Moose::Util::TypeConstraint; # import Moose accessor type constraints
477
478         extends 'DBIx::Class'; # Moose changes the way we define our parent (base) package
479
480         has 'non_column_data' => ( is => 'rw', isa => 'Str' ); # define a simple attribute
481
482         __PACKAGE__->table('foo'); # etc
483
484 With either of these methods the resulting use of the accesssor would be
485
486         my $row;
487
488         # assume that somewhere in here $row will get assigned to a MyTable row
489
490         $row->non_column_data('some string'); # would set the non_column_data accessor
491
492         # some other stuff happens here
493
494         $row->update(); # would not inline the non_column_data accessor into the update
495
496
497 =item How do I use DBIx::Class objects in my TT templates?
498
499 Like normal objects, mostly. However you need to watch out for TT
500 calling methods in list context. When calling relationship accessors
501 you will not get resultsets, but a list of all the related objects.
502
503 Starting with version 0.07, you can use L<DBIx::Class::ResultSet/search_rs>
504 to work around this issue.
505
506 =item See the SQL statements my code is producing?
507
508 Turn on debugging! See L<DBIx::Class::Storage> for details of how
509 to turn on debugging in the environment, pass your own filehandle to
510 save debug to, or create your own callback.
511
512 =item Why didn't my search run any SQL?
513
514 L<DBIx::Class> runs the actual SQL statement as late as possible, thus
515 if you create a resultset using C<search> in scalar context, no query
516 is executed. You can create further resultset refinements by calling
517 search again or relationship accessors. The SQL query is only run when
518 you ask the resultset for an actual row object.
519
520 =item How do I deal with tables that lack a primary key?
521
522 If your table lacks a primary key, DBIx::Class can't work out which row
523 it should operate on, for example to delete or update.  However, a
524 UNIQUE constraint on one or more columns allows DBIx::Class to uniquely
525 identify the row, so you can tell L<DBIx::Class::ResultSource> these
526 columns act as a primary key, even if they don't from the database's
527 point of view:
528
529  $resultset->set_primary_key(@column);
530
531 =item How do I make my program start faster?
532
533 Look at the tips in L<DBIx::Class::Manual::Cookbook/"STARTUP SPEED">
534
535 =item How do I reduce the overhead of database queries?
536
537 You can reduce the overhead of object creation within L<DBIx::Class>
538 using the tips in L<DBIx::Class::Manual::Cookbook/"Skip row object creation for faster results">
539 and L<DBIx::Class::Manual::Cookbook/"Get raw data for blindingly fast results">
540
541 =item How do I override a run time method (e.g. a relationship accessor)?
542
543 If you need access to the original accessor, then you must "wrap around" the original method.
544 You can do that either with L<Moose::Manual::MethodModifiers> or L<Class::Method::Modifiers>.
545 The code example works for both modules:
546
547     package Your::Schema::Group;
548     use Class::Method::Modifiers;
549     
550     # ... declare columns ...
551     
552     __PACKAGE__->has_many('group_servers', 'Your::Schema::GroupServer', 'group_id');
553     __PACKAGE__->many_to_many('servers', 'group_servers', 'server');
554     
555     # if the server group is a "super group", then return all servers
556     # otherwise return only servers that belongs to the given group
557     around 'servers' => sub {
558         my $orig = shift;
559         my $self = shift;
560
561         return $self->$orig(@_) unless $self->is_super_group;
562         return $self->result_source->schema->resultset('Server')->all;
563     };
564
565 If you just want to override the original method, and don't care about the data
566 from the original accessor, then you have two options. Either use
567 L<Method::Signatures::Simple> that does most of the work for you, or do
568 it the "dirty way".
569
570 L<Method::Signatures::Simple> way:
571
572     package Your::Schema::Group;
573     use Method::Signatures::Simple;
574     
575     # ... declare columns ...
576     
577     __PACKAGE__->has_many('group_servers', 'Your::Schema::GroupServer', 'group_id');
578     __PACKAGE__->many_to_many('servers', 'group_servers', 'server');
579     
580     # The method keyword automatically injects the annoying my $self = shift; for you.
581     method servers {
582         return $self->result_source->schema->resultset('Server')->search({ ... });
583     }
584
585 The dirty way:
586
587     package Your::Schema::Group;
588     use Sub::Name;
589     
590     # ... declare columns ...
591     
592     __PACKAGE__->has_many('group_servers', 'Your::Schema::GroupServer', 'group_id');
593     __PACKAGE__->many_to_many('servers', 'group_servers', 'server');
594     
595     *servers = subname servers => sub {
596         my $self = shift;
597         return $self->result_source->schema->resultset('Server')->search({ ... });
598     };
599     
600 =back
601
602 =head2 Notes for CDBI users
603
604 =over 4
605
606 =item Is there a way to make an object auto-stringify itself as a
607 particular column or group of columns (a-la cdbi Stringfy column
608 group, or stringify_self method) ?
609
610 See L<DBIx::Class::Manual::Cookbook/Stringification>
611
612 =back
613
614 =head2 Troubleshooting
615
616 =over 4
617
618 =item Help, I can't connect to postgresql!
619
620 If you get an error such as:
621
622   DBI connect('dbname=dbic','user',...) failed: could not connect to server:
623   No such file or directory Is the server running locally and accepting
624   connections on Unix domain socket "/var/run/postgresql/.s.PGSQL.5432"?
625
626 Likely you have/had two copies of postgresql installed simultaneously, the
627 second one will use a default port of 5433, while L<DBD::Pg> is compiled with a
628 default port of 5432.
629
630 You can change the port setting in C<postgresql.conf>.
631
632 =item I've lost or forgotten my mysql password
633
634 Stop mysqld and restart it with the --skip-grant-tables option.
635
636 Issue the following statements in the mysql client.
637
638   UPDATE mysql.user SET Password=PASSWORD('MyNewPass') WHERE User='root';
639   FLUSH PRIVILEGES;
640
641 Restart mysql.
642
643 Taken from:
644
645 L<http://dev.mysql.com/doc/refman/5.1/en/resetting-permissions.html>.
646
647 =back