Japanized Perl Resources Project[凍結]

[perldocjp-cvs 159] CVS update: docs/modules/DBIx-Class-0.07006/lib/DBIx/Class/Manual

Kato Atsushi ktats****@users*****
2007年 6月 20日 (水) 08:17:51 JST

• 前の記事 [perldocjp-cvs 158] CVS update: docs/modules/DBIx-Class-0.07006/lib/DBIx/Class/Manual
• 次の記事 [perldocjp-cvs 160] CVS update: docs/modules/DBIx-Class-0.07006/lib/DBIx/Class/Manual
• 記事の並び順: [ 日付 ] [ スレッド ] [ 件名 ] [ 著者 ]

Index: docs/modules/DBIx-Class-0.07006/lib/DBIx/Class/Manual/Cookbook.pod
diff -u docs/modules/DBIx-Class-0.07006/lib/DBIx/Class/Manual/Cookbook.pod:1.1 docs/modules/DBIx-Class-0.07006/lib/DBIx/Class/Manual/Cookbook.pod:1.2
--- docs/modules/DBIx-Class-0.07006/lib/DBIx/Class/Manual/Cookbook.pod:1.1	Tue Jun 19 09:23:36 2007
+++ docs/modules/DBIx-Class-0.07006/lib/DBIx/Class/Manual/Cookbook.pod	Wed Jun 20 08:17:51 2007
@@ -1,18 +1,18 @@
-=head1 名前
+=head1 名前
 
-DBIx::Class::Manual::Cookbook - レシピいろいろ
+DBIx::Class::Manual::Cookbook - レシピいろいろ
 
-=head1 レシピ
+=head1 レシピ
 
-=head2 検索
+=head2 検索
 
-=head3 ページ処理された結果セット
+=head3 ページ処理された結果セット
 
 When you expect a large number of results, you can ask L<DBIx::Class> for a
 paged resultset, which will fetch only a small number of records at a time:
 
-結果セットが膨大になりそうなら、ページ処理された結果をL<DBIx::Class>で取得できます。
-一回に、少しのレコードしかとってきません:
+結果セットが膨大になりそうなら、ページ処理された結果をL<DBIx::Class>で取得できます。
+一回に、少しのレコードしかとってきません:
 
   my $rs = $schema->resultset('Artist')->search(
     undef,
@@ -26,7 +26,7 @@
 
 The C<page> attribute does not have to be specified in your search:
 
-C<page>属性は検索に指定する必要はありません:
+C<page>属性は検索に指定する必要はありません:
 
   my $rs = $schema->resultset('Artist')->search(
     undef,
@@ -40,16 +40,16 @@
 In either of the above cases, you can return a L<Data::Page> object for the
 resultset (suitable for use in e.g. a template) using the C<pager> method:
 
-上のケースでも、結果セットに、L<Data::Page>オブジェクト(テンプレートに使うのに適した)
-を得ることができます。C<pager>メソッドを使って:
+上のケースでも、結果セットに、L<Data::Page>オブジェクト(テンプレートに使うのに適した)
+を得ることができます。C<pager>メソッドを使って:
 
   return $rs->pager();
 
-=head3 複雑な WHERE節
+=head3 複雑な WHERE節
 
 Sometimes you need to formulate a query using specific operators:
 
-特定の演算子を使ったクエリを定式化する必要がある時もあるでしょう:
+特定の演算子を使ったクエリを定式化する必要がある時もあるでしょう:
 
   my @albums = $schema->resultset('Album')->search({
     artist => { 'like', '%Lamb%' },
@@ -58,13 +58,13 @@
 
 This results in something like the following C<WHERE> clause:
 
-結果は下記のC<WHERE>節のようなものになります:
+結果は下記のC<WHERE>節のようなものになります:
 
   WHERE artist LIKE '%Lamb%' AND title LIKE '%Fear of Fours%'
 
 Other queries might require slightly more complex logic:
 
-もうちょっと複雑なロジックが必要な他のクエリもあるでしょう:
+もうちょっと複雑なロジックが必要な他のクエリもあるでしょう:
 
   my @albums = $schema->resultset('Album')->search({
     -or => [
@@ -78,7 +78,7 @@
 
 This results in the following C<WHERE> clause:
 
-結果は下記のC<WHERE>節になります:
+結果は下記のC<WHERE>節になります:
 
   WHERE ( artist LIKE '%Smashing Pumpkins%' AND title = 'Siamese Dream' )
     OR artist = 'Starchildren'
@@ -86,18 +86,18 @@
 For more information on generating complex queries, see
 L<SQL::Abstract/WHERE CLAUSES>.
 
-複雑なクエリをつくるためのより詳しい説明は、L<SQL::Abstract/WHERE CLAUSES>を見てください。
+複雑なクエリをつくるためのより詳しい説明は、L<SQL::Abstract/WHERE CLAUSES>を見てください。
 
-=head3 特定のカラムを使う
+=head3 特定のカラムを使う
 
 When you only want specific columns from a table, you can use
 C<columns> to specify which ones you need. This is useful to avoid
 loading columns with large amounts of data that you aren't about to
 use anyway:
 
-テーブルから特定のカラムが欲しいだけのときには、C<columns>を使って、
-必要なものを指定できます。何にも使わない大量のデータを取り込むのを
-避けることができます。
+テーブルから特定のカラムが欲しいだけのときには、C<columns>を使って、
+必要なものを指定できます。何にも使わない大量のデータを取り込むのを
+避けることができます。
 
   my $rs = $schema->resultset('Artist')->search(
     undef,
@@ -112,10 +112,10 @@
 This is a shortcut for C<select> and C<as>, see below. C<columns>
 cannot be used together with C<select> and C<as>.
 
-後でも見ますが、これは、C<select>とC<as>のショートカットです。
-C<columns>はC<select>とC<as>と一緒には使えません。
+後でも見ますが、これは、C<select>とC<as>のショートカットです。
+C<columns>はC<select>とC<as>と一緒には使えません。
 
-=head3 データベースの関数やストアドプロシージャを使う
+=head3 データベースの関数やストアドプロシージャを使う
 
 The combination of C<select> and C<as> can be used to return the result of a
 database function or stored procedure as a column value. You use C<select> to
@@ -123,11 +123,11 @@
 stored procedure name). You then use C<as> to set the column name you will use
 to access the returned value:
 
-C<select>とC<as>の組み合わせで、カラムの値としてデータベース関数やストアド
-プロシージャの結果を返すのに使うことが出来ます。C<select>を使って、カラムの
-値のためのソースを指定できます(例えば、カラム名、関数、ストアドプロシージャ名)。
-それから、C<as>を、返された値にアクセスするのに使うカラム名をセットするのに
-使えます:
+C<select>とC<as>の組み合わせで、カラムの値としてデータベース関数やストアド
+プロシージャの結果を返すのに使うことが出来ます。C<select>を使って、カラムの
+値のためのソースを指定できます(例えば、カラム名、関数、ストアドプロシージャ名)。
+それから、C<as>を、返された値にアクセスするのに使うカラム名をセットするのに
+使えます:
 
   my $rs = $schema->resultset('Artist')->search(
     {},
@@ -148,11 +148,11 @@
 just access it as normal. Our C<Artist> class has a C<name> column, so
 we just use the C<name> accessor:
 
-C< as >属性は、SQLのシンタックスC< SELECT foo AS bar>とまったく関係ないことに
-気をつけてください(L<DBIx::Class::ResultSet/ATTRIBUTES>のドキュメントを見てください)。
-ベースクラスにカラムとしてエイリアスがある(すなわち、C<add_columns>で追加されている)のなら、
-普通にそれにアクセスできます。C<Artist>クラスには、C<name>カラムがあるので、
-C<name>アクセサを使えます:
+C< as >属性は、SQLのシンタックスC< SELECT foo AS bar>とまったく関係ないことに
+気をつけてください(L<DBIx::Class::ResultSet/ATTRIBUTES>のドキュメントを見てください)。
+ベースクラスにカラムとしてエイリアスがある(すなわち、C<add_columns>で追加されている)のなら、
+普通にそれにアクセスできます。C<Artist>クラスには、C<name>カラムがあるので、
+C<name>アクセサを使えます:
 
   my $artist = $rs->first();
   my $name = $artist->name();
@@ -160,16 +160,16 @@
 If on the other hand the alias does not correspond to an existing column, you
 have to fetch the value using the C<get_column> accessor:
 
-一方で、エイリアスが既存のカラムに一致しないなら、C<get_column>アクセサを使って、
-値を取得する必要があります:
+一方で、エイリアスが既存のカラムに一致しないなら、C<get_column>アクセサを使って、
+値を取得する必要があります:
 
   my $name_length = $artist->get_column('name_length');
 
 If you don't like using C<get_column>, you can always create an accessor for
 any of your aliases using either of these:
 
-C<get_column>が気に入らなければ、いつでも、下記のいずれかを使ってどんな
-エイリアスにもアクセサを作れます:
+C<get_column>が気に入らなければ、いつでも、下記のいずれかを使ってどんな
+エイリアスにもアクセサを作れます:
 
   # Define accessor manually:
   sub name_length { shift->get_column('name_length'); }
@@ -203,11 +203,11 @@
     }
   );
 
-=head3 結果のグルーピング
+=head3 結果のグルーピング
 
 L<DBIx::Class> supports C<GROUP BY> as follows:
 
-L<DBIx::Class>はC<GROUP BY>をサポートします:
+L<DBIx::Class>はC<GROUP BY>をサポートします:
 
   my $rs = $schema->resultset('Artist')->search(
     {},
@@ -228,16 +228,16 @@
 are in any way unsure about the use of the attributes above (C< join
 >, C< select >, C< as > and C< group_by >).
 
-上記の(C< join >、 C< select >、 C< as >、 C< group_by>)属性の使い方がわからなければ、
-L<DBIx::Class::ResultSet/ATTRIBUTES>ドキュメントをみてください。
+上記の(C< join >、 C< select >、 C< as >、 C< group_by>)属性の使い方がわからなければ、
+L<DBIx::Class::ResultSet/ATTRIBUTES>ドキュメントをみてください。
 
-=head3 先に定義された検索
+=head3 先に定義された検索
 
 You can write your own L<DBIx::Class::ResultSet> class by inheriting from it
 and define often used searches as methods:
 
-L<DBIx::Class::ResultSet>クラスを継承して、自分自身のクラスを書き、よく使う
-検索をメソッドとして定義できます:
+L<DBIx::Class::ResultSet>クラスを継承して、自分自身のクラスを書き、よく使う
+検索をメソッドとして定義できます:
 
   package My::DBIC::ResultSet::CD;
   use strict;
@@ -258,26 +258,26 @@
 To use your resultset, first tell DBIx::Class to create an instance of it
 for you, in your My::DBIC::Schema::CD class:
 
-自分の結果セット使うには、最初に、自分のMy::DBIC::Schema::CDクラスの中で、
-DBIx::Classにそのインスタンスを作るように教えます。
+自分の結果セット使うには、最初に、自分のMy::DBIC::Schema::CDクラスの中で、
+DBIx::Classにそのインスタンスを作るように教えます。
 
   __PACKAGE__->resultset_class('My::DBIC::ResultSet::CD');
 
 Then call your new method in your code:
 
-それから、コードの中で、新しい壊疽っ度を呼びます:
+それから、コードの中で、新しい壊疽っ度を呼びます:
 
    my $ordered_cds = $schema->resultset('CD')->search_cds_ordered();
 
 
-=head3 ResultSetクラスを書かかない、先に定義された検索
+=head3 ResultSetクラスを書かかない、先に定義された検索
 
 Alternatively you can automatically generate a DBIx::Class::ResultSet
 class by using the ResultSetManager component and tagging your method
 as ResultSet:
 
-別のやりかたとして、ResultSetManagerコンポーネントを使い、ResultSetとして
-自分のメソッドをタギングすることで、DBIx::Class::ResultSetクラスを自動的に作れます。
+別のやりかたとして、ResultSetManagerコンポーネントを使い、ResultSetとして
+自分のメソッドをタギングすることで、DBIx::Class::ResultSetクラスを自動的に作れます。
 
   __PACKAGE__->load_components(qw/ ResultSetManager Core /);
 
@@ -291,19 +291,19 @@
 
 Then call your method in the same way from your code:
 
-これで、コードから同じ方法で呼べます:
+これで、コードから同じ方法で呼べます:
 
    my $ordered_cds = $schema->resultset('CD')->search_cds_ordered();
 
-=head2 joins と prefetch を使う
+=head2 joins と prefetch を使う
 
 You can use the C<join> attribute to allow searching on, or sorting your
 results by, one or more columns in a related table. To return all CDs matching
 a particular artist name:
 
-C<join>属性を使って、関連するテーブルの1つ以上のカラムを使って、
-検索や、結果のソートができます。特定のアーティスト名の全てのCDを
-返すためには:
+C<join>属性を使って、関連するテーブルの1つ以上のカラムを使って、
+検索や、結果のソートができます。特定のアーティスト名の全てのCDを
+返すためには:
 
   my $rs = $schema->resultset('CD')->search(
     {
@@ -322,8 +322,8 @@
 If required, you can now sort on any column in the related tables by including
 it in your C<order_by> attribute:
 
-必要なら、C<order_by>属性にそれを含めて、関連するテーブルのいずれかのカラムで
-ソート摺ることも出来ます。
+必要なら、C<order_by>属性にそれを含めて、関連するテーブルのいずれかのカラムで
+ソート摺ることも出来ます。
 
   my $rs = $schema->resultset('CD')->search(
     {
@@ -345,16 +345,16 @@
 sort using columns in a related table. Joining related tables when you only
 need columns from the main table will make performance worse!
 
-C<join>属性は関連するテーブルのカラムを使って検索やソートをする必要があるときにのみ
-使われるべきだということに注意してください。
-メインのテーブルからカラムが必要なときに、関連するテーブルを結合するのは、
-パフォーマンスが悪いです!
+C<join>属性は関連するテーブルのカラムを使って検索やソートをする必要があるときにのみ
+使われるべきだということに注意してください。
+メインのテーブルからカラムが必要なときに、関連するテーブルを結合するのは、
+パフォーマンスが悪いです!
 
 Now let's say you want to display a list of CDs, each with the name of the
 artist. The following will work fine:
 
-で、、CDのリストを、それぞれのアーティストの名前と一緒に表示したいとしましょう。
-下記のやりかたでうまくいきます:
+で、、CDのリストを、それぞれのアーティストの名前と一緒に表示したいとしましょう。
+下記のやりかたでうまくいきます:
 
   while (my $cd = $rs->next) {
     print "CD: " . $cd->title . ", Artist: " . $cd->artist->name;
@@ -365,9 +365,9 @@
 the artist name for any of the CD objects returned, L<DBIx::Class> will go back
 to the database:
 
-ですが、一つ問題があります。このメインクエリで、C<cd>とC<artist>テーブルの両方を
-検索していますが、C<cd>からのみデータが返されています。返されたCDオブジェクトの一部で、
-アーティスト名を得るために、L<DBIx::Class>は、データベースに戻ります:
+ですが、一つ問題があります。このメインクエリで、C<cd>とC<artist>テーブルの両方を
+検索していますが、C<cd>からのみデータが返されています。返されたCDオブジェクトの一部で、
+アーティスト名を得るために、L<DBIx::Class>は、データベースに戻ります:
 
   SELECT artist.* FROM artist WHERE artist.id = ?
 
@@ -375,15 +375,15 @@
 main query. Five CDs, five extra queries. A hundred CDs, one hundred extra
 queries!
 
-上記のようなステートメントが、メインクエリによって返された、それぞれの、全ての
-CDで走ります。5つのCDであれば、5つの別のクエリです。100のCDであれば、100の別の
-クエリ!
+上記のようなステートメントが、メインクエリによって返された、それぞれの、全ての
+CDで走ります。5つのCDであれば、5つの別のクエリです。100のCDであれば、100の別の
+クエリ!
 
 Thankfully, L<DBIx::Class> has a C<prefetch> attribute to solve this problem.
 This allows you to fetch results from related tables in advance:
 
-ありがたいことに、L<DBIx::Class>は、C<prefetch>属性があり、この問題を解決できます。
-この属性を使うと、先に関連するテーブルから結果をとってこれます:
+ありがたいことに、L<DBIx::Class>は、C<prefetch>属性があり、この問題を解決できます。
+この属性を使うと、先に関連するテーブルから結果をとってこれます:
 
 
   my $rs = $schema->resultset('CD')->search(
@@ -405,7 +405,7 @@
 
 The code to print the CD list remains the same:
 
-CDのリストを表示するコードは同じ物が使えます:
+CDのリストを表示するコードは同じ物が使えます:
 
   while (my $cd = $rs->next) {
     print "CD: " . $cd->title . ", Artist: " . $cd->artist->name;
@@ -415,33 +415,33 @@
 so no additional SQL statements are executed. You now have a much more
 efficient query.
 
-L<DBIx::Class>はC<artist>テーブルからすべてのマッチするデータを先にとってきています。
-そのため、余分なSQLステートメントは実行されません。より効率的なクエリになりました。
+L<DBIx::Class>はC<artist>テーブルからすべてのマッチするデータを先にとってきています。
+そのため、余分なSQLステートメントは実行されません。より効率的なクエリになりました。
 
 Note that as of L<DBIx::Class> 0.05999_01, C<prefetch> I<can> be used with
 C<has_many> relationships.
 
-L<DBIx::Class> 0.05999_01の辞典で、 C<has_many>のリレーションシップで、
-C<prefetch>をI<使え>たのに注意してください。
+L<DBIx::Class> 0.05999_01の辞典で、 C<has_many>のリレーションシップで、
+C<prefetch>をI<使え>たのに注意してください。
 
 Also note that C<prefetch> should only be used when you know you will
 definitely use data from a related table. Pre-fetching related tables when you
 only need columns from the main table will make performance worse!
 
 
-また、C<prefetch>は、関連するテーブルからデータを必ず使うとわかっているときのみに、
-使うべきです。メインテーブルからのカラムしか必要としないなら、
-関連するテーブルから先に取得するのは、パフォーマンスを悪くします!
+また、C<prefetch>は、関連するテーブルからデータを必ず使うとわかっているときのみに、
+使うべきです。メインテーブルからのカラムしか必要としないなら、
+関連するテーブルから先に取得するのは、パフォーマンスを悪くします!
 
-=head3 マルチステップの結合(join)
+=head3 マルチステップの結合(join)
 
 Sometimes you want to join more than one relationship deep. In this example,
 we want to find all C<Artist> objects who have C<CD>s whose C<LinerNotes>
 contain a specific string:
 
-ひとつ以上の深いリレーションシップでjoinしたいときもあるでしょう。
-この例では、C<LinerNotes>に特定の文字が含まれるC<CD>を持っている、
-C<Artist>オブジェクトを探したいとします:
+ひとつ以上の深いリレーションシップでjoinしたいときもあるでしょう。
+この例では、C<LinerNotes>に特定の文字が含まれるC<CD>を持っている、
+C<Artist>オブジェクトを探したいとします:
 
   # Relationships defined elsewhere:
   # Artist->has_many('cds' => 'CD', 'artist');
@@ -468,8 +468,8 @@
 want to reduce the number of Artists returned based on who wrote the liner
 notes:
 
-結合は任意のレベルでネストできます。ですので、後から、ライナーノーツを
-誰が書いたかを元に、返されるアーティストの数を減らしたいと決めたとしたら:
+結合は任意のレベルでネストできます。ですので、後から、ライナーノーツを
+誰が書いたかを元に、返されるアーティストの数を減らしたいと決めたとしたら:
 
   # Relationship defined elsewhere:
   # LinerNotes->belongs_to('author' => 'Person');
@@ -496,13 +496,13 @@
   # WHERE liner_notes.notes LIKE '%some text%'
   # AND author.name = 'A. Writer'
 
-=head2 マルチステップのprefetch
+=head2 マルチステップのprefetch
 
 From 0.04999_05 onwards, C<prefetch> can be nested more than one relationship
 deep using the same syntax as a multi-step join:
 
-0.04999_05以前から、C<prefetch>は、マルチステップの結合と同じシンタックスで、
-一つ以上の深いリレーションシップでネストできました:
+0.04999_05以前から、C<prefetch>は、マルチステップの結合と同じシンタックスで、
+一つ以上の深いリレーションシップでネストできました:
 
   my $rs = $schema->resultset('Tag')->search(
     {},
@@ -522,8 +522,8 @@
 SQL statements:
 
 
-これで、C<cd>とC<artist>のリレーションシップにアクセスするのに、
-追加のSQLステートメントは必要ありません:
+これで、C<cd>とC<artist>のリレーションシップにアクセスするのに、
+追加のSQLステートメントは必要ありません:
 
   my $tag = $rs->first;
   print $tag->cd->artist->name;
@@ -533,8 +533,8 @@
 If you want to find the sum of a particular column there are several
 ways, the obvious one is to use search:
 
-特定のカラムの合計を探したければ、いくつもの方法があります。自明のものとしては、
-searchを使うものです:
+特定のカラムの合計を探したければ、いくつもの方法があります。自明のものとしては、
+searchを使うものです:
 
   my $rs = $schema->resultset('Items')->search(
     {},
@@ -549,23 +549,23 @@
 returned when you ask the C<ResultSet> for a column using
 C<get_column>:
 
-もしくは、L<DBIx::Class::ResultSetColumn>を使うことも出来ます。
-これは、C<ResultSet>でC<get_column>を使ってカラムを取るときに
-返されるものが取れます。
+もしくは、L<DBIx::Class::ResultSetColumn>を使うことも出来ます。
+これは、C<ResultSet>でC<get_column>を使ってカラムを取るときに
+返されるものが取れます。
 
   my $cost = $schema->resultset('Items')->get_column('Cost');
   my $tc = $cost->sum;
 
 With this you can also do:
 
-これを、次のようにできます:
+これを、次のようにできます:
 
   my $minvalue = $cost->min;
   my $maxvalue = $cost->max;
 
 Or just iterate through the values of this column only:
 
-または、このカラムの値のみを通してイテレートします:
+または、このカラムの値のみを通してイテレートします:
 
   while ( my $c = $cost->next ) {
     print $c;
@@ -579,66 +579,66 @@
 you need one that it doesn't have, then you can use the C<func> method
 instead:
 
-C<ResultSetColumn>は少しだけビルトインの関数があります。
-これにないものが必要なら、C<func>メソッドを変わりに使うことができます:
+C<ResultSetColumn>は少しだけビルトインの関数があります。
+これにないものが必要なら、C<func>メソッドを変わりに使うことができます:
 
   my $avg = $cost->func('AVERAGE');
 
 This will cause the following SQL statement to be run:
 
-こうすると、下記のSQLステートメントが走ります:
+こうすると、下記のSQLステートメントが走ります:
 
   SELECT AVERAGE(Cost) FROM Items me
 
 Which will of course only work if your database supports this function.
 See L<DBIx::Class::ResultSetColumn> for more documentation.
 
-もちろん、使っているデータベースがこの関数をサポートしていなければいけません。
-より詳しくは、L<DBIx::Class::ResultSetColumn>をみてください。
+もちろん、使っているデータベースがこの関数をサポートしていなければいけません。
+より詳しくは、L<DBIx::Class::ResultSetColumn>をみてください。
 
-=head2 リレーションシップを使う
+=head2 リレーションシップを使う
 
-=head3 関連するテーブルに新しい列を作る
+=head3 関連するテーブルに新しい列を作る
 
   my $book->create_related('author', { name => 'Fred'});
 
-=head3 関連するテーブルを検索する
+=head3 関連するテーブルを検索する
 
 Only searches for books named 'Titanic' by the author in $author.
 
-$autorの著者で、'Titanic'という名前の本だけを検索したい。
+$autorの著者で、'Titanic'という名前の本だけを検索したい。
 
   my $author->search_related('books', { name => 'Titanic' });
 
-=head3 関連するテーブルのデータを削除する
+=head3 関連するテーブルのデータを削除する
 
 Deletes only the book named Titanic by the author in $author.
 
-$autorの著者で、Titanicという名前の本だけを削除したい。
+$autorの著者で、Titanicという名前の本だけを削除したい。
 
   my $author->delete_related('books', { name => 'Titanic' });
 
-=head3 関係する結果セットの順序付け
+=head3 関係する結果セットの順序付け
 
 If you always want a relation to be ordered, you can specify this when you 
 create the relationship.
 
-順序付けられた関係が常にほしいなら、リレーションシップを作るときに、次の指定をできます。
+順序付けられた関係が常にほしいなら、リレーションシップを作るときに、次の指定をできます。
 
 To order C<< $book->pages >> by descending page_number.
 
-page_numberを降順で、C<< $book->pages >>を並び変えたいなら。
+page_numberを降順で、C<< $book->pages >>を並び変えたいなら。
 
   Book->has_many('pages' => 'Page', 'book', { order_by => \'page_number DESC'} );
 
-=head2 トランザクション
+=head2 トランザクション
 
 As of version 0.04001, there is improved transaction support in
 L<DBIx::Class::Storage::DBI> and L<DBIx::Class::Schema>.  Here is an
 example of the recommended way to use it:
 
-0.04001以前に、 L<DBIx::Class::Storage::DBI>とL<DBIx::Class::Schema>に、改良された
-トランザクションサポートがあります。これを使う推奨される方法の一例です:
+0.04001以前に、 L<DBIx::Class::Storage::DBI>とL<DBIx::Class::Schema>に、改良された
+トランザクションサポートがあります。これを使う推奨される方法の一例です:
 
   my $genus = $schema->resultset('Genus')->find(12);
 
@@ -674,17 +674,17 @@
 transactions (for databases that support them) will hopefully be added
 in the future.
 
-ネストされたトランザクションは期待どおりに動きます。
-一番外側のトランザクションだけが実際に$dbhにコミットを発行します。
-どのレベルのどのトランザクションでも、ロールバックしたら、
-全てのネストされたトランザクションが失敗します。
-セーブポイントと、本当にネストされたトランザクション
-(それをサポートしているデータベース用に)は、将来、うまくいけば、追加されるでしょう。
+ネストされたトランザクションは期待どおりに動きます。
+一番外側のトランザクションだけが実際に$dbhにコミットを発行します。
+どのレベルのどのトランザクションでも、ロールバックしたら、
+全てのネストされたトランザクションが失敗します。
+セーブポイントと、本当にネストされたトランザクション
+(それをサポートしているデータベース用に)は、将来、うまくいけば、追加されるでしょう。
 
-=head2 Many-to-many のリレーションシップ
+=head2 Many-to-many のリレーションシップ
 
 This is straightforward using L<ManyToMany|DBIx::Class::Relationship/many_to_many>:
-これは、単純にL<ManyToMany|DBIx::Class::Relationship/many_to_many>を使います:
+これは、単純にL<ManyToMany|DBIx::Class::Relationship/many_to_many>を使います:
 
   package My::DB;
   # ... set up connection ...
@@ -716,13 +716,13 @@
   $rs = $user->addresses(); # get all addresses for a user
   $rs = $address->users(); # get all users for an address
 
-=head2 列のデフォルトの値を用意する
+=head2 列のデフォルトの値を用意する
 
 It's as simple as overriding the C<new> method.  Note the use of
 C<next::method>.
 
-単純に、C<new>メソッドをオーバーライドします。
-C<next::method>の使いかたに注意してください。
+単純に、C<new>メソッドをオーバーライドします。
+C<next::method>の使いかたに注意してください。
 
   sub new {
     my ( $self, $attrs ) = @_;
@@ -738,67 +738,67 @@
 documentation. See also L<DBIx::Class::Manual::Component> for more
 ways to write your own base classes to do this.
 
-C<next::method>についてより詳しくは、L<Class::C3>のドキュメントを参照してください。
-これをするための、自分自身のベースクラスを書くための、より多くの方法については、
-L<DBIx::CLass::Manual::Component>を見てください。
+C<next::method>についてより詳しくは、L<Class::C3>のドキュメントを参照してください。
+これをするための、自分自身のベースクラスを書くための、より多くの方法については、
+L<DBIx::CLass::Manual::Component>を見てください。
 
 People looking for ways to do "triggers" with DBIx::Class are probably
 just looking for this.
 
-DBIx::Classで"triggers"をする方法を探している人も、これを探しているでしょう。
+DBIx::Classで"triggers"をする方法を探している人も、これを探しているでしょう。
 
 =head2 Stringification
 
 Employ the standard stringification technique by using the C<overload>
 module.
 
-C<overload> モジュールで標準的な文字列化のテクニックを使えます。
+C<overload> モジュールで標準的な文字列化のテクニックを使えます。
 
 To make an object stringify itself as a single column, use something
 like this (replace C<foo> with the column/method of your choice):
 
-ひとつのカラムについて、オブジェクト自身を文字列化するには、
-次のようにします。(カラム/メソッドでC<foo>を置き換えてください)
+ひとつのカラムについて、オブジェクト自身を文字列化するには、
+次のようにします。(カラム/メソッドでC<foo>を置き換えてください)
 
   use overload '""' => sub { shift->name}, fallback => 1;
 
 For more complex stringification, you can use an anonymous subroutine:
 
-より複雑な文字列化では、無名サブルーチンを使えます:
+より複雑な文字列化では、無名サブルーチンを使えます:
 
   use overload '""' => sub { $_[0]->name . ", " .
                              $_[0]->address }, fallback => 1;
 
-=head3 文字列化の例
+=head3 文字列化の例
 
 Suppose we have two tables: C<Product> and C<Category>. The table
 specifications are:
 
-二つのテーブルがあるとします:C<Product>とC<Cateogry>。
-テーブルの定義は次の通り:
+二つのテーブルがあるとします:C<Product>とC<Cateogry>。
+テーブルの定義は次の通り:
 
   Product(id, Description, category)
   Category(id, Description)
 
 C<category> is a foreign key into the Category table.
 
-C<category>はCategoryテーブルの外部キーです。
+C<category>はCategoryテーブルの外部キーです。
 
 If you have a Product object C<$obj> and write something like
 
-ProductオブジェクトC<$obj>があり、次のように書いたとすると、
+ProductオブジェクトC<$obj>があり、次のように書いたとすると、
 
   print $obj->category
 
 things will not work as expected.
 
-期待どおりには動きません。
+期待どおりには動きません。
 
 To obtain, for example, the category description, you should add this
 method to the class defining the Category table:
 
-カテゴリの内容を得たいなら、例えば、Categoryテーブルのクラス定義に次の
-メソッドを追加すべきです:
+カテゴリの内容を得たいなら、例えば、Categoryテーブルのクラス定義に次の
+メソッドを追加すべきです:
 
   use overload "" => sub {
       my $self = shift;
@@ -806,31 +806,31 @@
       return $self->Description;
   }, fallback => 1;
 
-=head2 きれいに切断
+=head2 きれいに切断
 
 If you find yourself quitting an app with Control-C a lot during
 development, you might like to put the following signal handler in
 your main database class to make sure it disconnects cleanly:
 
-開発中に、Cotrol-Cを多用して、アプリケーションを終了させることが
-多いなら、下記のようなシグナルハンドラーをデータベースクラスに置いて、
-確実にきれいに切断したいかもしれません:
+開発中に、Cotrol-Cを多用して、アプリケーションを終了させることが
+多いなら、下記のようなシグナルハンドラーをデータベースクラスに置いて、
+確実にきれいに切断したいかもしれません:
 
   $SIG{INT} = sub {
     __PACKAGE__->storage->disconnect;
   };
 
-=head2 スキーマのインポート/エクスポート
+=head2 スキーマのインポート/エクスポート
 
 This functionality requires you to have L<SQL::Translator> (also known as
 "SQL Fairy") installed.
 
-この機能を使うには、L<SQL::Translator>("SQL Fairy"とも知られる)を
-インストールする必要があります。
+この機能を使うには、L<SQL::Translator>("SQL Fairy"とも知られる)を
+インストールする必要があります。
 
 To create a DBIx::Class schema from an existing database:
 
-DBIx::Classスキーマを既存のデータベースから作ります:
+DBIx::Classスキーマを既存のデータベースから作ります:
 
  sqlt --from DBI
       --to DBIx::Class::File
@@ -839,8 +839,8 @@
 To create a MySQL database from an existing L<DBIx::Class> schema, convert the
 schema to MySQL's dialect of SQL:
 
-MySQLデータベースを既存のL<DBIx::Class>スキーマから作ります。
-スキーマをMySQLのSQL放言に変換します:
+MySQLデータベースを既存のL<DBIx::Class>スキーマから作ります。
+スキーマをMySQLのSQL放言に変換します:
 
   sqlt --from SQL::Translator::Parser::DBIx::Class 
        --to MySQL 
@@ -848,22 +848,21 @@
   
 And import using the mysql client:
 
-mysqlクライアントでimportします:
+mysqlクライアントでimportします:
 
   mysql -h "host" -D "database" -u "user" -p < Schema1.sql
 
-=head2 クラスベースからスキーマペースのセットアップへの簡単な移行
+=head2 クラスベースからスキーマペースのセットアップへの簡単な移行
 
 You want to start using the schema-based approach to L<DBIx::Class>
 (see L<SchemaIntro.pod>), but have an established class-based setup with lots
 of existing classes that you don't want to move by hand. Try this nifty script
 instead:
 
-L<DBIx::Class>へのスキーマベースのアプローチを使いたい(L<SchemaIntro.pod>をみてください)、
-でも、既存の大量のクラスで、従来のクラスベースのセットアップがあり、
-手でそれらを動かしたくはないとします。手で動かす変わりに、下記の気の利いたスクリプトを
-試してみて下さい:
-
+L<DBIx::Class>へのスキーマベースのアプローチを使いたい(L<SchemaIntro.pod>をみてください)、
+でも、既存の大量のクラスで、従来のクラスベースのセットアップがあり、
+手でそれらを動かしたくはないとします。手で動かす変わりに、下記の気の利いたスクリプトを
+試してみて下さい:
 
 
   use MyDB;
@@ -897,17 +896,17 @@
 You could use L<Module::Find> to search for all subclasses in the MyDB::*
 namespace, which is currently left as an exercise for the reader.
 
-L<Module::Find>を使って、MyDB::*名前空間にある全てのサブクラスを探すことが出来ますが、
-これは、今のところ、読者への課題としておきます。
+L<Module::Find>を使って、MyDB::*名前空間にある全てのサブクラスを探すことが出来ますが、
+これは、今のところ、読者への課題としておきます。
 
 
-=head2 スキーマのバージョニング
+=head2 スキーマのバージョニング
 
 The following example shows simplistically how you might use DBIx::Class to
 deploy versioned schemas to your customers. The basic process is as follows:
 
-下記の例では、DBIx::Classを使って、顧客向けにバージョン付きのスキーマをどうやって
-デプロイするかをお見せします。
+下記の例では、DBIx::Classを使って、顧客向けにバージョン付きのスキーマをどうやって
+デプロイするかをお見せします。
 
 =over 4
 
@@ -915,49 +914,49 @@
 
 Create a DBIx::Class schema
 
-DBIx::Classスキーマを作ります
+DBIx::Classスキーマを作ります
 
 =item 2.
 
 Save the schema
 
-スキーマを保存します
+スキーマを保存します
 
 =item 3.
 
 Deploy to customers
 
-顧客にデプロイします
+顧客にデプロイします
 
 =item 4.
 
 Modify schema to change functionality
 
-スキーマを変更して、 functionality を変更します
+スキーマを変更して、 functionality を変更します
 
 =item 5.
 
 Deploy update to customers
 
-顧客に更新をデプロイします
+顧客に更新をデプロイします
 
 =back
 
-=head3 DBIx::Calssスキーマを作る
+=head3 DBIx::Calssスキーマを作る
 
 This can either be done manually, or generated from an existing database as
 described under C<Schema import/export>.
 
-これは、手で行うことも、C<Schema import/export>で説明しますが、
-既存のデータベースから生成することもできます。
+これは、手で行うことも、C<Schema import/export>で説明しますが、
+既存のデータベースから生成することもできます。
 
-=head3 スキーマを保存する
+=head3 スキーマを保存する
 
 Use C<sqlt> to transform your schema into an SQL script suitable for your
 customer's database. E.g. for MySQL:
 
-C<sqlt>を使って、スキーマを変換して、顧客のデータベース(例えば、MySQL)に合った、
-SQLスクリプトにします。
+C<sqlt>を使って、スキーマを変換して、顧客のデータベース(例えば、MySQL)に合った、
+SQLスクリプトにします。
 
   sqlt --from SQL::Translator::Parser::DBIx::Class
        --to MySQL
@@ -966,20 +965,20 @@
 If you need to target databases from multiple vendors, just generate an SQL
 script suitable for each. To support PostgreSQL too:
 
-複数のベンダからデーベースをターゲットにしなければならないなら、
-それぞれに合ったSQLスクリプトを生成するだけです。PostgreSQLもサポートしています:
+複数のベンダからデーベースをターゲットにしなければならないなら、
+それぞれに合ったSQLスクリプトを生成するだけです。PostgreSQLもサポートしています:
 
   sqlt --from SQL::Translator::DBIx::Class
        --to PostgreSQL
        --DBIx::Class "MySchema.pm" > Schema1.pgsql.sql
 
-=head3 顧客にデプロイする
+=head3 顧客にデプロイする
 
 There are several ways you could deploy your schema. These are probably
 beyond the scope of this recipe, but might include:
 
-スキーマをデプロイするのには複数の方法があります。
-このレシピのスコープを逸脱していそうですが、含めておきます:
+スキーマをデプロイするのには複数の方法があります。
+このレシピの範疇を越えそうですが、含めておきます:
 
 =over 4
 
@@ -1423,6 +1422,16 @@
       return $self->generate_description;
   }
 
+=head1 翻訳について
 
-=cut
+翻訳者：加藤敦 (ktat.****@gmail*****)
+
+Perlドキュメント日本語訳 Project にて、
+Perlモジュール、ドキュメントの翻訳を行っております。
 
+ http://perldocjp.sourceforge.jp/
+ http://sourceforge.jp/projects/perldocjp/
+ http://www.freeml.com/ctrl/html/MLInfoForm/perld****@freem*****
+ http://www.perldoc.jp
+
+=cut

• 前の記事 [perldocjp-cvs 158] CVS update: docs/modules/DBIx-Class-0.07006/lib/DBIx/Class/Manual
• 次の記事 [perldocjp-cvs 160] CVS update: docs/modules/DBIx-Class-0.07006/lib/DBIx/Class/Manual
• 記事の並び順: [ 日付 ] [ スレッド ] [ 件名 ] [ 著者 ]