DBIx-Class-0.08127 > DBIx::Class::Manual::Intro
Other versions:


DBIx::Class::Manual::Intro - DBIx::Class イントロダクション


You're bored with SQL, and want a native Perl interface for your database? Or you've been doing this for a while with Class::DBI, and think there's a better way? You've come to the right place.

で、SQLにうんざりしてません?データベース用に自然なPerlのインターフェースが欲しくない? もしくは、しばらくClass::DBIで、それをしていたけど、もっと良いやりかたがあると思わなかった? 良いところに来ましたね。


Here are a few simple tips that will help you get your bearings with DBIx::Class.


テーブルはResult Class になる

DBIx::Class needs to know what your Table structure looks like. You do that by defining Result classes. Result classes are defined by calling methods proxied to DBIx::Class::ResultSource. Each Result class defines one Table, which defines the Columns it has, along with any Relationships it has to other tables. (And oh, so much more besides) The important thing to understand:

DBIx::Class は、対象となるテーブルの構造がどんなものなのかを知っている必要があります。 そのために、Result Classを定義します。Result Class はDBIx::Class::ResultSource を 経由することで定義されます。それぞれのResult Class に一つのテーブルがあり、そのカラムを 定義します。一緒に他のテーブルとのすべてのリレーションを定義します。 (そして、ああ、それ以上に、)理解しなればいけない、重要なことは:

  A Result class == Table

(most of the time, but just bear with my simplification)



So, we've got some ResultSources defined. Now, we want to actually use those definitions to help us translate the queries we need into handy perl objects!

ResultSources を定義したら、今度はそれらの定義を、 手軽な perl オブジェクトに必要なクエリを変換するために、実際に使いたいと思います!

Let's say we defined a ResultSource for an "album" table with three columns: "albumid", "artist", and "title". Any time we want to query this table, we'll be creating a DBIx::Class::ResultSet from its ResultSource. For example, the results of:

"alubum" テーブルのResultSource を定義します。テーブルには3つのカラムがあります: "albumid", "artist", "title" です。 このテーブルにクエリを投げたいなら、 ResultSource からDBIx::Class::ResultSetを作ります。例えば、結果は:

  SELECT albumid, artist, title FROM album;

Would be retrieved by creating a ResultSet object from the album table's ResultSource, likely by using the "search" method.

album テーブル から ResultSet オブジェクトを作るために、テーブルのResultSource から引いてきます。おそらく"search" メソッドを使います。

DBIx::Class doesn't limit you to creating only simple ResultSets -- if you wanted to do something like:

DBIx::Class は単純なResultSet を作るだけには留まりません。 -- もし次のようなものが 欲しいなら:

  SELECT title FROM album GROUP BY title;

You could easily achieve it.


The important thing to understand:


  Any time you would reach for a SQL query in DBI, you are
  creating a DBIx::Class::ResultSet.

Search は "prepare"のようなもの

DBIx::Class tends to wait until it absolutely must fetch information from the database. If you are returning a ResultSet, the query won't execute until you use a method that wants to access the data. (Such as "next", or "first")

DBIx::Classがデータベースから絶対に情報を取得しなければならない時まで、 DBIx::Classは待つ傾向があります。ResultSetを返しても、クエリはデータに アクセスするメソッド("next"や"first"のような)を使うまで実行されません。

The important thing to understand:


  Setting up a ResultSet does not execute the query; retrieving
  the data does.
  ResultSetのセットアップはクエリを実行しません; データの取得によって

Search results are returned as Rows

Rows of the search from the database are blessed into DBIx::Class::Row objects.

データベースからの検索の行は、bless されてDBIx::Class::Rowオブジェクトになります。


Let's look at how you can set and use your first native DBIx::Class tree.


First we'll see how you can set up your classes yourself. If you want them to be auto-discovered, just skip to the next section, which shows you how to use DBIx::Class::Schema::Loader.

最初に、自分でクラスをセットアップする方法を見ますが、クラスを自動で見付けたい場合は、 その次のセクションまでスキップしてください、その次のセクションでは、DBIx::Class::Schema::Loader を使った方法を説明します。


First, you should create your base schema class, which inherits from DBIx::Class::Schema:


  package My::Schema;
  use base qw/DBIx::Class::Schema/;

In this class you load your result_source ("table", "model") classes, which we will define later, using the load_namespaces() method:

このクラスには、result_source ("table", "model") クラス(後で定義します)をロードします。 load_namespaces() メソッドを使います:

  # load My::Schema::Result::* and their resultset classes

By default this loads all the Result (Row) classes in the My::Schema::Result:: namespace, and also any resultset classes in the My::Schema::ResultSet:: namespace (if missing, the resultsets are defaulted to be DBIx::Class::ResultSet objects). You can change the result and resultset namespaces by using options to the "load_namespaces" in DBIx::Class::Schema call.

デフォルトでは、My::Schema::Result:: 名前空間に全てのResult(Row)クラス 、My::Schema::ResultSet:: 名前空間のすべての結果セットクラスがロードされます。 (if missing, the resultsets are defaulted to be DBIx::Class::ResultSet objects). You can change the result and resultset namespaces by using options to the "load_namespaces" in DBIx::Class::Schema call.

It is also possible to do the same things manually by calling load_classes for the Row classes and defining in those classes any required resultset classes.

Row クラスのためにload_classesを呼ぶことと、 それらのクラスで全ての必要な結果セットクラスを定義することで、 手で同じことができます。

Next, create each of the classes you want to load as specified above:


  package My::Schema::Result::Album;
  use base qw/DBIx::Class::Core/;

Load any additional components you may need with the load_components() method, and provide component configuration if required. For example, if you want automatic row ordering:

それぞれのクラスに必要な追加のコンポーネントを load_components() メソッドでロードします。 必要ならコンポーネントの設定を与えます。例えば、自動的な行の並びかえなら:

  __PACKAGE__->load_components(qw/ Ordered /);

Ordered will refer to a field called 'position' unless otherwise directed. Here you are defining the ordering field to be named 'rank'. (NOTE: Insert errors may occur if you use the Ordered component, but have not defined a position column or have a 'position' field in your row.)

並びかえは、他のものが指示されなければ、'position' と呼ばれるフィールドを参照します。 ここでは、'rank' という名前のフィールドを並びかえに定義しています。 (注意: 並びかえされたコンポーネントを使っているのに、position カラムを定義していないか、 'position' フィールドが列になければ、挿入エラーが起きるでしょう。)

Set the table for your class:



Add columns to your class:


  __PACKAGE__->add_columns(qw/ albumid artist title rank /);

Each column can also be set up with its own accessor, data_type and other pieces of information that it may be useful to have -- just pass add_columns a hash:

それぞれのカラムは、それ自身のアクセサや、あったほうが便利な、data_type や他の情報も add_columnsに次のようなハッシュを渡します:

  __PACKAGE__->add_columns(albumid =>
                            { accessor  => 'album',
                              data_type => 'integer',
                              size      => 16,
                              is_nullable => 0,
                              is_auto_increment => 1,
                              default_value => '',
                          artist =>
                            { data_type => 'integer',
                              size      => 16,
                              is_nullable => 0,
                              is_auto_increment => 0,
                              default_value => '',
                          title  =>
                            { data_type => 'varchar',
                              size      => 256,
                              is_nullable => 0,
                              is_auto_increment => 0,
                              default_value => '',
                          rank =>
                            { data_type => 'integer',
                              size      => 16,
                              is_nullable => 0,
                              is_auto_increment => 0,
                              default_value => '',

DBIx::Class doesn't directly use most of this data yet, but various related modules such as DBIx::Class::WebForm make use of it. Also it allows you to create your database tables from your Schema, instead of the other way around. See "deploy" in DBIx::Class::Schema for details.

このデータのほとんどは、まだ、DBIx::Classで直接に使われません。ですが、 DBIx::Class::WebFormのような、関連する様々なモジュールがそれを使います。 また、他のやりかたの代わりに、スキーマからデータベースを作ることもできます。 詳しくはSQL::Translatorを見てください:

See DBIx::Class::ResultSource for more details of the possible column attributes.

可能なカラムの属性の詳細については、 DBIx::Class::ResultSourceを見てください。

Accessors are created for each column automatically, so My::Schema::Result::Album will have albumid() (or album(), when using the accessor), artist() and title() methods.

アクセサはそれぞれのカラム用に、自動的に作られます。 My::Schema::Result::Albumは、albumid() (または、アクセサを使ったら、album())、artist()、title() のメソッドが使えます。

Define a primary key for your class:



If you have a multi-column primary key, just pass a list instead:


  __PACKAGE__->set_primary_key( qw/ albumid artistid / );

Define this class' relationships with other classes using either belongs_to to describe a column which contains an ID of another Table, or has_many to make a predefined accessor for fetching objects that contain this Table's foreign key:

belongs_toを使って、他のテーブルのIDを含むカラムを説明することで、 クラスがのリレーションシップを定義することが出来ます。 また、has_manyで、 カラムの1つに、このテーブルの外部キーを含むオブジェクトを取得する 定義済みのアクセサを作れます。

  # in My::Schema::Result::Artist
  __PACKAGE__->has_many('albums', 'My::Schema::Result::Album', 'artist');

See DBIx::Class::Relationship for more information about the various types of available relationships and how you can design your own.

様々なタイプの可能なリレーションシップについてと、自分自身のリレーションシップ を設計する方法についての詳しい情報は、DBIx::Class::Relationshipにあります。


This is an external module, and not part of the DBIx::Class distribution. It inspects your database, and automatically creates classes for all the tables in your database.

これは外部のモジュールであり、DBIx::Classのディストリビューション一部ではありません。 データベース内の全てのテーブル用のクラスを自動的に作ります。

The simplest way to use it is via the dbicdump script from the DBIx::Class::Schema::Loader distribution. For example:

最も単純な方法はdbicdump スクリプトをDBIx::Class::Schema::Loader ディストリビューション から使うことです。例:

    $ dbicdump -o dump_directory=./lib MyApp::Schema dbi:mysql:mydb user pass

If you have a mixed-case database, use the preserve_case option, e.g.:


    $ dbicdump -o dump_directory=./lib -o preserve_case=1 MyApp::Schema \
        dbi:mysql:mydb user pass

If you are using Catalyst, then you can use the helper that comes with Catalyst::Model::DBIC::Schema:

Catalystを使っているなら、Catalyst::Model::DBIC::Schemaにある、 ヘルパーを使えます。

    $ script/myapp_create.pl model MyDB DBIC::Schema MyDB::Schema \
        create=static moniker_map='{ foo => "FOO" }' dbi:SQLite:./myapp.db \
        on_connect_do='PRAGMA foreign_keys=ON' quote_char='"'

See Catalyst::Helper::Model::DBIC::Schema for more information on this helper.

このヘルパーについてのより詳しい情報は、Catalyst::Helper::Model::DBIC::Schemaを 見てください。

See the DBIx::Class::Schema::Loader and DBIx::Class::Schema::Loader::Base documentation for more information on the many loader options.

DBIx::Class::Schema::LoaderDBIx::Class::Schema::Loader::Base のドキュメントを見てください。たくさんの他のオプションに関する情報があります。


To connect to your Schema, you need to provide the connection details or a database handle.



The arguments are the same as for "connect" in DBI:

引数は、"connect" in DBIと同じです:

  my $schema = My::Schema->connect('dbi:SQLite:/home/me/myapp/my.db');

You can create as many different schema instances as you need. So if you have a second database you want to access:

必要に応じて、多くの違ったスキーマインスタンスを作ることが出来ます。 2つ目のデータベースがあり、アクセスしたいなら:

  my $other_schema = My::Schema->connect( $dsn, $user, $password, $attrs );

Note that DBIx::Class::Schema does not cache connections for you. If you use multiple connections, you need to do this manually.

DBIx::Class::Schemaは接続をキャッシュしないことに注意してください。 複数のコネクションを使うなら、手でしなければなりません。

To execute some SQL statements on every connect you can add them as an option in a special fifth argument to connect:

接続毎に、いくつかのsql文実行したいなら、connectの特別な5版目の引数に オプションとしてとして追加できます:

  my $another_schema = My::Schema->connect(
      { on_connect_do => \@on_connect_sql_statments }

See "connect_info" in DBIx::Class::Storage::DBI for more information about this and other special connect-time options.

この特別なconnect-時の他のオプションについて詳しくは、 "connect_info" in DBIx::Class::Storage::DBIを見てください。


The supplied coderef is expected to return a single connected database handle (e.g. a DBI $dbh)

与えられたコードリファレンスは一つの接続されたデータベースハンドルを返すことが期待されます。 (e.g. DBI $dbh)

  my $schema = My::Schema->connect (
    sub { Some::DBH::Factory->connect },


Once you've defined the basic classes, either manually or using DBIx::Class::Schema::Loader, you can start interacting with your database.

基本のクラスを定義したら、手でも、 DBIx::Class::Schema::Loaderでも、 データベースへの連携を始められます。

To access your database using your $schema object, you can fetch a "ResultSet" in DBIx::Class::Manual::Glossary representing each of your tables by calling the resultset method.

$schemaオブジェクトでデータベースにアクセスするのに、 resultsetメソッドを呼び出すことで、それぞれのテーブルを表す、 "ResultSet" in DBIx::Class::Manual::Glossaryを取ります。

The simplest way to get a record is by primary key:


  my $album = $schema->resultset('Album')->find(14);

This will run a SELECT with albumid = 14 in the WHERE clause, and return an instance of My::Schema::Result::Album that represents this row. Once you have that row, you can access and update columns:

WHERE節にalbumid=4で、SELECTが実行され、その列を表す My::Schema::Albumのインスタンスを返します。 その列があれば、カラムにアクセスでき、アップデートできます。

  $album->title('Physical Graffiti');
  my $title = $album->title; # $title holds 'Physical Graffiti'

If you prefer, you can use the set_column and get_column accessors instead:


  $album->set_column('title', 'Presence');
  $title = $album->get_column('title');

Just like with Class::DBI, you call update to save your changes to the database (by executing the actual UPDATE statement):

ちょうどClass::DBIと同じように、updateを呼んで、 変更をデータベースにコミットできます:


If needed, you can throw away your local changes:


  $album->discard_changes if $album->is_changed;

As you can see, is_changed allows you to check if there are local changes to your object.

御覧の通り、is_changedでオブジェクトにローカルの変更が加えられたか どうかをチェックできます。


To create a new record in the database, you can use the create method. It returns an instance of My::Schema::Result::Album that can be used to access the data in the new record:

データベースに新しいレコードを作るためには、createメソッドを使います。 My::Schema::Result::Albumのインスタンスを返し、新しいレコードのデータにアクセスするのに 使えます:

  my $new_album = $schema->resultset('Album')->create({
    title  => 'Wish You Were Here',
    artist => 'Pink Floyd'

Now you can add data to the new record:



Likewise, you can remove it from the database:



You can also remove records without retrieving them first, by calling delete directly on a ResultSet object.

最初にレコードを取ってこずに削除することもできます。 ResultSetオブジェクトで直接にdeleteを呼びます。

  # Delete all of Falco's albums
  $schema->resultset('Album')->search({ artist => 'Falco' })->delete;


DBIx::Class provides a few different ways to retrieve data from your database. Here's one example:

DBIx::Classは、データベースからデータを取得するのに、いくつかの 違った方法を提供しています。1つの例として:

  # Find all of Santana's albums
  my $rs = $schema->resultset('Album')->search({ artist => 'Santana' });

In scalar context, as above, search returns a DBIx::Class::ResultSet object. It can be used to peek at the first album returned by the database:

スカラコンテキストでは、searchは、DBIx::Class::ResultSetオブジェクト を返します。データベースから返された最初のアルバムを覗くのに使えます:

  my $album = $rs->first;
  print $album->title;

You can loop over the albums and update each one:


  while (my $album = $rs->next) {
    print $album->artist . ' - ' . $album->title;

Or, you can update them all at once:


  $rs->update({ year => 2001 });

In list context, the search method returns all of the matching rows:


  # Fetch immediately all of Carlos Santana's albums
  my @albums = $schema->resultset('Album')->search(
    { artist => 'Carlos Santana' }
  foreach my $album (@albums) {
    print $album->artist . ' - ' . $album->title;

We also provide a handy shortcut for doing a LIKE search:


  # Find albums whose artist starts with 'Jimi'
  my $rs = $schema->resultset('Album')->search_like({ artist => 'Jimi%' });

Or you can provide your own WHERE clause:


  # Find Peter Frampton albums from the year 1986
  my $where = 'artist = ? AND year = ?';
  my @bind  = ( 'Peter Frampton', 1986 );
  my $rs    = $schema->resultset('Album')->search_literal( $where, @bind );

The preferred way to generate complex queries is to provide a SQL::Abstract construct to search:

複雑なクエリを生成する好ましい方法は、SQL::Abstractの構造を searchに渡すことです:

  my $rs = $schema->resultset('Album')->search({
    artist  => { '!=', 'Janis Joplin' },
    year    => { '<' => 1980 },
    albumid => { '-in' => [ 1, 14, 15, 65, 43 ] }

This results in something like the following WHERE clause:


  WHERE artist != 'Janis Joplin'
    AND year < 1980
    AND albumid IN (1, 14, 15, 65, 43)

For more examples of complex queries, see DBIx::Class::Manual::Cookbook.


The search can also be modified by passing another hash with attributes:

属性に他のハッシュを渡すことで、search を修正できます:

  my @albums = My::Schema->resultset('Album')->search(
    { artist => 'Bob Marley' },
    { rows => 2, order_by => 'year DESC' }

@albums then holds the two most recent Bob Marley albums.

@albumns には、最新のBob Marleyのアルバム2つがあります。

For more information on what you can do with a DBIx::Class::ResultSet, see "METHODS" in DBIx::Class::ResultSet.

DBIx::Class::ResultSetで何が出来るかについてのより詳しい情報は、 "METHODS" in DBIx::Class::ResultSetを見てください。

For a complete overview of the available attributes, see "ATTRIBUTES" in DBIx::Class::ResultSet.

使える属性の完全な概観は、"ATTRIBUTES" in DBIx::Class::ResultSetを見てください



The concept of a primary key in DBIx::Class warrants special discussion. The formal definition (which somewhat resembles that of a classic RDBMS) is a unique constraint that is least likely to change after initial row creation. However this is where the similarity ends. Any time you call a CRUD operation on a row (e.g. delete, update, discard_changes, etc.) DBIx::Class will use the values of of the primary key columns to populate the WHERE clause necessary to accomplish the operation. This is why it is important to declare a primary key on all your result sources even if the underlying RDBMS does not have one. In a pinch one can always declare each row identifiable by all its columns:

 __PACKAGE__->set_primary_keys (__PACKAGE__->columns);

Note that DBIx::Class is smart enough to store a copy of the PK values before any row-object changes take place, so even if you change the values of PK columns the WHERE clause will remain correct.

If you elect not to declare a primary key, DBIx::Class will behave correctly by throwing exceptions on any row operation that relies on unique identifiable rows. If you inherited datasets with multiple identical rows in them, you can still operate with such sets provided you only utilize DBIx::Class::ResultSet CRUD methods: search, update, delete

For example, the following would not work (assuming People does not have a declared PK):

 my $row = $schema->resultset('People')
                   ->search({ last_name => 'Dantes' })
 $row->update({ children => 2 }); # <-- exception thrown because $row isn't
                                  # necessarily unique

So instead the following should be done:

         ->search({ last_name => 'Dantes' })
          ->update({ children => 2 }); # <-- update's ALL Dantes to have children of 2

Problems on RHEL5/CentOS5

There used to be an issue with the system perl on Red Hat Enterprise Linux 5, some versions of Fedora and derived systems. Further information on this can be found in DBIx::Class::Manual::Troubleshooting



翻訳者:加藤敦 (ktat.is at gmail.com)

Perlドキュメント日本語訳 Project にて、 Perlモジュール、ドキュメントの翻訳を行っております。