L<Catalyst::Plugin::ConfigLoader|Catalyst::Plugin::ConfigLoader> and
L<Config::Any|Config::Any>). If you are using a versions of
Catalyst::Devel prior to 1.06, you can convert to the newer format by
-simply creating the C<myapp.yml> file manually and deleting
+simply creating the C<myapp.conf> file manually and deleting
C<myapp.yml>. The default contents of C<myapp.conf> should only
consist of one line: C<name MyApp>.
=back
-For out application, we want to add one new plugin into the mix. To
+For our application, we want to add one new plugin into the mix. To
do this, edit C<lib/MyApp.pm> (this file is generally referred to as
your I<application class>) and delete the line with:
StackTrace
/);
+B<Note:> Recent versions of C<Catalyst::Devel> have used a variety of
+techniques to load these plugins/flags. If you are following along in
+Ubuntu 8.10, you should have C<Catalyst::Devel> v1.07 and see the
+default code shown above. If you are using v1.08, you should see the
+following by default:
+
+ use Catalyst qw/-Debug
+ ConfigLoader
+ Static::Simple/;
+ ...
+ __PACKAGE__->setup();
+
+Don't let these variations confuse you -- they all accomplish the same
+result.
+
This tells Catalyst to start using one new plugin,
L<Catalyst::Plugin::StackTrace|Catalyst::Plugin::StackTrace>, to add a
stack trace to the standard Catalyst "debug screen" (the screen
=back
-Both are similar, but C<TT> merely creates the C<lib/MyApp/View/TT.pm>
+Both helpers are similar. C<TT> creates the C<lib/MyApp/View/TT.pm>
file and leaves the creation of any hierarchical template organization
entirely up to you. (It also creates a C<t/view_TT.t> file for testing;
-test cases will be discussed in Part 8.) On the other hand, the
-C<TTSite> helper creates a modular and hierarchical view layout with
+test cases will be discussed in Part 8.) C<TTSite>, on the other hand,
+creates a modular and hierarchical view layout with
separate Template Toolkit (TT) files for common header and footer
information, configuration values, a CSS stylesheet, and more.
-While TTSite is useful to bootstrap a project, most in the Catalyst
-community recommend that it's easier to learn both Catalyst and
-Tempalte Toolkit if you use the more basic TT approach. Consequently,
-this tutorial will use "plain old TT."
+While C<TTSite> was useful to bootstrap a project, its use is now
+deprecated and to be considered historical. For most Catalyst
+applications it adds redundant functionality and structure; many in the
+Catalyst community recommend that it's easier to learn both Catalyst and
+Template Toolkit if you use the more basic C<TT> approach.
+Consequently, this tutorial will use "plain old TT."
Enter the following command to enable the C<TT> style of view
rendering for this tutorial:
TEMPLATE_EXTENSION => '.tt2',
# Set the location for TT files
INCLUDE_PATH => [
- MyApp->path_to( 'root/src' ),
+ MyApp->path_to( 'root', 'src' ),
],
);
B<NOTE:> Make sure to add a comma after '.tt2' outside the single
quote.
-This changes the default extenstion for Template Toolkit from '.tt' to
+This changes the default extension for Template Toolkit from '.tt' to
'.tt2' and changes the base directory for your template files from
-C<root> to C<root/src>.
+C<root> to C<root/src>. These changes from the default are done mostly
+to facilitate the application we're developing in this tutorial; as with
+most things Perl, there's more than one way to do it...
=head2 Create a TT Template Page
".q" to exit from SQLite from the SQLite interactive mode and return to
your OS command prompt.
+For using other databases, such as PostgreSQL or MySQL, see
+L<Appendix 2|Catalyst::Manual::Tutorial::Appendices>.
=head1 DATABASE ACCESS WITH C<DBIx::Class>
-Catalyst can be used with virtually any form of persistent datastore
-available via Perl. For example,
-L<Catalyst::Model::DBI|Catalyst::Model::DBI> can be used to
-easily access databases through the traditional Perl C<DBI> interface.
-However, most Catalyst applications use some form of ORM technology to
-automatically create and save model objects as they are used. Although
-Tony Bowden's L<Class::DBI|Class::DBI> has been a popular choice
-in the past, Matt Trout's L<DBIx::Class|DBIx::Class> (abbreviated
-as "DBIC") has rapidly emerged as the Perl-based ORM technology of choice.
-Most new Catalyst applications rely on DBIC, as will this tutorial.
+Catalyst can be used with virtually any form of persistent datastore
+available via Perl. For example,
+L<Catalyst::Model::DBI|Catalyst::Model::DBI> can be used to easily
+access databases through the traditional Perl C<DBI> interface. However,
+most Catalyst applications use some form of ORM technology to
+automatically create and save model objects as they are used. Although
+L<Class::DBI|Class::DBI> has been a popular choice in the past, Matt
+Trout's L<DBIx::Class|DBIx::Class> (abbreviated as "DBIC") has rapidly
+emerged as the Perl-based ORM technology of choice. Most new Catalyst
+applications rely on DBIC, as will this tutorial.
=head2 Create a Dynamic DBIC Model
the helper, it use
L<DBIx::Class::Schema::Loader|DBIx::Class::Schema::Loader> to
dynamically load the schema information from the database every time
-the application starts. And finally, C<dbi:SQLite:myapp.db> is the
-standard DBI connect string for use with SQLite.
+the application starts. DBIC uses the schema to load other classes
+that represent the tables in your database (DBIC refers to these
+"table objects" as "result sources," see
+L<DBIx::Class::ResultSource|DBIx::Class::ResultSource>). And finally,
+C<dbi:SQLite:myapp.db> is the standard DBI connect string for use with
+SQLite.
B<NOTE:> Although the C<create=dynamic> option to the DBIC helper
makes for a nifty demonstration, is only really suitable for very
=head1 ENABLE THE MODEL IN THE CONTROLLER
-Open C<lib/MyApp/Controller/Books.pm> and uncomment the model code we
-left disabled earlier (uncomment the line containing
+Open C<lib/MyApp/Controller/Books.pm> and un-comment the model code we
+left disabled earlier (un-comment the line containing
C<[$c-E<gt>model('DB::Books')-E<gt>all]> and delete the next 2 lines):
=head2 list
$c->stash->{template} = 'books/list.tt2';
}
-B<TIP>: You may see the C<$c-E<gt>model('DB::Book')> uncommented above
-written as C<$c-E<gt>model('DB')-E<gt>resultset('Book')>. The two
-are equivalent.
+B<TIP>: You may see the C<$c-E<gt>model('DB::Book')> un-commented
+above written as C<$c-E<gt>model('DB')-E<gt>resultset('Book')>. The
+two are equivalent. Either way, C<$c-E<gt>model> returns a
+L<DBIx::Class::ResultSet|DBIx::Class::ResultSet> which handles queries
+against the database and iterating over the set of results that are
+returned.
+
+We are using the C<-E<gt>all> to fetch all of the books. DBIC
+supports a wide variety of more advanced operations to easily do
+things like filtering and sorting the results. For example, the
+following could be used to sort the results by descending title:
+
+ $c->model('DB::Books')->search({}, {order_by => 'title DESC'});
+
+Some other examples are provided in
+L<DBIx::Class::Manual::Cookbook/Complex WHERE clauses>, with
+additional information found at L<DBIx::Class::ResultSet/search>,
+L<DBIx::Class::Manual::FAQ/Searching>,
+L<DBIx::Class::Manual::Intro|DBIx::Class::Manual::Intro>
+and L<Catalyst::Model::DBIC::Schema|Catalyst::Model::DBIC::Schema>.
=head2 Test Run The Application
L<http://localhost:3000/books/list>. You should get a list of the five
books loaded by the C<myapp01.sql> script above without any formatting.
The rating for each book should appear on each row, but the "Author(s)"
-column will sitll be blank (we will fill that in later).
+column will still be blank (we will fill that in later).
Also notice in the output of the C<script/myapp_server.pl> that DBIC
used the following SQL to retrieve the data:
TEMPLATE_EXTENSION => '.tt2',
# Set the location for TT files
INCLUDE_PATH => [
- MyApp->path_to( 'root/src' ),
+ MyApp->path_to( 'root', 'src' ),
],
# Set to 1 for detailed timer stats in your HTML as comments
TIMER => 0,
</div><!-- end bodyblock -->
<div id="footer">Copyright (c) your name goes here</div>
- </div><!-- end outter -->
+ </div><!-- end outer -->
</body>
</html>
class (L<DBIx::Class::Schema::Loader|DBIx::Class::Schema::Loader> is
only being used by the helper to load the schema once and then create
the static files for us) and C<Schema.pm> only contains a call to the
-C<load_classes> method. You will also find that C<lib/MyApp/Schema>
+C<load_classes> method. You will also find that C<lib/MyApp>
contains a C<Schema> subdirectory, with one file inside this directory
for each of the tables in our simple database (C<Authors.pm>,
C<BookAuthors.pm>, and C<Books.pm>). These three files were created
three dynamically created model class (one for each of the
table-specific schema classes we created).
-Then hit the URL L<http://localhost:3000/books/list> and be sure that
-the book list is displayed.
+Then hit the URL L<http://localhost:3000/books/list> and be sure that
+the book list is displayed via the relationships established above. You
+can leave the development server running for the next step if you wish.
-You can leave the development server running for the next step if you
-wish.
+B<Note:> You will not see the authors yet because the view does not yet
+use the new relations. Read on to the next section where we update the
+template to do that.
=head1 UPDATING THE VIEW
debug output (one for each book as the authors are being retrieved by
DBIC).
-Also note that we are using "| html", a type of TT filter, to escape
-characters such as E<lt> and E<gt> to < and > and avoid various
-types of dangerous hacks against your application. In a real
-application, you would probably want to put "| html" at the end of
-every field where a user has control over the information that can
-appear in that field (and can therefore inject markup or code if you
-don't "neutralize" those fields). In addition to "| html", Template
-Toolkit has a variety of other useful filters that can found in the
-documentation for L<Template::Filters|Template::Filters>.
+ SELECT me.id, me.title, me.rating FROM books me:
+ SELECT me.book_id, me.author_id FROM book_authors me WHERE ( me.book_id = ? ): '1'
+ SELECT me.book_id, me.author_id FROM book_authors me WHERE ( me.book_id = ? ): '2'
+ SELECT me.book_id, me.author_id FROM book_authors me WHERE ( me.book_id = ? ): '3'
+ SELECT me.book_id, me.author_id FROM book_authors me WHERE ( me.book_id = ? ): '4'
+ SELECT me.book_id, me.author_id FROM book_authors me WHERE ( me.book_id = ? ): '5'
+
+Also note in C<root/src/books/list.tt2> that we are using "| html", a
+type of TT filter, to escape characters such as E<lt> and E<gt> to <
+and > and avoid various types of dangerous hacks against your
+application. In a real application, you would probably want to put
+"| html" at the end of every field where a user has control over the
+information that can appear in that field (and can therefore inject
+markup or code if you don't "neutralize" those fields). In addition to
+"| html", Template Toolkit has a variety of other useful filters that
+can found in the documentation for
+L<Template::Filters|Template::Filters>.
=head1 RUNNING THE APPLICATION FROM THE COMMAND LINE
Please report any errors, issues or suggestions to the author. The
most recent version of the Catalyst Tutorial can be found at
-L<http://dev.catalyst.perl.org/repos/Catalyst/trunk/Catalyst-Manual/lib/Catalyst/Manual/Tutorial/>.
+L<http://dev.catalyst.perl.org/repos/Catalyst/Catalyst-Manual/5.70/trunk/lib/Catalyst/Manual/Tutorial/>.
Copyright 2006-2008, Kennedy Clark, under Creative Commons License
(L<http://creativecommons.org/licenses/by-sa/3.0/us/>).
projects / catagits/Catalyst-Manual.git / blobdiff