Class yii\db\ActiveRecord

Returns the list of all attribute names of the model.

The default implementation will return all column names of the table associated with this AR class.

Deletes the table row corresponding to this active record.

This method performs the following steps in order:

1. call beforeDelete(). If the method returns false, it will skip the rest of the steps;
2. delete the record from the database;
3. call afterDelete().

In the above step 1 and 3, events named EVENT_BEFORE_DELETE and EVENT_AFTER_DELETE will be raised by the corresponding methods.

Deletes rows in the table using the provided conditions.

For example, to delete all customers whose status is 3:

Customer::deleteAll('status = 3');

Warning: If you do not specify any condition, this method will delete all rows in the table.

Note that this method will not trigger any events. If you need EVENT_BEFORE_DELETE or EVENT_AFTER_DELETE to be triggered, you need to find the models first and then call delete() on each of them. For example an equivalent of the example above would be:

$models = Customer::find()->where('status = 3')->all();
foreach ($models as $model) {
    $model->delete();
}

For a large set of models you might consider using yii\db\ActiveQuery::each() to keep memory usage within limits.

Deletes an ActiveRecord without considering transaction.

Returns a value indicating whether the given active record is the same as the current one.

The comparison is made by comparing the table names and the primary key values of the two active records. If one of the records \yii\db\isNewRecord they are also considered not equal.

Filters array condition before it is assiged to a Query filter.

This method will ensure that an array condition only filters on existing table columns.

Returns table aliases which are not the same as the name of the tables.

Valid column names are table column names or column names prefixed with table name or table alias

{@inheritdoc}

Finds ActiveRecord instance(s) by the given condition.

This method is internally called by findOne() and findAll().

Creates an yii\db\ActiveQuery instance with a given SQL statement.

Note that because the SQL statement is already specified, calling additional query modification methods (such as where(), order()) on the created yii\db\ActiveQuery instance will have no effect. However, calling with(), asArray() or indexBy() is still fine.

Below is an example:

$customers = Customer::findBySql('SELECT * FROM customer')->all();

Returns the database connection used by this AR class.

By default, the "db" application component is used as the database connection. You may override this method if you want to use a different database connection.

Returns the schema information of the DB table associated with this AR class.

Inserts a row into the associated database table using the attribute values of this record.

This method performs the following steps in order:

1. call beforeValidate() when $runValidation is true. If beforeValidate() returns false, the rest of the steps will be skipped;
2. call afterValidate() when $runValidation is true. If validation failed, the rest of the steps will be skipped;
3. call beforeSave(). If beforeSave() returns false, the rest of the steps will be skipped;
4. insert the record into database. If this fails, it will skip the rest of the steps;
5. call afterSave();

In the above step 1, 2, 3 and 5, events EVENT_BEFORE_VALIDATE, EVENT_AFTER_VALIDATE, EVENT_BEFORE_INSERT, and EVENT_AFTER_INSERT will be raised by the corresponding methods.

Only the \yii\db\dirtyAttributes will be inserted into database.

If the table's primary key is auto-incremental and is null during insertion, it will be populated with the actual value after insertion.

For example, to insert a customer record:

$customer = new Customer;
$customer->name = $name;
$customer->email = $email;
$customer->insert();

Inserts an ActiveRecord into DB without considering transaction.

Returns a value indicating whether the specified operation is transactional in the current \yii\db\$scenario.

Loads default values from database table schema.

You may call this method to load default values after creating a new instance:

// class Customer extends \yii\db\ActiveRecord
$customer = new Customer();
$customer->loadDefaultValues();

{@inheritdoc}

Returns the primary key name(s) for this AR class.

The default implementation will return the primary key(s) as declared in the DB table that is associated with this AR class.

If the DB table does not declare any primary key, you should override this method to return the attributes that you want to use as primary keys for this AR class.

Note that an array should be returned even for a table with single primary key.

{@inheritdoc}

Declares the name of the database table associated with this AR class.

By default this method returns the class name as the table name by calling yii\helpers\Inflector::camel2id() with prefix yii\db\Connection::$tablePrefix. For example if yii\db\Connection::$tablePrefix is tbl_, Customer becomes tbl_customer, and OrderItem becomes tbl_order_item. You may override this method if the table is not named after this convention.

Declares which DB operations should be performed within a transaction in different scenarios.

The supported DB operations are: OP_INSERT, OP_UPDATE and OP_DELETE, which correspond to the insert(), update() and delete() methods, respectively. By default, these methods are NOT enclosed in a DB transaction.

In some scenarios, to ensure data consistency, you may want to enclose some or all of them in transactions. You can do so by overriding this method and returning the operations that need to be transactional. For example,

return [
    'admin' => self::OP_INSERT,
    'api' => self::OP_INSERT | self::OP_UPDATE | self::OP_DELETE,
    // the above is equivalent to the following:
    // 'api' => self::OP_ALL,

];

The above declaration specifies that in the "admin" scenario, the insert operation (insert()) should be done in a transaction; and in the "api" scenario, all the operations should be done in a transaction.

Saves the changes to this active record into the associated database table.

This method performs the following steps in order:

1. call beforeValidate() when $runValidation is true. If beforeValidate() returns false, the rest of the steps will be skipped;
2. call afterValidate() when $runValidation is true. If validation failed, the rest of the steps will be skipped;
3. call beforeSave(). If beforeSave() returns false, the rest of the steps will be skipped;
4. save the record into database. If this fails, it will skip the rest of the steps;
5. call afterSave();

In the above step 1, 2, 3 and 5, events EVENT_BEFORE_VALIDATE, EVENT_AFTER_VALIDATE, EVENT_BEFORE_UPDATE, and EVENT_AFTER_UPDATE will be raised by the corresponding methods.

Only the \yii\db\dirtyAttributes will be saved into database.

For example, to update a customer record:

$customer = Customer::findOne($id);
$customer->name = $name;
$customer->email = $email;
$customer->update();

Note that it is possible the update does not affect any row in the table. In this case, this method will return 0. For this reason, you should use the following code to check if update() is successful or not:

if ($customer->update() !== false) {
    // update successful
} else {
    // update failed
}

Updates the whole table using the provided attribute values and conditions.

For example, to change the status to be 1 for all customers whose status is 2:

Customer::updateAll(['status' => 1], 'status = 2');

Warning: If you do not specify any condition, this method will update all rows in the table.

Note that this method will not trigger any events. If you need EVENT_BEFORE_UPDATE or EVENT_AFTER_UPDATE to be triggered, you need to find the models first and then call update() on each of them. For example an equivalent of the example above would be:

$models = Customer::find()->where('status = 2')->all();
foreach ($models as $model) {
    $model->status = 1;
    $model->update(false); // skipping validation as no user input is involved
}

For a large set of models you might consider using yii\db\ActiveQuery::each() to keep memory usage within limits.

Updates the whole table using the provided counter changes and conditions.

For example, to increment all customers' age by 1,

Customer::updateAllCounters(['age' => 1]);

Note that this method will not trigger any events.