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 is new 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

Creates an yii\db\ActiveQueryInterface instance for query purpose.

The returned yii\db\ActiveQueryInterface instance can be further customized by calling methods defined in yii\db\ActiveQueryInterface before one() or all() is called to return populated ActiveRecord instances. For example,

// find the customer whose ID is 1
$customer = Customer::find()->where(['id' => 1])->one();

// find all active customers and order them by their age:
$customers = Customer::find()
    ->where(['status' => 1])
    ->orderBy('age')
    ->all();

This method is also called by yii\db\BaseActiveRecord::hasOne() and yii\db\BaseActiveRecord::hasMany() to create a relational query.

You may override this method to return a customized query. For example,

class Customer extends ActiveRecord
{
    public static function find()
    {
        // use CustomerQuery instead of the default ActiveQuery
        return new CustomerQuery(get_called_class());
    }
}

The following code shows how to apply a default condition for all queries:

class Customer extends ActiveRecord
{
    public static function find()
    {
        return parent::find()->where(['deleted' => false]);
    }
}

// Use andWhere()/orWhere() to apply the default condition
// SELECT FROM customer WHERE `deleted`=:deleted AND age>30
$customers = Customer::find()->andWhere('age>30')->all();

// Use where() to ignore the default condition
// SELECT FROM customer WHERE age>30
$customers = Customer::find()->where('age>30')->all();

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.

See yii\db\BaseActiveRecord::hasMany() for more info.

See yii\db\BaseActiveRecord::hasMany() for more info.

See yii\db\BaseActiveRecord::hasOne() for more info.

See yii\db\BaseActiveRecord::hasOne() for more info.

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 changed attribute values 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 $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();

Populates an active record object using a row of data from the database/storage.

This is an internal method meant to be called to create active record objects after fetching data from the database. It is mainly used by yii\db\ActiveQuery to populate the query results into active records.

When calling this method manually you should call afterFind() on the created record to trigger the afterFind Event.

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.

Repopulates this active record with the latest data.

If the refresh is successful, an EVENT_AFTER_REFRESH event will be triggered. This event is available since version 2.0.8.

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 changed attribute values 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.