Skip to content

Y
yii2
Commit 469c9688 by 东方孤思子（Paris·QianSen）
Options

Use a slightly more recent version

parent df82aabe
Showing with 152 additions and 196 deletions
docs/guide-zh-CN/db-active-record.md
Active Record（活动记录）
Active Record
=============
> 注意：该章节还在开发中。
[Active Record](http://zh.wikipedia.org/wiki/Active_Record) （活动记录，以下简称AR）提供了一个面向对象的接口，
用以访问数据库中的数据。一个 AR 类关联一张数据表，
每个 AR 对象对应表中的一行，对象的属性（即 AR 的特性Attribute）映射到数据行的对应列。
......@@ -94,7 +96,7 @@ $customer->save();
----------------------
AR 用一个 [[yii\db\Connection|DB connection]] 对象与数据库交换数据。
它使用 `db` 组件作为其连接对象。详见[数据库基础](database-basics.md)章节，
默认的，它使用 `db` 组件作为其连接对象。详见[数据库基础](database-basics.md)章节，
你可以在应用程序配置文件中设置下 `db` 组件，就像这样，
......@@ -164,22 +166,28 @@ $sql = 'SELECT * FROM customer';
$customers = Customer::findBySql($sql)->all();
```
> 小贴士：在上面的代码中，`Customer::STATUS_ACTIVE` 是一个在 `Customer` 类里定义的常量。（译者注：这种常量的值一般都是tinyint）相较于直接在代码中写死字符串或数字，使用一个更有意义的常量名称是一种更好的编程习惯。
> 小技巧：在上面的代码中，`Customer::STATUS_ACTIVE` 是一个在 `Customer` 类里定义的常量。（译者注：这种常量的值一般都是tinyint）相较于直接在代码中写死字符串或数字，使用一个更有意义的常量名称是一种更好的编程习惯。
`find()` 方法也支持用一种简化的用法，让你直接通过主键的值或者一系列其他字段值的数组来获取 AR 对象。
主要的不同点在于，
它并不返回 [[yii\db\ActiveQuery]] 对象，而是基于输入的字段值，直接返回一个 AR 对象
而无需调用 `one()` 方法。
有两个快捷方法：`findOne` 和 `findAll()` 用来返回一个或者一组`ActiveRecord`实例。前者返回第一个匹配到的实例，后者返回所有。
例如：
```php
// 返回ID为1的客户：
$customer = Customer::find(1);
// 返回 id 为 1 的客户
$customer = Customer::findOne(1);
// 返回ID为1的活跃客户：
$customer = Customer::find([
// 返回 id 为 1 且状态为 *active* 的客户
$customer = Customer::findOne([
'id' => 1,
'status' => Customer::STATUS_ACTIVE,
]);
// 返回id为1、2、3的一组客户
$customers = Customer::findAll([1, 2, 3]);
// 返回所有状态为 "deleted" 的客户
$customer = Customer::findAll([
'status' => Customer::STATUS_DELETED,
]);
```
### 以数组形式获取数据
......@@ -241,19 +249,22 @@ AR 銝瘜隞亙銝 AR 蝐餅
```php
// 插入新客户的记录
$customer = new Customer();
$customer->name = '詹姆斯';
$customer->email = '007@example.com';
$customer->name = 'James';
$customer->email = 'james@example.com';
$customer->save(); // 等同于 $customer->insert();
// 更新现有客户记录
$customer = Customer::find($id);
$customer->email = '邦德@demo.com';
$customer = Customer::findOne($id);
$customer->email = 'james@example.com';
$customer->save(); // 等同于 $customer->update();
// 删除已有客户记录
$customer = Customer::find($id);
$customer = Customer::findOne($id);
$customer->delete();
// 删除多个年龄大于20，性别为男（Male）的客户记录
Customer::deleteAll('age > :age AND gender = :gender', [':age' => 20, ':gender' => 'M']);
// 所有客户的age（年龄）字段加1：
Customer::updateAllCounters(['age' => 1]);
```
......@@ -267,40 +278,33 @@ Customer::updateAllCounters(['age' => 1]);
### 数据输入与有效性验证
Because Active Record extends from [[yii\base\Model]], it supports the same data input and validation features
as described in [Model](model.md). For example, you may declare validation rules by overwriting the
[[yii\base\Model::rules()|rules()]] method; you may massively assign user input data to an Active Record instance;
and you may call [[yii\base\Model::validate()|validate()]] to trigger data validation.
由于AR继承自[[yii\base\Model]]，所以它同样也支持[Model](model.md)的数据输入、验证等特性。例如，你可以声明一个rules方法用来覆盖掉[[yii\base\Model::rules()|rules()]]里的；你也可以给AR实例批量赋值；你也可以通过调用[[yii\base\Model::validate()|validate()]]执行数据验证。
When you call `save()`, `insert()` or `update()`, these methods will automatically call [[yii\base\Model::validate()|validate()]].
If the validation fails, the corresponding data saving operation will be cancelled.
当你调用 `save()`、`insert()`、`update()` 这三个方法时，会自动调用[[yii\base\Model::validate()|validate()]]方法。如果验证失败，数据将不会保存进数据库。
The following example shows how to use an Active Record to collect/validate user input and save them into database:
下面的例子演示了如何使用AR 获取/验证用户输入的数据并将他们保存进数据库：
```php
// creating a new record
// 新建一条记录
$model = new Customer;
if ($model->load(Yii::$app->request->post()) && $model->save()) {
// the user input has been collected, validated and saved
// 获取用户输入的数据，验证并保存
}
// updating a record whose primary key is $id
$model = Customer::find($id);
// 更新主键为$id的AR
$model = Customer::findOne($id);
if ($model === null) {
throw new NotFoundHttpException;
}
if ($model->load(Yii::$app->request->post()) && $model->save()) {
// the user input has been collected, validated and saved
// 获取用户输入的数据，验证并保存
}
```
### 读取默认值
Your table columns may be defined with default values. Sometimes, you may want to pre-populate your
Web form for an Active Record with these values. To do so, call the `loadDefaultValues()` method before
rendering the form:
你的表列也许定义了默认值。有时候，你可能需要在使用web表单的时候给AR预设一些值。如果你需要这样做，可以在显示表单内容前通过调用`loadDefaultValues()`方法来实现：
```php
$customer = new Customer();
$customer->loadDefaultValues();
......@@ -308,25 +312,40 @@ $customer->loadDefaultValues();
```
AR的生命周期
-----------------------------
理解AR的生命周期对于你操作数据库非常重要。生命周期通常都会有些典型的事件存在。对于开发AR的behaviors来说非常有用。
《《《待整理暂停线，下面的是以前翻译的，跟强哥前两天更新的不一样，还没有完全整理。
当你实例化一个新的AR对象时，我们将获得如下的生命周期：
1. constructor
2. [[yii\db\ActiveRecord::init()|init()]]: 会触发一个 [[yii\db\ActiveRecord::EVENT_INIT|EVENT_INIT]] 事件
当你通过 [[yii\db\ActiveRecord::find()|find()]] 方法查询数据时，每个AR实例都将有以下生命周期：
1. constructor
2. [[yii\db\ActiveRecord::init()|init()]]: 会触发一个 [[yii\db\ActiveRecord::EVENT_INIT|EVENT_INIT]] 事件
3. [[yii\db\ActiveRecord::afterFind()|afterFind()]]: 会触发一个 [[yii\db\ActiveRecord::EVENT_AFTER_FIND|EVENT_AFTER_FIND]] 事件
当通过 [[yii\db\ActiveRecord::save()|save()]] 方法写入或者更新数据时, 我们将获得如下生命周期：
1. [[yii\db\ActiveRecord::beforeValidate()|beforeValidate()]]: 会触发一个 [[yii\db\ActiveRecord::EVENT_BEFORE_VALIDATE|EVENT_BEFORE_VALIDATE]] 事件
2. [[yii\db\ActiveRecord::afterValidate()|afterValidate()]]: 会触发一个 [[yii\db\ActiveRecord::EVENT_AFTER_VALIDATE|EVENT_AFTER_VALIDATE]] 事件
3. [[yii\db\ActiveRecord::beforeSave()|beforeSave()]]: 会触发一个 [[yii\db\ActiveRecord::EVENT_BEFORE_INSERT|EVENT_BEFORE_INSERT]] 或 [[yii\db\ActiveRecord::EVENT_BEFORE_UPDATE|EVENT_BEFORE_UPDATE]] 事件
4. 执行实际的数据写入或更新
5. [[yii\db\ActiveRecord::afterSave()|afterSave()]]: 会触发一个 [[yii\db\ActiveRecord::EVENT_AFTER_INSERT|EVENT_AFTER_INSERT]] 或 [[yii\db\ActiveRecord::EVENT_AFTER_UPDATE|EVENT_AFTER_UPDATE]] 事件
数据输入和有效性验证
-------------------------
最后，当调用 [[yii\db\ActiveRecord::delete()|delete()]] 删除数据时, 我们将获得如下生命周期：
AR 继承了 [[yii\base\Model]] 的数据有效性验证和数据输入能力。有效性验证的方法会在数据保存时被调用。
数据的有效性验证会在 `save()` 方法执行时自动完成，如果验证失败，数据保存操作将取消。
1. [[yii\db\ActiveRecord::beforeDelete()|beforeDelete()]]: 会触发一个 [[yii\db\ActiveRecord::EVENT_BEFORE_DELETE|EVENT_BEFORE_DELETE]] 事件
2. 执行实际的数据删除
3. [[yii\db\ActiveRecord::afterDelete()|afterDelete()]]: 会触发一个 [[yii\db\ActiveRecord::EVENT_AFTER_DELETE|EVENT_AFTER_DELETE]] 事件
更多细节请参看本指南的 [Model](model.md) 部分。
查询关联的数据
------------------------
-----------------------------
使用 AR 方法也可以查询数据表的关联数据（如，选出表A的数据可以拉出表B的关联数据）。
有了 AR，
返回的关联数据连接就像连接关联主表的 AR 对象的属性一样。
......@@ -337,19 +356,21 @@ AR 蝏扳鈭 [[yii\base\Model]] 折颲
定义关联关系使用一个可以返回 [[yii\db\ActiveQuery]] 对象的 getter 方法，
[[yii\db\ActiveQuery]]对象有关联上下文的相关信息，因此可以只查询关联数据。
例如：
```php
class Customer extends \yii\db\ActiveRecord
{
public function getOrders()
{
// 客户和订单通过 Order.customer_id -> id 关联的一对多关系
// 客户和订单通过 Order.customer_id -> id 关联建立一对多关系
return $this->hasMany(Order::className(), ['customer_id' => 'id']);
}
}
class Order extends \yii\db\ActiveRecord
{
// 订单和客户通过 Customer.id -> customer_id 关联的一对一关系
// 订单和客户通过 Customer.id -> customer_id 关联建立一对一关系
public function getCustomer()
{
return $this->hasOne(Customer::className(), ['id' => 'customer_id']);
......@@ -373,7 +394,7 @@ class Order extends \yii\db\ActiveRecord
```php
// 取得客户的订单
$customer = Customer::find(1);
$customer = Customer::findOne(1);
$orders = $customer->orders; // $orders 是 Order 对象数组
```
......@@ -422,22 +443,12 @@ $orders = $customer->getBigOrders(200)->all();
（如果查询结果为空则返回空数组）。
中间表关联
--------------------------
有时，两个表通过中间表关联，定义这样的关联关系，
可以通过调用 [[yii\db\ActiveQuery::via()|via()]] 方法或 [[yii\db\ActiveQuery::viaTable()|viaTable()]] 方法来定制 [[yii\db\ActiveQuery]] 对象
。
举例而言，如果 `order` 表和 `item` 表通过中间表 `order_item`关联起来，
可以在 `Order` 类声明 `items` 关联关系取代中间表：
《《《待处理标识符：上面两句狗屁不通的话需要参照原文修订下。
中间关联表
-----------------
有时，两个表通过中间表关联，定义这样的关联关系， 可以通过调用 [[yii\db\ActiveQuery::via()|via()]] 方法或 [[yii\db\ActiveQuery::viaTable()|viaTable()]] 方法来定制 [[yii\db\ActiveQuery]] 对象 。
举例而言，如果 `order` 表和 `item` 表通过中间表 `order_item` 关联起来， 可以在 `Order` 类声明 `items` 关联关系取代中间表：
```php
class Order extends \yii\db\ActiveRecord
......@@ -450,9 +461,7 @@ class Order extends \yii\db\ActiveRecord
}
```
两个方法是相似的，除了
[[yii\db\ActiveQuery::via()|via()]] 方法的第一个参数是使用 AR 类中定义的关联名。
以上方法取代了中间表，等价于：
两个方法是相似的，除了 [[yii\db\ActiveQuery::via()|via()]] 方法的第一个参数是使用 AR 类中定义的关联名。 以上方法取代了中间表，等价于：
```php
class Order extends \yii\db\ActiveRecord
......@@ -470,19 +479,14 @@ class Order extends \yii\db\ActiveRecord
}
```
[pivot table]: http://en.wikipedia.org/wiki/Pivot_table "Pivot table（既中间表，英文，维基百科）"
延迟加载和即时加载（又称惰性加载与贪婪加载）
----------------------
-----------------
如前所述，当你第一次连接关联对象时， AR 将执行一个数据库查询
来检索请求数据并填充到关联对象的相应属性。
如果再次连接相同的关联对象，不再执行任何查询语句，这种数据库查询的执行方法称为“延迟加载”。如：
如前所述，当你第一次连接关联对象时， AR 将执行一个数据库查询 来检索请求数据并填充到关联对象的相应属性。 如果再次连接相同的关联对象，不再执行任何查询语句，这种数据库查询的执行方法称为“延迟加载”。如：
```php
// SQL executed: SELECT * FROM customer WHERE id=1
$customer = Customer::find(1);
$customer = Customer::findOne(1);
// SQL executed: SELECT * FROM order WHERE customer_id=1
$orders = $customer->orders;
// 没有 SQL 语句被执行
......@@ -502,11 +506,9 @@ foreach ($customers as $customer) {
}
```
假设数据库查出的客户超过100个，以上代码将执行多少条 SQL 语句？
101 条！第一条 SQL 查询语句取回100个客户，然后，
每个客户要执行一条 SQL 查询语句以取回该客户的所有订单。
假设数据库查出的客户超过100个，以上代码将执行多少条 SQL 语句？ 101 条！第一条 SQL 查询语句取回100个客户，然后， 每个客户要执行一条 SQL 查询语句以取回该客户的所有订单。
为解决以上性能问题，可以通过调用 [[yii\db\ActiveQuery::with()]] 方法使用*即时加载*解决。
为解决以上性能问题，可以通过调用 [[yii\db\ActiveQuery::with()]] 方法使用即时加载解决。
```php
// SQL executed: SELECT * FROM customer LIMIT 100;
......@@ -522,13 +524,8 @@ foreach ($customers as $customer) {
```
如你所见，同样的任务只需要两个 SQL 语句。
> 须知：通常，即时加载 N 个关联关系而通过 `via()` 或者 `viaTable()` 定义了 M 个关联关系，
将有 1+M+N 条 SQL 查询语句被执行：一个查询取回主表行数，
一个查询给每一个 (M) 中间表，一个查询给每个 (N) 关联表。
> 注意:当用即时加载定制 `select()` 时，确保连接
到关联模型的列都被包括了，否则，关联模型不会载入。如：
>须知：通常，即时加载 N 个关联关系而通过 via() 或者 viaTable() 定义了 M 个关联关系， 将有 1+M+N 条 SQL 查询语句被执行：一个查询取回主表行数， 一个查询给每一个 (M) 中间表，一个查询给每个 (N) 关联表。
注意:当用即时加载定制 select() 时，确保连接 到关联模型的列都被包括了，否则，关联模型不会载入。如：
```php
$orders = Order::find()->select(['id', 'amount'])->with('customer')->all();
......@@ -536,16 +533,15 @@ $orders = Order::find()->select(['id', 'amount'])->with('customer')->all();
$orders = Order::find()->select(['id', 'amount', 'customer_id'])->with('customer')->all();
```
有时候，你想自由的自定义关联查询，
延迟加载和即时加载都可以实现，如：
有时候，你想自由的自定义关联查询，延迟加载和即时加载都可以实现，如：
```php
$customer = Customer::find(1);
// lazy loading: SELECT * FROM order WHERE customer_id=1 AND subtotal>100
$customer = Customer::findOne(1);
// 延迟加载: SELECT * FROM order WHERE customer_id=1 AND subtotal>100
$orders = $customer->getOrders()->where('subtotal>100')->all();
// eager loading: SELECT * FROM customer LIMIT 100
// SELECT * FROM order WHERE customer_id IN (1,2,...) AND subtotal>100
// 即时加载: SELECT * FROM customer LIMIT 100
// SELECT * FROM order WHERE customer_id IN (1,2,...) AND subtotal>100
$customers = Customer::find()->limit(100)->with([
'orders' => function($query) {
$query->andWhere('subtotal>100');
......@@ -553,12 +549,10 @@ $customers = Customer::find()->limit(100)->with([
])->all();
```
逆关系
-----------------
关联关系通常成对定义，如， `Customer` 可以有个名为 `orders` 关联项，
而 `Order` 也有个名为`customer` 的关联项：
关联关系通常成对定义，如：Customer 可以有个名为 orders 关联项， 而 Order 也有个名为customer 的关联项：
```php
class Customer extends ActiveRecord
......@@ -580,25 +574,22 @@ class Order extends ActiveRecord
}
```
如果我们执行以下查询，可以发现订单的 `customer` 和
找到这些订单的客户对象并不是同一个。连接 `customer->orders` 将触发一条 SQL 语句
而连接一个订单的 `customer` 将触发另一条 SQL 语句。
如果我们执行以下查询，可以发现订单的 customer 和 找到这些订单的客户对象并不是同一个。连接 customer->orders 将触发一条 SQL 语句 而连接一个订单的 customer 将触发另一条 SQL 语句。
```php
// SELECT * FROM customer WHERE id=1
$customer = Customer::find(1);
// echoes "not equal"
$customer = Customer::findOne(1);
// 输出 "不相同"
// SELECT * FROM order WHERE customer_id=1
// SELECT * FROM customer WHERE id=1
if ($customer->orders[0]->customer === $customer) {
echo 'equal';
echo '相同';
} else {
echo 'not equal';
echo '不相同';
}
```
为避免多余执行的后一条语句，我们可以为 `customer`或 `orders` 关联关系定义相反的关联关系，
通过调用 [[yii\db\ActiveQuery::inverseOf()|inverseOf()]] 方法可以实现。
为避免多余执行的后一条语句，我们可以为 customer或 orders 关联关系定义相反的关联关系，通过调用 [[yii\db\ActiveQuery::inverseOf()|inverseOf()]] 方法可以实现。
```php
class Customer extends ActiveRecord
......@@ -615,18 +606,17 @@ class Customer extends ActiveRecord
```php
// SELECT * FROM customer WHERE id=1
$customer = Customer::find(1);
$customer = Customer::findOne(1);
// 输出相同
// SELECT * FROM order WHERE customer_id=1
if ($customer->orders[0]->customer === $customer) {
echo 'equal';
echo '相同';
} else {
echo 'not equal';
echo '不相同';
}
```
以上我们展示了如何在延迟加载中使用相对关联关系，
相对关系也可以用在即时加载中：
以上我们展示了如何在延迟加载中使用相对关联关系， 相对关系也可以用在即时加载中：
```php
// SELECT * FROM customer
......@@ -634,15 +624,13 @@ if ($customer->orders[0]->customer === $customer) {
$customers = Customer::find()->with('orders')->all();
// 输出相同
if ($customers[0]->orders[0]->customer === $customers[0]) {
echo 'equal';
echo '相同';
} else {
echo 'not equal';
echo '不相同';
}
```
> 注意:相对关系不能在包含中间表的关联关系中定义。
> 即是，如果你的关系是通过[[yii\db\ActiveQuery::via()|via()]] 或 [[yii\db\ActiveQuery::viaTable()|viaTable()]]方法定义的，
> 就不能调用[[yii\db\ActiveQuery::inverseOf()]]方法了。
>注意:相对关系不能在包含中间表的关联关系中定义。 即是，如果你的关系是通过[[yii\db\ActiveQuery::via()|via()]] 或 [[yii\db\ActiveQuery::viaTable()|viaTable()]]方法定义的， 就不能调用[[yii\db\ActiveQuery::inverseOf()]]方法了。
JOIN 类型关联查询
......@@ -661,7 +649,6 @@ $orders = Order::find()->innerJoinWith('books')->all();
```
以上，方法 [[yii\db\ActiveQuery::innerJoinWith()|innerJoinWith()]] 是访问 `INNER JOIN` 类型的 [[yii\db\ActiveQuery::joinWith()|joinWith()]] 的快捷方式。
。
可以连接一个或多个关联关系，可以自由使用查询条件到关联查询，
也可以嵌套连接关联查询。如：
......@@ -743,50 +730,40 @@ $users = User::find()->joinWith('books')->all();
```php
// SELECT * FROM user WHERE id=10
$user = User::find(10);
$user = User::findOne(10);
// SELECT * FROM item WHERE owner_id=10 AND category_id=1
$books = $user->books;
```
关联表操作
--------------------------
-----------------
ActiveRecord 提供下列两个方法来建立或移除
两个 ActiveRecord 对象之间的关系。
AR 提供了下面两个方法用来建立和解除两个关联对象之间的关系：
- [[yii\db\ActiveRecord::link()|link()]]
- [[yii\db\ActiveRecord::unlink()|unlink()]]
* [[yii\db\ActiveRecord::link()|link()]]
* [[yii\db\ActiveRecord::unlink()|unlink()]]
如，给定一个客户和一个新订单，我们可以使用以下代码
把订单和客户关联起来：
例如，给定一个customer和order对象，我们可以通过下面的代码使得customer对象拥有order对象：
```php
$customer = Customer::find(1);
$customer = Customer::findOne(1);
$order = new Order();
$order->subtotal = 100;
$customer->link('orders', $order);
```
上面调用的 [[yii\db\ActiveRecord::link()|link()]] 会设置 order 的 `customer_id` 为主键
$customer 的值，然后调用 [[yii\db\ActiveRecord::save()|save()]] 方法保存订单到数据库。
[[yii\db\ActiveRecord::link()|link()]] 调用上述将设置 customer_id 的顺序是 $customer 的主键值，然后调用 [[yii\db\ActiveRecord::save()|save()]] 要将顺序保存到数据库中。
作用域
------
--------------
当调用[[yii\db\ActiveRecord::find()|find()]]或[[yii\db\ActiveRecord::findBySql()|findBySql()]]方法，
将返回[[yii\db\ActiveQuery|ActiveQuery]] 实例。
你也可以调用其他方法，如 [[yii\db\ActiveQuery::where()|where()]], [[yii\db\ActiveQuery::orderBy()|orderBy()]],
以更细化查询条件。
当你调用[[yii\db\ActiveRecord::find()|find()]] 或 [[yii\db\ActiveRecord::findBySql()|findBySql()]]方法时，将会返回一个[[yii\db\ActiveQuery|ActiveQuery]]实例。之后，你可以调用其他查询方法，如 [[yii\db\ActiveQuery::where()|where()]]，[[yii\db\ActiveQuery::orderBy()|orderBy()]], 进一步的指定查询条件。
有可能需要不同地方多次调用同一个查询方法集合，这种情况，
可以考虑定义一个所谓的作用域（*scopes*），作用域本质上也是一个方法，定义在一个自定的查询类中，这个类
调用了一系列的查询方法来修正查询对象，使用作用域方法如同调用一个普通查询方法一样。
有时候你可能需要在不同的地方使用相同的查询方法。如果出现这种情况，你应该考虑定义所谓的作用域。作用域是本质上要求一组的查询方法来修改查询对象的自定义查询类中定义的方法。 之后你就可以像使用普通方法一样使用作用域。
定义一个作用域方法需要两个步骤，首先为模型创建一个自定的查询类并在此类定义必须的作用域方法。
如，为 `Comment` 模型创建 `CommentQuery` 类，
定义`active()`作用域方法如下：
只需两步即可定义一个作用域。首先给你的model创建一个自定义的查询类，在此类中定义的所需的范围方法。例如，给Comment模型创建一个 CommentQuery类，然后在CommentQuery类中定义一个active()的方法为作用域，像下面的代码：
```php
namespace app\models;
......@@ -803,14 +780,13 @@ class CommentQuery extends ActiveQuery
}
```
重点是：
重点:
1. 类必须继承自 `yii\db\ActiveQuery`或其子类。
2.方法必须是公开的并返回 `$this` 以便方法链成立。可以接收参数。
3.确认 [[yii\db\ActiveQuery]] 方法对修改查询条件非常有用。
1. 类必须继承 yii\db\ActiveQuery (或者是其他的 ActiveQuery ，比如 yii\mongodb\ActiveQuery)。
2. 必须是一个public类型的方法且必须返回 $this 实现链式操作。可以传入参数。
3. 检查 [[yii\db\ActiveQuery]] 对于修改查询条件是非常有用的方法。
其次，覆写 [[yii\db\ActiveRecord::createQuery()]] 方法以便可以使用自定的查询类而不是默认的 [[yii\db\ActiveQuery|ActiveQuery]] 类。
以下是示例：
其次，覆盖[[yii\db\ActiveRecord::find()]] 方法使其返回自定义的查询对象而不是常规的[[yii\db\ActiveQuery|ActiveQuery]]。对于上述例子，你需要编写如下代码：
```php
namespace app\models;
......@@ -819,22 +795,25 @@ use yii\db\ActiveRecord;
class Comment extends ActiveRecord
{
public static function createQuery($config = [])
/**
* @inheritdoc
* @return CommentQuery
*/
public static function find()
{
$config['modelClass'] = get_called_class();
return new CommentQuery($config);
return new CommentQuery(get_called_class());
}
}
```
就这样。现在你可以使用自定的作用域方法了：
就这样，现在你可以使用自定义的作用域方法了：
```php
$comments = Comment::find()->active()->all();
$inactiveComments = Comment::find()->active(false)->all();
```
当定义关联关系时也可以使用作用域，如：
你也能在定义的关联里使用作用域方法，比如：
```php
class Post extends \yii\db\ActiveRecord
......@@ -847,7 +826,7 @@ class Post extends \yii\db\ActiveRecord
}
```
或当执行关联查询时使用作用域传输：
或者在执行关联查询的时候使用（on-the-fly 是啥？）：
```php
$posts = Post::find()->with([
......@@ -857,66 +836,30 @@ $posts = Post::find()->with([
])->all();
```
### 让 IDE 更好地支持
为了让现代 IDE 自动完成更智能，你需要为一些模型和查询方法覆写返回类型，
如下：
```php
/**
* @method \app\models\CommentQuery|static|null find($q = null) static
* @method \app\models\CommentQuery findBySql($sql, $params = []) static
*/
class Comment extends ActiveRecord
{
// ...
}
```
```php
/**
* @method \app\models\Comment|array|null one($db = null)
* @method \app\models\Comment[]|array all($db = null)
*/
class CommentQuery extends ActiveQuery
{
// ...
}
```
### 默认作用域
如果你以前曾用过 Yii 1.1,你已经了解一个缺省作用域的概念。缺省作用域就是对所有的数据库查询生效的作用域。
你可以通过覆写 [[yii\db\ActiveRecord::createQuery()]] 方法来自定义缺省作用域，如
如果你之前用过 Yii 1.1 就应该知道默认作用域的概念。一个默认的作用域可以作用于所有查询。你可以很容易的通过重写[[yii\db\ActiveRecord::find()]]方法来定义一个默认作用域，例如：
```php
public static function createQuery($config = [])
public static function find()
{
$config['modelClass'] = get_called_class();
return (new ActiveQuery($config))->where(['deleted' => false]);
return parent::find()->where(['deleted' => false]);
}
```
注意现在你的所有查询都不能使用[[yii\db\ActiveQuery::where()|where()]]方法，
只能使用[[yii\db\ActiveQuery::where()|where()]]和[[yii\db\ActiveQuery::orWhere()|orWhere()]]方法，
以避免覆写了缺省条件。
注意，你之后所有的查询都不能用 [[yii\db\ActiveQuery::where()|where()]]，但是可以用 [[yii\db\ActiveQuery::andWhere()|andWhere()]] 和 [[yii\db\ActiveQuery::orWhere()|orWhere()]]，他们不会覆盖掉默认作用域。（译者注：如果你要使用默认作用域，就不能在 xxx::find()后使用where()方法，你必须使用andXXX()或者orXXX()系的方法，否则默认作用域不会起效果，至于原因，打开where()方法的代码一看便知）
事务处理
------------------------
事务操作
------------------
当一些 DB 操作是相关的且被同时执行
当执行几个相关联的数据库操作的时候
TODO: FIXME: WIP, TBD, https://github.com/yiisoft/yii2/issues/226
TODO: FIXME: WIP, TBD, [https://github.com/yiisoft/yii2/issues/226](https://github.com/yiisoft/yii2/issues/226)
,
[[yii\db\ActiveRecord::afterSave()|afterSave()]], [[yii\db\ActiveRecord::beforeDelete()|beforeDelete()]] 和 [[yii\db\ActiveRecord::afterDelete()|afterDelete()]]生命周期方法.
开发者的解决方案是通过数据库事务包覆写[[yii\db\ActiveRecord::save()|save()]]方法
甚至在控制器功能方法中使用事务，这个解决方式严格来说不是最佳实践
(违背了 “小控制器大模型”的基本规则）。
, [[yii\db\ActiveRecord::afterSave()|afterSave()]], [[yii\db\ActiveRecord::beforeDelete()|beforeDelete()]] and/or [[yii\db\ActiveRecord::afterDelete()|afterDelete()]] 生命周期周期方法(life cycle methods 我觉得这句翻译成“模板方法”会不会更好点？)。开发者可以通过重写[[yii\db\ActiveRecord::save()|save()]]方法然后在控制器里使用事务操作，严格地说是似乎不是一个好的做法 （召回"瘦控制器 / 肥模型"基本规则）。
以下就是这些方式（**不要** 使用，除非你确定你真的需要这么做）。模型：
这些方法在这里(如果你不明白自己实际在干什么，请不要使用他们)，Models：
```php
class Feature extends \yii\db\ActiveRecord
......@@ -925,7 +868,7 @@ class Feature extends \yii\db\ActiveRecord
public function getProduct()
{
return $this->hasOne(Product::className(), ['product_id' => 'id']);
return $this->hasOne(Product::className(), ['id' => 'product_id']);
}
}
......@@ -935,7 +878,7 @@ class Product extends \yii\db\ActiveRecord
public function getFeatures()
{
return $this->hasMany(Feature::className(), ['id' => 'product_id']);
return $this->hasMany(Feature::className(), ['product_id' => 'id']);
}
}
```
......@@ -943,7 +886,6 @@ class Product extends \yii\db\ActiveRecord
重写 [[yii\db\ActiveRecord::save()|save()]] 方法：
```php
class ProductController extends \yii\web\Controller
{
public function actionCreate()
......@@ -952,8 +894,9 @@ class ProductController extends \yii\web\Controller
}
}
```
(译者注：我觉得上面应该是原手册里的bug)
控制器层面使用事务处理
在控制器层使用事务：
```php
class ProductController extends \yii\web\Controller
......@@ -965,7 +908,7 @@ class ProductController extends \yii\web\Controller
}
```
代替以上弱相关的方法，可以使用原子级场景和操作特性。
作为这些脆弱方法的替代，你应该使用原子操作方案特性。
```php
class Feature extends \yii\db\ActiveRecord
......@@ -1023,6 +966,18 @@ class Product extends \yii\db\ActiveRecord
}
```
Controller里的代码将变得很简洁：
```php
class ProductController extends \yii\web\Controller
{
public function actionCreate()
{
// FIXME: TODO: WIP, TBD
}
}
```
控制器非常简洁：
```php
......@@ -1036,17 +991,17 @@ class ProductController extends \yii\web\Controller
```
乐观锁（Optimistic Locks）
----------------
-------------------
TODO
被污染属性
----------------
-------------------
TODO
另见
--------
-------------------
- [模型（Model）](model.md)
- [[yii\db\ActiveRecord]]
- [[yii\db\ActiveRecord]]
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment