<?php

class Customer extends \yii\db\ActiveRecord
{
    public static function tableName()
    {
        return 'customer';
    }
}

$user = new User();
$user->name = 'Qiang';
$user->save();  // a new row is inserted into user table

// the following will retrieve the user 'CeBe' from the database
$user = User::find()->where(['name' => 'CeBe'])->one();

// this will get related records from orders table when relation is defined
$orders = $user->orders;

attributes() public method

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.

public array attributes ( )
return	array	List of attribute names.

delete() public method

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.

public integer|false delete ( )
return	integer|false	The number of rows deleted, or false if the deletion is unsuccessful for some reason. Note that it is possible the number of rows deleted is 0, even though the deletion execution is successful.
throws	yii\db\StaleObjectException	if optimistic locking is enabled and the data being deleted is outdated.
throws	Exception	in case delete failed.

deleteAll() public static method

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.

public static integer deleteAll ( $condition = null, $params = [] )
$condition	string|array	The conditions that will be put in the WHERE part of the DELETE SQL. Please refer to yii\db\Query::where() on how to specify this parameter.
$params	array	The parameters (name => value) to be bound to the query.
return	integer	The number of rows deleted

deleteInternal() protected method

Deletes an ActiveRecord without considering transaction.

protected integer|false deleteInternal ( )
return	integer|false	The number of rows deleted, or false if the deletion is unsuccessful for some reason. Note that it is possible the number of rows deleted is 0, even though the deletion execution is successful.
throws	yii\db\StaleObjectException

equals() public method

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.

public boolean equals ( $record )
$record	yii\db\ActiveRecord	Record to compare to
return	boolean	Whether the two active records refer to the same row in the same database table.

find() public static method

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();

public static yii\db\ActiveQuery find ( )
return	yii\db\ActiveQuery	The newly created yii\db\ActiveQuery instance.

findByCondition() protected static method

Finds ActiveRecord instance(s) by the given condition.

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

protected static yii\db\ActiveQueryInterface findByCondition ( $condition )
$condition	mixed	Please refer to findOne() for the explanation of this parameter
return	yii\db\ActiveQueryInterface	The newly created ActiveQuery instance.
throws	yii\base\InvalidConfigException	if there is no primary key defined

findBySql() public static method

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();

public static yii\db\ActiveQuery findBySql ( $sql, $params = [] )
$sql	string	The SQL statement to be executed
$params	array	Parameters to be bound to the SQL statement during execution.
return	yii\db\ActiveQuery	The newly created yii\db\ActiveQuery instance

getDb() public static method

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.

public static yii\db\Connection getDb ( )
return	yii\db\Connection	The database connection used by this AR class.

getTableSchema() public static method

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

public static yii\db\TableSchema getTableSchema ( )
return	yii\db\TableSchema	The schema information of the DB table associated with this AR class.
throws	yii\base\InvalidConfigException	if the table for the AR class does not exist.

insert() public method

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();

public boolean insert ( $runValidation = true, $attributes = null )
$runValidation	boolean	Whether to perform validation (calling validate()) before saving the record. Defaults to true. If the validation fails, the record will not be saved to the database and this method will return false.
$attributes	array	List of attributes that need to be saved. Defaults to null, meaning all attributes that are loaded from DB will be saved.
return	boolean	Whether the attributes are valid and the record is inserted successfully.
throws	Exception	in case insert failed.

insertInternal() protected method

Inserts an ActiveRecord into DB without considering transaction.

protected boolean insertInternal ( $attributes = null )
$attributes	array	List of attributes that need to be saved. Defaults to null, meaning all attributes that are loaded from DB will be saved.
return	boolean	Whether the record is inserted successfully.

isTransactional() public method

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

public boolean isTransactional ( $operation )
$operation	integer	The operation to check. Possible values are OP_INSERT, OP_UPDATE and OP_DELETE.
return	boolean	Whether the specified operation is transactional in the current $scenario.

loadDefaultValues() public method

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();

public $this loadDefaultValues ( $skipIfSet = true )
$skipIfSet	boolean	Whether existing value should be preserved. This will only set defaults for attributes that are null.
return	$this	The model instance itself.

populateRecord() public static method

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.

public static void populateRecord ( $record, $row )
$record	yii\db\BaseActiveRecord	The record to be populated. In most cases this will be an instance created by instantiate() beforehand.
$row	array	Attribute values (name => value)

primaryKey() public static method

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.

public static string[] primaryKey ( )
return	string[]	The primary keys of the associated database table.

tableName() public static method

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.

public static string tableName ( )
return	string	The table name

transactions() public method

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.

public array transactions ( )
return	array	The declarations of transactional operations. The array keys are scenarios names, and the array values are the corresponding transaction operations.

update() public method

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
}

public integer|false update ( $runValidation = true, $attributeNames = null )
$runValidation	boolean	Whether to perform validation (calling validate()) before saving the record. Defaults to true. If the validation fails, the record will not be saved to the database and this method will return false.
$attributeNames	array	List of attributes that need to be saved. Defaults to null, meaning all attributes that are loaded from DB will be saved.
return	integer|false	The number of rows affected, or false if validation fails or beforeSave() stops the updating process.
throws	yii\db\StaleObjectException	if optimistic locking is enabled and the data being updated is outdated.
throws	Exception	in case update failed.

updateAll() public static method

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.

public static integer updateAll ( $attributes, $condition = '', $params = [] )
$attributes	array	Attribute values (name-value pairs) to be saved into the table
$condition	string|array	The conditions that will be put in the WHERE part of the UPDATE SQL. Please refer to yii\db\Query::where() on how to specify this parameter.
$params	array	The parameters (name => value) to be bound to the query.
return	integer	The number of rows updated

updateAllCounters() public static method

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.

public static integer updateAllCounters ( $counters, $condition = '', $params = [] )
$counters	array	The counters to be updated (attribute name => increment value). Use negative values if you want to decrement the counters.
$condition	string|array	The conditions that will be put in the WHERE part of the UPDATE SQL. Please refer to yii\db\Query::where() on how to specify this parameter.
$params	array	The parameters (name => value) to be bound to the query. Do not name the parameters as :bp0, :bp1, etc., because they are used internally by this method.
return	integer	The number of rows updated