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