モデル¶

各データベースごとのデータ型の関係¶

各 RDBMS は、それぞれ少しずつ異なる形式でデータ型を定義しています。CakePHP は、各データベースシステム用のデータソースクラス内でこれらの型をマッピングし、分かりやすく統一したインターフェイスを生成することで、データベースシステムの種類を意識せずにすむようにしています。

次に、それぞれのデータベースの型がどのようにマッピングされているかを説明します。

タイトル¶

体感として、オブジェクトは名前やタイトルをもっていて、それを使用して何かを説明しています。人は、John・Mac・Buddy のような名前をもっています。ブログの投稿にはタイトルがあります。カテゴリは名前をもっています。

title または name フィールドを指定すると、CakePHP は自動的にさまざまな状況でこのラベルを使用します:

• Scaffolding — ページタイトル, フィールドのラベル

• Lists — 通常 <select> のドロップダウンリストに使用します

• TreeBehavior — reordering, ツリービュー

テーブルにタイトル かつ 名前のフィールドがある場合、タイトルが優先されます。

この規約に従わないものを使いたい場合は、 var $displayField = 'some_field';をセットしてください。ただし、これに2つ以上のフィールドをセットすることはできません。

created と modified¶

データベースのテーブル内で datetime フィールドとして created または modified フィールドを定義すると、CakePHP はそれらのフィールドを認識し、レコードがデータベースに作成・更新されるときに自動的に埋め込まれます（保存されるデータが既にこれらのフィールドの値を含んでいる場合を除いて）。

created や modified フィールドは、レコードが一番初めに追加されたときに、現在日時をセットします。modified フィールドは、すでに存在するレコードが保存されたときに、現在日時で更新されます。

注意: フィールド名 updated は modified と同じ振る舞いをします。これらのフィールドは、datetime フィールドである必要があり、デフォルト値として CakePHP で認識される NULL をセットします。

もしModel::save()の直前に$this->dataがupdated、created、modifiedなどの値を（Model::readやModel::setを経由して）保持しているなら、 これらは自動的に更新されることはなく、$this->dataから値をとってくることになります。

unset($this->data['Model']['modified'])などとするか、あるいは以下のようにModel::save()をオーバーライドして、このようなことを常体化することができます。

class AppModel extends Model {
//
//
    function save($data = null, $validate = true, $fieldList = array()) {

        // "modified"の値を保存前ごとに削除する
        if (isset($this->data) && isset($this->data[$this->name]))
            unset($this->data[$this->name]['modified']);
        if (isset($data) && isset($data[$this->name]))
            unset($data[$this->name]['modified']);

        return parent::save($data, $validate, $fieldList);
    }
//
//
}

プライマリーキーとして UUID を使用する¶

プライマリーキーは、通常 INT フィールドとして定義されます。データベースは、新しいレコードが追加されるたびに自動的にフィールドをインクリメントし、１から始まります。あるいは、CHAR(36) または BINARY(36)としてプライマリーキーを指定した場合、CakePHP は、新しいレコードが作製されたときに、自動的に UUIDs を生成します。

UUID は４つのハイフンで区切られた 32 バイトの文字列で、トータル 36 文字になります。たとえば次のようなものです:

550e8400-e29b-41d4-a716-446655440000

UUID は、単一テーブル内ではなくテーブルやデータベースを超えた単位でユニークになるように設計されています。システム間でフィールドをユニークにする必要がある場合、UUID はすばらしいアプローチになります。

find¶

find($type, $params)

findはモデルのデータを検索するための多くの機能を持った働き者です。$type は 'all'、'first'、'count'、'list'、'neighbors' または 'threaded' のいずれかです。デフォルトは 'first' です。$typeは大文字と小文字を区別することを覚えておいてください。大文字を使うと（例：'All'）、期待する結果を得られないことがあります。

$params はオプションの配列です。キーとして次のものが有効です。:

array(
    'conditions' => array('Model.field' => $thisValue), //条件の配列
    'recursive' => 1, //int
    'fields' => array('Model.field1', 'DISTINCT Model.field2'), //フィールド名の配列
    'order' => array('Model.created', 'Model.field3 DESC'), //文字列か配列でのorder定義
    'group' => array('Model.field'), //GROUP BYするためのフィールド
    'limit' => n, //int
    'page' => n, //int
    'offset' => n, //int
    'callbacks' => true //false, 'before', 'after'が指定できます。
)

また、いくつかのタイプのfind、ビヘイビアで使われる他のパラメータも指定することができます。もちろん独自のモデルメソッドにおいても可能です。

有効なモデルのコールバックに関する詳細は、こちら を参照してください。

function some_function() {
   ...
   $this->Article->order = null; // これがセットされているとリセットされます
   $semiRandomArticle = $this->Article->find();
   $this->Article->order = 'Article.created DESC'; // モデルがデフォルトの並び順を持つようにシミュレートします
   $lastCreated = $this->Article->find();
   $alsoLastCreated = $this->Article->find('first', array('order' => array('Article.created DESC')));
   $specificallyThisOne = $this->Article->find('first', array('conditions' => array('Article.id' => 1)));
   ...
}

Array
(
    [ModelName] => Array
        (
            [id] => 83
            [field1] => value1
            [field2] => value2
            [field3] => value3
        )

    [AssociatedModelName] => Array
        (
            [id] => 1
            [field1] => value1
            [field2] => value2
            [field3] => value3
        )
)

function some_function() {
   ...
   $total = $this->Article->find('count');
   $pending = $this->Article->find('count', array('conditions' => array('Article.status' => 'pending')));
   $authors = $this->Article->User->find('count');
   $publishedAuthors = $this->Article->find('count', array(
      'fields' => 'DISTINCT Article.user_id',
      'conditions' => array('Article.status !=' => 'pending')
   ));
   ...
}

function some_function() {
   ...
   $allArticles = $this->Article->find('all');
   $pending = $this->Article->find('all', array('conditions' => array('Article.status' => 'pending')));
   $allAuthors = $this->Article->User->find('all');
   $allPublishedAuthors = $this->Article->User->find('all', array('conditions' => array('Article.status !=' => 'pending')));
   ...
}

Array
(
    [0] => Array
        (
            [ModelName] => Array
                (
                    [id] => 83
                    [field1] => value1
                    [field2] => value2
                    [field3] => value3
                )

            [AssociatedModelName] => Array
                (
                    [id] => 1
                    [field1] => value1
                    [field2] => value2
                    [field3] => value3
                )

        )
)

function some_function() {
   ...
   $allArticles = $this->Article->find('list');
   $pending = $this->Article->find('list', array('conditions' => array('Article.status' => 'pending')));
   $allAuthors = $this->Article->User->find('list');
   $allPublishedAuthors = $this->Article->User->find('list', array('conditions' => array('Article.status !=' => 'pending')));
   ...
}

Array
(
    //[id] => 'displayValue',
    [1] => 'displayValue1',
    [2] => 'displayValue2',
    [4] => 'displayValue4',
    [5] => 'displayValue5',
    [6] => 'displayValue6',
    [3] => 'displayValue3',
)

function some_function() {
   ...
   $justusernames = $this->Article->User->find('list', array('fields' => array('User.username')));
   $usernameMap = $this->Article->User->find('list', array('fields' => array('User.username', 'User.first_name')));
   $usernameGroups = $this->Article->User->find('list', array('fields' => array('User.username', 'User.first_name', 'User.group')));
   ...
}

$justusernames = Array
(
    //[id] => 'username',
    [213] => 'AD7six',
    [25] => '_psychic_',
    [1] => 'PHPNut',
    [2] => 'gwoo',
    [400] => 'jperras',
)

$usernameMap = Array
(
    //[username] => 'firstname',
    ['AD7six'] => 'Andy',
    ['_psychic_'] => 'John',
    ['PHPNut'] => 'Larry',
    ['gwoo'] => 'Gwoo',
    ['jperras'] => 'Joël',
)

$usernameGroups = Array
(
    ['Uber'] => Array
        (
        ['PHPNut'] => 'Larry',
        ['gwoo'] => 'Gwoo',
        )

    ['Admin'] => Array
        (
        ['_psychic_'] => 'John',
        ['AD7six'] => 'Andy',
        ['jperras'] => 'Joël',
        )

)

function some_function() {
   ...
   $allCategories = $this->Category->find('threaded');
   $aCategory = $this->Category->find('first', array('conditions' => array('parent_id' => 42))); // not the root
   $someCategories = $this->Category->find('threaded', array(
    'conditions' => array(
        'Article.lft >=' => $aCategory['Category']['lft'],
        'Article.rght <=' => $aCategory['Category']['rght']
    )
   ));
   ...
}

Array
(
    [0] => Array
        (
            [ModelName] => Array
                (
                    [id] => 83
                    [parent_id] => null
                    [field1] => value1
                    [field2] => value2
                    [field3] => value3
                )

            [AssociatedModelName] => Array
                (
                    [id] => 1
                    [field1] => value1
                    [field2] => value2
                    [field3] => value3
                )
            [children] => Array
                (
            [0] => Array
            (
                [ModelName] => Array
                (
                    [id] => 42
                            [parent_id] => 83
                    [field1] => value1
                    [field2] => value2
                    [field3] => value3
                )

                [AssociatedModelName] => Array
                (
                    [id] => 2
                    [field1] => value1
                    [field2] => value2
                    [field3] => value3
                )
                    [children] => Array
                (
                )
                    )
            ...
                )
        )
)

function some_function() {
   $neighbors = $this->Article->find('neighbors', array('field' => 'id', 'value' => 3));
}

Array
(
    [prev] => Array
        (
            [ModelName] => Array
                (
                    [id] => 2
                    [field1] => value1
                    [field2] => value2
                    ...
                )
            [AssociatedModelName] => Array
                (
                    [id] => 151
                    [field1] => value1
                    [field2] => value2
                    ...
                )
        )
    [next] => Array
        (
            [ModelName] => Array
                (
                    [id] => 4
                    [field1] => value1
                    [field2] => value2
                    ...
                )
            [AssociatedModelName] => Array
                (
                    [id] => 122
                    [field1] => value1
                    [field2] => value2
                    ...
                )
        )
)

findAllBy¶

findAllBy(string $value)

これらの魔法のような関数はあるフィールドを指定してテーブルを検索するためのショートカットとして使用することができます。関数名の最後にキャメルケース形式のフィールド名を追加し、第1引数としてそのフィールド用の判定基準を与えてください。

findBy¶

findBy(string $value)

これらの魔法のような関数はあるフィールドを指定してテーブルを検索するためのショートカットとして使用することができます。関数名の最後にキャメルケース形式のフィールド名を追加し、第1引数としてそのフィールド用の判定基準を与えてください。

PHP4 は、大文字と小文字を区別しないため、この関数の使用方法は少々異なります:

findBy() 関数は find('first',...) と、 findAllBy() 関数は find('all',...) と似ています。

いずれの場合でも、返り値は配列となり、 find() または findAll() を実行したときと同じ形式になります。

query¶

query(string $query)

モデルの query() メソッドを使用すると独自の SQL 呼び出しを作成できます。

アプリケーションで独自の SQL クエリーを使用している場合、CakePHP の Sanitize ライブラリ(このマニュアルの後で説明されています)を必ず参照してください。SQL インジェクションやクロスサイトスクリプティング攻撃を防ぐためにユーザデータをきれいにする目的があります。

query() は、モデルの呼び出しとは本質的に分離した機能で、 $Model->cachequeries の状態に従いません。query を呼び出すにあたりキャッシングを無効にするには、query($query, $cachequeries = false) というように第2引数に false を設定します。

query() のクエリ文中ではモデル名でなく、テーブル名を使用し、返却される配列のキーもテーブル名になります。例えば、

$this->Picture->query("SELECT * FROM pictures LIMIT 2;");

これの戻り値は以下の通りです。

Array
(
    [0] => Array
        (
            [pictures] => Array
                (
                    [id] => 1304
                    [user_id] => 759
                )
        )

    [1] => Array
        (
            [pictures] => Array
                (
                    [id] => 1305
                    [user_id] => 759
                )
        )
)

配列のキー値にモデル名を使用し、Findメソッドを使用した時との一貫性を持たせる場合は、クエリは以下のようにします：

$this->Picture->query("SELECT * FROM pictures AS Picture LIMIT 2;");

戻り値は次のようになります。

Array
(
    [0] => Array
        (
            [Picture] => Array
                (
                    [id] => 1304
                    [user_id] => 759
                )
        )

    [1] => Array
        (
            [Picture] => Array
                (
                    [id] => 1305
                    [user_id] => 759
                )
        )
)

field¶

field(string $name, array $conditions = null, string $order = null)

$order の順に $conditions にマッチした最初のレコードから $name で指定した単一のフィールドの値を返します。 conditions が渡されておらず、モデルの id がセットされていた場合、現在のモデルの結果がフィールドの値として返されます。マッチしたレコードが見つからなかった場合、 false が返されます。

$model->id = 22;
echo $model->field('name'); // id が 22 の name が出力されます

echo $model->field('name', array('created <' => date('Y-m-d H:i:s')), 'created DESC'); // 最後に作成されたインスタンスの name が出力されます

read()¶

read($fields, $id)

read() is a method used to set the current model data (Model::$data)--such as during edits--but it can also be used in other circumstances to retrieve a single record from the database.

$fields is used to pass a single field name, as a string, or an array of field names; if left empty, all fields will be fetched.

$id specifies the ID of the record to be read. By default, the currently selected record, as specified by Model::$id, is used. Passing a different value to $id will cause that record to be selected.

read() always returns an array (even if only a single field name is requested). Use field to retrieve the value of a single field.

function beforeDelete($cascade) {
   ...
   $rating = $this->read('rating'); // gets the rating of the record being deleted.
   $name = $this->read('name', 2); // gets the name of a second record.
   $rating = $this->read('rating'); // gets the rating of the second record.
   $this->id = 3; //
   $this->read(); // reads a third record
   $record = $this->data // stores the third record in $record
   ...
}

Notice that the third call to read() fetches the rating of the same record read before. That is because read() changes Model::$id to any value passed as $id. Lines 6-8 demonstrate how read() changes the current model data. read() will also unset all validation errors on the model. If you would like to keep them, use find('first') instead.

The example above works if you run this code within the beforeDelete() method of the model itself. If you want to call read() from a controller, it would look something like this:

function article($action) {
   ...
   $this->Article->id = 3; //
   $this->Article->read(); // reads a third record
   $record = $this->Article->data // stores the third record in $record
   ...
}

複雑な find の条件¶

多くの場合モデルの find 呼び出しをする際に、様々な方法で検索条件のセットを渡すことになります。最も簡単な方法は、SQL の WHERE 句の抜粋を使用することです。もっと細かく制御する必要がある場合、配列を使用します。

配列を使用すると、すっきりと読みやすくなり、クエリーを作成しやすくなります。この構文はクエリーの要素(fields, values, operators など)を分離し、扱いやすくします。このおかげで CakePHP は最も効率よくクエリーを生成することが可能になり、適切な SQL 構文を保証し、クエリーの各部分を適切にエスケープすることができます。

ごく基本的な配列をベースにしたクエリは、次のようになります。:

$conditions = array("Post.title" => "This is a post");
//モデルでの使用例:
$this->Post->find($conditions);

この構造はどういうことを表すか一目瞭然です: title が "This is a post" と等しいすべての Post を検索します。フィールド名として "title" だけを使用することができますが、クエリーを構築する際に常にモデル名を指定する習慣をつけておきましょう。コードが明確になりますし、後にスキーマを変更した際の衝突を避けるのに役立ちます。

他の形式の条件についてはどうでしょうか？これも同じように簡単です。title が "This is a post" ではない Post をすべて検索してみましょう:

array("Post.title <>" => "This is a post")

フィールド名の次に続く '<>' に注意してください。CakePHP はあらゆる有効な SQL 比較演算子を解析することができます。たとえば、LIKE, BETWEEN, REGEX のような一致表現を含みます。ただし、フィールド名と演算子の間にはスペースが必要です。一つの例外は IN (...) 形式の条件です。さて、title が与えられた値に含まれる Post を検索してみましょう:

array(
    "Post.title" => array("First post", "Second post", "Third post")
)

与えた値以外の title で、NOT IN(...) によるマッチにより posts を検索する場合は次のようにします:

array(
    "NOT" => array( "Post.title" => array("First post", "Second post", "Third post") )
)

条件にフィルタを追加するには、キー/値を配列に追加するだけです:

array (
    "Post.title" => array("First post", "Second post", "Third post"),
    "Post.created >" => date('Y-m-d', strtotime("-2 weeks"))
)

データベース内の２つのフィールドを比較する検索を作成することもできます。

array("Post.created = Post.modified")

上記の例は、作成日付(created date)と更新日付(modified date)が等しい複数の Post を返します。（1度も更新されていない Post も返します）

このメソッドの中に WHERE 句として定義することができないものがあった場合(例えばブール値の操作)、文字列のようにして定義できることをおぼえておいてください:

array(
    'Model.field & 8 = 1',
    //other conditions as usual
)

デフォルトでは、CakePHP は複数の条件を AND で結合します。これは次のことを意味します。抜粋した上記コードは、２週間前に生成され、かつ title が与えられた値にマッチする Post だけを取得します。しかし、簡単にどちらかの条件にマッチする Post を検索することもできます。:

array( "or" => array (
    "Post.title" => array("First post", "Second post", "Third post"),
    "Post.created >" => date('Y-m-d', strtotime("-2 weeks"))
    )
)

CCake はすべての有効な SQL 演算子(AND, OR, NOT, XOR など)を使用できます。大文字でも小文字でもどちらでも構いません。これらの条件は無制限にネストすることができます。Posts と Authors に belongsTo の関連があるとします。あるキーワード (“magic”) を含むか、または2週間前に作成されたすべての Post のうち、 Bob によって記述された Post のみ取得してみましょう:

array (
    "Author.name" => "Bob",
    "or" => array (
        "Post.title LIKE" => "%magic%",
        "Post.created >" => date('Y-m-d', strtotime("-2 weeks"))
    )
)

Cake は値が null のフィールドをチェックすることもできます。この例では、クエリーは Post の title が null ではないレコードを返します:

array ("not" => array (
        "Post.title" => null,








    )
)

BETWEEN クエリーを処理するには、次のように使用することができます:

array('Post.id BETWEEN ?AND ?' => array(1,10))

注意: CakePHP は使用している DB のフィールドの型に依存して数値をクォートします。

GROUP BY はどのように行うのでしょうか?

array('fields'=>array('Product.type','MIN(Product.price) as price'), 'group' => 'Product.type');

DISTINCT クエリを用いた簡単な例は次のようになります。MIN() や MAX()、その他の演算子も、同じように扱えます。

array('fields'=>array('DISTINCT (User.name) AS my_column_name'), 'order'=>array('User.id DESC'));

とても複雑な条件を、ネストした複数の条件の配列によって作成することができます:

array(
   'OR' => array(
      array('Company.name' => 'Future Holdings'),
      array('Company.name' => 'Steel Mega Works')
   ),
   'AND' => array(
      array(
         'OR'=>array(
            array('Company.status' => 'active'),
            'NOT'=>array(
               array('Company.status'=> array('inactive', 'suspended'))
            )
         )
     )
   )
);

これは次のような SQL になります:

SELECT `Company`.`id`, `Company`.`name`,
`Company`.`description`, `Company`.`location`,
`Company`.`created`, `Company`.`status`, `Company`.`size`

FROM
   `companies` AS `Company`
WHERE
   ((`Company`.`name` = 'Future Holdings')
   OR
   (`Company`.`name` = 'Steel Mega Works'))
AND
   ((`Company`.`status` = 'active')
   OR (NOT (`Company`.`status` IN ('inactive', 'suspended'))))

サブクエリ(Sub-queries)

例えば、Usersテーブルに、id, name, statusカラムがあるとします。 ステータスの値は、A, B, Cのいずれかです。 この前提で、ステータスがB以外のユーザを、サブクエリを使って取得する例を挙げます。

サブクエリを使うには、モデルのDatasourceオブジェクトを取得し、クエリを組み立てます(DatasourceのbuildStatement()メソッドを利用して)。この返値は、SQL文がそのまま入ります。そのSQL文を使ってfindメソッドの条件(conditions)を組み立てます。

$conditionsSubQuery['`User2`.`status`'] = 'B';

$dbo = $this->User->getDataSource(); //Datasourceオブジェクトを取得

$subQuery = $dbo->buildStatement(
    array(
        'fields' => array('`User2`.`id`'),
        'table' => $dbo->fullTableName($this->User),
        'alias' => 'User2',
        'limit' => null,
        'offset' => null,
        'joins' => array(),
        'conditions' => $conditionsSubQuery,
        'order' => null,
        'group' => null
    ),
    $this->User
);
$subQuery = ' `User`.`id` NOT IN (' . $subQuery . ') ';
$subQueryExpression = $dbo->expression($subQuery);

$conditions[] = $subQueryExpression;

$this->User->find('all', compact('conditions'));

上記の条件を用いてfindメソッドを呼び出すと、下記のSQL文が発行されます

SELECT
    `User`.`id` ,
    `User`.`name` ,
    `User`.`status`
FROM
    `users` AS `User`
WHERE
    `User`.`id` NOT IN (
        SELECT
            `User2`.`id`
        FROM
            `users` AS `User2`
        WHERE
            `User2`.`status` = 'B'
    )

もし、SQLの条件式を直接記述したい場合は、Datasourceのexpression()メソッドを利用すれば、それをそのままfindメソッドの条件配列に渡すことができます。

関連モデル (hasOne, hasMany, belongsTo)のデータを保存する¶

あるモデルのデータを保存するとき、それに関連付いているモデルのデータも一緒に処理されるということを意識しておいてください。新しい Post とそれに関連した Comments を保存する場合、保存処理の実行中には Post と Comment モデルを両方とも使用します。

システムに、関連したモデルのレコードがまだ無い場合(たとえば、新しい User とそれに関連した Profile レコードを同時に保存した場合)、はじめに主となるモデル、または親モデルを保存する必要があります。

これがどのように動作するか理解するために、新しい User とそれに関連した Profile の保存を取り扱うアクションが UserController にある状態を考えてみましょう。次のアクションの例は、1つの User と1つの Profile を生成するのに(Form ヘルパーを使用して)十分なデータを POST によって取得したと仮定しています。

<?php
function add() {
    if (!empty($this->data)) {
        // User モデルのデータを保存します。
        // このデータは $this->data['User'] にあります。

        $user = $this->User->save($this->data);

        // User が保存されたら、Profile データに User の情報を追加し
        // 保存します。
        if (!empty($user)) {
            // 新しく生成した User の ID は、
            // $this->User->id にセットされます。
            $this->data['Profile']['user_id'] = $this->User->id;

            // User は Profile と hasOne のアソシエーションで関連付いているので
            // User モデルを通して Profile モデルにアクセスできます:
            $this->User->Profile->save($this->data);
        }
    }
}
?>

hasOne, hasMany, belongsTo の関連を扱う場合は、キーの処理が重要な点です。基本的な考えは、1つのモデルからキーを取得し、他のモデルの外部キーフィールドにそのキーを指定することです。save() の後にモデルクラスの $id 属性を使用する時もあれば、フォームの hidden フィールドからコントローラのアクションに POST された ID を使用する場合もあります。

上述した基本的なアプローチに加え、 CakePHP には saveAll() という、複数のモデルをバリデートし保存するとても便利なメソッドもあります。さらに、saveAll() は、データベース中のデータ整合性のためにトランザクションをサポートしています(つまり、1つのモデルの保存に失敗した場合、その他のモデルも保存されません)。

MySQL においてトランザクションを正しく機能させるには、テーブルが InnoDB エンジンである必要があります。MyISAM のテーブルはトランザクションをサポートしていないことに注意してください。

saveAll() を使って、Company と Account モデルを同時に保存する例を見てみましょう。

まず、Company と Account モデルのためのフォームを構築します(Company hasMany Account と仮定します)。

echo $form->create('Company', array('action'=>'add'));
echo $form->input('Company.name', array('label'=>'Company name'));
echo $form->input('Company.description');
echo $form->input('Company.location');

echo $form->input('Account.0.name', array('label'=>'Account name'));
echo $form->input('Account.0.username');
echo $form->input('Account.0.email');

echo $form->end('Add');

Account モデルに対するフォームフィールドの名前に注目してください。Company が主のモデルである場合、 saveAll() は関連したモデル(Account)のデータが特定のフォーマットで届くことを期待します。特定のフォーマットとは、 Account.0.fieldName といった形式のものです。

上述したフィールド名は hasMany アソシエーションにおいて必要となります。モデル間のアソシエーションが hasOne であるなら、関連したモデルのためのフィールド名は ModelName.fieldName という形式の名前にします。

これで companies_controller において add() アクションを作成する準備が整いました。

function add() {
   if(!empty($this->data)) {
      $this->Company->saveAll($this->data, array('validate'=>'first'));
   }
}

これで完了です。Company と Account モデルは、同時にバリデートされ保存されました。このとき array('validate'=>'first') を指定しておくと、両方のモデルに対するバリデーションが確実に行われます。

my_model_count

class Image extends AppModel {
    var $belongsTo = array(
        'ImageAlbum' => array('counterCache' => true)
    );
}

class Image extends AppModel {
    var $belongsTo = array(
        'ImageAlbum' => array(
            'counterCache' => true,
            'counterScope' => array('Image.active' => 1) // only count if "Image" is active = 1
    ));
}

関連モデルのデータ (HABTM) を保存する¶

hasOne, belongsTo hasMany によって関連付けられたモデルの保存はとても簡単です。ただ関連するモデルの foreign key のフィールドを付け加えるだけで、モデルの save() メソッドを呼び出せば、すべてが正しく結合して動作します。

HABTMでは、関連するモデルのIDを送信データにセットする必要があります。ここでは、新しい tag を作成し、ある recipe と関連付けるようリクエストを送信するフォームを考えます。

簡単なコード例は以下の様になります ($recipe_idにはすでに何らかの値が入っています)。

<?php echo $form->create('Tag');?>
    <?php echo $form->input(
        'Recipe.id',
        array('type'=>'hidden', 'value' => $recipe_id)); ?>
    <?php echo $form->input('Tag.name'); ?>
    <?php echo $form->end('Add Tag'); ?>

このように、tag と関連付けたい recipe の ID を Recipe.id という id の hidden field として付け加えます。

これで、controller で save() メソッドが呼ばれたときに、HABTM で関連付けられたデータが自動的にデータベースに保存されます。

function add() {

    //Save the association
    if ($this->Tag->save($this->data)) {
        //do something on success
    }
}

上記のコードで、新しい Tag が作成され、$this->data['Recipe']['id'] の ID を持つ Recipe に関連付けられます。

また、関連するデータの候補をドロップダウンリストで提示したいことがあるかもしれません。この場合はまず、データを find('list') メソッドを用いてモデルから抽出し、モデルの名前がついた view 変数にセットします。そして、同じ名前の入力フィールドを配置すれば、自動的にこれらのデータを <select> タグの中にセットします。

// in the controller:
$this->set('tags', $this->Recipe->Tag->find('list'));

// in the view:
$form->input('tags');

よりありそうな状況としては、複数選択可能な <select> タグで HABTM 関係にあるデータを扱うということが考えられます。例として、Recipe が複数の Tag を関係として持つことができる状況を考えます。この場合は、同じ方法でモデルのデータを抽出します、しかし入力フィールドの配置方法はすこし異なります。tag の名前は ModelName の方法で定義します (つまり、単語の区切りを大文字とした単数形の記法です)。

// in the controller:
$this->set('tags', $this->Recipe->Tag->find('list'));

// in the view:
$form->input('Tag');

上記のコードでは、複数選択可能なドロップダウンリストが作成され、選択された tag は Recipe に関連するものとしてデータベースに保存されます。

複雑な HABTM 関係になった場合、どのようにするべきか

デフォルトでは HABTM 関係のデータを保存する場合、Cake は一旦すべてのレコードを消去したあと、新しいものを追加します。例として Club に 10人の Children が関連付けられている場合を考えましょう。この後 Club に所属する children が所属する状態で更新したとします。この時、Club は 2人の children を持つ状態になります。12人ではありません。

また、join table (結合の情報を記述するテーブル) に (関係の作成時刻や、メタデータなどの) フィールドを付け加えたい場合にも言及しておきましょう。HABTM の join table に付け加える事もできますが、もっと簡単な方法もあります。

2つのモデルの HABTM 関係は、本当は、hasMany と belongTo による3つのモデルの関係を省略して表したものです。

次の例を見てください:

Child hasAndBelongsToMany Club

一方、Membership を加えて3つのモデルを使って関係を記述する場合は次の様になります:

Child hasMany Membership
Membership belongsTo Child, Club
Club hasMany Membership.

これら二つの例は内部的にはほとんど同じ事です。これらの例は、データベースで同じ数、同じ名前のフィールドを使用します。ただひとつ重要な違いは、同じ働きをする "join table" のためのモデルの名称が異なるということです。

join table に、ふたつの foreign key 以外のフィールドを持たせたい場合は、HABTM 関係の代わりに前述のような join table を使い、hasMany, belongTo 関係を使ってモデルの関係を構築するのが簡単でしょう。

delete¶

delete(int $id = null, boolean $cascade = true);

$id で指定されたレコードをを削除します。デフォルトでは、削除するレコードに依存したレコードも削除します。

たとえば、多くの Recipe レコードに結びついている User レコードを削除するとします:

• モデルの dependent の値が true にセットされており、$cascade が true の場合、関連する Recipe のレコードも削除されます。

• $cascade が false の場合、User のレコードを削除しても Recipe のレコードは削除されません。

deleteAll¶

deleteAll(mixed $conditions, $cascade = true)

deleteAll() 以外の del() や remove() と同様に、指定された条件にマッチするすべてのレコードを削除します。$conditions 配列は SQL 文かあるいは配列として指定することができます。

関連の形式¶

CakePHP で使用する関連の形式は: hasOne, hasMany, belongsTo, hasAndBelongsToMany (HABTM) の4つです。

関連は、定義したい関連の名前がついたクラス変数を生成することで定義します。クラス変数は単純に文字列とすることもできますが、関連の設定を定義するために多次元配列にすることもできます。

<?php

class User extends AppModel {
    var $name = 'User';
    var $hasOne = 'Profile';
    var $hasMany = array(
        'Recipe' => array(
            'className'  => 'Recipe',
            'conditions' => array('Recipe.approved' => '1'),
            'order'      => 'Recipe.created DESC'
        )
    );
}

?>

上記の例では、'Recipe' という単語の最初のインスタンスが 'エイリアス(別名)' になります。これは関係で使用する識別子となり、これを選択するだけで様々なことが実行できます。通常は、クラス名と同じ名前を選択しますが。ただしエイリアスは、単独のモデル内の belongsTo/hasMany または belongsTo/hasOne の関連において、ユニークでなければなりません。モデルのエイリアスにユニークでない名前を選択すると、不具合が発生します。

hasOne¶

では、User モデルを作成しましょう。このモデルは、Profile モデルと hasOne の関係があります。

まずはデータベーステーブルのキーが正確に設定されている必要があります。hasOne の関係が動作するには、あるテーブルは外部キーを持つ必要があり、そのキーはもう一方のレコードを指し示します。profile テーブルは、user_id というフィールドを持っています。基本的な形式は次のようになります:

Table: hasOne: 自分以外のモデルに外部キーが含まれる

User モデルファイルを /app/models/user.php に保存します。‘User hasOne Profile’の関係を定義するために、モデルクラスに $hasOne プロパティを追加します。/app/models/profile.php 内に Profile モデルを指定することを忘れないでください。そうしないと関連は動作しません。

<?php

class User extends AppModel {
    var $name = 'User';
    var $hasOne = 'Profile';
}
?>

モデルファイル内にこの関係を記述するには2つの方法があります。もっとも簡単な方法は、上記で指定したように関連モデルのクラス名を含む文字列を $hasOne プロパティにセットすることです。

より細かい制御が必要な場合、配列を使用して関連を定義します。たとえば、１つだけのレコードを含むように関連を限定したいというような場合です。

<?php

class User extends AppModel {
    var $name = 'User';
    var $hasOne = array(
        'Profile' => array(
            'className'    => 'Profile',
            'conditions'   => array('Profile.published' => '1'),
            'dependent'    => true
        )
    );
}
?>

hasOne 関連の配列で指定可能なキーは次の通りです:

• className: 現在のモデルに関連したモデルのクラス名。‘User hasOne Profile’ という関係を定義する場合、className キーは‘Profile’ になります。

• foreignKey: もう一方のモデルにある外部キーの名前。複数の hasOne 関係を定義する必要がある場合に特に便利です。このキーのデフォルト値は、現在のモデル名のアンダースコア区切りの単数形で、末尾に‘_id’をつけたものです。上記の例では、'user_id' となります。

• conditions: 関連モデルのレコードを限定するための SQL。SQL 内でモデル名を使用することを習慣にしておくようにしておきましょう:“approved = 1.” よりも、“Profile.approved = 1” の方が良い記述です。

• fields: 関連モデルのデータが取得された際に取り出すフィールドのリストです。デフォルトではすべてのフィールドを返します。

• dependent: dependent キーを true にセットし、delete() メソッドの cascade 引数を true をセットして呼び出すと、関連するモデルのレコードも併せて削除されます。この場合、true をセットしているので、User を削除すると、関連する Profile も削除します。

この関連を定義すると、User モデルの find は、関連した Profile モデルのレコードも(もし存在すれば)取り出します:

// $this->User->find() を呼び出した結果のサンプルArray
(
    [User] => Array
        (
            [id] => 121
            [name] => Gwoo the Kungwoo
            [created] => 2007-05-01 10:31:01
        )
    [Profile] => Array
        (
            [id] => 12
            [user_id] => 121
            [skill] => Baking Cakes
            [created] => 2007-05-01 10:31:01
        )
)

belongsTo¶

ここでは、User モデルから Profile のデータにアクセスします。User のデータに関連したデータにアクセスするために Profile モデルに belongsTo 関連を定義します。belongsTo 関連は、自然に hasOne や hasMany 関連の対になります: 他の方向からデータをみることができます。

データベースのテーブルに belongsTo 関係のためのキーを作成するには、次のような規則になります:

Table: belongsTo: 現在の モデルが外部キーをもちます

モデル（テーブル）が外部キーを持つ場合、そのモデルは他のモデル（テーブル）に属します。

次のような構文を使用して、/app/models/profile.php 内で Profile モデルに belongsTo 関連を定義することができます:

<?php

class Profile extends AppModel {
    var $name = 'Profile';
    var $belongsTo = 'User';
}
?>

配列を使用してより詳細な関係を定義することもできます。

<?php

class Profile extends AppModel {
    var $name = 'Profile';
    var $belongsTo = array(
        'User' => array(
            'className'    => 'User',
            'foreignKey'    => 'user_id'
        )
    );
}
?>

belongsTo 関連の配列で有効なキーは以下のようになります:

• className: 現在のモデルに関連したモデルのクラス名。‘Profile belongsTo User’ という関係を定義する場合、className キーは‘User’になります。

• foreignKey: 現在のモデルにある外部キー名。複数の belongsTo 関係を定義する必要がある場合に、これは特に便利です。このキーのデフォルト値は、他のモデル名のアンダースコアで区切られた単数形で、末尾に‘_id’が付きます。

• conditions: 関連モデルのレコードを限定するために使用する SQL。SQL にモデル名を使用するのは良い習慣となります: “User.active = 1” は常に“active = 1”よりも推奨されます。

• fields: 関連モデルのデータを取得した際に取り出すフィールドのリスト。デフォルトではすべてのフィールドを返します。

• counterCache: (bool) true にセットすると、save() または delete() が呼び出されるたびに、関連モデルは自動的に外部テーブルの“[singular_model_name]_count”というフィールドをインクリメントまたはデクリメントします。カウンタフィールドの値は関連する行の番号を表します。

この関連が定義されると、Profile モデルの find 操作は、存在する場合は関連する User レコードを取得するでしょう:

//Sample results from a $this->Profile->find() call.

Array
(
   [Profile] => Array
        (
            [id] => 12
            [user_id] => 121
            [skill] => Baking Cakes
            [created] => 2007-05-01 10:31:01
        )
    [User] => Array
        (
            [id] => 121
            [name] => Gwoo the Kungwoo
            [created] => 2007-05-01 10:31:01
        )
)

hasMany¶

次のステップに進みましょう: “User hasMany Comment” という関連を定義します。 hasMany 関連を定義すると、User レコードを取得する際に、ユーザのコメントも取得できます。

データベースのテーブルに hasMany 関係のためのキーを作成するには、次のような規則で行います:

hasMany: 自分以外のモデルに外部キーが含まれる

関係

スキーマ

User hasMany Comment

Comment.user_id

Cake hasMany Virtue

Virtue.cake_id

Product hasMany Option

Option.product_id

次のような構文を使用して、/app/models/user.php 内で User モデルに hasMany 関連を定義することができます。

<?php

class User extends AppModel {
    var $name = 'User';
    var $hasMany = 'Comment';
}
?>

配列を使用してより詳細な関係を定義することもできます。

<?php

class User extends AppModel {
    var $name = 'User';
    var $hasMany = array(
        'Comment' => array(
            'className'     => 'Comment',
            'foreignKey'    => 'user_id',
            'conditions'    => array('Comment.status' => '1'),
            'order'    => 'Comment.created DESC',
            'limit'        => '5',
            'dependent'=> true
        )
    );
}
?>

hasMany 関連の配列で指定可能なキーは次の通りです:

• className: 現在のモデルに関連したモデルのクラス名。‘User hasMany Comment’ という関係を定義する場合、className キーは‘Comment’ になります。

• foreignKey: もう一方のモデルにある外部キーの名前。複数の hasMany 関係を定義する必要がある場合に特に便利です。このキーのデフォルト値は、現在のモデル名のアンダースコア区切りの単数形で、末尾に‘_id’をつけたものです。

• conditions: 関連モデルのレコードを限定するための SQL。SQL 内でモデル名を使用することを習慣にしておくようにしておきましょう:“status = 1.” よりも、“Comment.status = 1” の方が良い記述です。

• fields: 関連モデルのデータが取得された際に取り出すフィールドのリストです。デフォルトではすべてのフィールドを返します。

• order: 返される関連する行の並び順を定義する SQL。.

• limit: 返して欲しい関連する行の最大数。

• offset: 与えられた現在の条件と順番で関連したモデルのレコードを取り出す時に、スキップする行の数。

• dependent: dependent キーが true にセットされると、再帰的なモデルの削除が可能になります。この例の場合、Comment レコードは、関連する User レコードが削除されたときに、同時に削除されます。

  再帰的な削除をするためには、 Model->delete() メソッドの第2パラメータを true にセットしなければなりません。

• exclusive: exclusive が true にセットされると、再帰的なモデルの削除は、各エントリーを個別に削除するのではなく、deleteAll() の呼び出しによって削除されます。

• finderQuery: 関連モデルのレコードを取得するために CakePHP が使用できる完全な SQL。これは独自の結果が必要な場合に使用します。

この関連を定義すると、User モデルの find は、関連した Comment モデルのレコードも(もし存在すれば)取り出します:

// $this->User->find() を呼び出した結果のサンプルArray
(
    [User] => Array
        (
            [id] => 121
            [name] => Gwoo the Kungwoo
            [created] => 2007-05-01 10:31:01
        )
    [Comment] => Array
        (
            [0] => Array
                (
                    [id] => 123
                    [user_id] => 121
                    [title] => On Gwoo the Kungwoo
                    [body] => The Kungwooness is not so Gwooish
                    [created] => 2006-05-01 10:31:01
                )
            [1] => Array
                (
                    [id] => 123
                    [user_id] => 121
                    [title] => More on Gwoo
                    [body] => But what of the ‘Nut?                    [created] => 2006-05-01 10:41:01
                )
        )
)

1つ覚えておいてほしいのは、両方の方向からデータを取得するためには、Comment が User と belongsTo 関連である必要があるということです。この章で述べてきたことは、User から Comment データを取得することができるということです。Comment モデル内で User と belongsTo 関連を追加すると、Comment モデルから User データを取得できます - 接続が完全であれば、どちらかのモデルからみても情報を流すことができます。

hasAndBelongsToMany (HABTM)¶

さて、この時点で、すでに CakePHP におけるモデルの関連付けの専門家になっていることでしょう。すでに3つの関連に精通し、オブジェクトの関連付けの大半を学んできました。

それでは最後の関連である hasAndBelongsToMany もしくは HABTM に取り組みましょう。この関連が使用されるのは、2つのモデルがあり、それらがさまざまな方法で繰り返し何度も連携する必要がある場合です。

hasMany と HABTM の間の主な違いは、HABTM 内のモデル間の結びつきが排他的ではないということです。たとえば、HABTM を使用して Recipe モデルが Tag モデルと連携するとします。おばあちゃんのニョッキ(訳注:イタリアの伝統料理)レシピに "Italian" というタグを割り当てても、タグを「使い切る」ことにはなりません。蜂蜜でテカテカの BBQ スパゲッティにも、"Italian" とタグ付けできます。

hasMany 関連のオブジェクトの間の結びつきは排他的です。User が Comment と hasMany である場合、コメントは特定のユーザにのみ結び付けられます。あるユーザに結びついたコメントは、もう他のユーザに結びつけることはできません。

先に進めましょう。HABTM 関連を扱うには、追加のテーブルをデータベースにセットアップする必要があります。この新しい追加のテーブルの名前は、両方のモデルの名前が含まれており、それらをアルファベット順に並べてアンダースコア(「_」)で繋げたものにします。テーブルは少なくも2つのフィールドを含み、それぞれの外部キー(integer にすべき)が各モデルの主キーである必要があります。問題を避けるために、これら2つのフィールドを複合主キーにしないでください。アプリケーションにおいてそうする必要がある場合は、ユニークなインデックスを定義します。このテーブルに何か情報を追加する場合は、他のモデルと同じように簡単に扱えるよう、主キーのフィールド(規約上は「id」という名前のフィールド)を追加するとよいでしょう。

HABTM 両方のモデル名を含んだテーブルを追加する必要があります

テーブル名は規約によりアルファベット順です。

新しいテーブルが作成されると、モデルのファイルに HABTM 関連を定義できます。ここでは、文字列による定義ではなく、配列の構文を使いましょう:

<?php

class Recipe extends AppModel {
    var $name = 'Recipe';
    var $hasAndBelongsToMany = array(
        'Tag' =>
            array(
                 'className'              => 'Tag',
                 'joinTable'              => 'recipes_tags',
                 'with'                   => '',
                'foreignKey'             => 'recipe_id',
                'associationForeignKey'  => 'tag_id',
                'unique'                 => true,
                'conditions'             => '',
                'fields'                 => '',
                'order'                  => '',
                'limit'                  => '',
                'offset'                 => '',
                'finderQuery'            => '',
                'deleteQuery'            => '',
                'insertQuery'            => ''
            )
    );
}
?>

HABTM 関連の配列で指定可能なキーは次の通りです:

• className: 現在のモデルに関連したモデルのクラス名。‘Recipe HABTM Tag’ という関係を定義する場合、className キーは‘Tag’ になります。

• joinTable: 関連で使用する結合テーブルの名前(もし HBTM の結合テーブル名が規約に従っていない場合)

• with: 結合テーブルのモデル名の定義。デフォルトでは CakePHP は自動的にモデルを生成します。上述の例だと、RecipesTag が呼び出されます。デフォルトの名前を上書きするために、このキーを使います。結合テーブルのモデルは、あらゆる「通常の」モデルのように、結合テーブルへアクセスするために使用することができます。

• foreignKey: 現在のモデルにある外部キーの名前。複数の HABTM 関係を定義する必要がある場合に特に便利です。このキーのデフォルト値は、現在のモデル名のアンダースコア区切りの単数形で、末尾に‘_id’をつけたものです。

• associationForeignKey: もう一方のモデルにある外部キーの名前。複数の HABTM 関係を定義する必要がある場合に特に便利です。このキーのデフォルト値は、もう一方のモデル名のアンダースコア区切りの単数形で、末尾に‘_id’をつけたものです。

• unique: もし true(デフォルト)なら、Cake は更新を行う際、外部キーのテーブルに新たなレコードを挿入する前に既存の関連レコードを削除します。したがって、更新を行う際には、既存の関連するレコードをもう一度渡す必要があります。

• conditions: 関連モデルのレコードを限定するための SQL。SQL 内でモデル名を使用することを習慣にしておくようにしておきましょう:“status = 1.” よりも、“Comment.status = 1” の方が良い記述です。

• fields: 関連モデルのデータが取得された際に取り出すフィールドのリストです。デフォルトではすべてのフィールドを返します。

• order: 返される関連する行の並び順を定義する SQL。.

• limit: 返して欲しい関連する行の最大数。

• offset: 与えられた現在の条件と順番で関連したモデルのレコードを取り出す時に、スキップする行の数。

• finderQuery, deleteQuery, insertQuery: 関連モデルのレコードを取得・削除・生成するために CakePHP が使用できる完全な SQL。これは独自の結果が必要な場合に使用します。

この関連を定義すると、Recipe モデルの find は、関連した Tag モデルのレコードも(もし存在すれば)取り出します:

// $this->Recipe->find() を呼び出した結果のサンプルArray
(
    [Recipe] => Array
        (
            [id] => 2745
            [name] => Chocolate Frosted Sugar Bombs
            [created] => 2007-05-01 10:31:01
            [user_id] => 2346
        )
    [Tag] => Array
        (
            [0] => Array
                (
                    [id] => 123
                    [name] => Breakfast
                )
           [1] => Array
                (
                    [id] => 124
                    [name] => Dessert
                )
           [2] => Array
                (
                    [id] => 125
                    [name] => Heart Disease
                )
        )
)

Tag モデルを使用する際に Recipe データを取得したい場合は、Tag モデルに HABTM の関連を定義することを覚えておいてください。

HABTM 関連に基づいた独自の find クエリを実行することもできます。次の例をみてください:

上記の例と同じ構造(Recipe HABTM Tag)を仮定し、'Dessert' タグをもつすべての Recipe を取得したいとします。これを達成できる一つの方法(ただし悪い方法)は、アソシエーションそのものに検索する条件を適用することです:

$this->Recipe->bindModel(array(
    'hasAndBelongsToMany' => array(
        'Tag' => array('conditions'=>array('Tag.name'=>'Dessert'))
)));
$this->Recipe->find('all');

//Data Returned
Array
(
    0 => Array
        {
        [Recipe] => Array
            (
                [id] => 2745
                [name] => Chocolate Frosted Sugar Bombs
                [created] => 2007-05-01 10:31:01
                [user_id] => 2346
            )
        [Tag] => Array
            (
               [0] => Array
                    (
                        [id] => 124
                        [name] => Dessert
                    )
            )
    )
    1 => Array
        {
        [Recipe] => Array
            (
                [id] => 2745
                [name] => Crab Cakes
                [created] => 2008-05-01 10:31:01
                [user_id] => 2349
            )
        [Tag] => Array
            (
            }
        }
}

この例では "Dessert" タグがついた全てのレシピしか返せないことに注意してください。これをきちんと達成するには、いくつかの方法があります。一つの方法は、Recipe ではなく Tag モデルを検索し、関連付いた Recipe も全て取得する方法です。

$this->Recipe->Tag->find('all', array('conditions'=>array('Tag.name'=>'Dessert')));

与えられた ID を検索するために、CakePHP が提供する結合テーブルのモデルを使うことも出来ます。

$this->Recipe->bindModel(array('hasOne' => array('RecipesTag')));
$this->Recipe->find('all', array(
        'fields' => array('Recipe.*'),
        'conditions'=>array('RecipesTag.tag_id'=>124) // id of Dessert
));

フィルタリングを行うために必要な数の結合を生成するために、風変わりな関連付けを作成することもできます。例を見てください:

$this->Recipe->bindModel(array(
    'hasOne' => array(
        'RecipesTag',
        'FilterTag' => array(
            'className' => 'Tag',
            'foreignKey' => false,
            'conditions' => array('FilterTag.id = RecipesTag.tag_id')
))));
$this->Recipe->find('all', array(
        'fields' => array('Recipe.*'),
        'conditions'=>array('FilterTag.name'=>'Dessert')
));

両方の例は、次のデータを返します:

//Data Returned
Array
(
    0 => Array
        {
        [Recipe] => Array
            (
                [id] => 2745
                [name] => Chocolate Frosted Sugar Bombs
                [created] => 2007-05-01 10:31:01
                [user_id] => 2346
            )
    [Tag] => Array
        (
            [0] => Array
                (
                    [id] => 123
                    [name] => Breakfast
                )
           [1] => Array
                (
                    [id] => 124
                    [name] => Dessert
                )
           [2] => Array
                (
                    [id] => 125
                    [name] => Heart Disease
                )
        )
}

同じようなバインディングトリックで、 HABTM モデルのページ付けを簡単にすることができます。一点だけ注意が必要です。ページ付けで2つのクエリ(レコードの数を数えるものと、実際のデータを取得するもの)が必要な場合、必ず bindModel(); の false パラメータをセットしてください。こうすることで、デフォルトのビヘイビアのように、単一ではなく複数のクエリにまたがってモデルの関連が維持されます。詳細は API に関する文書を参照してください。

アソシエーションをその場で取り扱うことについての詳しい情報は、その場でアソシエーションを生成、廃棄の章を参照してください。

その時々の目的に応じて、これらのテクニックを組み合わせたり適用してください。

hasMany through (The Join Model)¶

It is sometimes desirable to store additional data with a many to many association. Consider the following

Student hasAndBelongsToMany Course Course hasAndBelongsToMany Student

In other words, a Student can take many Courses and a Course can be taken my many Students. This is a simple many to many association demanding a table such as this

id | student_id | course_id

Now what if we want to store the number of days that were attended by the student on the course and their final grade? The table we'd want would be

id | student_id | course_id | days_attended | grade

The trouble is, hasAndBelongsToMany will not support this type of scenario because when hasAndBelongsToMany associations are saved, the association is deleted first. You would lose the extra data in the columns as it is not replaced in the new insert.

The way to implement our requirement is to use a join model, otherwise known (in Rails) as a hasMany through association. That is, the association is a model itself. So, we can create a new model CourseMembership. Take a look at the following models.

student.php

class Student extends AppModel
{
    public $hasMany = array(
        'CourseMembership'
    );

    public $validate = array(
        'first_name' => array(
            'rule' => 'notEmpty',
            'message' => 'A first name is required'
        ),
        'last_name' => array(
            'rule' => 'notEmpty',
            'message' => 'A last name is required'
        )
    );
}

course.php

class Course extends AppModel
{
    public $hasMany = array(
        'CourseMembership'
    );

    public $validate = array(
        'name' => array(
            'rule' => 'notEmpty',
            'message' => 'A course name is required'
        )
    );
}

course_membership.php

class CourseMembership extends AppModel
{
    public $belongsTo = array(
        'Student', 'Course'
    );

    public $validate = array(
        'days_attended' => array(
            'rule' => 'numeric',
            'message' => 'Enter the number of days the student attended'
        ),
        'grade' => array(
            'rule' => 'notEmpty',
            'message' => 'Select the grade the student received'
        )
    );
}

The CourseMembership join model uniquely identifies a given Student's participation on a Course in addition to extra meta-information.

Working with join model data¶

Now that the models have been defined, let's see how we can save all of this. Let's say the Head of Cake School has asked us the developer to write an application that allows him to log a student's attendance on a course with days attended and grade. Take a look at the following code.

controllers/course_membership_controller.php

class CourseMembershipsController extends AppController
{
    public $uses = array('CourseMembership');

    public function index() {
        $this->set('course_memberships_list', $this->CourseMembership->find('all'));
    }

    public function add() {

        if (! empty($this->data)) {

            if ($this->CourseMembership->saveAll(
                $this->data, array('validate' => 'first'))) {


                $this->redirect(array('action' => 'index'));
            }
        }
    }
}

views/course_memberships/add.ctp

<?php echo $form->create('CourseMembership'); ?>
    <?php echo $form->input('Student.first_name'); ?>
    <?php echo $form->input('Student.last_name'); ?>
    <?php echo $form->input('Course.name'); ?>
    <?php echo $form->input('CourseMembership.days_attended'); ?>
    <?php echo $form->input('CourseMembership.grade'); ?>
    <button type="submit">Save</button>
<?php echo $form->end(); ?>

You can see that the form uses the form helper's dot notation to build up the data array for the controller's save which looks a bit like this when submitted.

Array
(
    [Student] => Array
        (
            [first_name] => Joe
            [last_name] => Bloggs
        )

    [Course] => Array
        (
            [name] => Cake
        )

    [CourseMembership] => Array
        (
            [days_attended] => 5
            [grade] => A
        )

)

Cake will happily be able to save the lot together and assigning the foreign keys of the Student and Course into CourseMembership with a saveAll call with this data structure. If we run the index action of our CourseMembershipsController the data structure received now from a find('all') is:

Array
(
    [0] => Array
        (
            [CourseMembership] => Array
                (
                    [id] => 1
                    [student_id] => 1
                    [course_id] => 1
                    [days_attended] => 5
                    [grade] => A
                )

            [Student] => Array
                (
                    [id] => 1
                    [first_name] => Joe
                    [last_name] => Bloggs
                )

            [Course] => Array
                (
                    [id] => 1
                    [name] => Cake
                )

        )

)

There are of course many ways to work with a join model. The version above assumes you want to save everything at-once. There will be cases where you want to create the Student and Course independently and at a later point associate the two together with a CourseMembership. So you might have a form that allows selection of existing students and courses from picklists or ID entry and then the two meta-fields for the CourseMembership, e.g.

views/course_memberships/add.ctp

<?php echo $form->create('CourseMembership'); ?>
    <?php echo $form->input('Student.id', array('type' => 'text', 'label' => 'Student ID', 'default' => 1)); ?>
    <?php echo $form->input('Course.id', array('type' => 'text', 'label' => 'Course ID', 'default' => 1)); ?>
    <?php echo $form->input('CourseMembership.days_attended'); ?>
    <?php echo $form->input('CourseMembership.grade'); ?>
    <button type="submit">Save</button>
<?php echo $form->end(); ?>

And the resultant POST

Array
(
    [Student] => Array
        (
            [id] => 1
        )

    [Course] => Array
        (
            [id] => 1
        )

    [CourseMembership] => Array
        (
            [days_attended] => 10
            [grade] => 5
        )

)

Again Cake is good to us and pulls the Student id and Course id into the CourseMembership with the saveAll.

Join models are pretty useful things to be able to use and Cake makes it easy to do so with its built-in hasMany and belongsTo associations and saveAll feature.

その場でアソシエーションを生成、廃棄¶

その場でモデルのアソシエーションを生成したり廃棄したりする必要がときどきあります。例えば、次のような理由があります:

• 取ってくる関連データを減らしたいが、すべてのアソシエーションが第一レベルのrecursionで設定されている。

• 関連データをソートしたりフィルタリングしたりするために、アソシエーションの設定を変えたい。

このアソシエーションの生成や廃棄は、CakePHP のbindModel()やunbindModel()などのモデルメソッドを使って実現できます。（"Containable" という非常に便利なビヘイビアもあります。詳細は組み込みのビヘイビアについてのマニュアルを参照してください）では、モデルを設定してみて、bindModel() や unbindModel() がどのように動作するかを見てみましょう。２つのモデルで始めます:

<?php

class Leader extends AppModel {
    var $name = 'Leader';

    var $hasMany = array(
        'Follower' => array(
            'className' => 'Follower',
            'order'     => 'Follower.rank'
        )
    );
}

?>

<?php

class Follower extends AppModel {
    var $name = 'Follower';
}

?>

LeadersController では、Leader やそれに関連する Follower を取得するために、Leader モデル内の find() メソッドを使用できます。上記に示したように、Leader モデル内の 関連配列には "Leader hasMany Followers" という関係を定義しています。デモとして、コントローラのアクション内でその関連を廃棄するために unbindModel() を使用してみましょう。

function someAction() {
    // これは Leader を取得して、Follower も取得します
    $this->Leader->findAll();

    // hasMany を削除しましょう
    $this->Leader->unbindModel(
        array('hasMany' => array('Follower'))
    );

    // ここで find 関数を使用すると、
    // Leaders を返しますが、Follower は返しません。
    $this->Leader->findAll();

    // 注意: unbindModel はすぐ次の find 関数にのみ影響します。
    // その次の find 呼び出しは設定済みの関連情報を使用して
    // 呼び出されます。

    // unbindModel() の後にすでに findAll() を使用してしまったので、
    // ここでは Leader とともに関連する Follower も取得されます。
    $this->Leader->findAll();
}

もう１点。第２引数に false をセットしない限り、bindModel() や unbindModel() を使用した関連の削除や追加は、 次の モデル操作のみに作用します。第２引数が false にセットされると、bind は指定されたままの状態になります。次に unbindModel() の基本的な使用方法のパターンを示します:

$this->Model->unbindModel(
    array('associationType' => array('associatedModelClassName'))
);

その場でアソシエーションを削除できたので、今度は追加してみましょう。まだ何も設定されていない Leader には Principle（"指導方針"） を関連づけないといけません。Principle モデルのモデルファイルは、変数 $name 以外の設定は書き込まれていません。その場で Leader に Principleモデルを関連付けてみましょう。（しかし次の find 操作にのみ影響することを忘れないでください）この関数は LeadersController 内にあります:

function anotherAction() {
    // leader.php モデルファイル内には
    // Leader hasMany Principle がないのでここでは
    // Leader のみ取得します。
    $this->Leader->findAll();

    // bindModel() を使用して Leader モデルに新しい関連を
    // 追加しましょう:
    $this->Leader->bindModel(
        array('hasMany' => array(
                'Principle' => array(
                    'className' => 'Principle'
                )
            )
        )
    );

    // 正しく関連付けされたので
    // １回の find 関数で Leader を取得すると
    // 関連する Principle も取得されます:
    $this->Leader->findAll();
}

bindModel() の基本的な使い方は、通常の関連配列と同じで、キーは作成しようとしている関連の種類の後に記述します:

$this->Model->bindModel(
        array('associationName' => array(
                'associatedModelClassName' => array(
                    // 通常の関連のキーをここに記述します
                )
            )
        )
    );

新しく結合されたモデルは、モデルファイル内に関連の定義は必要ありませんが、適切に新しい関連が動作するためには正しくキーを設定する必要があります。

Multiple relations to the same model¶

There are cases where a Model has more than one relation to another Model. For example you might have a Message model that has two relations to the User model. One relation to the user that sends a message, and a second to the user that receives the message. The messages table will have a field user_id, but also a field recipient_id. Now your Message model can look something like:

<?php
class Message extends AppModel {
    var $name = 'Message';
    var $belongsTo = array(
        'Sender' => array(
            'className' => 'User',
            'foreignKey' => 'user_id'
        ),
        'Recipient' => array(
            'className' => 'User',
            'foreignKey' => 'recipient_id'
        )
    );
}
?>

Recipient is an alias for the User model. Now let's see what the User model would look like.

<?php
class User extends AppModel {
    var $name = 'User';
    var $hasMany = array(
        'MessageSent' => array(
            'className' => 'Message',
            'foreignKey' => 'user_id'
        ),
        'MessageReceived' => array(
            'className' => 'Message',
            'foreignKey' => 'recipient_id'
        )
    );
}
?>

It is also possible to create self associations as shown below.

<?php
class Post extends AppModel {
    var $name = 'Post';

    var $belongsTo = array(
        'Parent' => array(
            'className' => 'Post',
            'foreignKey' => 'parent_id'
        )
    );

    var $hasMany = array(
        'Children' => array(
            'className' => 'Post',
            'foreignKey' => 'parent_id'
        )
    );
}
?>

An alternate method of associating a model with itself (without assuming a parent/child relationship) is to have both the $belongsTo and $hasMany relationships of a model each to declare an identical alias, className, and foreignKey [property].

<?php
class MySchema extends CakeSchema {
    public $users = array (
        'id' => array ('type' => 'integer', 'default' => null, 'key' => 'primary'),
        'username' => array ('type' => 'string', 'null' => false, 'key' => 'index'),
        // more schema properties...
        'last_user_id' => array ('type' => 'integer', 'default' => null, 'key' => 'index'),

        'indexes' => array (
            'PRIMARY' => array ('column' => 'id', 'unique' => true),
            // more keys...
            'last_user' => array ('column' => 'last_user_id', 'unique' => false)
        )
    );
}

class User extends AppModel {
    public $hasMany = array (
        'Tag' => array (
            'foreignKey' => 'last_user_id'
        ),
        // more hasMany relationships...
        'LastUser' => array (
            'className' => 'User',
            'foreignKey' => 'last_user_id'
        )
    );
    public $belongsTo = array (
        // in most cases this would be the only belongsTo relationship for this model
        'LastUser' => array (
            'className' => 'User',
            'foreignKey' => 'last_user_id',
            'dependent' => true
        )
    );
}
?>

Reasoning [for this particular self-association method]: Say there are many models which contain the property $modelClass.lastUserId. Each model has the foreign key last_user_id, a reference to the last user that updated/modified the record in question. The model User also contains the same property (last_user_id), since it may be neat to know if someone has committed a security breach through the modification of any User record other than their own (you could also use strict ACL behaviors).

Fetching a nested array of associated records:

If your table has parent_id field you can also use `find('threaded') <https://book.cakephp.org/view/1023/find-threaded>`_ to fetch nested array of records using a single query without setting up any associations.

Joining tables¶

In SQL you can combine related tables using the JOIN statement. This allows you to perform complex searches across multiples tables (i.e: search posts given several tags).

In CakePHP some associations (belongsTo and hasOne) perform automatic joins to retrieve data, so you can issue queries to retrieve models based on data in the related one.

But this is not the case with hasMany and hasAndBelongsToMany associations. Here is where forcing joins comes to the rescue. You only have to define the necessary joins to combine tables and get the desired results for your query.

Remember you need to set the recursion to -1 for this to work. I.e: $this->Channel->recursive = -1;

To force a join between tables you need to use the "modern" syntax for Model::find(), adding a 'joins' key to the $options array. For example:

$options['joins'] = array(
    array('table' => 'channels',
        'alias' => 'Channel',
        'type' => 'LEFT',
        'conditions' => array(
            'Channel.id = Item.channel_id',
        )
    )
);

$Item->find('all', $options);

Note that the 'join' arrays are not keyed.

In the above example, a model called Item is left joined to the channels table. You can alias the table with the Model name, so the retrieved data complies with the CakePHP data structure.

The keys that define the join are the following:

• table: The table for the join.

• alias: An alias to the table. The name of the model associated with the table is the best bet.

• type: The type of join: inner, left or right.

• conditions: The conditions to perform the join.

With joins, you could add conditions based on Related model fields:

$options['joins'] = array(
    array('table' => 'channels',
        'alias' => 'Channel',
        'type' => 'LEFT',
        'conditions' => array(
            'Channel.id = Item.channel_id',
        )
    )
);

$options['conditions'] = array(
    'Channel.private' => 1
);

$privateItems = $Item->find('all', $options);

You could perform several joins as needed in hasBelongsToMany:

Suppose a Book hasAndBelongsToMany Tag association. This relation uses a books_tags table as join table, so you need to join the books table to the books_tags table, and this with the tags table:

$options['joins'] = array(
    array('table' => 'books_tags',
        'alias' => 'BooksTag',
        'type' => 'inner',
        'conditions' => array(
            'Books.id = BooksTag.books_id'
        )
    ),
    array('table' => 'tags',
        'alias' => 'Tag',
        'type' => 'inner',
        'conditions' => array(
            'BooksTag.tag_id = Tag.id'
        )
    )
);

$options['conditions'] = array(
    'Tag.tag' => 'Novel'
);

$books = $Book->find('all', $options);

Using joins with Containable behavior could lead to some SQL errors (duplicate tables), so you need to use the joins method as an alternative for Containable if your main goal is to perform searches based on related data. Containable is best suited to restricting the amount of related data brought by a find statement.

beforeFind¶

beforeFind(mixed $queryData)

find 関連の操作の前に呼び出されます。このコールバックに渡される $queryData は現在のクエリーについての情報を持っています: conditions, fields などです

find 操作を開始したくない場合（おそらく $queryData オプションに関連した決定に基づきます）、false を返します。もしそうでない場合は、変更した $queryData を返すか、find に渡したいものやそれ相応のものを返します。

ユーザの役割（権限）に基づき find 操作を制限したり、現在の読み込みに基づきキャッシュを作成するかどうかを決定したりするために、このコールバックは使われるでしょう。

afterFind¶

afterFind(array $results, bool $primary)

find から返された結果を変更するため、あるいは他の find の後にロジックを実行するためにこのコールバックを使用します。このコールバックに渡された $results パラメータには、モデルの find から返された結果が含まれます。たとえば次のようなものです:

$results = array(
  0 => array(
    'ModelName' => array(
      'field1' => 'value1',
      'field2' => 'value2',
    ),
  ),
);

このコールバックの返り値は、このコールバックを呼び出した find の結果(を加工したもの)にするべきです。

$primary が false の場合、$results のフォーマットは期待するものとは少し異なります。通常の find の結果の代わりに次のようになります:

$results = array(
  'field_1' => 'value',
  'field_2' => 'value2'
);

再帰的に find を使用した場合、$primary が true であると期待しているコードは "Cannot use string offset as an array" という fatal エラーになるでしょう。

afterFind によってデータをフォーマットする例を次に示します。

function afterFind($results) {
    foreach ($results as $key => $val) {
        if (isset($val['Event']['begindate'])) {
            $results[$key]['Event']['begindate'] = $this->dateFormatAfterFind($val['Event']['begindate']);
        }
    }
    return $results;
}

function dateFormatAfterFind($dateString) {
    return date('d-m-Y', strtotime($dateString));
}

beforeValidate¶

beforeValidate()

バリデートされる前にモデルのデータを変更するか、必要に応じてバリデーションルールを変更するために、このコールバックを使用します。この関数は true を返さなければなりません。そうでない場合、現在の save() の実行が中断されます。

beforeSave¶

beforeSave()

この関数に保存前のロジックを置きます。この関数はモデルのデータがバリデートに成功した後、データが保存される前に実行されます。save の処理を継続するには、この関数は true を返す必要があります。

このコールバックは、データが保存される前にそのデータを加工する場合、特に便利です。ストレージエンジンが特別な形式の日付を必要とする場合、$this->data でアクセスし、変更します。

afterSave によってどのようにデータを加工するかの例を次に示します。この例におけるコードは、begindate がデータベース中では YYYY-MM-DD という書式で、アプリケーションにおいては DD-MM-YYYY という書式にするコードです。もちろん、この変更は簡単に行えます。このコードを適切なモデルにおいて使用します。

function beforeSave() {
    if(!empty($this->data['Event']['begindate']) && !empty($this->data['Event']['enddate'])) {
            $this->data['Event']['begindate'] = $this->dateFormatBeforeSave($this->data['Event']['begindate']);
            $this->data['Event']['enddate'] = $this->dateFormat($this->data['Event']['enddate']);
    }
    return true;
}

function dateFormatBeforeSave($dateString) {
    return date('Y-m-d', strtotime($dateString)); // Direction is from
}

beforeSave() が true を返すようにしてください。そうしないと save は失敗します。

afterSave¶

afterSave(boolean $created)

各 save 操作の後に実行する必要のあるロジックがある場合、このコールバックメソッドに置きます。

新しいオブジェクトが（更新ではなく）生成された場合、$created は true になります。

beforeDelete¶

beforeDelete()

この関数に 削除前ロジックを置きます。削除を継続したい場合は、この関数は true を返す必要があります。アボートしたい場合は false を返します。

afterDelete¶

afterDelete()

このコールバックメソッドに、削除の後に実行したいロジックを置きます。

onError¶

onError()

問題が起こった場合に呼び出されます。