3 DBIx::Class::Manual::Cookbook - Miscellaneous recipes
11 When you expect a large number of results, you can ask L<DBIx::Class> for a
12 paged resultset, which will fetch only a small number of records at a time:
14 my $rs = $schema->resultset('Artist')->search(
17 page => 1, # page to return (defaults to 1)
18 rows => 10, # number of results per page
22 return $rs->all(); # all records for page 1
24 The C<page> attribute does not have to be specified in your search:
26 my $rs = $schema->resultset('Artist')->search(
33 return $rs->page(1); # DBIx::Class::ResultSet containing first 10 records
35 In either of the above cases, you can return a L<Data::Page> object for the
36 resultset (suitable for use in e.g. a template) using the C<pager> method:
40 =head3 Complex WHERE clauses
42 Sometimes you need to formulate a query using specific operators:
44 my @albums = $schema->resultset('Album')->search({
45 artist => { 'like', '%Lamb%' },
46 title => { 'like', '%Fear of Fours%' },
49 This results in something like the following C<WHERE> clause:
51 WHERE artist LIKE '%Lamb%' AND title LIKE '%Fear of Fours%'
53 Other queries might require slightly more complex logic:
55 my @albums = $schema->resultset('Album')->search({
58 artist => { 'like', '%Smashing Pumpkins%' },
59 title => 'Siamese Dream',
61 artist => 'Starchildren',
65 This results in the following C<WHERE> clause:
67 WHERE ( artist LIKE '%Smashing Pumpkins%' AND title = 'Siamese Dream' )
68 OR artist = 'Starchildren'
70 For more information on generating complex queries, see
71 L<SQL::Abstract/WHERE CLAUSES>.
73 =head3 Using specific columns
75 When you only want selected columns from a table, you can use C<cols> to
76 specify which ones you need:
78 my $rs = $schema->resultset('Artist')->search(
81 columns => [qw/ name /]
86 # SELECT artist.name FROM artist
88 =head3 Using database functions or stored procedures
90 The combination of C<select> and C<as> can be used to return the result of a
91 database function or stored procedure as a column value. You use C<select> to
92 specify the source for your column value (e.g. a column name, function, or
93 stored procedure name). You then use C<as> to set the column name you will use
94 to access the returned value:
96 my $rs = $schema->resultset('Artist')->search(
99 select => [ 'name', { LENGTH => 'name' } ],
100 as => [qw/ name name_length /],
105 # SELECT name name, LENGTH( name ) name_length
108 If your alias exists as a column in your base class (i.e. it was added with
109 C<add_columns>), you just access it as normal. Our C<Artist> class has a C<name>
110 column, so we just use the C<name> accessor:
112 my $artist = $rs->first();
113 my $name = $artist->name();
115 If on the other hand the alias does not correspond to an existing column, you
116 can get the value using the C<get_column> accessor:
118 my $name_length = $artist->get_column('name_length');
120 If you don't like using C<get_column>, you can always create an accessor for
121 any of your aliases using either of these:
123 # Define accessor manually:
124 sub name_length { shift->get_column('name_length'); }
126 # Or use DBIx::Class::AccessorGroup:
127 __PACKAGE__->mk_group_accessors('column' => 'name_length');
129 =head3 SELECT DISTINCT with multiple columns
131 my $rs = $schema->resultset('Foo')->search(
135 { distinct => [ $source->columns ] }
137 as => [ $source->columns ]
141 my $count = $rs->next->get_column('count');
143 =head3 SELECT COUNT(DISTINCT colname)
145 my $rs = $schema->resultset('Foo')->search(
149 { count => { distinct => 'colname' } }
155 =head3 Grouping results
157 L<DBIx::Class> supports C<GROUP BY> as follows:
159 my $rs = $schema->resultset('Artist')->search(
163 select => [ 'name', { count => 'cds.cdid' } ],
164 as => [qw/ name cd_count /],
165 group_by => [qw/ name /]
170 # SELECT name, COUNT( cds.cdid ) FROM artist me
171 # LEFT JOIN cd cds ON ( cds.artist = me.artistid )
174 =head3 Predefined searches
176 You can write your own DBIx::Class::ResultSet class by inheriting from it
177 and define often used searches as methods:
179 package My::DBIC::ResultSet::CD;
182 use base 'DBIx::Class::ResultSet';
184 sub search_cds_ordered {
187 return $self->search(
189 { order_by => 'name DESC' },
195 To use your resultset, first tell DBIx::Class to create an instance of it
196 for you, in your My::DBIC::Schema::CD class:
198 __PACKAGE__->resultset_class('My::DBIC::ResultSet::CD');
200 Then call your new method in your code:
202 my $ordered_cds = $schema->resultset('CD')->search_cds_ordered();
205 =head3 Predefined searches without writing a ResultSet class
207 Alternatively you can automatically generate a DBIx::Class::ResultSet
208 class by using the ResultSetManager component and tagging your method
211 __PACKAGE__->load_components(qw/ ResultSetManager Core /);
213 sub search_cds_ordered : ResultSet {
215 return $self->search(
217 { order_by => 'name DESC' },
221 Then call your method in the same way from your code:
223 my $ordered_cds = $schema->resultset('CD')->search_cds_ordered();
225 =head2 Using joins and prefetch
227 You can use the C<join> attribute to allow searching on, or sorting your
228 results by, one or more columns in a related table. To return all CDs matching
229 a particular artist name:
231 my $rs = $schema->resultset('CD')->search(
233 'artist.name' => 'Bob Marley'
236 join => [qw/artist/], # join the artist table
241 # SELECT cd.* FROM cd
242 # JOIN artist ON cd.artist = artist.id
243 # WHERE artist.name = 'Bob Marley'
245 If required, you can now sort on any column in the related tables by including
246 it in your C<order_by> attribute:
248 my $rs = $schema->resultset('CD')->search(
250 'artist.name' => 'Bob Marley'
253 join => [qw/ artist /],
254 order_by => [qw/ artist.name /]
259 # SELECT cd.* FROM cd
260 # JOIN artist ON cd.artist = artist.id
261 # WHERE artist.name = 'Bob Marley'
262 # ORDER BY artist.name
264 Note that the C<join> attribute should only be used when you need to search or
265 sort using columns in a related table. Joining related tables when you only
266 need columns from the main table will make performance worse!
268 Now let's say you want to display a list of CDs, each with the name of the
269 artist. The following will work fine:
271 while (my $cd = $rs->next) {
272 print "CD: " . $cd->title . ", Artist: " . $cd->artist->name;
275 There is a problem however. We have searched both the C<cd> and C<artist> tables
276 in our main query, but we have only returned data from the C<cd> table. To get
277 the artist name for any of the CD objects returned, L<DBIx::Class> will go back
280 SELECT artist.* FROM artist WHERE artist.id = ?
282 A statement like the one above will run for each and every CD returned by our
283 main query. Five CDs, five extra queries. A hundred CDs, one hundred extra
286 Thankfully, L<DBIx::Class> has a C<prefetch> attribute to solve this problem.
287 This allows you to fetch results from related tables in advance:
289 my $rs = $schema->resultset('CD')->search(
291 'artist.name' => 'Bob Marley'
294 join => [qw/ artist /],
295 order_by => [qw/ artist.name /],
296 prefetch => [qw/ artist /] # return artist data too!
300 # Equivalent SQL (note SELECT from both "cd" and "artist"):
301 # SELECT cd.*, artist.* FROM cd
302 # JOIN artist ON cd.artist = artist.id
303 # WHERE artist.name = 'Bob Marley'
304 # ORDER BY artist.name
306 The code to print the CD list remains the same:
308 while (my $cd = $rs->next) {
309 print "CD: " . $cd->title . ", Artist: " . $cd->artist->name;
312 L<DBIx::Class> has now prefetched all matching data from the C<artist> table,
313 so no additional SQL statements are executed. You now have a much more
316 Note that as of L<DBIx::Class> 0.05999_01, C<prefetch> I<can> be used with
317 C<has_many> relationships.
319 Also note that C<prefetch> should only be used when you know you will
320 definitely use data from a related table. Pre-fetching related tables when you
321 only need columns from the main table will make performance worse!
323 =head3 Multi-step joins
325 Sometimes you want to join more than one relationship deep. In this example,
326 we want to find all C<Artist> objects who have C<CD>s whose C<LinerNotes>
327 contain a specific string:
329 # Relationships defined elsewhere:
330 # Artist->has_many('cds' => 'CD', 'artist');
331 # CD->has_one('liner_notes' => 'LinerNotes', 'cd');
333 my $rs = $schema->resultset('Artist')->search(
335 'liner_notes.notes' => { 'like', '%some text%' },
339 'cds' => 'liner_notes'
345 # SELECT artist.* FROM artist
346 # JOIN ( cd ON artist.id = cd.artist )
347 # JOIN ( liner_notes ON cd.id = liner_notes.cd )
348 # WHERE liner_notes.notes LIKE '%some text%'
350 Joins can be nested to an arbitrary level. So if we decide later that we
351 want to reduce the number of Artists returned based on who wrote the liner
354 # Relationship defined elsewhere:
355 # LinerNotes->belongs_to('author' => 'Person');
357 my $rs = $schema->resultset('Artist')->search(
359 'liner_notes.notes' => { 'like', '%some text%' },
360 'author.name' => 'A. Writer'
365 'liner_notes' => 'author'
372 # SELECT artist.* FROM artist
373 # JOIN ( cd ON artist.id = cd.artist )
374 # JOIN ( liner_notes ON cd.id = liner_notes.cd )
375 # JOIN ( author ON author.id = liner_notes.author )
376 # WHERE liner_notes.notes LIKE '%some text%'
377 # AND author.name = 'A. Writer'
379 =head2 Multi-step prefetch
381 From 0.04999_05 onwards, C<prefetch> can be nested more than one relationship
382 deep using the same syntax as a multi-step join:
384 my $rs = $schema->resultset('Tag')->search(
394 # SELECT tag.*, cd.*, artist.* FROM tag
395 # JOIN cd ON tag.cd = cd.cdid
396 # JOIN artist ON cd.artist = artist.artistid
398 Now accessing our C<cd> and C<artist> relationships does not need additional
401 my $tag = $rs->first;
402 print $tag->cd->artist->name;
404 =head2 Using relationships
406 =head3 Create a new row in a related table
408 my $book->create_related('author', { name => 'Fred'});
410 =head3 Search in a related table
412 Only searches for books named 'Titanic' by the author in $author.
414 my $author->search_related('books', { name => 'Titanic' });
416 =head3 Delete data in a related table
418 Deletes only the book named Titanic by the author in $author.
420 my $author->delete_related('books', { name => 'Titanic' });
422 =head3 Ordering a relationship result set
424 If you always want a relation to be ordered, you can specify this when you
425 create the relationship.
427 To order C<< $book->pages >> by descending page_number.
429 Book->has_many('pages' => 'Page', 'book', { order_by => \'page_number DESC'} );
435 As of version 0.04001, there is improved transaction support in
436 L<DBIx::Class::Storage::DBI> and L<DBIx::Class::Schema>. Here is an
437 example of the recommended way to use it:
439 my $genus = $schema->resultset('Genus')->find(12);
447 $genus->add_to_species({ name => 'troglodyte' });
450 $schema->txn_do($coderef2); # Can have a nested transaction
451 return $genus->species;
456 $rs = $schema->txn_do($coderef1);
459 if ($@) { # Transaction failed
460 die "the sky is falling!" #
461 if ($@ =~ /Rollback failed/); # Rollback failed
463 deal_with_failed_transaction();
466 Nested transactions will work as expected. That is, only the outermost
467 transaction will actually issue a commit to the $dbh, and a rollback
468 at any level of any transaction will cause the entire nested
469 transaction to fail. Support for savepoints and for true nested
470 transactions (for databases that support them) will hopefully be added
473 =head2 Many-to-many relationships
475 This is straightforward using L<DBIx::Class::Relationship::ManyToMany>:
478 # ... set up connection ...
482 __PACKAGE__->table('user');
483 __PACKAGE__->add_columns(qw/id name/);
484 __PACKAGE__->set_primary_key('id');
485 __PACKAGE__->has_many('user_address' => 'My::UserAddress', 'user');
486 __PACKAGE__->many_to_many('addresses' => 'user_address', 'address');
488 package My::UserAddress;
490 __PACKAGE__->table('user_address');
491 __PACKAGE__->add_columns(qw/user address/);
492 __PACKAGE__->set_primary_key(qw/user address/);
493 __PACKAGE__->belongs_to('user' => 'My::User');
494 __PACKAGE__->belongs_to('address' => 'My::Address');
498 __PACKAGE__->table('address');
499 __PACKAGE__->add_columns(qw/id street town area_code country/);
500 __PACKAGE__->set_primary_key('id');
501 __PACKAGE__->has_many('user_address' => 'My::UserAddress', 'address');
502 __PACKAGE__->many_to_many('users' => 'user_address', 'user');
504 $rs = $user->addresses(); # get all addresses for a user
505 $rs = $address->users(); # get all users for an address
507 =head2 Setting default values for a row
509 It's as simple as overriding the C<new> method. Note the use of
513 my ( $class, $attrs ) = @_;
515 $attrs->{foo} = 'bar' unless defined $attrs->{foo};
517 $class->next::method($attrs);
520 For more information about C<next::method>, look in the L<Class::C3>
521 documentation. See also L<DBIx::Class::Manual::Component> for more
522 ways to write your own base classes to do this.
524 People looking for ways to do "triggers" with DBIx::Class are probably
525 just looking for this.
527 =head2 Stringification
529 Employ the standard stringification technique by using the C<overload>
530 module. Replace C<foo> with the column/method of your choice.
532 use overload '""' => 'foo', fallback => 1;
534 =head2 Disconnecting cleanly
536 If you find yourself quitting an app with Control-C a lot during
537 development, you might like to put the following signal handler in
538 your main database class to make sure it disconnects cleanly:
541 __PACKAGE__->storage->disconnect;
544 =head2 Schema import/export
546 This functionality requires you to have L<SQL::Translator> (also known as
547 "SQL Fairy") installed.
549 To create a DBIx::Class schema from an existing database:
552 --to DBIx::Class::File
553 --prefix "MySchema" > MySchema.pm
555 To create a MySQL database from an existing L<DBIx::Class> schema, convert the
556 schema to MySQL's dialect of SQL:
558 sqlt --from DBIx::Class --to MySQL --DBIx::Class "MySchema.pm" > Schema1.sql
560 And import using the mysql client:
562 mysql -h "host" -D "database" -u "user" -p < Schema1.sql
564 =head2 Easy migration from class-based to schema-based setup
566 You want to start using the schema-based approach to L<DBIx::Class>
567 (see L<SchemaIntro.pod>), but have an established class-based setup with lots
568 of existing classes that you don't want to move by hand. Try this nifty script
574 my $schema = MyDB->schema_instance;
576 my $translator = SQL::Translator->new(
577 debug => $debug || 0,
578 trace => $trace || 0,
579 no_comments => $no_comments || 0,
580 show_warnings => $show_warnings || 0,
581 add_drop_table => $add_drop_table || 0,
582 validate => $validate || 0,
584 'DBIx::Schema' => $schema,
587 'prefix' => 'My::Schema',
591 $translator->parser('SQL::Translator::Parser::DBIx::Class');
592 $translator->producer('SQL::Translator::Producer::DBIx::Class::File');
594 my $output = $translator->translate(@args) or die
595 "Error: " . $translator->error;
599 You could use L<Module::Find> to search for all subclasses in the MyDB::*
600 namespace, which is currently left as an exercise for the reader.
602 =head2 Schema versioning
604 The following example shows simplistically how you might use DBIx::Class to
605 deploy versioned schemas to your customers. The basic process is as follows:
611 Create a DBIx::Class schema
623 Modify schema to change functionality
627 Deploy update to customers
631 =head3 Create a DBIx::Class schema
633 This can either be done manually, or generated from an existing database as
634 described under C<Schema import/export>.
636 =head3 Save the schema
638 Use C<sqlt> to transform your schema into an SQL script suitable for your
639 customer's database. E.g. for MySQL:
641 sqlt --from DBIx::Class
643 --DBIx::Class "MySchema.pm" > Schema1.mysql.sql
645 If you need to target databases from multiple vendors, just generate an SQL
646 script suitable for each. To support PostgreSQL too:
648 sqlt --from DBIx::Class
650 --DBIx::Class "MySchema.pm" > Schema1.pgsql.sql
652 =head3 Deploy to customers
654 There are several ways you could deploy your schema. These are probably
655 beyond the scope of this recipe, but might include:
661 Require customer to apply manually using their RDBMS.
665 Package along with your app, making database dump/schema update/tests
666 all part of your install.
670 =head3 Modify the schema to change functionality
672 As your application evolves, it may be necessary to modify your schema to
673 change functionality. Once the changes are made to your schema in DBIx::Class,
674 export the modified schema as before, taking care not to overwrite the original:
676 sqlt --from DBIx::Class
678 --DBIx::Class "Anything.pm" > Schema2.mysql.sql
680 Next, use sqlt-diff to create an SQL script that will update the customer's
683 sqlt-diff --to MySQL Schema1=MySQL Schema2=MySQL > SchemaUpdate.mysql.sql
685 =head3 Deploy update to customers
687 The schema update can be deployed to customers using the same method as before.
689 =head2 Setting limit dialect for SQL::Abstract::Limit
691 In some cases, SQL::Abstract::Limit cannot determine the dialect of the remote
692 SQL-server by looking at the database-handle. This is a common problem when
693 using the DBD::JDBC, since the DBD-driver only know that in has a Java-driver
694 available, not which JDBC-driver the Java component has loaded.
695 This specifically sets the limit_dialect to Microsoft SQL-server (Se more names
696 in SQL::Abstract::Limit -documentation.
698 __PACKAGE__->storage->sql_maker->limit_dialect('mssql');
700 The JDBC-bridge is one way of getting access to a MSSQL-server from a platform
701 that Microsoft doesn't deliver native client libraries for. (e.g. Linux)
703 =head2 Setting quotes for the generated SQL.
705 If the database contains columnames with spaces and/or reserved words, the
706 SQL-query needs to be quoted. This is done using:
708 __PACKAGE__->storage->sql_maker->quote_char([ qw/[ ]/] );
709 __PACKAGE__->storage->sql_maker->name_sep('.');
711 The first sets the quotesymbols. If the quote i "symmetric" as " or '
713 __PACKAGE__->storage->sql_maker->quote_char('"');
715 is enough. If the left quote differs form the right quote, the first
716 notation should be used. name_sep needs to be set to allow the
717 SQL generator to put the quotes the correct place.
719 =head2 Overloading methods
721 L<DBIx::Class> uses the L<Class::C3> package, which provides for redispatch of
722 method calls. You have to use calls to C<next::method> to overload methods.
723 More information on using L<Class::C3> with L<DBIx::Class> can be found in
724 L<DBIx::Class::Manual::Component>.
726 =head3 Changing one field whenever another changes
728 For example, say that you have three columns, C<id>, C<number>, and
729 C<squared>. You would like to make changes to C<number> and have
730 C<squared> be automagically set to the value of C<number> squared.
731 You can accomplish this by overriding C<store_column>:
734 my ( $self, $name, $value ) = @_;
735 if ($name eq 'number') {
736 $self->squared($value * $value);
738 $self->next::method($name, $value);
741 Note that the hard work is done by the call to C<next::method>, which
742 redispatches your call to store_column to the superclass(es).
744 =head3 Automatically creating related objects
746 You might have a class C<Artist> which has many C<CD>s. Further, you
747 want to create a C<CD> object every time you insert an C<Artist> object.
748 You can accomplish this by overriding C<insert> on your objects:
751 my ( $self, @args ) = @_;
752 $self->next::method(@args);
753 $self->cds->new({})->fill_from_artist($self)->insert;
757 where C<fill_from_artist> is a method you specify in C<CD> which sets
758 values in C<CD> based on the data in the C<Artist> object you pass in.
760 =head2 Debugging DBIx::Class objects with Data::Dumper
762 L<Data::Dumper> can be a very useful tool for debugging, but sometimes it can
763 be hard to find the pertinent data in all the data it can generate.
764 Specifically, if one naively tries to use it like so,
768 my $cd = $schema->resultset('CD')->find(1);
771 several pages worth of data from the CD object's schema and result source will
772 be dumped to the screen. Since usually one is only interested in a few column
773 values of the object, this is not very helpful.
775 Luckily, it is possible to modify the data before L<Data::Dumper> outputs
776 it. Simply define a hook that L<Data::Dumper> will call on the object before
777 dumping it. For example,
784 result_source => undef,
792 local $Data::Dumper::Freezer = '_dumper_hook';
794 my $cd = $schema->resultset('CD')->find(1);
796 # dumps $cd without its ResultSource
798 If the structure of your schema is such that there is a common base class for
799 all your table classes, simply put a method similar to C<_dumper_hook> in the
800 base class and set C<$Data::Dumper::Freezer> to its name and L<Data::Dumper>
801 will automagically clean up your data before printing it. See
802 L<Data::Dumper/EXAMPLES> for more information.
804 =head2 Retrieving a row object's Schema
806 It is possible to get a Schema object from a row object like so,
808 my $schema = $cd->result_source->schema;
809 my $artist_rs = $schema->resultset('Artist');
812 This can be useful when you don't want to pass around a Schema object to every
817 When you enable L<DBIx::Class::Storage::DBI>'s debugging it prints the SQL
818 executed as well as notifications of query completion and transaction
819 begin/commit. If you'd like to profile the SQL you can subclass the
820 L<DBIx::Class::Storage::Statistics> class and write your own profiling
823 package My::Profiler;
826 use base 'DBIx::Class::Storage::Statistics';
828 use Time::HiRes qw(time);
837 print "Executing $sql: ".join(', ', @params)."\n";
846 printf("Execution took %0.4f seconds.\n", time() - $start);
852 You can then install that class as the debugging object:
854 __PACKAGE__->storage()->debugobj(new My::Profiler());
855 __PACKAGE__->storage()->debug(1);
857 A more complicated example might involve storing each execution of SQL in an
865 my $elapsed = time() - $start;
866 push(@{ $calls{$sql} }, {
872 You could then create average, high and low execution times for an SQL
873 statement and dig down to see if certain parameters cause aberrant behavior.
875 =head2 Getting the value of the primary key for the last database insert
877 AKA getting last_insert_id
879 If you are using PK::Auto, this is straightforward:
881 my $foo = $rs->create(\%blah);
883 my $id = $foo->id; # foo->my_primary_key_field will also work.
885 If you are not using autoincrementing primary keys, this will probably
886 not work, but then you already know the value of the last primary key anyway.
888 =head2 Dynamic Sub-classing DBIx::Class proxy classes
889 (AKA multi-class object inflation from one table)
891 L<DBIx::Class> classes are proxy classes, therefore some different techniques
892 need to be employed for more than basic subclassing. In this example we have
893 a single user table that carries a boolean bit for admin. We would like
894 like to give the admin users objects(L<DBIx::Class::Row>) the same methods as
895 a regular user but also special admin only methods. It doesn't make sense to
896 create two seperate proxy-class files for this. We would be copying all the
897 user methods into the Admin class. There is a cleaner way to accomplish this.
899 Overriding the C<inflate_results()> method within the User proxy-class gives
900 us the effect we want. This method is called by L<DBIx::Class::ResultSet> when
901 inflating a result from storage. So we grab the object being returned, inspect
902 the values we are looking for, bless it if it's an admin object, and then
903 return it. Running the test file below will confirm this works.
909 use base qw/DBIx::Class::Schema/;
911 __PACKAGE__->load_classes(qw/User/);
914 B<Proxy-Class definitions>
916 package DB::Schema::User;
920 use base qw/DBIx::Class/;
922 ### Defined what our admin class is for ensure_class_loaded
923 my $admin_class = __PACKAGE__ . '::Admin';
925 __PACKAGE__->load_components(qw/PK::Auto Core/);
927 __PACKAGE__->table('users');
929 __PACKAGE__->add_columns(qw/user_id email password
930 firstname lastname active
933 __PACKAGE__->set_primary_key('user_id');
937 my $ret = $self->next::method(@_);
938 if( $ret->admin ) {### If this is an admin rebless for extra functions
939 $self->ensure_class_loaded( $admin_class );
940 bless $ret, $admin_class;
946 print "I am a regular user.\n";
951 package DB::Schema::User::Admin;
955 use base qw/DB::Schema::User/;
959 print "I am an admin.\n";
965 print "I am doing admin stuff\n";
975 my $user_data = { email => 'someguy@place.com',
979 my $admin_data = { email => 'someadmin@adminplace.com',
983 my $schema = DB::Schema->connection('dbi:Pg:dbname=test');
985 $schema->resultset('User')->create( $user_data );
986 $schema->resultset('User')->create( $admin_data );
988 ### Now we search for them
989 my $user = $schema->resultset('User')->single( $user_data );
990 my $admin = $schema->resultset('User')->single( $admin_data );
992 print ref $user, "\n";
993 print ref $admin, "\n";
995 print $user->password , "\n"; # pass1
996 print $admin->password , "\n";# pass2; inherited from User
997 print $user->hello , "\n";# I am a regular user.
998 print $admin->hello, "\n";# I am an admin.
1000 ### The statement below will NOT print
1001 print "I can do admin stuff\n" if $user->can('do_admin_stuff');
1002 ### The statement below will print
1003 print "I can do admin stuff\n" if $admin->can('do_admin_stuff');