active-record.md 26 KB
Newer Older
Alexander Makarov committed
1 2 3
Active Record
=============

Larry Ullman committed
4
Active Record implements the [Active Record design pattern](http://en.wikipedia.org/wiki/Active_record).
Larry Ullman committed
5
The premise behind Active Record is that an individual [[ActiveRecord]] object is associated with a specific row in a database table. The object's attributes are mapped to the columns of the corresponding table. Referencing an Active Record attribute is equivalent to accessing
6
the corresponding table column for that record.
Larry Ullman committed
7

Larry Ullman committed
8
As an example, say that the `Customer` ActiveRecord class is associated with the
Larry Ullman committed
9
`tbl_customer` table. This would mean that the class's `name` attribute is automatically mapped to the `name` column in `tbl_customer`.
Larry Ullman committed
10
Thanks to Active Record, assuming the variable `$customer` is an object of type `Customer`, to get the value of the `name` column for the table row, you can use the expression `$customer->name`. In this example, Active Record is providing an object-oriented interface for accessing data stored in the database. But Active Record provides much more functionality than this.
Larry Ullman committed
11 12

With Active Record, instead of writing raw SQL statements to perform database queries, you can call intuitive methods to achieve the same goals. For example, calling [[ActiveRecord::save()|save()]] would perform an INSERT or UPDATE query, creating or updating a row in the associated table of the ActiveRecord class:
Alexander Makarov committed
13 14 15 16

```php
$customer = new Customer();
$customer->name = 'Qiang';
Qiang Xue committed
17
$customer->save();  // a new row is inserted into tbl_customer
Alexander Makarov committed
18 19 20 21 22 23 24
```


Declaring ActiveRecord Classes
------------------------------

To declare an ActiveRecord class you need to extend [[\yii\db\ActiveRecord]] and
Larry Ullman committed
25
implement the `tableName` method:
Alexander Makarov committed
26 27

```php
Qiang Xue committed
28 29 30
use yii\db\ActiveRecord;

class Customer extends ActiveRecord
Alexander Makarov committed
31 32 33 34 35 36 37 38 39 40 41
{
	/**
	 * @return string the name of the table associated with this ActiveRecord class.
	 */
	public static function tableName()
	{
		return 'tbl_customer';
	}
}
```

Larry Ullman committed
42 43 44 45 46 47 48
The `tableName` method only has to return the name of the database table associated with the class.

Class instances are obtained in one of two ways:

* Using the `new` operator to create a new, empty object
* Using a method to fetch an existing record (or records) from the database

Larry Ullman committed
49
Connecting to the Database
Alexander Makarov committed
50 51
----------------------

Qiang Xue committed
52
ActiveRecord relies on a [[Connection|DB connection]] to perform the underlying DB operations.
Larry Ullman committed
53 54
By default, ActiveRecord assumes that there is an application component named `db` which provides the needed
[[Connection]] instance. Usually this component is configured in application configuration file:
Alexander Makarov committed
55 56

```php
Alexander Makarov committed
57 58 59
return [
	'components' => [
		'db' => [
Alexander Makarov committed
60 61 62 63
			'class' => 'yii\db\Connection',
			'dsn' => 'mysql:host=localhost;dbname=testdb',
			'username' => 'demo',
			'password' => 'demo',
Alexander Makarov committed
64 65 66
		],
	],
];
Alexander Makarov committed
67 68
```

Larry Ullman committed
69
Please read the [Database basics](database-basics.md) section to learn more on how to configure and use database connections.
Alexander Makarov committed
70

Larry Ullman committed
71
Querying Data from the Database
Qiang Xue committed
72
---------------------------
Alexander Makarov committed
73

Qiang Xue committed
74
There are two ActiveRecord methods for querying data from database:
Alexander Makarov committed
75

Qiang Xue committed
76 77
 - [[ActiveRecord::find()]]
 - [[ActiveRecord::findBySql()]]
Alexander Makarov committed
78

79
Both methods return an [[ActiveQuery]] instance, which extends [[Query]], and thus supports the same set of flexible and powerful DB query methods. The following examples demonstrate some of the possibilities.
Alexander Makarov committed
80 81 82 83

```php
// to retrieve all *active* customers and order them by their ID:
$customers = Customer::find()
Alexander Makarov committed
84
	->where(['status' => $active])
Alexander Makarov committed
85 86 87 88
	->orderBy('id')
	->all();

// to return a single customer whose ID is 1:
Qiang Xue committed
89 90 91
$customer = Customer::find(1);

// the above code is equivalent to the following:
Alexander Makarov committed
92
$customer = Customer::find()
Alexander Makarov committed
93
	->where(['id' => 1])
Alexander Makarov committed
94 95 96 97 98 99 100 101
	->one();

// to retrieve customers using a raw SQL statement:
$sql = 'SELECT * FROM tbl_customer';
$customers = Customer::findBySql($sql)->all();

// to return the number of *active* customers:
$count = Customer::find()
Alexander Makarov committed
102
	->where(['status' => $active])
Alexander Makarov committed
103 104 105
	->count();

// to return customers in terms of arrays rather than `Customer` objects:
Qiang Xue committed
106 107 108 109
$customers = Customer::find()
	->asArray()
	->all();
// each element of $customers is an array of name-value pairs
Alexander Makarov committed
110 111 112 113 114 115 116 117 118 119

// to index the result by customer IDs:
$customers = Customer::find()->indexBy('id')->all();
// $customers array is indexed by customer IDs
```


Accessing Column Data
---------------------

Larry Ullman committed
120
ActiveRecord maps each column of the corresponding database table row to an attribute in the ActiveRecord
121
object. The attribute behaves like any regular object public property. The attribute's name will be the same as the corresponding column name, and is case-sensitive.
Alexander Makarov committed
122

Larry Ullman committed
123
To read the value of a column, you can use the following syntax:
Alexander Makarov committed
124 125

```php
Larry Ullman committed
126
// "id" and "email" are the names of columns in the table associated with $customer ActiveRecord object
Alexander Makarov committed
127
$id = $customer->id;
Larry Ullman committed
128
$email = $customer->email;
Alexander Makarov committed
129 130
```

Larry Ullman committed
131
To change the value of a column, assign a new value to the associated property and save the object:
Alexander Makarov committed
132 133

```
Larry Ullman committed
134 135 136
$customer->email = 'jane@example.com';
$customer->save();
```
Alexander Makarov committed
137

Larry Ullman committed
138
Manipulating Data in the Database
Qiang Xue committed
139
-----------------------------
Alexander Makarov committed
140

Qiang Xue committed
141
ActiveRecord provides the following methods to insert, update and delete data in the database:
Alexander Makarov committed
142

Qiang Xue committed
143 144 145 146 147 148 149 150 151
- [[ActiveRecord::save()|save()]]
- [[ActiveRecord::insert()|insert()]]
- [[ActiveRecord::update()|update()]]
- [[ActiveRecord::delete()|delete()]]
- [[ActiveRecord::updateCounters()|updateCounters()]]
- [[ActiveRecord::updateAll()|updateAll()]]
- [[ActiveRecord::updateAllCounters()|updateAllCounters()]]
- [[ActiveRecord::deleteAll()|deleteAll()]]

152
Note that [[ActiveRecord::updateAll()|updateAll()]], [[ActiveRecord::updateAllCounters()|updateAllCounters()]] and [[ActiveRecord::deleteAll()|deleteAll()]] are static methods that apply to the whole database table. The other methods only apply to the row associated with the ActiveRecord object through which the method is being called.
Alexander Makarov committed
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169

```php
// to insert a new customer record
$customer = new Customer;
$customer->name = 'James';
$customer->email = 'james@example.com';
$customer->save();  // equivalent to $customer->insert();

// to update an existing customer record
$customer = Customer::find($id);
$customer->email = 'james@example.com';
$customer->save();  // equivalent to $customer->update();

// to delete an existing customer record
$customer = Customer::find($id);
$customer->delete();

Qiang Xue committed
170
// to increment the age of ALL customers by 1
Alexander Makarov committed
171
Customer::updateAllCounters(['age' => 1]);
Alexander Makarov committed
172 173
```

Qiang Xue committed
174 175 176
> Info: The `save()` method will either perform an `INSERT` or `UPDATE` SQL statement, depending
  on whether the ActiveRecord being saved is new or not by checking `ActiveRecord::isNewRecord`.

Larry Ullman committed
177 178 179 180 181 182 183 184

Data Input and Validation
-------------------------

ActiveRecord inherits data validation and data input features from [[\yii\base\Model]]. Data validation is called
automatically when `save()` is performed. If data validation fails, the saving operation will be cancelled.

For more details refer to the [Model](model.md) section of this guide.
Alexander Makarov committed
185

Qiang Xue committed
186 187
Querying Relational Data
------------------------
Alexander Makarov committed
188

Larry Ullman committed
189 190
You can use ActiveRecord to also query a table's relational data (i.e., selection of data from Table A can also pull in related data from Table B). Thanks to ActiveRecord, the relational data returned can be accessed like a property of the ActiveRecord object associated with the primary table.

Qiang Xue committed
191 192
For example, with an appropriate relation declaration, by accessing `$customer->orders` you may obtain
an array of `Order` objects which represent the orders placed by the specified customer.
Alexander Makarov committed
193

Qiang Xue committed
194
To declare a relation, define a getter method which returns an [[ActiveRelation]] object. For example,
Alexander Makarov committed
195 196 197 198 199 200

```php
class Customer extends \yii\db\ActiveRecord
{
	public function getOrders()
	{
201
		// Customer has_many Order via Order.customer_id -> id
Luciano Baraglia committed
202
		return $this->hasMany(Order::className(), ['customer_id' => 'id']);
Alexander Makarov committed
203 204 205 206 207
	}
}

class Order extends \yii\db\ActiveRecord
{
208
	// Order has_one Customer via Customer.id -> customer_id
Alexander Makarov committed
209 210
	public function getCustomer()
	{
211
		return $this->hasOne(Customer::className(), ['id' => 'customer_id']);
Alexander Makarov committed
212 213 214 215
	}
}
```

Qiang Xue committed
216 217 218 219
The methods [[ActiveRecord::hasMany()]] and [[ActiveRecord::hasOne()]] used in the above
are used to model the many-one relationship and one-one relationship in a relational database.
For example, a customer has many orders, and an order has one customer.
Both methods take two parameters and return an [[ActiveRelation]] object:
Alexander Makarov committed
220

Qiang Xue committed
221
 - `$class`: the name of the class of the related model(s). This should be a fully qualified class name.
Qiang Xue committed
222 223 224 225
 - `$link`: the association between columns from the two tables. This should be given as an array.
   The keys of the array are the names of the columns from the table associated with `$class`,
   while the values of the array are the names of the columns from the declaring class.
   It is a good practice to define relationships based on table foreign keys.
Alexander Makarov committed
226

Qiang Xue committed
227 228
After declaring relations, getting relational data is as easy as accessing a component property
that is defined by the corresponding getter method:
Alexander Makarov committed
229 230

```php
Qiang Xue committed
231 232
// get the orders of a customer
$customer = Customer::find(1);
Alexander Makarov committed
233
$orders = $customer->orders;  // $orders is an array of Order objects
Qiang Xue committed
234 235 236
```

Behind the scene, the above code executes the following two SQL queries, one for each line of code:
Alexander Makarov committed
237

Qiang Xue committed
238 239 240
```sql
SELECT * FROM tbl_customer WHERE id=1;
SELECT * FROM tbl_order WHERE customer_id=1;
Alexander Makarov committed
241 242
```

Qiang Xue committed
243 244 245 246 247 248 249 250
> Tip: If you access the expression `$customer->orders` again, will it perform the second SQL query again?
Nope. The SQL query is only performed the first time when this expression is accessed. Any further
accesses will only return the previously fetched results that are cached internally. If you want to re-query
the relational data, simply unset the existing one first: `unset($customer->orders);`.

Sometimes, you may want to pass parameters to a relational query. For example, instead of returning
all orders of a customer, you may want to return only big orders whose subtotal exceeds a specified amount.
To do so, declare a `bigOrders` relation with the following getter method:
Alexander Makarov committed
251 252 253 254 255 256

```php
class Customer extends \yii\db\ActiveRecord
{
	public function getBigOrders($threshold = 100)
	{
257
		return $this->hasMany(Order::className(), ['customer_id' => 'id'])
Alexander Makarov committed
258
			->where('subtotal > :threshold', [':threshold' => $threshold])
Alexander Makarov committed
259 260 261 262 263
			->orderBy('id');
	}
}
```

Qiang Xue committed
264 265 266 267 268 269 270 271 272 273 274 275 276 277
Remember that `hasMany()` returns an [[ActiveRelation]] object which extends from [[ActiveQuery]]
and thus supports the same set of querying methods as [[ActiveQuery]].

With the above declaration, if you access `$customer->bigOrders`, it will only return the orders
whose subtotal is greater than 100. To specify a different threshold value, use the following code:

```php
$orders = $customer->getBigOrders(200)->all();
```


Relations with Pivot Table
--------------------------

Alexander Makarov committed
278
Sometimes, two tables are related together via an intermediary table called
Qiang Xue committed
279
[pivot table](http://en.wikipedia.org/wiki/Pivot_table). To declare such relations, we can customize
Alexander Makarov committed
280 281 282 283 284 285 286 287 288 289 290
the [[ActiveRelation]] object by calling its [[ActiveRelation::via()]] or [[ActiveRelation::viaTable()]]
method.

For example, if table `tbl_order` and table `tbl_item` are related via pivot table `tbl_order_item`,
we can declare the `items` relation in the `Order` class like the following:

```php
class Order extends \yii\db\ActiveRecord
{
	public function getItems()
	{
291
		return $this->hasMany(Item::className(), ['id' => 'item_id'])
Alexander Makarov committed
292
			->viaTable('tbl_order_item', ['order_id' => 'id']);
Alexander Makarov committed
293 294 295 296 297
	}
}
```

[[ActiveRelation::via()]] method is similar to [[ActiveRelation::viaTable()]] except that
Qiang Xue committed
298 299
the first parameter of [[ActiveRelation::via()]] takes a relation name declared in the ActiveRecord class
instead of the pivot table name. For example, the above `items` relation can be equivalently declared as follows:
Alexander Makarov committed
300 301 302 303 304 305

```php
class Order extends \yii\db\ActiveRecord
{
	public function getOrderItems()
	{
306
		return $this->hasMany(OrderItem::className(), ['order_id' => 'id']);
Alexander Makarov committed
307 308 309 310
	}

	public function getItems()
	{
311
		return $this->hasMany(Item::className(), ['id' => 'item_id'])
Alexander Makarov committed
312 313 314 315 316 317
			->via('orderItems');
	}
}
```


Qiang Xue committed
318 319 320 321
Lazy and Eager Loading
----------------------

As described earlier, when you access the related objects the first time, ActiveRecord will perform a DB query
Alexander Makarov committed
322 323 324 325 326 327 328 329 330 331 332 333
to retrieve the corresponding data and populate it into the related objects. No query will be performed
if you access the same related objects again. We call this *lazy loading*. For example,

```php
// SQL executed: SELECT * FROM tbl_customer WHERE id=1
$customer = Customer::find(1);
// SQL executed: SELECT * FROM tbl_order WHERE customer_id=1
$orders = $customer->orders;
// no SQL executed
$orders2 = $customer->orders;
```

Qiang Xue committed
334
Lazy loading is very convenient to use. However, it may suffer from a performance issue in the following scenario:
Alexander Makarov committed
335 336 337 338 339 340 341 342 343 344 345 346 347 348

```php
// SQL executed: SELECT * FROM tbl_customer LIMIT 100
$customers = Customer::find()->limit(100)->all();

foreach ($customers as $customer) {
	// SQL executed: SELECT * FROM tbl_order WHERE customer_id=...
	$orders = $customer->orders;
	// ...handle $orders...
}
```

How many SQL queries will be performed in the above code, assuming there are more than 100 customers in
the database? 101! The first SQL query brings back 100 customers. Then for each customer, a SQL query
Qiang Xue committed
349
is performed to bring back the orders of that customer.
Alexander Makarov committed
350

Qiang Xue committed
351
To solve the above performance problem, you can use the so-called *eager loading* approach by calling [[ActiveQuery::with()]]:
Alexander Makarov committed
352 353

```php
Qiang Xue committed
354
// SQL executed: SELECT * FROM tbl_customer LIMIT 100;
Alexander Makarov committed
355 356 357 358 359 360 361 362 363 364 365 366 367 368
//               SELECT * FROM tbl_orders WHERE customer_id IN (1,2,...)
$customers = Customer::find()->limit(100)
	->with('orders')->all();

foreach ($customers as $customer) {
	// no SQL executed
	$orders = $customer->orders;
	// ...handle $orders...
}
```

As you can see, only two SQL queries are needed for the same task.


Qiang Xue committed
369
Sometimes, you may want to customize the relational queries on the fly. This can be
Alexander Makarov committed
370 371 372 373 374 375 376
done for both lazy loading and eager loading. For example,

```php
$customer = Customer::find(1);
// lazy loading: SELECT * FROM tbl_order WHERE customer_id=1 AND subtotal>100
$orders = $customer->getOrders()->where('subtotal>100')->all();

Алексей committed
377 378
// eager loading: SELECT * FROM tbl_customer LIMIT 100
//                SELECT * FROM tbl_order WHERE customer_id IN (1,2,...) AND subtotal>100
Alexander Makarov committed
379
$customers = Customer::find()->limit(100)->with([
Alexander Makarov committed
380 381 382
	'orders' => function($query) {
		$query->andWhere('subtotal>100');
	},
Alexander Makarov committed
383
])->all();
Alexander Makarov committed
384 385 386
```


387 388 389 390 391
Joining with Relations
----------------------

When working with relational databases, a common task is to join multiple tables and apply various
query conditions and parameters to the JOIN SQL statement. Instead of calling [[ActiveQuery::join()]]
392 393
explicitly to build up the JOIN query, you may reuse the existing relation definitions and call
[[ActiveQuery::joinWith()]] to achieve this goal. For example,
394 395

```php
396 397
// find all orders and sort the orders by the customer id and the order id. also eager loading "customer"
$orders = Order::find()->joinWith('customer')->orderBy('tbl_customer.id, tbl_order.id')->all();
398
// find all orders that contain books, and eager loading "books"
399
$orders = Order::find()->innerJoinWith('books')->all();
400 401
```

402 403
In the above, the method [[ActiveQuery::innerJoinWith()|innerJoinWith()]] is a shortcut to [[ActiveQuery::joinWith()|joinWith()]]
with the join type set as `INNER JOIN`.
Qiang Xue committed
404

405 406
You may join with one or multiple relations; you may apply query conditions to the relations on-the-fly;
and you may also join with sub-relations. For example,
Qiang Xue committed
407 408 409 410

```php
// join with multiple relations
// find out the orders that contain books and are placed by customers who registered within the past 24 hours
411
$orders = Order::find()->innerJoinWith([
Qiang Xue committed
412 413
	'books',
	'customer' => function ($query) {
Alexander Kochetov committed
414
		$query->where('tbl_customer.created_at > ' . (time() - 24 * 3600));
Qiang Xue committed
415 416 417 418 419 420
	}
])->all();
// join with sub-relations: join with books and books' authors
$orders = Order::find()->joinWith('books.author')->all();
```

421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437
Behind the scene, Yii will first execute a JOIN SQL statement to bring back the primary models
satisfying the conditions applied to the JOIN SQL. It will then execute a query for each relation
and populate the corresponding related records.

The difference between [[ActiveQuery::joinWith()|joinWith()]] and [[ActiveQuery::with()|with()]] is that
the former joins the tables for the primary model class and the related model classes to retrieve
the primary models, while the latter just queries against the table for the primary model class to
retrieve the primary models.

Because of this difference, you may apply query conditions that are only available to a JOIN SQL statement.
For example, you may filter the primary models by the conditions on the related models, like the example
above. You may also sort the primary models using columns from the related tables.

When using [[ActiveQuery::joinWith()|joinWith()]], you are responsible to disambiguate column names.
In the above examples, we use `tbl_item.id` and `tbl_order.id` to disambiguate the `id` column references
because both of the order table and the item table contain a column named `id`.

Qiang Xue committed
438 439 440
By default, when you join with a relation, the relation will also be eagerly loaded. You may change this behavior
by passing the `$eagerLoading` parameter which specifies whether to eager load the specified relations.

441 442 443
And also by default, [[ActiveQuery::joinWith()|joinWith()]] uses `LEFT JOIN` to join the related tables.
You may pass it with the `$joinType` parameter to customize the join type. As a shortcut to the `INNER JOIN` type,
you may use [[ActiveQuery::innerJoinWith()|innerJoinWith()]].
Qiang Xue committed
444 445 446 447 448

Below are some more examples,

```php
// find all orders that contain books, but do not eager loading "books".
449
$orders = Order::find()->innerJoinWith('books', false)->all();
450
// which is equivalent to the above
451
$orders = Order::find()->joinWith('books', false, 'INNER JOIN')->all();
Qiang Xue committed
452
```
453

454 455 456 457 458 459 460 461
Sometimes when joining two tables, you may need to specify some extra condition in the ON part of the JOIN query.
This can be done by calling the [[\yii\db\ActiveRelation::onCondition()]] method like the following:

```php
class User extends ActiveRecord
{
	public function getBooks()
	{
462
		return $this->hasMany(Item::className(), ['owner_id' => 'id'])->onCondition(['category_id' => 1]);
463 464 465 466 467 468 469 470 471 472 473 474 475
	}
}
```

In the above, the `hasMany()` method returns an `ActiveRelation` instance, upon which `onCondition()` is called
to specify that only items whose `category_id` is 1 should be returned.

When you perform query using [[ActiveQuery::joinWith()|joinWith()]], the on-condition will be put in the ON part
of the corresponding JOIN query. For example,

```php
// SELECT tbl_user.* FROM tbl_user LEFT JOIN tbl_item ON tbl_item.owner_id=tbl_user.id AND category_id=1
// SELECT * FROM tbl_item WHERE owner_id IN (...) AND category_id=1
476
$users = User::find()->joinWith('books')->all();
477 478 479 480 481 482 483
```

Note that if you use eager loading via [[ActiveQuery::with()]] or lazy loading, the on-condition will be put
in the WHERE part of the corresponding SQL statement, because there is no JOIN query involved. For example,

```php
// SELECT * FROM tbl_user WHERE id=10
484
$user = User::find(10);
485 486 487 488
// SELECT * FROM tbl_item WHERE owner_id=10 AND category_id=1
$books = $user->books;
```

489

Alexander Makarov committed
490 491 492 493 494 495
Working with Relationships
--------------------------

ActiveRecord provides the following two methods for establishing and breaking a
relationship between two ActiveRecord objects:

Qiang Xue committed
496 497
- [[ActiveRecord::link()|link()]]
- [[ActiveRecord::unlink()|unlink()]]
Alexander Makarov committed
498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545

For example, given a customer and a new order, we can use the following code to make the
order owned by the customer:

```php
$customer = Customer::find(1);
$order = new Order;
$order->subtotal = 100;
$customer->link('orders', $order);
```

The [[link()]] call above will set the `customer_id` of the order to be the primary key
value of `$customer` and then call [[save()]] to save the order into database.


Life Cycles of an ActiveRecord Object
-------------------------------------

An ActiveRecord object undergoes different life cycles when it is used in different cases.
Subclasses or ActiveRecord behaviors may "inject" custom code in these life cycles through
method overriding and event handling mechanisms.

When instantiating a new ActiveRecord instance, we will have the following life cycles:

1. constructor
2. [[init()]]: will trigger an [[EVENT_INIT]] event

When getting an ActiveRecord instance through the [[find()]] method, we will have the following life cycles:

1. constructor
2. [[init()]]: will trigger an [[EVENT_INIT]] event
3. [[afterFind()]]: will trigger an [[EVENT_AFTER_FIND]] event

When calling [[save()]] to insert or update an ActiveRecord, we will have the following life cycles:

1. [[beforeValidate()]]: will trigger an [[EVENT_BEFORE_VALIDATE]] event
2. [[afterValidate()]]: will trigger an [[EVENT_AFTER_VALIDATE]] event
3. [[beforeSave()]]: will trigger an [[EVENT_BEFORE_INSERT]] or [[EVENT_BEFORE_UPDATE]] event
4. perform the actual data insertion or updating
5. [[afterSave()]]: will trigger an [[EVENT_AFTER_INSERT]] or [[EVENT_AFTER_UPDATE]] event

Finally when calling [[delete()]] to delete an ActiveRecord, we will have the following life cycles:

1. [[beforeDelete()]]: will trigger an [[EVENT_BEFORE_DELETE]] event
2. perform the actual data deletion
3. [[afterDelete()]]: will trigger an [[EVENT_AFTER_DELETE]] event


546 547
Custom scopes
-------------
Alexander Makarov committed
548

549 550
When [[find()]] or [[findBySql()]] Active Record method is being called without parameters it returns an [[ActiveQuery]]
instance. This object holds all the parameters and conditions for a future query and also allows you to customize these
551
using a set of methods that are called scopes. By default there is a good set of such methods some of which we've
552 553 554 555
already used above: `where`, `orderBy`, `limit` etc.

In many cases it is convenient to wrap extra conditions into custom scope methods. In order to do so you need two things.
First is creating a custom query class for your model. For example, a `Comment` may have a `CommentQuery`:
Alexander Makarov committed
556 557

```php
558 559
namespace app\models;

560
use yii\db\ActiveQuery;
561 562

class CommentQuery extends ActiveQuery
Alexander Makarov committed
563
{
564 565 566 567 568 569 570
	public function active($state = true)
	{
		$this->andWhere(['active' => $state]);
		return $this;
	}
}
```
Alexander Makarov committed
571

572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587
Important points are:

1. Class should extend from `yii\db\ActiveQuery` (or another `ActiveQuery` such as `yii\mongodb\ActiveQuery`).
2. A method should be `public` and should return `$this` in order to allow method chaining. It may accept parameters.
3. Check `ActiveQuery` methods that are very useful for modifying query conditions.

The second step is to use `CommentQuery` instead of regular `ActiveQuery` for `Comment` model:

```
namespace app\models;

use yii\db\ActiveRecord;

class Comment extends ActiveRecord
{
	public static function createQuery()
Alexander Makarov committed
588
	{
589
		return new CommentQuery(['modelClass' => get_called_class()]);
Alexander Makarov committed
590 591
	}
}
592
```
Alexander Makarov committed
593

594 595 596
That's it. Now you can use your custom scope methods:

```php
597
$comments = Comment::find()->active()->all();
598
$inactiveComments = Comment::find()->active(false)->all();
599 600 601 602 603 604 605 606 607 608 609 610 611
```

You can also use scopes when defining relations. For example,

```php
class Post extends \yii\db\ActiveRecord
{
	public function getComments()
	{
		return $this->hasMany(Comment::className(), ['post_id' => 'id'])->active();

	}
}
Alexander Makarov committed
612 613
```

614 615 616 617 618 619 620 621 622
Or use the scopes on-the-fly when performing relational query:

```php
$posts = Post::find()->with([
	'comments' => function($q) {
		$q->active();
	}
])->all();
```
Alexander Makarov committed
623

624 625
### Making it IDE-friendly

626 627
In order to make most modern IDE autocomplete happy you need to override return types for some methods of both model
and query like the following:
Alexander Makarov committed
628 629

```php
630 631 632 633 634
/**
 * @method \app\models\CommentQuery|static|null find($q = null) static
 * @method \app\models\CommentQuery findBySql($sql, $params = []) static
 */
class Comment extends ActiveRecord
Alexander Makarov committed
635
{
636
	// ...
Alexander Makarov committed
637 638 639
}
```

640
```php
641 642 643 644 645
/**
 * @method \app\models\Comment|array|null one($db = null)
 * @method \app\models\Comment[]|array all($db = null)
 */
class CommentQuery extends ActiveQuery
646
{
647
	// ...
648 649 650
}
```

Qiang Xue committed
651 652 653 654 655
Transactional operations
------------------------


When a few DB operations are related and are executed
Alexander Makarov committed
656

657 658
TODO: FIXME: WIP, TBD, https://github.com/yiisoft/yii2/issues/226

Qiang Xue committed
659
,
660
[[afterSave()]], [[beforeDelete()]] and/or [[afterDelete()]] life cycle methods. Developer may come
Qiang Xue committed
661
to the solution of overriding ActiveRecord [[save()]] method with database transaction wrapping or
662 663
even using transaction in controller action, which is strictly speaking doesn't seem to be a good
practice (recall "skinny-controller / fat-model" fundamental rule).
664

665
Here these ways are (**DO NOT** use them unless you're sure what you are actually doing). Models:
666 667 668 669 670 671 672 673

```php
class Feature extends \yii\db\ActiveRecord
{
	// ...

	public function getProduct()
	{
674
		return $this->hasOne(Product::className(), ['product_id' => 'id']);
675 676 677 678 679 680 681 682 683
	}
}

class Product extends \yii\db\ActiveRecord
{
	// ...

	public function getFeatures()
	{
684
		return $this->hasMany(Feature::className(), ['id' => 'product_id']);
685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722
	}
}
```

Overriding [[save()]] method:

```php

class ProductController extends \yii\web\Controller
{
	public function actionCreate()
	{
		// FIXME: TODO: WIP, TBD
	}
}
```

Using transactions within controller layer:

```php
class ProductController extends \yii\web\Controller
{
	public function actionCreate()
	{
		// FIXME: TODO: WIP, TBD
	}
}
```

Instead of using these fragile methods you should consider using atomic scenarios and operations feature.

```php
class Feature extends \yii\db\ActiveRecord
{
	// ...

	public function getProduct()
	{
723
		return $this->hasOne(Product::className(), ['product_id' => 'id']);
724 725 726 727
	}

	public function scenarios()
	{
Alexander Makarov committed
728 729 730 731 732 733
		return [
			'userCreates' => [
				'attributes' => ['name', 'value'],
				'atomic' => [self::OP_INSERT],
			],
		];
734 735 736 737 738 739 740 741 742
	}
}

class Product extends \yii\db\ActiveRecord
{
	// ...

	public function getFeatures()
	{
743
		return $this->hasMany(Feature::className(), ['id' => 'product_id']);
744 745 746 747
	}

	public function scenarios()
	{
Alexander Makarov committed
748 749 750 751 752 753
		return [
			'userCreates' => [
				'attributes' => ['title', 'price'],
				'atomic' => [self::OP_INSERT],
			],
		];
754 755 756 757 758 759 760 761 762 763
	}

	public function afterValidate()
	{
		parent::afterValidate();
		// FIXME: TODO: WIP, TBD
	}

	public function afterSave($insert)
	{
764
		parent::afterSave($insert);
765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782
		if ($this->getScenario() === 'userCreates') {
			// FIXME: TODO: WIP, TBD
		}
	}
}
```

Controller is very thin and neat:

```php
class ProductController extends \yii\web\Controller
{
	public function actionCreate()
	{
		// FIXME: TODO: WIP, TBD
	}
}
```
Alexander Makarov committed
783

Qiang Xue committed
784 785 786 787 788 789 790 791 792 793
Optimistic Locks
----------------

TODO

Dirty Attributes
----------------

TODO

Alexander Makarov committed
794 795 796 797
See also
--------

- [Model](model.md)
798
- [[\yii\db\ActiveRecord]]