エントリー

YiiとNode.jsのファンであるすべてのKhabrovitesにこんにちは。
これは、 Jiiフレームワーク（ GitHub ）に関する2番目の記事です。 前回の記事では、データアクセスオブジェクトとクエリビルダーについて説明しました。
約束どおり、この記事ではActive Recordの使用について説明します。

アクティブな記録

Active Recordは、データベースに保存されたデータにアクセスして操作するためのオブジェクト指向インターフェースを提供します。 Active Recordクラスはデータベーステーブルに関連付けられ、クラスのインスタンスはこのテーブルの行に対応し、属性はこの行の特定の列の値です。 SQLステートメントを明示的に記述する代わりに、データを操作するActive Recordの属性とメソッドにアクセスできます。

テーブル `customer`に関連付けられたActive Recordクラス` app.models.Customer`があり、 `name`はテーブル` customer`の列の名前だとします。 次のコードを記述して、 `customer`テーブルに新しい行を追加できます。

var customer = new app.models.Customer(); customer.name = 'Vladimir'; customer.save(); 

これは、次のコードと同等です。このコードでは、書き込み時にさらにミスを犯したり、さまざまなタイプのデータとの非互換性がある場合があります。

 db.createCommand('INSERT INTO `customer` (`name`) VALUES (:name)', { ':name': 'Vladimir', }).execute(); 

アクティブレコードクラスの宣言

始めるには、 Jii.sql.ActiveRecordを継承してActive Recordクラスを宣言します。 各Active Recordクラスはデータベーステーブルに関連付けられているため、このクラスでは、静的なJii.sql.ActiveRecord.tableName（）メソッドをオーバーライドして、クラスが関連付けられているテーブルを示す必要があります。

次の例では、テーブル `customer`に対して` app.models.Customer`という名前のクラスを宣言します。

 var Jii = require('jii'); /** * @class app.models.Customer * @extends Jii.sql.ActiveRecord */ Jii.defineClass('app.models.Customer', /** @lends app.models.Customer.prototype */{ __extends: Jii.sql.ActiveRecord, __static: /** @lends app.models.Customer */{ tableName: function() { return 'customer'; } } }); 

Active Recordクラスはモデルなので、通常はActive Recordクラスを `models`名前空間に配置します。

Jii.sql.ActiveRecordクラスはJii.base.Modelを継承します。 つまり 、属性、検証ルール、データシリアル化などのモデルの機能をすべて*すべて継承します。

データベース接続の作成

デフォルトでは、Active Recordは `db` アプリケーションコンポーネントを使用します 。これにはJii.sql.BaseConnectionのインスタンスが含まれており、データベース内のデータを読み取り、変更します。 前の記事の「データベースアクセスオブジェクト」セクションで説明したように、次のように `db`アプリケーションコンポーネントを設定できます。

 return { components: { db: { className: 'Jii.sql.mysql.Connection', host: '127.0.0.1', database: 'testdb', username: 'demo', password: 'demo', charset: 'utf8', } } }; 

別のデータベース接続を使用する場合は、 Jii.sql.ActiveRecord.getDb（）メソッドをオーバーライドする必要があります。

 /** * @class app.models.Customer * @extends Jii.sql.ActiveRecord */ Jii.defineClass('app.models.Customer', /** @lends app.models.Customer.prototype */{ __extends: Jii.sql.ActiveRecord, __static: /** @lends app.models.Customer */{ STATUS_INACTIVE: 0, STATUS_ACTIVE: 1, // ... getDb: function() { // use the "db2" application component return Jii.app.db2; } } }); 

データサンプリング

Active Recordクラスを宣言した後、これを使用して、対応するデータベーステーブルからデータをクエリできます。
これを行うには、次の3つのアクションを実行する必要があります。

1. Jii.sql.ActiveRecord.find（）メソッドを呼び出して、新しいクエリオブジェクトを作成します。
2.要求を作成するためのメソッドを呼び出して、要求オブジェクトを生成します。
3.クエリメソッドの1つを呼び出して、アクティブレコードレコードの形式でデータを取得します。

これらのアクションは、クエリデザイナで作業するときのアクションと非常に似ています。 唯一の違いは、リクエストオブジェクトを作成するには、 Jii.sql.ActiveRecord.find（）メソッドを呼び出す必要があり、 `new`を介してインスタンスを作成する必要がないことです。

Active Queryを使用してデータを取得する方法を示すいくつかの例を見てみましょう。

 //    ID 123 // SELECT * FROM `customer` WHERE `id` = 123 app.models.Customer.find() .where({id: 123}) .one() .then(function(customer) { // ... }); //    ,   ID // SELECT * FROM `customer` WHERE `status` = 1 ORDER BY `id` app.models.Customer.find() .where({status: app.models.Customer.STATUS_ACTIVE}) .orderBy('id') .all() .then(function(customers) { // ... }); //     // SELECT COUNT(*) FROM `customer` WHERE `status` = 1 app.models.Customer.find() .where({status': app.models.Customer.STATUS_ACTIVE}) .count() .then(function(count) { // ... }); //      ,    ID  // SELECT * FROM `customer` app.models.Customer.find() .indexBy('id') .all() .then(function(customers) { // ... }); 

IDによるモデルの取得を簡素化するために、メソッドが作成されました：

• Jii.sql.ActiveRecord.findOne（） ：クエリ結果の最初の行に対応するアクティブレコードインスタンスを返します。
• Jii.sql.ActiveRecord.findAll（） ：クエリ結果の行に対応する複数のアクティブレコードの配列またはオブジェクトを返します。

両方のメソッドは、次の形式の最初の引数を受け入れます。

• スカラー値：値は、検索されている主キーの値と見なされます。 主キーは、データベーススキーマから自動的に決定されます。
• スカラー値の配列：配列は、検索される主キーの値と見なされます。 -キーが列の名前であり、値が検索される列の値に対応するオブジェクト。

次の例は、これらのメソッドの使用方法を示しています。

 //    ID 123 // SELECT * FROM `customer` WHERE `id` = 123 app.models.Customer .findOne(123) .then(function(customer) { // ... }); //   ID 100, 101, 123  124 // SELECT * FROM `customer` WHERE `id` IN (100, 101, 123, 124) app.models.Customer .findAll([100, 101, 123, 124]) .then(function(customers) { // ... }); //     ID 123 // SELECT * FROM `customer` WHERE `id` = 123 AND `status` = 1 app.models.Customer .findOne({ id: 123, status: app.models.Customer.STATUS_ACTIVE }) .then(function(customer) { // ... }); //     // SELECT * FROM `customer` WHERE `status` = 0 app.models.Customer .findAll({ status: app.models.Customer.STATUS_INACTIVE }) .then(function(customers) { // ... }); 

注： Jii.sql.ActiveRecord.findOne（）もJii.sql.ActiveQuery.one（）も、SQL式に「LIMIT 1」を追加しません。 リクエストが本当に多くのデータを返すことができる場合、制限を設定するために、たとえば `app.models.Customer.find（）。Limit（1）.one（）`のように、 `limit（1）`を呼び出す必要があります。

また、通常のSQLクエリを使用してデータを取得し、Active Recordに入力することもできます。 これを行うには、 Jii.sql.ActiveRecord.findBySql（）メソッドを使用します。

 //     var sql = 'SELECT * FROM customer WHERE status=:status'; app.models.Customer .findBySql(sql, {':status': app.models.Customer.STATUS_INACTIVE}) .all() .then(function(customers) { // ... }); 

Jii.sql.ActiveRecord.findBySql（）を呼び出した後、クエリ作成メソッドを呼び出さないでください。これらは無視されます。

データアクセス

前述のように、アクティブレコードインスタンスにはSQLクエリの結果からのデータが入力され、クエリ結果の各行は1つのアクティブレコードインスタンスに対応します。 Active Record属性を介して列の値にアクセスできます。たとえば、

 //   "id"  "email"   "customer" app.models.Customer .findOne(123) .then(function(customer) { var id = customer.get('id'); var email = customer.get('email'); }); 

オブジェクトのデータを取得する

データをアクティブレコードとして取得するのは便利ですが、アクティブレコードインスタンスの作成に費やされるメモリ消費が大きいため、最適でない場合があります。 この場合、それらを通常のオブジェクトとして取得できます。そのためには、 Jii.sql.ActiveQuery.asArray（）メソッドを呼び出す必要があります。

実際、JavaScriptでは、オブジェクトで満たされた配列を取得します。 したがって、 asObject（）メソッドを呼び出す方がより適切であり、そのようなメソッド（同義語）があります。 しかし、Yii 2 APIを保存するために、 asArray（）メソッドは残されています。

 //   ,    //    app.models.Customer.find() .asArray() // alias is asObject() .all() .then(function(customers) { // ... }); 

データ保存

Active Recordを使用して、次の手順に従ってデータベースにデータを保存できます。

1. Active Recordのインスタンスを取得または作成します。
2. 属性に新しい値を設定する
3. Jii.sql.ActiveRecord.save（）メソッドを呼び出してデータを保存します。

例えば

 //      var customer = new app.models.Customer(); customer.set('name', 'James'); customer.set('email', 'james@example.com'); customer.save().then(function(success) { return app.models.Customer.findOne(123); }).then(function(customer) { //   customer.set('email', 'james@newexample.com'); return customer.save(); }).then(function(success) { // ... }); 

Jii.sql.ActiveRecord.save（）メソッドは、アクティブレコードの状態に応じて、行データを追加または更新できます。 インスタンスが「new」演算子を使用して作成された場合、メソッドは新しい行を追加します。 インスタンスがfind（）メソッドを介して取得され、それに類似している場合、またはsave（）メソッドが以前に呼び出された場合、 save（）メソッド
データを更新します。

データ検証

Jii.sql.ActiveRecordクラスはJii.base.Modelを継承しているため、データ検証を使用できます。 Jii.sql.ActiveRecord.rules（）メソッドをオーバーライドして実装ルールを設定し、 Jii.sql.ActiveRecord.validate（）メソッドを介して値が正しいことを確認できます。

Jii.sql.ActiveRecord.save（）メソッドを呼び出すと、デフォルトで、 Jii.sql.ActiveRecord.validate（）メソッドが自動的に呼び出されます。 検証済みのデータのみをデータベースに保存する必要があります。 データが正しくない場合、メソッドは「 false 」を返し、 Jii.sql.ActiveRecord.getErrors（）メソッドなどを通じてエラーを受け取る場合があります。

複数の属性を変更する

通常のモデルと同様に、Active Recordインスタンスはオブジェクト転送による属性の変更もサポートしています。 このメソッドを使用すると、1つのメソッドを呼び出すことにより、複数のアクティブレコード属性の値を割り当てることができます。 安全な属性のみを大規模に割り当てることができることに注意してください。

 var values = { name: 'James', email: 'james@example.com' }; var customer = new app.models.Customer(); customer.setAttributes(values); customer.save(); 

変更された属性

Jii.sql.ActiveRecord.save（）メソッドを呼び出すと、変更されたActive Record属性のみが保存されます。 値が変更された場合、属性は変更されたと見なされます。 変更された属性の存在に関係なく、データ検証が実行されることに注意してください。

Active Recordは、変更された属性のリストを自動的に保存します。 古いバージョンの属性を保存し、最新バージョンと比較します。 変更された属性を取得するには、 Jii.sql.ActiveRecord.getDirtyAttributes（）メソッドを使用します。

古い属性値を取得するには、 Jii.sql.ActiveRecord.getOldAttributes（）またはJii.sql.ActiveRecord.getOldAttribute（）メソッドを呼び出します。

デフォルト値

テーブルの一部の列には、データベースで定義されたデフォルト値が含まれている場合があります。 Jii.sql.ActiveRecord.loadDefaultValues（）メソッドを呼び出すことにより、これらの値をActive Recordに事前入力できます。 この方法は同期的です データベーススキーマは、接続が開かれるときにプリロードされます。

 var customer = new app.models.Customer(); customer.loadDefaultValues(); // customer.get('xyz')   `xyz`    -   `xyz`. 

複数の行を更新する

上記のメソッドは、Active Recordインスタンスで機能します。 複数の行を一度に更新するには、静的なJii.sql.ActiveRecord.updateAll（）メソッドを呼び出します。

 // UPDATE `customer` SET `status` = 1 WHERE `email` LIKE `%@example.com%` app.models.Customer.updateAll({status: app.models.Customer.STATUS_ACTIVE}, {'like', 'email', '@example.com'}); 

データ削除

テーブルから行を削除するには、この行に対応するActive RecordインスタンスでJii.sql.ActiveRecord.delete（）メソッドを呼び出す必要があります。

 app.models.Customer .findOne(123) .then(function(customer) { customer.delete(); }); 

静的メソッドJii.sql.ActiveRecord.deleteAll（）を呼び出して、条件ごとに多くの行を削除できます。
例えば

 app.models.Customer.deleteAll({status: app.models.Customer.STATUS_INACTIVE}); 

関連データを操作する

Active Recordは、個々のデータベーステーブルでの作業に加えて、プライマリデータを介してデータをリンクできます。 たとえば、顧客データを注文に関連付けることができます。 Active Recordで対応する接続​​を宣言すると、式「customer.load（ 'orders'）」を使用して顧客注文に関する情報を取得でき、出力では「app.models.Order」のインスタンスの配列を取得できます。

依存関係の宣言

Active Recordを使用してリレーショナルデータを操作するには、最初にActive Recordクラスでリレーションを宣言する必要があります。 例えば

 /** * @class app.models.Customer * @extends Jii.sql.ActiveRecord */ Jii.defineClass('app.models.Customer', /** @lends app.models.Customer.prototype */{ // ... getOrders: function() { return this.hasMany(app.models.Order.className(), {customer_id: 'id'}); } }); /** * @class app.models.Order * @extends Jii.sql.ActiveRecord */ Jii.defineClass('app.models.Order', /** @lends app.models.Order.prototype */{ // ... getCustomer: function() { return this.hasOne(app.models.Customer.className(), {id: 'customer_id'}); } }); 

上記のコードでは、クラス `app.models.Customer`に対してリレーション` orders`を、クラス `app.models.Order`に対してリレーション` customer`を宣言しました。

各リレーションメソッドは、 `getXyz`（get +小文字の最初の文字でリレーションの名前）として名前を付ける必要があります。 リレーションシップ名は*大文字と小文字を区別することに注意してください*。

関連して、次の情報を提供する必要があります。

• 通信の多重度： Jii.sql.ActiveRecord.hasMany（）またはJii.sql.ActiveRecord.hasOne（）メソッドを呼び出すときに指定されます。 上記の例では、顧客には多数の注文があり、注文には顧客が1人しかいません。
• 関連付けられたクラスActive Record：の名前は、上記のメソッドの最初のパラメーターとして示されます。 `Xyz.className（）`を介してクラス名を取得し、まず関係を構築する段階でクラスの存在を確認し、次にIDEが書き込み時にクラス名を通知することをお勧めします。
• 2つのテーブルスキーマ間の関係：2つのデータ型がリンクされる列を定義します。 オブジェクト値はプライマリデータ列であり、キーは関連データ列です。

関連データへのアクセス

関係を宣言した後、関係の名前を使用して関連データにアクセスできます。 関連データがすでにアクティブレコードにロードされていることが確実な場合は、 get（）メソッドを介してオブジェクトのプロパティにアクセスするのと同じ方法で関連アクティブレコードを取得できます。 それ以外の場合は、 Jii.sql.ActiveRecord.load（）メソッドを使用して関連データをロードすることをお勧めします。これにより、常に `Promise`オブジェクトが返されますが、接続が以前にロードされている場合は追加のリクエストはデータベースに送信されません。

 // SELECT * FROM `customer` WHERE `id` = 123 app.models.Customer .findOne(123) .then(function(customer) { // SELECT * FROM `order` WHERE `customer_id` = 123 return customer.load('orders'); }) .then(function(orders) { // orders -    `app.models.Order` }); 

リレーションがJii.sql.ActiveRecord.hasMany（）メソッドによって宣言されている場合、これらのリレーションはActive Recordインスタンスの配列（または空の配列）で表されます。 Jii.sql.ActiveRecord.hasOne（）メソッドの場合、これらのリレーションはActive Recordインスタンスまたはデータが利用できない場合は「null」によって表されます。

初めてリレーションにアクセスすると、上記の例に示すように、データベースでSQLクエリが実行されます。 繰り返しの異議申し立てでは、リクエストは実行されません。

追加のテーブル（ジャンクションテーブル）を介したリレーション

データベースをモデル化するときに、2つの多対多テーブル間にリレーションシップがある場合、通常、追加のテーブル- ジャンクションテーブルが追加されます。 たとえば、テーブル「order」とテーブル「item」は、テーブル「order_item」を使用してリンクできます。

このような関係を宣言するときは、追加のテーブルでJii.sql.ActiveQuery.via（）またはJii.sql.ActiveQuery.viaTable（）メソッドを呼び出す必要があります。 これらの方法の違いは、前者は現在の関係名の観点から遷移表を示すのに対し、後者は表を直接補完することです。 例えば

 /** * @class app.models.Order * @extends Jii.sql.ActiveRecord */ Jii.defineClass('app.models.Order', /** @lends app.models.Order.prototype */{ // ... getItems: function() { return this.hasMany(app.models.Item.className(), {id: 'item_id'}) .viaTable('order_item', {order_id: 'id'}); } }); 

または代わりに

 /** * @class app.models.Order * @extends Jii.sql.ActiveRecord */ Jii.defineClass('app.models.Order', /** @lends app.models.Order.prototype */{ // ... getOrderItems: function() { return this.hasMany(app.models.OrderItem.className(), {order_id: 'id'}); }, getItems: function() { return this.hasMany(app.models.Item.className(), {id: 'item_id'}) .via('orderItems'); } }); 

追加のテーブルで宣言された関係の使用は、通常の関係に似ています。 例えば

 // SELECT * FROM `order` WHERE `id` = 100 app.models.Order .findOne(100) .then(function(order) { // SELECT * FROM `order_item` WHERE `order_id` = 100 // SELECT * FROM `item` WHERE `item_id` IN (...) return order.load('items'); }) .then(function(items) { // items -   `app.models.Item` }); 

遅延読み込みと貪欲な読み込み

関連データアクセスセクションでは、 get（）またはload（）メソッドを使用してActive Recordからリレーションにアクセスする方法について説明しました。 SQLクエリは、関連付けられたデータに最初にアクセスしたときにのみデータベースに送信されます。 このようなデータの読み込み方法は、遅延読み込みと呼ばれます。
例えば

 // SELECT * FROM `customer` WHERE `id` = 123 app.models.Customer .findOne(123) .then(function(customer) { // SELECT * FROM `order` WHERE `customer_id` = 123 customer.load('orders').then(function(orders) { // SQL    return customer.load('orders'); }).then(function(orders2) { //   ,      <i>get()</i>. var orders3 = customer.get('orders'); }); }); 

遅延ロードは非常に便利に使用できます。 ただし、Active Recordの複数のインスタンスの関連レコードにアクセスする必要がある場合、これはパフォーマンスの問題を引き起こす可能性があります。 次のコード例を考えてみてください。いくつのSQLクエリが実行されますか？

 // SELECT * FROM `customer` LIMIT 100 app.models.Customer.find() .limit(100) .all() .then(function(customers) { return Promise.all(customers.map(function(customer) { // SELECT * FROM `order` WHERE `customer_id` = ... return customer.load('orders'); })); }).then(function(result) { var firstOrder = result[0][0]; // ... }); 

この例では、101個のSQLクエリが実行されます！ クライアントアプリケーションごとに個別のリクエストを受信するためです。 このパフォーマンスの問題を解決するには、以下に示す*欲張り*アプローチを使用できます。

 // SELECT * FROM `customer` LIMIT 100; // SELECT * FROM `orders` WHERE `customer_id` IN (...) app.models.Customer.find() .with('orders') .limit(100) .all() .then(function(customers) { customers.forEach(function(customer) { //  SQL  var orders = customer.get('orders'); }); }); 

マスターレコードとともに1つ以上の関係をアップロードできます。 すぐにネストされた関係をアップロードすることもできます。 たとえば、「apps.models.Customer」が「orders」という関係を通じて「app.models.Order」に関連付けられ、「app.models.Order」が「items」から「Item」に関連付けられている場合です。 `app.models.Customer`をリクエストするとき、 with（）メソッドで ` orders.items`を指定することで、すぐに `items`リレーションをロードできます。

次のコードは、 Jii.sql.ActiveQuery.with（）のさまざまな使用法を示しています。 クラス `app.models.Customer`には` orders`と `country`の2つの関係があり、クラス` app.models.Order`には `items`の関係があると仮定します。

 //    "orders"  "country" app.models.Customer.find() .with('orders', 'country') .all() .then(function(customers) { // ... }); //      app.models.Customer.find() .with(['orders', 'country']) .all() .then(function(customers) { //  SQL  var orders = customers[0].get('orders'); var country = customers[0].get('country'); }); //    "orders"    "orders.items" app.models.Customer.find() .with('orders.items') .all() .then(function(customers) { //         //  SQL  var items = customers[0].get('orders')[0].get('items'); }); 

「abcd」などの強制的にネストされた関係をロードできます。 すべての親関係が強制的にロードされます。

関係を貪欲にロードする場合、匿名関数を渡すことにより、対応するリクエストをカスタマイズできます。 例えば

 //          // SELECT * FROM `customer` // SELECT * FROM `country` WHERE `id` IN (...) // SELECT * FROM `order` WHERE `customer_id` IN (...) AND `status` = 1 app.models.Customer.find() .with({ country: 'country', orders: function (query) { query.andWhere({'status': app.models.Order.STATUS_ACTIVE}); } }) .all() .then(function(customers) { // ... }); 

通信用のリレーショナルクエリを設定する場合、オブジェクトのキーとしてリレーションシップの名前を指定し、対応するオブジェクトの値として匿名関数を使用する必要があります。 匿名関数の最初の引数は、 Jii.sql.ActiveQueryオブジェクトであるクエリパラメーターになります。 上記の例では、注文のステータスに追加の条件を追加してリクエストを変更します。

逆関係

Active Recordクラス間の関係は、しばしば互いに逆の関係にあります。 たとえば、クラス「app.models.Customer」はリレーション「orders」を介して「app.models.Order」にリンクされ、クラス「app.models.Order」はリレーションシップ「customer」を介してクラス「app.models.Customer」にリンクされます。

 /** * @class app.models.Customer * @extends Jii.sql.ActiveRecord */ Jii.defineClass('app.models.Customer', /** @lends app.models.Customer.prototype */{ // ... getOrders: function() { return this.hasMany(app.models.Order.className(), {customer_id: 'id'}); } }); /** * @class app.models.Order * @extends Jii.sql.ActiveRecord */ Jii.defineClass('app.models.Order', /** @lends app.models.Order.prototype */{ // ... getCustomer: function() { return this.hasOne(app.models.Customer.className(), {id: 'customer_id'}); } }); 

次に、次のコードスニペットについて考えます。

 // SELECT * FROM `customer` WHERE `id` = 123 app.models.Customer .findOne(123) .then(function(customer) { // SELECT * FROM `order` WHERE `customer_id` = 123 return customer.load('orders'); }).then(function(orders) { var order = orders[0]; // SELECT * FROM `customer` WHERE `id` = 123 return order.load('customer'); }).then(function(customer2) { //  "not the same" console.log(customer2 === customer ? 'same' : 'not the same'); }); 

「customer」オブジェクトと「customer2」オブジェクトは同じであると想定していますが、実際にはそうではありません。それらは異なるインスタンスで同じデータを含んでいます。「order.customer」にアクセスすると、追加のSQLクエリが実行され、新しいオブジェクト「customer2」が取得されます。

上記の例で最後のSQLクエリの冗長な実行を避けるために、Jii.sql.ActiveQuery.inverseOf（）メソッドを使用して、 `customer`が* ordersに*逆に依存*することを示す必要があります。

 /** * @class app.models.Customer * @extends Jii.sql.ActiveRecord */ Jii.defineClass('app.models.Customer', /** @lends app.models.Customer.prototype */{ // ... getOrders: function() { return this.hasMany(app.models.Order.className(), {customer_id: 'id'}).inverseOf('customer'); } }); 

これらの変更後、以下を受け取ります。

 // SELECT * FROM `customer` WHERE `id` = 123 app.models.Customer .findOne(123) .then(function(customer) { // SELECT * FROM `order` WHERE `customer_id` = 123 return customer.load('orders'); }).then(function(orders) { var order = orders[0]; // SELECT * FROM `customer` WHERE `id` = 123 return order.load('customer'); }).then(function(customer2) { //  "same" console.log(customer2 === customer ? 'same' : 'not the same'); }); 

注：オプションのジャンクションテーブルで宣言された多対多リレーションシップでは、逆リレーションシップは機能しません。

依存関係の保存

リレーショナルデータを使用する場合、多くの場合、異なるデータ間にリレーションシップを追加するか、既存のリレーションシップを削除する必要があります。これを行うには、関係を定義する列に正しい値を設定します。Active Recordを使用すると、次のようなことができます。

 app.models.Customer .findOne(123) .then(function(customer) { var order = new app.models.Order(); order.subtotal = 100; // ... //  ,   "customer"  `app.models.Order`  . order.customer_id = customer.id; order.save(); }); 

Active RecordはJii.sql.ActiveRecord.link（）メソッドを提供します。これにより、これをよりエレガントに行うことができます。

 app.models.Customer .findOne(123) .then(function(customer) { var order = new app.models.Order(); order.subtotal = 100; // ... order.link('customer', customer); }); 

Jii.sql.ActiveRecord.link（）メソッドは、リレーションシップの名前と、レコードが接続されるアクティブレコードインスタンスを予期します。このメソッドは、アクティブレコードの2つのインスタンスを接続し、それらをデータベースに保存します。上記の例では、 `customer_id`属性を` app.models.Order`に設定します。

注：新しく作成された2つのActive Recordインスタンスをリンクすることはできません。

Jii.sql.ActiveRecord.link（）メソッドを使用する利点は、追加のテーブルを使用してリレーションシップが決定されるとさらに明白になります。たとえば、次のコードを使用して、「app.models.Order」のインスタンスを「app.models.Item」に関連付けることができます。

 order.link('items', item); 

このコードは、テーブル `order_item`に行を自動的に追加してリンクを作成します。

Active Recordの2つのインスタンスのリンクを解除するには、Jii.sql.ActiveRecord.unlink（）| unlink（）メソッドを使用します。
例えば

 app.models.Customer.find() .with('orders') .all() .then(function(customer) { customer.unlink('orders', customer.get('orders')[0]); }); 

デフォルトでは、Jii.sql.ActiveRecord.unlink（）メソッドはリレーションを指定するキーの値を「null」に設定します。ただし、テーブルから行を削除するには、「isDelete」パラメーターを「true」として渡すことができます。

結論として

現時点では、トランザクションはJiiのActive Recordに実装されていません。そのことは必要であり、したがって、今後表示されるでしょう。前の記事で
述べたように、Jiiはオープンソースプロジェクトですので、誰かがJiiの開発に参加してくれたらとても嬉しいです。affka@affka.ruに書き込みます。ウェブサイトのフレームワーク- jiiframework.ru GitHubの- github.com/jiisoft