ActiveRecord is the base class for classes representing relational data in terms of objects.
Active Record implements the Active Record design pattern. The premise behind Active Record is that an individual yii\db\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 the corresponding table column for that record.
As an example, say that the Customer ActiveRecord class is associated with the customer table. This would mean that the class's name attribute is automatically mapped to the name column in customer table. 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.
To declare an ActiveRecord class you need to extend yii\db\ActiveRecord and implement the tableName method:
<?php
class Customer extends \yii\db\ActiveRecord
{
public static function tableName()
{
return 'customer';
}
}
The tableName method only has to return the name of the database table associated with the class.
Tip: You may also use the Gii code generator to generate ActiveRecord classes from your database tables.
Class instances are obtained in one of two ways:
new operator to create a new, empty objectBelow is an example showing some typical usage of ActiveRecord:
$user = new User();
$user->name = 'Qiang';
$user->save();
$user = User::find()->where(['name' => 'CeBe'])->one();
$orders = $user->orders;
For more details and usage information on ActiveRecord, see the guide article on ActiveRecord.
Defined in: yii\base\Component::__call()
Calls the named method which is not a class method.
This method will check if any attached behavior has the named method and will execute it if available.
Do not call this method directly as it is a PHP magic method that will be implicitly called when an unknown method is being invoked.
public function __call($name, $params)
{
$this->ensureBehaviors();
foreach ($this->_behaviors as $object) {
if ($object->hasMethod($name)) {
return call_user_func_array([$object, $name], $params);
}
}
throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
}
Defined in: yii\base\Model::__clone()
This method is called after the object is created by cloning an existing one.
It removes all behaviors because they are attached to the old object.
public function __clone()
{
parent::__clone();
$this->_errors = null;
$this->_validators = null;
}
Defined in: yii\base\BaseObject::__construct()
Constructor.
The default implementation does two things:
$config.If this method is overridden in a child class, it is recommended that
$config here.Name-value pairs that will be used to initialize the object properties
public function __construct($config = [])
{
if (!empty($config)) {
Yii::configure($this, $config);
}
$this->init();
}
public function __get($name)
{
if (array_key_exists($name, $this->_attributes)) {
return $this->_attributes[$name];
}
if ($this->hasAttribute($name)) {
return null;
}
if (array_key_exists($name, $this->_related)) {
return $this->_related[$name];
}
$value = parent::__get($name);
if ($value instanceof ActiveQueryInterface) {
$this->setRelationDependencies($name, $value);
return $this->_related[$name] = $value->findFor($name, $this);
}
return $value;
}
Defined in: yii\db\BaseActiveRecord::__isset()
Checks if a property value is null.
This method overrides the parent implementation by checking if the named attribute is null or not.
public function __isset($name)
{
try {
return $this->__get($name) !== null;
} catch (\Exception $t) {
return false;
} catch (\Throwable $e) {
return false;
}
}
public void __set ( $name, $value ) $name string
Property name
$value mixedProperty value
public function __set($name, $value)
{
if ($this->hasAttribute($name)) {
if (
!empty($this->_relationsDependencies[$name])
&& (!array_key_exists($name, $this->_attributes) || $this->_attributes[$name] !== $value)
) {
$this->resetDependentRelations($name);
}
$this->_attributes[$name] = $value;
} else {
parent::__set($name, $value);
}
}
Defined in: yii\db\BaseActiveRecord::__unset()
Sets a component property to be null.
This method overrides the parent implementation by clearing the specified attribute value.
public void __unset ( $name ) $name stringThe property name or the event name
public function __unset($name)
{
if ($this->hasAttribute($name)) {
unset($this->_attributes[$name]);
if (!empty($this->_relationsDependencies[$name])) {
$this->resetDependentRelations($name);
}
} elseif (array_key_exists($name, $this->_related)) {
unset($this->_related[$name]);
} elseif ($this->getRelation($name, false) === null) {
parent::__unset($name);
}
}
public function activeAttributes()
{
$scenario = $this->getScenario();
$scenarios = $this->scenarios();
if (!isset($scenarios[$scenario])) {
return [];
}
$attributes = array_keys(array_flip($scenarios[$scenario]));
foreach ($attributes as $i => $attribute) {
if (strncmp($attribute, '!', 1) === 0) {
$attributes[$i] = substr($attribute, 1);
}
}
return $attributes;
}
public void addError ( $attribute, $error = '' ) $attribute string
Attribute name
$error stringNew error message
public function addError($attribute, $error = '')
{
$this->_errors[$attribute][] = $error;
}
public void addErrors ( array $items ) $items array
A list of errors. The array keys must be attribute names. The array values should be error messages. If an attribute has multiple errors, these errors must be given in terms of an array. You may use the result of getErrors() as the value for this parameter.
public function addErrors(array $items)
{
foreach ($items as $attribute => $errors) {
if (is_array($errors)) {
foreach ($errors as $error) {
$this->addError($attribute, $error);
}
} else {
$this->addError($attribute, $errors);
}
}
}
Defined in: yii\db\BaseActiveRecord::afterDelete()
This method is invoked after deleting a record.
The default implementation raises the EVENT_AFTER_DELETE event. You may override this method to do postprocessing after the record is deleted. Make sure you call the parent implementation so that the event is raised properly.
public function afterDelete()
{
$this->trigger(self::EVENT_AFTER_DELETE);
}
Defined in: yii\db\BaseActiveRecord::afterFind()
This method is called when the AR object is created and populated with the query result.
The default implementation will trigger an EVENT_AFTER_FIND event. When overriding this method, make sure you call the parent implementation to ensure the event is triggered.
public function afterFind()
{
$this->trigger(self::EVENT_AFTER_FIND);
}
public function afterRefresh()
{
$this->trigger(self::EVENT_AFTER_REFRESH);
}
public void afterSave ( $insert, $changedAttributes ) $insert boolean
Whether this method called while inserting a record. If false, it means the method is called while updating a record.
The old values of attributes that had changed and were saved. You can use this parameter to take action based on the changes made for example send an email when the password had changed or implement audit trail that tracks all the changes. $changedAttributes gives you the old attribute values while the active record ($this) has already the new, updated values.
Note that no automatic type conversion performed by default. You may use yii\behaviors\AttributeTypecastBehavior to facilitate attribute typecasting. See https://www.yiiframework.com/doc-2.0/guide-db-active-record.html#attributes-typecasting.
public function afterSave($insert, $changedAttributes)
{
$this->trigger($insert ? self::EVENT_AFTER_INSERT : self::EVENT_AFTER_UPDATE, new AfterSaveEvent([
'changedAttributes' => $changedAttributes,
]));
}
Defined in: yii\base\Model::afterValidate()
This method is invoked after validation ends.
The default implementation raises an afterValidate event. You may override this method to do postprocessing after validation. Make sure the parent implementation is invoked so that the event can be raised.
public function afterValidate()
{
$this->trigger(self::EVENT_AFTER_VALIDATE);
}
public function attachBehavior($name, $behavior)
{
$this->ensureBehaviors();
return $this->attachBehaviorInternal($name, $behavior);
}
public void attachBehaviors ( $behaviors ) $behaviors array
List of behaviors to be attached to the component
public function attachBehaviors($behaviors)
{
$this->ensureBehaviors();
foreach ($behaviors as $name => $behavior) {
$this->attachBehaviorInternal($name, $behavior);
}
}
Defined in: yii\base\Model::attributeHints()
Returns the attribute hints.
Attribute hints are mainly used for display purpose. For example, given an attribute isPublic, we can declare a hint Whether the post should be visible for not logged in users, which provides user-friendly description of the attribute meaning and can be displayed to end users.
Unlike label hint will not be generated, if its explicit declaration is omitted.
Note, in order to inherit hints defined in the parent class, a child class needs to merge the parent hints with child hints using functions such as array_merge().
public function attributeHints()
{
return [];
}
Defined in: yii\base\Model::attributeLabels()
Returns the attribute labels.
Attribute labels are mainly used for display purpose. For example, given an attribute firstName, we can declare a label First Name which is more user-friendly and can be displayed to end users.
By default an attribute label is generated using generateAttributeLabel(). This method allows you to explicitly specify attribute labels.
Note, in order to inherit labels defined in the parent class, a child class needs to merge the parent labels with child labels using functions such as array_merge().
See also generateAttributeLabel().
public function attributeLabels()
{
return [];
}
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 function attributes()
{
return static::getTableSchema()->getColumnNames();
}
Defined in: yii\db\BaseActiveRecord::beforeDelete()
This method is invoked before deleting a record.
The default implementation raises the EVENT_BEFORE_DELETE event. When overriding this method, make sure you call the parent implementation like the following:
public function beforeDelete()
{
if (!parent::beforeDelete()) {
return false;
}
return true;
}
public function beforeDelete()
{
$event = new ModelEvent();
$this->trigger(self::EVENT_BEFORE_DELETE, $event);
return $event->isValid;
}
Defined in: yii\db\BaseActiveRecord::beforeSave()
This method is called at the beginning of inserting or updating a record.
The default implementation will trigger an EVENT_BEFORE_INSERT event when $insert is true, or an EVENT_BEFORE_UPDATE event if $insert is false. When overriding this method, make sure you call the parent implementation like the following:
public function beforeSave($insert)
{
if (!parent::beforeSave($insert)) {
return false;
}
return true;
}
Whether this method called while inserting a record. If false, it means the method is called while updating a record.
Whether the insertion or updating should continue. If false, the insertion or updating will be cancelled.
public function beforeSave($insert)
{
$event = new ModelEvent();
$this->trigger($insert ? self::EVENT_BEFORE_INSERT : self::EVENT_BEFORE_UPDATE, $event);
return $event->isValid;
}
Defined in: yii\base\Model::beforeValidate()
This method is invoked before validation starts.
The default implementation raises a beforeValidate event. You may override this method to do preliminary checks before validation. Make sure the parent implementation is invoked so that the event can be raised.
Whether the validation should be executed. Defaults to true. If false is returned, the validation will stop and the model is considered invalid.
public function beforeValidate()
{
$event = new ModelEvent();
$this->trigger(self::EVENT_BEFORE_VALIDATE, $event);
return $event->isValid;
}
Defined in: yii\base\Component::behaviors()
Returns a list of behaviors that this component should behave as.
Child classes may override this method to specify the behaviors they want to behave as.
The return value of this method should be an array of behavior objects or configurations indexed by behavior names. A behavior configuration can be either a string specifying the behavior class or an array of the following structure:
'behaviorName' => [
'class' => 'BehaviorClass',
'property1' => 'value1',
'property2' => 'value2',
]
Note that a behavior class must extend from yii\base\Behavior. Behaviors can be attached using a name or anonymously. When a name is used as the array key, using this name, the behavior can later be retrieved using getBehavior() or be detached using detachBehavior(). Anonymous behaviors can not be retrieved or detached.
Behaviors declared in this method will be attached to the component automatically (on demand).
public function behaviors()
{
return [];
}
Defined in: yii\db\BaseActiveRecord::canGetProperty()
Returns a value indicating whether a property can be read.
A property can be read if:
$checkVars is true);$checkBehaviors is true).The property name
$checkVars booleanWhether to treat member variables as properties
$checkBehaviors booleanWhether to treat behaviors' properties as properties of this component
return booleanWhether the property can be read
public function canGetProperty($name, $checkVars = true, $checkBehaviors = true)
{
if (parent::canGetProperty($name, $checkVars, $checkBehaviors)) {
return true;
}
try {
return $this->hasAttribute($name);
} catch (\Exception $e) {
return false;
}
}
public function canSetOldAttribute($name)
{
return (isset($this->_oldAttributes[$name]) || $this->hasAttribute($name));
}
Defined in: yii\db\BaseActiveRecord::canSetProperty()
Returns a value indicating whether a property can be set.
A property can be written if:
$checkVars is true);$checkBehaviors is true).The property name
$checkVars booleanWhether to treat member variables as properties
$checkBehaviors booleanWhether to treat behaviors' properties as properties of this component
return booleanWhether the property can be written
public function canSetProperty($name, $checkVars = true, $checkBehaviors = true)
{
if (parent::canSetProperty($name, $checkVars, $checkBehaviors)) {
return true;
}
try {
return $this->hasAttribute($name);
} catch (\Exception $e) {
return false;
}
}
Deprecated since 2.0.14. On PHP >=5.5, use ::class instead.
public static function className()
{
return get_called_class();
}
public void clearErrors ( $attribute = null ) $attribute string|null
Attribute name. Use null to remove errors for all attributes.
public function clearErrors($attribute = null)
{
if ($attribute === null) {
$this->_errors = [];
} else {
unset($this->_errors[$attribute]);
}
}
protected function createRelationQuery($class, $link, $multiple)
{
$query = $class::find();
$query->primaryModel = $this;
$query->link = $link;
$query->multiple = $multiple;
return $query;
}
public function createValidators()
{
$validators = new ArrayObject();
foreach ($this->rules() as $rule) {
if ($rule instanceof Validator) {
$validators->append($rule);
} elseif (is_array($rule) && isset($rule[0], $rule[1])) {
$validator = Validator::createValidator($rule[1], $this, (array) $rule[0], array_slice($rule, 2));
$validators->append($validator);
} else {
throw new InvalidConfigException('Invalid validation rule: a rule must specify both attribute names and validator type.');
}
}
return $validators;
}
Deletes the table row corresponding to this active record.
This method performs the following steps in order:
false, it will skip the rest of the steps;In the above step 1 and 3, events named EVENT_BEFORE_DELETE and EVENT_AFTER_DELETE will be raised by the corresponding methods.
public function delete()
{
if (!$this->isTransactional(self::OP_DELETE)) {
return $this->deleteInternal();
}
$transaction = static::getDb()->beginTransaction();
try {
$result = $this->deleteInternal();
if ($result === false) {
$transaction->rollBack();
} else {
$transaction->commit();
}
return $result;
} catch (\Exception $e) {
$transaction->rollBack();
throw $e;
} catch (\Throwable $e) {
$transaction->rollBack();
throw $e;
}
}
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|nullThe 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 arrayThe parameters (name => value) to be bound to the query.
return integerThe number of rows deleted
public static function deleteAll($condition = null, $params = [])
{
$command = static::getDb()->createCommand();
$command->delete(static::tableName(), $condition, $params);
return $command->execute();
}
Deletes an ActiveRecord without considering transaction.
protected function deleteInternal()
{
if (!$this->beforeDelete()) {
return false;
}
$condition = $this->getOldPrimaryKey(true);
$lock = $this->optimisticLock();
if ($lock !== null) {
$condition[$lock] = $this->$lock;
}
$result = static::deleteAll($condition);
if ($lock !== null && !$result) {
throw new StaleObjectException('The object being deleted is outdated.');
}
$this->setOldAttributes(null);
$this->afterDelete();
return $result;
}
public function detachBehavior($name)
{
$this->ensureBehaviors();
if (isset($this->_behaviors[$name])) {
$behavior = $this->_behaviors[$name];
unset($this->_behaviors[$name]);
$behavior->detach();
return $behavior;
}
return null;
}
public function detachBehaviors()
{
$this->ensureBehaviors();
foreach ($this->_behaviors as $name => $behavior) {
$this->detachBehavior($name);
}
}
public function ensureBehaviors()
{
if ($this->_behaviors === null) {
$this->_behaviors = [];
foreach ($this->behaviors() as $name => $behavior) {
$this->attachBehaviorInternal($name, $behavior);
}
}
}
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 function equals($record)
{
if ($this->isNewRecord || $record->isNewRecord) {
return false;
}
return static::tableName() === $record->tableName() && $this->getPrimaryKey() === $record->getPrimaryKey();
}
Defined in: yii\base\ArrayableTrait::fields()
Returns the list of fields that should be returned by default by toArray() when no specific fields are specified.
A field is a named element in the returned array by toArray().
This method should return an array of field names or field definitions. If the former, the field name will be treated as an object property name whose value will be used as the field value. If the latter, the array key should be the field name while the array value should be the corresponding field definition which can be either an object property name or a PHP callable returning the corresponding field value. The signature of the callable should be:
function ($model, $field) {
}
For example, the following code declares four fields:
email: the field name is the same as the property name email;firstName and lastName: the field names are firstName and lastName, and their values are obtained from the first_name and last_name properties;fullName: the field name is fullName. Its value is obtained by concatenating first_name and last_name.return [
'email',
'firstName' => 'first_name',
'lastName' => 'last_name',
'fullName' => function () {
return $this->first_name . ' ' . $this->last_name;
},
];
In this method, you may also want to return different lists of fields based on some context information. For example, depending on the privilege of the current application user, you may return different sets of visible fields or filter out some fields.
The default implementation of this method returns the public object member variables indexed by themselves.
See also toArray().
public array fields ( ) return arrayThe list of field names or field definitions.
public function fields()
{
$fields = array_keys(Yii::getObjectVars($this));
return array_combine($fields, $fields);
}
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,
$customer = Customer::find()->where(['id' => 1])->one();
$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()
{
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]);
}
}
$customers = Customer::find()->andWhere('age>30')->all();
$customers = Customer::find()->where('age>30')->all();
public static function find()
{
return Yii::createObject(ActiveQuery::className(), [get_called_class()]);
}
Defined in: yii\db\BaseActiveRecord::findAll()
Returns a list of active record models that match the specified primary key value(s) or a set of column values.
The method accepts:
WHERE condition.['id' => 1, 2] is treated as a non-associative array. Column names are limited to current records table columns for SQL DBMS, or filtered otherwise to be limted to simple filter conditions.This method will automatically call the all() method and return an array of ActiveRecord instances.
Note: As this is a short-hand method only, using more complex conditions, like ['!=', 'id', 1] will not work. If you need to specify more complex conditions, use find() in combination with where() instead.
See the following code for usage examples:
$customers = Customer::findAll(10);
$customers = Customer::find()->where(['id' => 10])->all();
$customers = Customer::findAll([10, 11, 12]);
$customers = Customer::find()->where(['id' => [10, 11, 12]])->all();
$customers = Customer::findAll(['age' => 30, 'status' => 1]);
$customers = Customer::find()->where(['age' => 30, 'status' => 1])->all();
If you need to pass user input to this method, make sure the input value is scalar or in case of array condition, make sure the array structure can not be changed from the outside:
public function actionView($id)
{
$model = Post::findOne($id);
}
$model = Post::findOne(['id' => Yii::$app->request->get('id')]);
$model = Post::findOne(Yii::$app->request->get('id'));
Primary key value or a set of column values
return yii\db\BaseActiveRecord[]An array of ActiveRecord instances, or an empty array if nothing matches.
public static function findAll($condition)
{
return static::findByCondition($condition)->all();
}
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 function findBySql($sql, $params = [])
{
$query = static::find();
$query->sql = $sql;
return $query->params($params);
}
Defined in: yii\db\BaseActiveRecord::findOne()
Returns a single active record model instance by a primary key or an array of column values.
The method accepts:
null if not found).null if not found).null if not found). Note that ['id' => 1, 2] is treated as a non-associative array. Column names are limited to current records table columns for SQL DBMS, or filtered otherwise to be limited to simple filter conditions.That this method will automatically call the one() method and return an ActiveRecord instance.
Note: As this is a short-hand method only, using more complex conditions, like ['!=', 'id', 1] will not work. If you need to specify more complex conditions, use find() in combination with where() instead.
See the following code for usage examples:
$customer = Customer::findOne(10);
$customer = Customer::find()->where(['id' => 10])->one();
$customers = Customer::findOne([10, 11, 12]);
$customers = Customer::find()->where(['id' => [10, 11, 12]])->one();
$customer = Customer::findOne(['age' => 30, 'status' => 1]);
$customer = Customer::find()->where(['age' => 30, 'status' => 1])->one();
If you need to pass user input to this method, make sure the input value is scalar or in case of array condition, make sure the array structure can not be changed from the outside:
public function actionView($id)
{
$model = Post::findOne($id);
}
$model = Post::findOne(['id' => Yii::$app->request->get('id')]);
$model = Post::findOne(Yii::$app->request->get('id'));
Primary key value or a set of column values
return yii\db\BaseActiveRecord|nullActiveRecord instance matching the condition, or null if nothing matches.
public static function findOne($condition)
{
return static::findByCondition($condition)->one();
}
Defined in: yii\base\Model::formName()
Returns the form name that this model class should use.
The form name is mainly used by yii\widgets\ActiveForm to determine how to name the input fields for the attributes in a model. If the form name is "A" and an attribute name is "b", then the corresponding input name would be "A[b]". If the form name is an empty string, then the input name would be "b".
The purpose of the above naming schema is that for forms which contain multiple different models, the attributes of each model are grouped in sub-arrays of the POST-data and it is easier to differentiate between them.
By default, this method returns the model class name (without the namespace part) as the form name. You may override it when the model is used in different forms.
See also load().
public function formName()
{
$reflector = new ReflectionClass($this);
if (PHP_VERSION_ID >= 70000 && $reflector->isAnonymous()) {
throw new InvalidConfigException('The "formName()" method should be explicitly defined for anonymous models');
}
return $reflector->getShortName();
}
Defined in: yii\base\Model::generateAttributeLabel()
Generates a user friendly attribute label based on the give attribute name.
This is done by replacing underscores, dashes and dots with blanks and changing the first letter of each word to upper case. For example, 'department_name' or 'DepartmentName' will generate 'Department Name'.
public function generateAttributeLabel($name)
{
return Inflector::camel2words($name, true);
}
public function getActiveValidators($attribute = null)
{
$activeAttributes = $this->activeAttributes();
if ($attribute !== null && !in_array($attribute, $activeAttributes, true)) {
return [];
}
$scenario = $this->getScenario();
$validators = [];
foreach ($this->getValidators() as $validator) {
if ($attribute === null) {
$validatorAttributes = $validator->getValidationAttributes($activeAttributes);
$attributeValid = !empty($validatorAttributes);
} else {
$attributeValid = in_array($attribute, $validator->getValidationAttributes($attribute), true);
}
if ($attributeValid && $validator->isActive($scenario)) {
$validators[] = $validator;
}
}
return $validators;
}
public mixed getAttribute ( $name ) $name string
The attribute name
return mixedThe attribute value. null if the attribute is not set or does not exist.
public function getAttribute($name)
{
return isset($this->_attributes[$name]) ? $this->_attributes[$name] : null;
}
public function getAttributeHint($attribute)
{
$hints = $this->attributeHints();
if (isset($hints[$attribute])) {
return $hints[$attribute];
} elseif (strpos($attribute, '.')) {
$attributeParts = explode('.', $attribute);
$neededAttribute = array_pop($attributeParts);
$relatedModel = $this;
foreach ($attributeParts as $relationName) {
if ($relatedModel->isRelationPopulated($relationName) && $relatedModel->$relationName instanceof self) {
$relatedModel = $relatedModel->$relationName;
} else {
try {
$relation = $relatedModel->getRelation($relationName);
} catch (InvalidParamException $e) {
return '';
}
$modelClass = $relation->modelClass;
$relatedModel = $modelClass::instance();
}
}
$hints = $relatedModel->attributeHints();
if (isset($hints[$neededAttribute])) {
return $hints[$neededAttribute];
}
}
return '';
}
Defined in: yii\db\BaseActiveRecord::getAttributeLabel()
Returns the text label for the specified attribute.
The attribute may be specified in a dot format to retrieve the label from related model or allow this model to override the label defined in related model. For example, if the attribute is specified as 'relatedModel1.relatedModel2.attr' the function will return the first label definition it can find in the following order:
See also:
public function getAttributeLabel($attribute)
{
$model = $this;
$modelAttribute = $attribute;
for (;;) {
$labels = $model->attributeLabels();
if (isset($labels[$modelAttribute])) {
return $labels[$modelAttribute];
}
$parts = explode('.', $modelAttribute, 2);
if (count($parts) < 2) {
break;
}
list ($relationName, $modelAttribute) = $parts;
if ($model->isRelationPopulated($relationName) && $model->$relationName instanceof self) {
$model = $model->$relationName;
} else {
try {
$relation = $model->getRelation($relationName);
} catch (InvalidArgumentException $e) {
break;
}
$modelClass = $relation->modelClass;
$model = $modelClass::instance();
}
}
return $this->generateAttributeLabel($attribute);
}
public array getAttributes ( $names = null, $except = [] ) $names array|null
List of attributes whose value needs to be returned. Defaults to null, meaning all attributes listed in attributes() will be returned. If it is an array, only the attributes in the array will be returned.
$except arrayList of attributes whose value should NOT be returned.
return arrayAttribute values (name => value).
public function getAttributes($names = null, $except = [])
{
$values = [];
if ($names === null) {
$names = $this->attributes();
}
foreach ($names as $name) {
$values[$name] = $this->$name;
}
foreach ($except as $name) {
unset($values[$name]);
}
return $values;
}
public function getBehavior($name)
{
$this->ensureBehaviors();
return isset($this->_behaviors[$name]) ? $this->_behaviors[$name] : null;
}
public function getBehaviors()
{
$this->ensureBehaviors();
return $this->_behaviors;
}
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 function getDb()
{
return Yii::$app->getDb();
}
Defined in: yii\db\BaseActiveRecord::getDirtyAttributes()
Returns the attribute values that have been modified since they are loaded or saved most recently.
The comparison of new and old values is made for identical values using ===.
The names of the attributes whose values may be returned if they are changed recently. If null, attributes() will be used.
return arrayThe changed attribute values (name-value pairs)
public function getDirtyAttributes($names = null)
{
if ($names === null) {
$names = $this->attributes();
}
$names = array_flip($names);
$attributes = [];
if ($this->_oldAttributes === null) {
foreach ($this->_attributes as $name => $value) {
if (isset($names[$name])) {
$attributes[$name] = $value;
}
}
} else {
foreach ($this->_attributes as $name => $value) {
if (isset($names[$name]) && (!array_key_exists($name, $this->_oldAttributes) || $this->isValueDifferent($value, $this->_oldAttributes[$name]))) {
$attributes[$name] = $value;
}
}
}
return $attributes;
}
public array getErrorSummary ( $showAllErrors ) $showAllErrors boolean
Boolean, if set to true every error message for each attribute will be shown otherwise only the first error message for each attribute will be shown.
return arrayErrors for all attributes as a one-dimensional array. Empty array is returned if no error.
public function getErrorSummary($showAllErrors)
{
$lines = [];
$errors = $showAllErrors ? $this->getErrors() : $this->getFirstErrors();
foreach ($errors as $es) {
$lines = array_merge($lines, (array)$es);
}
return $lines;
}
public array getErrors ( $attribute = null ) $attribute string|null
Attribute name. Use null to retrieve errors for all attributes.
return arrayErrors for all attributes or the specified attribute. Empty array is returned if no error. See getErrors() for detailed description. Note that when returning errors for all attributes, the result is a two-dimensional array, like the following:
[
'username' => [
'Username is required.',
'Username must contain only word characters.',
],
'email' => [
'Email address is invalid.',
]
]
public function getErrors($attribute = null)
{
if ($attribute === null) {
return $this->_errors === null ? [] : $this->_errors;
}
return isset($this->_errors[$attribute]) ? $this->_errors[$attribute] : [];
}
public function getFirstError($attribute)
{
return isset($this->_errors[$attribute]) ? reset($this->_errors[$attribute]) : null;
}
public array getFirstErrors ( ) return array
The first errors. The array keys are the attribute names, and the array values are the corresponding error messages. An empty array will be returned if there is no error.
public function getFirstErrors()
{
if (empty($this->_errors)) {
return [];
}
$errors = [];
foreach ($this->_errors as $name => $es) {
if (!empty($es)) {
$errors[$name] = reset($es);
}
}
return $errors;
}
public function getIsNewRecord()
{
return $this->_oldAttributes === null;
}
public function getIterator()
{
$attributes = $this->getAttributes();
return new ArrayIterator($attributes);
}
public mixed getOldAttribute ( $name ) $name string
The attribute name
return mixedThe old attribute value. null if the attribute is not loaded before or does not exist.
public function getOldAttribute($name)
{
return isset($this->_oldAttributes[$name]) ? $this->_oldAttributes[$name] : null;
}
public function getOldAttributes()
{
return $this->_oldAttributes === null ? [] : $this->_oldAttributes;
}
Defined in: yii\db\BaseActiveRecord::getOldPrimaryKey()
Returns the old primary key value(s).
This refers to the primary key value that is populated into the record after executing a find method (e.g. find(), findOne()). The value remains unchanged even if the primary key attribute is manually assigned with a different value.
public mixed getOldPrimaryKey ( $asArray = false ) $asArray booleanWhether to return the primary key value as an array. If true, the return value will be an array with column name as key and column value as value. If this is false (default), a scalar value will be returned for non-composite primary key.
The old primary key value. An array (column name => column value) is returned if the primary key is composite or $asArray is true. A string is returned otherwise (null will be returned if the key value is null).
if the AR model does not have a primary key
public function getOldPrimaryKey($asArray = false)
{
$keys = static::primaryKey();
if (empty($keys)) {
throw new Exception(get_class($this) . ' does not have a primary key. You should either define a primary key for the corresponding table or override the primaryKey() method.');
}
if (!$asArray && count($keys) === 1) {
return isset($this->_oldAttributes[$keys[0]]) ? $this->_oldAttributes[$keys[0]] : null;
}
$values = [];
foreach ($keys as $name) {
$values[$name] = isset($this->_oldAttributes[$name]) ? $this->_oldAttributes[$name] : null;
}
return $values;
}
public mixed getPrimaryKey ( $asArray = false ) $asArray boolean
Whether to return the primary key value as an array. If true, the return value will be an array with column names as keys and column values as values. Note that for composite primary keys, an array will always be returned regardless of this parameter value.
The primary key value. An array (column name => column value) is returned if the primary key is composite or $asArray is true. A string is returned otherwise (null will be returned if the key value is null).
public function getPrimaryKey($asArray = false)
{
$keys = static::primaryKey();
if (!$asArray && count($keys) === 1) {
return isset($this->_attributes[$keys[0]]) ? $this->_attributes[$keys[0]] : null;
}
$values = [];
foreach ($keys as $name) {
$values[$name] = isset($this->_attributes[$name]) ? $this->_attributes[$name] : null;
}
return $values;
}
public function getRelation($name, $throwException = true)
{
$getter = 'get' . $name;
try {
$relation = $this->$getter();
} catch (UnknownMethodException $e) {
if ($throwException) {
throw new InvalidArgumentException(get_class($this) . ' has no relation named "' . $name . '".', 0, $e);
}
return null;
}
if (!$relation instanceof ActiveQueryInterface) {
if ($throwException) {
throw new InvalidArgumentException(get_class($this) . ' has no relation named "' . $name . '".');
}
return null;
}
if (method_exists($this, $getter)) {
$method = new \ReflectionMethod($this, $getter);
$realName = lcfirst(substr($method->getName(), 3));
if ($realName !== $name) {
if ($throwException) {
throw new InvalidArgumentException('Relation names are case sensitive. ' . get_class($this) . " has a relation named \"$realName\" instead of \"$name\".");
}
return null;
}
}
return $relation;
}
Defined in: yii\base\Model::getScenario()
Returns the scenario that this model is used in.
Scenario affects how validation is performed and which attributes can be massively assigned.
public function getScenario()
{
return $this->_scenario;
}
Returns the schema information of the DB table associated with this AR class.
public static function getTableSchema()
{
$tableSchema = static::getDb()
->getSchema()
->getTableSchema(static::tableName());
if ($tableSchema === null) {
throw new InvalidConfigException('The table does not exist: ' . static::tableName());
}
return $tableSchema;
}
Defined in: yii\base\Model::getValidators()
Returns all the validators declared in rules().
This method differs from getActiveValidators() in that the latter only returns the validators applicable to the current $scenario.
Because this method returns an ArrayObject object, you may manipulate it by inserting or removing validators (useful in model behaviors). For example,
$model->validators[] = $newValidator;
public function getValidators()
{
if ($this->_validators === null) {
$this->_validators = $this->createValidators();
}
return $this->_validators;
}
public function hasAttribute($name)
{
return isset($this->_attributes[$name]) || in_array($name, $this->attributes(), true);
}
public function hasErrors($attribute = null)
{
return $attribute === null ? !empty($this->_errors) : isset($this->_errors[$attribute]);
}
public function hasEventHandlers($name)
{
$this->ensureBehaviors();
if (!empty($this->_events[$name])) {
return true;
}
foreach ($this->_eventWildcards as $wildcard => $handlers) {
if (!empty($handlers) && StringHelper::matchWildcard($wildcard, $name)) {
return true;
}
}
return Event::hasHandlers($this, $name);
}
Defined in: yii\base\Component::hasMethod()
Returns a value indicating whether a method is defined.
A method is defined if:
$checkBehaviors is true).The property name
$checkBehaviors booleanWhether to treat behaviors' methods as methods of this component
return booleanWhether the method is defined
public function hasMethod($name, $checkBehaviors = true)
{
if (method_exists($this, $name)) {
return true;
} elseif ($checkBehaviors) {
$this->ensureBehaviors();
foreach ($this->_behaviors as $behavior) {
if ($behavior->hasMethod($name)) {
return true;
}
}
}
return false;
}
Defined in: yii\base\Component::hasProperty()
Returns a value indicating whether a property is defined for this component.
A property is defined if:
$checkVars is true);$checkBehaviors is true).See also:
public boolean hasProperty ( $name, $checkVars = true, $checkBehaviors = true ) $name stringThe property name
$checkVars booleanWhether to treat member variables as properties
$checkBehaviors booleanWhether to treat behaviors' properties as properties of this component
return booleanWhether the property is defined
public function hasProperty($name, $checkVars = true, $checkBehaviors = true)
{
return $this->canGetProperty($name, $checkVars, $checkBehaviors) || $this->canSetProperty($name, false, $checkBehaviors);
}
public function init()
{
parent::init();
$this->trigger(self::EVENT_INIT);
}
Inserts a row into the associated database table using the attribute values of this record.
This method performs the following steps in order:
$runValidation is true. If beforeValidate() returns false, the rest of the steps will be skipped;$runValidation is true. If validation failed, the rest of the steps will be skipped;false, the rest of the steps will be skipped;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();
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.
List of attributes that need to be saved. Defaults to null, meaning all attributes that are loaded from DB will be saved.
Whether the attributes are valid and the record is inserted successfully.
throws Throwablein case insert failed.
public function insert($runValidation = true, $attributes = null)
{
if ($runValidation && !$this->validate($attributes)) {
Yii::info('Model not inserted due to validation error.', __METHOD__);
return false;
}
if (!$this->isTransactional(self::OP_INSERT)) {
return $this->insertInternal($attributes);
}
$transaction = static::getDb()->beginTransaction();
try {
$result = $this->insertInternal($attributes);
if ($result === false) {
$transaction->rollBack();
} else {
$transaction->commit();
}
return $result;
} catch (\Exception $e) {
$transaction->rollBack();
throw $e;
} catch (\Throwable $e) {
$transaction->rollBack();
throw $e;
}
}
Inserts an ActiveRecord into DB without considering transaction.
protected boolean insertInternal ( $attributes = null ) $attributes array|nullList of attributes that need to be saved. Defaults to null, meaning all attributes that are loaded from DB will be saved.
Whether the record is inserted successfully.
protected function insertInternal($attributes = null)
{
if (!$this->beforeSave(true)) {
return false;
}
$values = $this->getDirtyAttributes($attributes);
if (($primaryKeys = static::getDb()->schema->insert(static::tableName(), $values)) === false) {
return false;
}
foreach ($primaryKeys as $name => $value) {
$id = static::getTableSchema()->columns[$name]->phpTypecast($value);
$this->setAttribute($name, $id);
$values[$name] = $id;
}
$changedAttributes = array_fill_keys(array_keys($values), null);
$this->setOldAttributes($values);
$this->afterSave(true, $changedAttributes);
return true;
}
public static static instance ( $refresh = false ) $refresh boolean
Whether to re-create static instance even, if it is already cached.
return yii\db\ActiveRecordClass instance.
public static function instance($refresh = false)
{
$className = get_called_class();
if ($refresh || !isset(self::$_instances[$className])) {
self::$_instances[$className] = Yii::createObject($className);
}
return self::$_instances[$className];
}
Defined in: yii\db\BaseActiveRecord::instantiate()
Creates an active record instance.
This method is called together with populateRecord() by yii\db\ActiveQuery. It is not meant to be used for creating new records directly.
You may override this method if the instance being created depends on the row data to be populated into the record. For example, by creating a record based on the value of a column, you may implement the so-called single-table inheritance mapping.
public static function instantiate($row)
{
return new static();
}
public function isAttributeActive($attribute)
{
return in_array($attribute, $this->activeAttributes(), true);
}
public boolean isAttributeChanged ( $name, $identical = true ) $name string
The name of the attribute.
$identical booleanWhether the comparison of new and old value is made for identical values using ===, defaults to true. Otherwise == is used for comparison. This parameter is available since version 2.0.4.
Whether the attribute has been changed
public function isAttributeChanged($name, $identical = true)
{
if (isset($this->_attributes[$name], $this->_oldAttributes[$name])) {
if ($identical) {
return $this->_attributes[$name] !== $this->_oldAttributes[$name];
}
return $this->_attributes[$name] != $this->_oldAttributes[$name];
}
return isset($this->_attributes[$name]) || isset($this->_oldAttributes[$name]);
}
Defined in: yii\base\Model::isAttributeRequired()
Returns a value indicating whether the attribute is required.
This is determined by checking if the attribute is associated with a required validation rule in the current $scenario.
Note that when the validator has a conditional validation applied using $when this method will return false regardless of the when condition because it may be called be before the model is loaded with data.
public function isAttributeRequired($attribute)
{
foreach ($this->getActiveValidators($attribute) as $validator) {
if ($validator instanceof RequiredValidator && $validator->when === null) {
return true;
}
}
return false;
}
public function isAttributeSafe($attribute)
{
return in_array($attribute, $this->safeAttributes(), true);
}
public static boolean isPrimaryKey ( $keys ) $keys array
The set of attributes to check
return booleanWhether the given set of attributes represents the primary key for this model
public static function isPrimaryKey($keys)
{
$pks = static::primaryKey();
if (count($keys) === count($pks)) {
return count(array_intersect($keys, $pks)) === count($pks);
}
return false;
}
public boolean isRelationPopulated ( $name ) $name string
The relation name, e.g. orders for a relation defined via getOrders() method (case-sensitive).
Whether relation has been populated with records.
public function isRelationPopulated($name)
{
return array_key_exists($name, $this->_related);
}
Returns a value indicating whether the specified operation is transactional in the current $scenario.
public function isTransactional($operation)
{
$scenario = $this->getScenario();
$transactions = $this->transactions();
return isset($transactions[$scenario]) && ($transactions[$scenario] & $operation);
}
Defined in: yii\db\BaseActiveRecord::link()
Establishes the relationship between two models.
The relationship is established by setting the foreign key value(s) in one model to be the corresponding primary key value(s) in the other model. The model with the foreign key will be saved into database without performing validation and without events/behaviors.
If the relationship involves a junction table, a new row will be inserted into the junction table which contains the primary key values from both models.
Note that this method requires that the primary key value is not null.
public function link($name, $model, $extraColumns = [])
{
$relation = $this->getRelation($name);
if ($relation->via !== null) {
if ($this->getIsNewRecord() || $model->getIsNewRecord()) {
throw new InvalidCallException('Unable to link models: the models being linked cannot be newly created.');
}
if (is_array($relation->via)) {
list($viaName, $viaRelation) = $relation->via;
$viaClass = $viaRelation->modelClass;
unset($this->_related[$viaName]);
} else {
$viaRelation = $relation->via;
$viaTable = reset($relation->via->from);
}
$columns = [];
foreach ($viaRelation->link as $a => $b) {
$columns[$a] = $this->$b;
}
foreach ($relation->link as $a => $b) {
$columns[$b] = $model->$a;
}
foreach ($extraColumns as $k => $v) {
$columns[$k] = $v;
}
if (is_array($relation->via)) {
$record = Yii::createObject($viaClass);
foreach ($columns as $column => $value) {
$record->$column = $value;
}
$record->insert(false);
} else {
static::getDb()->createCommand()->insert($viaTable, $columns)->execute();
}
} else {
$p1 = $model->isPrimaryKey(array_keys($relation->link));
$p2 = static::isPrimaryKey(array_values($relation->link));
if ($p1 && $p2) {
if ($this->getIsNewRecord()) {
if ($model->getIsNewRecord()) {
throw new InvalidCallException('Unable to link models: at most one model can be newly created.');
}
$this->bindModels(array_flip($relation->link), $this, $model);
} else {
$this->bindModels($relation->link, $model, $this);
}
} elseif ($p1) {
$this->bindModels(array_flip($relation->link), $this, $model);
} elseif ($p2) {
$this->bindModels($relation->link, $model, $this);
} else {
throw new InvalidCallException('Unable to link models: the link defining the relation does not involve any primary key.');
}
}
if (!$relation->multiple) {
$this->_related[$name] = $model;
} elseif (isset($this->_related[$name])) {
if ($relation->indexBy !== null) {
if ($relation->indexBy instanceof \Closure) {
$index = call_user_func($relation->indexBy, $model);
} else {
$index = $model->{$relation->indexBy};
}
$this->_related[$name][$index] = $model;
} else {
$this->_related[$name][] = $model;
}
}
}
Defined in: yii\base\Model::load()
Populates the model with input data.
This method provides a convenient shortcut for:
if (isset($_POST['FormName'])) {
$model->attributes = $_POST['FormName'];
if ($model->save()) {
}
}
which, with load() can be written as:
if ($model->load($_POST) && $model->save()) {
}
load() gets the 'FormName' from the model's formName() method (which you may override), unless the $formName parameter is given. If the form name is empty, load() populates the model with the whole of $data, instead of $data['FormName'].
Note, that the data being populated is subject to the safety check by setAttributes().
public boolean load ( $data, $formName = null ) $data arrayThe data array to load, typically $_POST or $_GET.
The form name to use to load the data into the model, empty string when form not use. If not set, formName() is used.
return booleanWhether load() found the expected form in $data.
public function load($data, $formName = null)
{
$scope = $formName === null ? $this->formName() : $formName;
if ($scope === '' && !empty($data)) {
$this->setAttributes($data);
return true;
} elseif (isset($data[$scope])) {
$this->setAttributes($data[$scope]);
return true;
}
return false;
}
Loads default values from database table schema.
You may call this method to load default values after creating a new instance:
$customer = new Customer();
$customer->loadDefaultValues();
Whether existing value should be preserved. This will only set defaults for attributes that are null.
The model instance itself.
public function loadDefaultValues($skipIfSet = true)
{
$columns = static::getTableSchema()->columns;
foreach ($this->attributes() as $name) {
if (isset($columns[$name])) {
$defaultValue = $columns[$name]->defaultValue;
if ($defaultValue !== null && (!$skipIfSet || $this->getAttribute($name) === null)) {
$this->setAttribute($name, $defaultValue);
}
}
}
return $this;
}
Defined in: yii\base\Model::loadMultiple()
Populates a set of models with the data from end user.
This method is mainly used to collect tabular data input. The data to be loaded for each model is $data[formName][index], where formName refers to the value of formName(), and index the index of the model in the $models array. If formName() is empty, $data[index] will be used to populate each model. The data being populated to each model is subject to the safety check by setAttributes().
The models to be populated. Note that all models should have the same class.
$data arrayThe data array. This is usually $_POST or $_GET, but can also be any valid array supplied by end user.
The form name to be used for loading the data into the models. If not set, it will use the formName() value of the first model in $models. This parameter is available since version 2.0.1.
Whether at least one of the models is successfully populated.
public static function loadMultiple($models, $data, $formName = null)
{
if ($formName === null) {
$first = reset($models);
if ($first === false) {
return false;
}
$formName = $first->formName();
}
$success = false;
foreach ($models as $i => $model) {
if ($formName == '') {
if (!empty($data[$i]) && $model->load($data[$i], '')) {
$success = true;
}
} elseif (!empty($data[$formName][$i]) && $model->load($data[$formName][$i], '')) {
$success = true;
}
}
return $success;
}
Defined in: yii\db\BaseActiveRecord::loadRelations()
Eager loads related models for the already loaded primary model.
Helps to reduce the number of queries performed against database if some related models are only used when a specific condition is met. For example:
$customer = Customer::find()->where(['id' => 123])->one();
if (Yii:app()->getUser()->getIdentity()->canAccessOrders()) {
$customer->loadRelations('orders.items');
}
The names of the relations of this model to be loaded from database. See yii\db\ActiveQueryInterface::with() on how to specify this argument.
$asArray booleanWhether to load each relation as an array or an object (if the relation itself does not specify that).
public function loadRelations($relationNames, $asArray = false)
{
$models = [$this];
static::loadRelationsFor($models, $relationNames, $asArray);
}
Defined in: yii\db\BaseActiveRecord::loadRelationsFor()
Eager loads related models for the already loaded primary models.
Helps to reduce the number of queries performed against database if some related models are only used when a specific condition is met. For example:
$customers = Customer::find()->where(['country_id' => 123])->all();
if (Yii:app()->getUser()->getIdentity()->canAccessOrders()) {
Customer::loadRelationsFor($customers, 'orders.items');
}
public static function loadRelationsFor(&$models, $relationNames, $asArray = false)
{
if (empty($models)) {
return;
}
static::find()->asArray($asArray)->findWith((array)$relationNames, $models);
}
public function markAttributeDirty($name)
{
unset($this->_oldAttributes[$name]);
}
Defined in: yii\base\Component::off()
Detaches an existing event handler from this component.
This method is the opposite of on().
Note: in case wildcard pattern is passed for event name, only the handlers registered with this wildcard will be removed, while handlers registered with plain names matching this wildcard will remain.
See also on().
public boolean off ( $name, $handler = null ) $name stringEvent name
$handler callable|nullThe event handler to be removed. If it is null, all handlers attached to the named event will be removed.
return booleanIf a handler is found and detached
public function off($name, $handler = null)
{
$this->ensureBehaviors();
if (empty($this->_events[$name]) && empty($this->_eventWildcards[$name])) {
return false;
}
if ($handler === null) {
unset($this->_events[$name], $this->_eventWildcards[$name]);
return true;
}
$removed = false;
if (isset($this->_events[$name])) {
foreach ($this->_events[$name] as $i => $event) {
if ($event[0] === $handler) {
unset($this->_events[$name][$i]);
$removed = true;
}
}
if ($removed) {
$this->_events[$name] = array_values($this->_events[$name]);
return true;
}
}
if (isset($this->_eventWildcards[$name])) {
foreach ($this->_eventWildcards[$name] as $i => $event) {
if ($event[0] === $handler) {
unset($this->_eventWildcards[$name][$i]);
$removed = true;
}
}
if ($removed) {
$this->_eventWildcards[$name] = array_values($this->_eventWildcards[$name]);
if (empty($this->_eventWildcards[$name])) {
unset($this->_eventWildcards[$name]);
}
}
}
return $removed;
}
public boolean offsetExists ( $offset ) $offset mixed
The offset to check on
return booleanWhether there is an element at the specified offset.
public function offsetExists($offset)
{
return $this->__isset($offset);
}
Defined in: yii\base\Model::offsetGet()
Returns the element at the specified offset.
This method is required by the SPL interface ArrayAccess. It is implicitly called when you use something like $value = $model[$offset];.
The offset to retrieve element.
return mixedThe element at the offset, null if no element is found at the offset
public function offsetGet($offset)
{
return $this->$offset;
}
Defined in: yii\base\Model::offsetSet()
Sets the element at the specified offset.
This method is required by the SPL interface ArrayAccess. It is implicitly called when you use something like $model[$offset] = $value;.
The offset to set element
$value mixedThe element value
public function offsetSet($offset, $value)
{
$this->$offset = $value;
}
public void offsetUnset ( $offset ) $offset mixed
The offset to unset element
public function offsetUnset($offset)
{
if (property_exists($this, $offset)) {
$this->$offset = null;
} else {
unset($this->$offset);
}
}
Defined in: yii\base\Component::on()
Attaches an event handler to an event.
The event handler must be a valid PHP callback. The following are some examples:
function ($event) { ... }
[$object, 'handleClick']
['Page', 'handleClick']
'handleClick'
The event handler must be defined with the following signature,
function ($event)
where $event is an yii\base\Event object which includes parameters associated with the event.
Since 2.0.14 you can specify event name as a wildcard pattern:
$component->on('event.group.*', function ($event) {
Yii::trace($event->name . ' is triggered.');
});
See also off().
public void on ( $name, $handler, $data = null, $append = true ) $name stringThe event name
$handler callableThe event handler
$data mixedThe data to be passed to the event handler when the event is triggered. When the event handler is invoked, this data can be accessed via yii\base\Event::$data.
$append booleanWhether to append new event handler to the end of the existing handler list. If false, the new handler will be inserted at the beginning of the existing handler list.
public function on($name, $handler, $data = null, $append = true)
{
$this->ensureBehaviors();
if (strpos($name, '*') !== false) {
if ($append || empty($this->_eventWildcards[$name])) {
$this->_eventWildcards[$name][] = [$handler, $data];
} else {
array_unshift($this->_eventWildcards[$name], [$handler, $data]);
}
return;
}
if ($append || empty($this->_events[$name])) {
$this->_events[$name][] = [$handler, $data];
} else {
array_unshift($this->_events[$name], [$handler, $data]);
}
}
Defined in: yii\base\Model::onUnsafeAttribute()
This method is invoked when an unsafe attribute is being massively assigned.
The default implementation will log a warning message if YII_DEBUG is on. It does nothing otherwise.
public void onUnsafeAttribute ( $name, $value ) $name stringThe unsafe attribute name
$value mixedThe attribute value
public function onUnsafeAttribute($name, $value)
{
if (YII_DEBUG) {
Yii::debug("Failed to set unsafe attribute '$name' in '" . get_class($this) . "'.", __METHOD__);
}
}
Defined in: yii\db\BaseActiveRecord::optimisticLock()
Returns the name of the column that stores the lock version for implementing optimistic locking.
Optimistic locking allows multiple users to access the same record for edits and avoids potential conflicts. In case when a user attempts to save the record upon some staled data (because another user has modified the data), a yii\db\StaleObjectException exception will be thrown, and the update or deletion is skipped.
Optimistic locking is only supported by update() and delete().
To use Optimistic locking:
BIGINT DEFAULT 0. Override this method to return the name of this column.The column name that stores the lock version of a table row. If null is returned (default implemented), optimistic locking will not be supported.
public function optimisticLock()
{
return null;
}
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 function populateRecord($record, $row)
{
$columns = static::getTableSchema()->columns;
foreach ($row as $name => $value) {
if (isset($columns[$name])) {
$row[$name] = $columns[$name]->phpTypecast($value);
}
}
parent::populateRecord($record, $row);
}
public function populateRelation($name, $records)
{
foreach ($this->_relationsDependencies as &$relationNames) {
unset($relationNames[$name]);
}
$this->_related[$name] = $records;
}
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 function primaryKey()
{
return static::getTableSchema()->primaryKey;
}
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.
public boolean refresh ( ) return booleanWhether the row still exists in the database. If true, the latest data will be populated to this active record. Otherwise, this record will remain unchanged.
public function refresh()
{
$query = static::find();
$tableName = key($query->getTablesUsedInFrom());
$pk = [];
foreach ($this->getPrimaryKey(true) as $key => $value) {
$pk[$tableName . '.' . $key] = $value;
}
$query->where($pk);
$record = $query->noCache()->one();
return $this->refreshInternal($record);
}
protected function refreshInternal($record)
{
if ($record === null) {
return false;
}
foreach ($this->attributes() as $name) {
$this->_attributes[$name] = isset($record->_attributes[$name]) ? $record->_attributes[$name] : null;
}
$this->_oldAttributes = $record->_oldAttributes;
$this->_related = [];
$this->_relationsDependencies = [];
$this->afterRefresh();
return true;
}
protected array resolveFields ( array $fields, array $expand ) $fields array
The fields being requested for exporting
$expand arrayThe additional fields being requested for exporting
return arrayThe list of fields to be exported. The array keys are the field names, and the array values are the corresponding object property names or PHP callables returning the field values.
protected function resolveFields(array $fields, array $expand)
{
$fields = $this->extractRootFields($fields);
$expand = $this->extractRootFields($expand);
$result = [];
foreach ($this->fields() as $field => $definition) {
if (is_int($field)) {
$field = $definition;
}
if (empty($fields) || in_array($field, $fields, true)) {
$result[$field] = $definition;
}
}
if (empty($expand)) {
return $result;
}
foreach ($this->extraFields() as $field => $definition) {
if (is_int($field)) {
$field = $definition;
}
if (in_array($field, $expand, true)) {
$result[$field] = $definition;
}
}
return $result;
}
Defined in: yii\base\Model::rules()
Returns the validation rules for attributes.
Validation rules are used by validate() to check if attribute values are valid. Child classes may override this method to declare different validation rules.
Each rule is an array with the following structure:
[
['attribute1', 'attribute2'],
'validator type',
'on' => ['scenario1', 'scenario2'],
]
where
A validator can be either an object of a class extending yii\validators\Validator, or a model class method (called inline validator) that has the following signature:
function validatorName($attribute, $params)
In the above $attribute refers to the attribute currently being validated while $params contains an array of validator configuration options such as max in case of string validator. The value of the attribute currently being validated can be accessed as $this->$attribute. Note the $ before attribute; this is taking the value of the variable $attribute and using it as the name of the property to access.
Yii also provides a set of built-in validators. Each one has an alias name which can be used when specifying a validation rule.
Below are some examples:
[
[['username', 'password'], 'required'],
['username', 'string', 'min' => 3, 'max' => 12],
['password', 'compare', 'compareAttribute' => 'password2', 'on' => 'register'],
['password', 'authenticate', 'on' => 'login'],
['dateRange', 'DateRangeValidator'],
];
Note, in order to inherit rules defined in the parent class, a child class needs to merge the parent rules with child rules using functions such as array_merge().
See also scenarios().
public function rules()
{
return [];
}
public function safeAttributes()
{
$scenario = $this->getScenario();
$scenarios = $this->scenarios();
if (!isset($scenarios[$scenario])) {
return [];
}
$attributes = [];
foreach ($scenarios[$scenario] as $attribute) {
if (
$attribute !== ''
&& strncmp($attribute, '!', 1) !== 0
&& !in_array('!' . $attribute, $scenarios[$scenario])
) {
$attributes[] = $attribute;
}
}
return $attributes;
}
public boolean save ( $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.
List of attribute names that need to be saved. Defaults to null, meaning all attributes that are loaded from DB will be saved.
return booleanWhether the saving succeeded (i.e. no validation errors occurred).
throws yii\db\Exceptionin case update or insert failed.
public function save($runValidation = true, $attributeNames = null)
{
if ($this->getIsNewRecord()) {
return $this->insert($runValidation, $attributeNames);
}
return $this->update($runValidation, $attributeNames) !== false;
}
Defined in: yii\base\Model::scenarios()
Returns a list of scenarios and the corresponding active attributes.
An active attribute is one that is subject to validation in the current scenario. The returned array should be in the following format:
[
'scenario1' => ['attribute11', 'attribute12', ...],
'scenario2' => ['attribute21', 'attribute22', ...],
...
]
By default, an active attribute is considered safe and can be massively assigned. If an attribute should NOT be massively assigned (thus considered unsafe), please prefix the attribute with an exclamation character (e.g. '!rank').
The default implementation of this method will return all scenarios found in the rules() declaration. A special scenario named SCENARIO_DEFAULT will contain all attributes found in the rules(). Each scenario will be associated with the attributes that are being validated by the validation rules that apply to the scenario.
public array scenarios ( ) return arrayA list of scenarios and the corresponding active attributes.
public function scenarios()
{
$scenarios = [self::SCENARIO_DEFAULT => []];
foreach ($this->getValidators() as $validator) {
foreach ($validator->on as $scenario) {
$scenarios[$scenario] = [];
}
foreach ($validator->except as $scenario) {
$scenarios[$scenario] = [];
}
}
$names = array_keys($scenarios);
foreach ($this->getValidators() as $validator) {
if (empty($validator->on) && empty($validator->except)) {
foreach ($names as $name) {
foreach ($validator->attributes as $attribute) {
$scenarios[$name][$attribute] = true;
}
}
} elseif (empty($validator->on)) {
foreach ($names as $name) {
if (!in_array($name, $validator->except, true)) {
foreach ($validator->attributes as $attribute) {
$scenarios[$name][$attribute] = true;
}
}
}
} else {
foreach ($validator->on as $name) {
foreach ($validator->attributes as $attribute) {
$scenarios[$name][$attribute] = true;
}
}
}
}
foreach ($scenarios as $scenario => $attributes) {
if (!empty($attributes)) {
$scenarios[$scenario] = array_keys($attributes);
}
}
return $scenarios;
}
public function setAttribute($name, $value)
{
if ($this->hasAttribute($name)) {
if (
!empty($this->_relationsDependencies[$name])
&& (!array_key_exists($name, $this->_attributes) || $this->_attributes[$name] !== $value)
) {
$this->resetDependentRelations($name);
}
$this->_attributes[$name] = $value;
} else {
throw new InvalidArgumentException(get_class($this) . ' has no attribute named "' . $name . '".');
}
}
public void setAttributes ( $values, $safeOnly = true ) $values array
Attribute values (name => value) to be assigned to the model.
$safeOnly booleanWhether the assignments should only be done to the safe attributes. A safe attribute is one that is associated with a validation rule in the current $scenario.
public function setAttributes($values, $safeOnly = true)
{
if (is_array($values)) {
$attributes = array_flip($safeOnly ? $this->safeAttributes() : $this->attributes());
foreach ($values as $name => $value) {
if (isset($attributes[$name])) {
$this->$name = $value;
} elseif ($safeOnly) {
$this->onUnsafeAttribute($name, $value);
}
}
}
}
public function setIsNewRecord($value)
{
$this->_oldAttributes = $value ? null : $this->_attributes;
}
public function setOldAttribute($name, $value)
{
if ($this->canSetOldAttribute($name)) {
$this->_oldAttributes[$name] = $value;
} else {
throw new InvalidArgumentException(get_class($this) . ' has no attribute named "' . $name . '".');
}
}
public void setOldAttributes ( $values ) $values array|null
Old attribute values to be set. If set to null this record is considered to be new.
public function setOldAttributes($values)
{
$this->_oldAttributes = $values;
}
public function setScenario($value)
{
$this->_scenario = $value;
}
public static function tableName()
{
return '{{%' . Inflector::camel2id(StringHelper::basename(get_called_class()), '_') . '}}';
}
Defined in: yii\base\ArrayableTrait::toArray()
Converts the model into an array.
This method will first identify which fields to be included in the resulting array by calling resolveFields(). It will then turn the model into an array with these fields. If $recursive is true, any embedded objects will also be converted into arrays. When embedded objects are yii\base\Arrayable, their respective nested fields will be extracted and passed to toArray().
If the model implements the yii\web\Linkable interface, the resulting array will also have a _link element which refers to a list of links as specified by the interface.
The fields being requested. If empty or if it contains '*', all fields as specified by fields() will be returned. Fields can be nested, separated with dots (.). e.g.: item.field.sub-field $recursive must be true for nested fields to be extracted. If $recursive is false, only the root fields will be extracted.
The additional fields being requested for exporting. Only fields declared in extraFields() will be considered. Expand can also be nested, separated with dots (.). e.g.: item.expand1.expand2 $recursive must be true for nested expands to be extracted. If $recursive is false, only the root expands will be extracted.
Whether to recursively return array representation of embedded objects.
return arrayThe array representation of the object
public function toArray(array $fields = [], array $expand = [], $recursive = true)
{
$data = [];
foreach ($this->resolveFields($fields, $expand) as $field => $definition) {
$attribute = is_string($definition) ? $this->$definition : $definition($this, $field);
if ($recursive) {
$nestedFields = $this->extractFieldsFor($fields, $field);
$nestedExpand = $this->extractFieldsFor($expand, $field);
if ($attribute instanceof Arrayable) {
$attribute = $attribute->toArray($nestedFields, $nestedExpand);
} elseif ($attribute instanceof \JsonSerializable) {
$attribute = $attribute->jsonSerialize();
} elseif (is_array($attribute)) {
$attribute = array_map(
function ($item) use ($nestedFields, $nestedExpand) {
if ($item instanceof Arrayable) {
return $item->toArray($nestedFields, $nestedExpand);
} elseif ($item instanceof \JsonSerializable) {
return $item->jsonSerialize();
}
return $item;
},
$attribute
);
}
}
$data[$field] = $attribute;
}
if ($this instanceof Linkable) {
$data['_links'] = Link::serialize($this->getLinks());
}
return $recursive ? ArrayHelper::toArray($data) : $data;
}
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 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 arrayThe declarations of transactional operations. The array keys are scenarios names, and the array values are the corresponding transaction operations.
public function transactions()
{
return [];
}
Defined in: yii\base\Component::trigger()
Triggers an event.
This method represents the happening of an event. It invokes all attached handlers for the event including class-level handlers.
public function trigger($name, ?Event $event = null)
{
$this->ensureBehaviors();
$eventHandlers = [];
foreach ($this->_eventWildcards as $wildcard => $handlers) {
if (StringHelper::matchWildcard($wildcard, $name)) {
$eventHandlers[] = $handlers;
}
}
if (!empty($this->_events[$name])) {
$eventHandlers[] = $this->_events[$name];
}
if (!empty($eventHandlers)) {
$eventHandlers = call_user_func_array('array_merge', $eventHandlers);
if ($event === null) {
$event = new Event();
}
if ($event->sender === null) {
$event->sender = $this;
}
$event->handled = false;
$event->name = $name;
foreach ($eventHandlers as $handler) {
$event->data = $handler[1];
call_user_func($handler[0], $event);
if ($event->handled) {
return;
}
}
}
Event::trigger($this, $name, $event);
}
Defined in: yii\db\BaseActiveRecord::unlink()
Destroys the relationship between two models.
The model with the foreign key of the relationship will be deleted if $delete is true. Otherwise, the foreign key will be set null and the model will be saved without validation.
The case sensitive name of the relationship, e.g. orders for a relation defined via getOrders() method.
The model to be unlinked from the current one. You have to make sure that the model is really related with the current model as this method does not check this.
$delete booleanWhether to delete the model that contains the foreign key. If false, the model's foreign key will be set null and saved. If true, the model containing the foreign key will be deleted.
if the models cannot be unlinked
throws yii\db\Exception throws yii\db\StaleObjectException public function unlink($name, $model, $delete = false)
{
$relation = $this->getRelation($name);
if ($relation->via !== null) {
if (is_array($relation->via)) {
list($viaName, $viaRelation) = $relation->via;
$viaClass = $viaRelation->modelClass;
unset($this->_related[$viaName]);
} else {
$viaRelation = $relation->via;
$viaTable = reset($relation->via->from);
}
$columns = [];
foreach ($viaRelation->link as $a => $b) {
$columns[$a] = $this->$b;
}
foreach ($relation->link as $a => $b) {
$columns[$b] = $model->$a;
}
$nulls = [];
foreach (array_keys($columns) as $a) {
$nulls[$a] = null;
}
if (property_exists($viaRelation, 'on') && $viaRelation->on !== null) {
$columns = ['and', $columns, $viaRelation->on];
}
if (is_array($relation->via)) {
if ($delete) {
$viaClass::deleteAll($columns);
} else {
$viaClass::updateAll($nulls, $columns);
}
} else {
$command = static::getDb()->createCommand();
if ($delete) {
$command->delete($viaTable, $columns)->execute();
} else {
$command->update($viaTable, $nulls, $columns)->execute();
}
}
} else {
$p1 = $model->isPrimaryKey(array_keys($relation->link));
$p2 = static::isPrimaryKey(array_values($relation->link));
if ($p2) {
if ($delete) {
$model->delete();
} else {
foreach ($relation->link as $a => $b) {
$model->$a = null;
}
$model->save(false);
}
} elseif ($p1) {
foreach ($relation->link as $a => $b) {
if (is_array($this->$b)) {
if (($key = array_search($model->$a, $this->$b, false)) !== false) {
$values = $this->$b;
unset($values[$key]);
$this->$b = array_values($values);
}
} else {
$this->$b = null;
}
}
$delete ? $this->delete() : $this->save(false);
} else {
throw new InvalidCallException('Unable to unlink models: the link does not involve any primary key.');
}
}
if (!$relation->multiple) {
unset($this->_related[$name]);
} elseif (isset($this->_related[$name])) {
foreach ($this->_related[$name] as $a => $b) {
if ($model->getPrimaryKey() === $b->getPrimaryKey()) {
unset($this->_related[$name][$a]);
}
}
}
}
Defined in: yii\db\BaseActiveRecord::unlinkAll()
Destroys the relationship in current model.
The model with the foreign key of the relationship will be deleted if $delete is true. Otherwise, the foreign key will be set null and the model will be saved without validation.
Note that to destroy the relationship without removing records make sure your keys can be set to null
public void unlinkAll ( $name, $delete = false ) $name stringThe case sensitive name of the relationship, e.g. orders for a relation defined via getOrders() method.
Whether to delete the model that contains the foreign key.
Note that the deletion will be performed using deleteAll(), which will not trigger any events on the related models. 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.
public function unlinkAll($name, $delete = false)
{
$relation = $this->getRelation($name);
if ($relation->via !== null) {
if (is_array($relation->via)) {
list($viaName, $viaRelation) = $relation->via;
$viaClass = $viaRelation->modelClass;
unset($this->_related[$viaName]);
} else {
$viaRelation = $relation->via;
$viaTable = reset($relation->via->from);
}
$condition = [];
$nulls = [];
foreach ($viaRelation->link as $a => $b) {
$nulls[$a] = null;
$condition[$a] = $this->$b;
}
if (!empty($viaRelation->where)) {
$condition = ['and', $condition, $viaRelation->where];
}
if (property_exists($viaRelation, 'on') && !empty($viaRelation->on)) {
$condition = ['and', $condition, $viaRelation->on];
}
if (is_array($relation->via)) {
if ($delete) {
$viaClass::deleteAll($condition);
} else {
$viaClass::updateAll($nulls, $condition);
}
} else {
$command = static::getDb()->createCommand();
if ($delete) {
$command->delete($viaTable, $condition)->execute();
} else {
$command->update($viaTable, $nulls, $condition)->execute();
}
}
} else {
$relatedModel = $relation->modelClass;
if (!$delete && count($relation->link) === 1 && is_array($this->{$b = reset($relation->link)})) {
$this->$b = [];
$this->save(false);
} else {
$nulls = [];
$condition = [];
foreach ($relation->link as $a => $b) {
$nulls[$a] = null;
$condition[$a] = $this->$b;
}
if (!empty($relation->where)) {
$condition = ['and', $condition, $relation->where];
}
if (property_exists($relation, 'on') && !empty($relation->on)) {
$condition = ['and', $condition, $relation->on];
}
if ($delete) {
$relatedModel::deleteAll($condition);
} else {
$relatedModel::updateAll($nulls, $condition);
}
}
}
unset($this->_related[$name]);
}
Saves the changes to this active record into the associated database table.
This method performs the following steps in order:
$runValidation is true. If beforeValidate() returns false, the rest of the steps will be skipped;$runValidation is true. If validation failed, the rest of the steps will be skipped;false, the rest of the steps will be skipped;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) {
} else {
}
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.
List of attributes that need to be saved. Defaults to null, meaning all attributes that are loaded from DB will be saved.
The number of rows affected, or false if validation fails or beforeSave() stops the updating process.
throws yii\db\StaleObjectExceptionif optimistic locking is enabled and the data being updated is outdated.
throws Throwablein case update failed.
public function update($runValidation = true, $attributeNames = null)
{
if ($runValidation && !$this->validate($attributeNames)) {
Yii::info('Model not updated due to validation error.', __METHOD__);
return false;
}
if (!$this->isTransactional(self::OP_UPDATE)) {
return $this->updateInternal($attributeNames);
}
$transaction = static::getDb()->beginTransaction();
try {
$result = $this->updateInternal($attributeNames);
if ($result === false) {
$transaction->rollBack();
} else {
$transaction->commit();
}
return $result;
} catch (\Exception $e) {
$transaction->rollBack();
throw $e;
} catch (\Throwable $e) {
$transaction->rollBack();
throw $e;
}
}
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);
}
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 arrayAttribute values (name-value pairs) to be saved into the table
$condition string|arrayThe 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 arrayThe parameters (name => value) to be bound to the query.
return integerThe number of rows updated
public static function updateAll($attributes, $condition = '', $params = [])
{
$command = static::getDb()->createCommand();
$command->update(static::tableName(), $attributes, $condition, $params);
return $command->execute();
}
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 arrayThe counters to be updated (attribute name => increment value). Use negative values if you want to decrement the counters.
$condition string|arrayThe 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 arrayThe 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.
The number of rows updated
public static function updateAllCounters($counters, $condition = '', $params = [])
{
$n = 0;
foreach ($counters as $name => $value) {
$counters[$name] = new Expression("[[$name]]+:bp{$n}", [":bp{$n}" => $value]);
$n++;
}
$command = static::getDb()->createCommand();
$command->update(static::tableName(), $counters, $condition, $params);
return $command->execute();
}
Defined in: yii\db\BaseActiveRecord::updateAttributes()
Updates the specified attributes.
This method is a shortcut to update() when data validation is not needed and only a small set attributes need to be updated.
You may specify the attributes to be updated as name list or name-value pairs. If the latter, the corresponding attribute values will be modified accordingly. The method will then save the specified attributes into database.
Note that this method will not perform data validation and will not trigger events.
public function updateAttributes($attributes)
{
$attrs = [];
foreach ($attributes as $name => $value) {
if (is_int($name)) {
$attrs[] = $value;
} else {
$this->$name = $value;
$attrs[] = $name;
}
}
$values = $this->getDirtyAttributes($attrs);
if (empty($values) || $this->getIsNewRecord()) {
return 0;
}
$rows = static::updateAll($values, $this->getOldPrimaryKey(true));
foreach ($values as $name => $value) {
$this->_oldAttributes[$name] = $this->_attributes[$name];
}
return $rows;
}
public boolean updateCounters ( $counters ) $counters array
The counters to be updated (attribute name => increment value) Use negative values if you want to decrement the counters.
return booleanWhether the saving is successful
public function updateCounters($counters)
{
if (static::updateAllCounters($counters, $this->getOldPrimaryKey(true)) > 0) {
foreach ($counters as $name => $value) {
if (!isset($this->_attributes[$name])) {
$this->_attributes[$name] = $value;
} else {
$this->_attributes[$name] += $value;
}
$this->_oldAttributes[$name] = $this->_attributes[$name];
}
return true;
}
return false;
}
protected function updateInternal($attributes = null)
{
if (!$this->beforeSave(false)) {
return false;
}
$values = $this->getDirtyAttributes($attributes);
if (empty($values)) {
$this->afterSave(false, $values);
return 0;
}
$condition = $this->getOldPrimaryKey(true);
$lock = $this->optimisticLock();
if ($lock !== null) {
$values[$lock] = $this->$lock + 1;
$condition[$lock] = $this->$lock;
}
$rows = static::updateAll($values, $condition);
if ($lock !== null && !$rows) {
throw new StaleObjectException('The object being updated is outdated.');
}
if (isset($values[$lock])) {
$this->$lock = $values[$lock];
}
$changedAttributes = [];
foreach ($values as $name => $value) {
$changedAttributes[$name] = isset($this->_oldAttributes[$name]) ? $this->_oldAttributes[$name] : null;
$this->_oldAttributes[$name] = $value;
}
$this->afterSave(false, $changedAttributes);
return $rows;
}
Defined in: yii\base\Model::validate()
Performs the data validation.
This method executes the validation rules applicable to the current $scenario. The following criteria are used to determine whether a rule is currently applicable:
This method will call beforeValidate() and afterValidate() before and after the actual validation, respectively. If beforeValidate() returns false, the validation will be cancelled and afterValidate() will not be called.
Errors found during the validation can be retrieved via getErrors(), getFirstErrors() and getFirstError().
public boolean validate ( $attributeNames = null, $clearErrors = true ) $attributeNames string[]|string|nullAttribute name or list of attribute names that should be validated. If this parameter is empty, it means any attribute listed in the applicable validation rules should be validated.
$clearErrors booleanWhether to call clearErrors() before performing validation
return booleanWhether the validation is successful without any error.
throws yii\base\InvalidArgumentExceptionif the current scenario is unknown.
public function validate($attributeNames = null, $clearErrors = true)
{
if ($clearErrors) {
$this->clearErrors();
}
if (!$this->beforeValidate()) {
return false;
}
$scenarios = $this->scenarios();
$scenario = $this->getScenario();
if (!isset($scenarios[$scenario])) {
throw new InvalidArgumentException("Unknown scenario: $scenario");
}
if ($attributeNames === null) {
$attributeNames = $this->activeAttributes();
}
$attributeNames = (array)$attributeNames;
foreach ($this->getActiveValidators() as $validator) {
$validator->validateAttributes($this, $attributeNames);
}
$this->afterValidate();
return !$this->hasErrors();
}
Defined in: yii\base\Model::validateMultiple()
Validates multiple models.
This method will validate every model. The models being validated may be of the same or different types.
public static boolean validateMultiple ( $models, $attributeNames = null ) $models arrayThe models to be validated
$attributeNames array|nullList of attribute names that should be validated. If this parameter is empty, it means any attribute listed in the applicable validation rules should be validated.
return booleanWhether all models are valid. False will be returned if one or multiple models have validation error.
public static function validateMultiple($models, $attributeNames = null)
{
$valid = true;
foreach ($models as $model) {
$valid = $model->validate($attributeNames) && $valid;
}
return $valid;
}
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4