Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.yiiframework.com/doc/api/2.0/yii-db-baseactiverecord below:

BaseActiveRecord, yii\db\BaseActiveRecord | API Documentation for Yii 2.0

Hide inherited methods

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.

Source code

                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.

Source code

                public function __clone()
{
    parent::__clone();
    $this->_errors = null;
    $this->_validators = null;
}

            

Defined in: yii\base\BaseObject::__construct()

Constructor.

The default implementation does two things:

• Initializes the object with the given configuration $config.
• Call init().

If this method is overridden in a child class, it is recommended that

• the last parameter of the constructor is a configuration array, like $config here.
• call the parent implementation at the end of the constructor.

Name-value pairs that will be used to initialize the object properties

Source code

                public function __construct($config = [])
{
    if (!empty($config)) {
        Yii::configure($this, $config);
    }
    $this->init();
}

            

PHP getter magic method.

This method is overridden so that attributes and related objects can be accessed like properties.

See also getAttribute().

Source code

                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;
}

            

Checks if a property value is null.

This method overrides the parent implementation by checking if the named attribute is null or not.

Source code

                public function __isset($name)
{
    try {
        return $this->__get($name) !== null;
    } catch (\Exception $t) {
        return false;
    } catch (\Throwable $e) {
        return false;
    }
}

            

PHP setter magic method.

This method is overridden so that AR attributes can be accessed like properties.

Property name

Property value

Source code

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

            

Sets a component property to be null.

This method overrides the parent implementation by clearing the specified attribute value.

The property name or the event name

Source code

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

            

Source code

                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;
}

            

Attribute name

New error message

Source code

                public function addError($attribute, $error = '')
{
    $this->_errors[$attribute][] = $error;
}

            

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.

Source code

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

            

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.

Source code

                public function afterDelete()
{
    $this->trigger(self::EVENT_AFTER_DELETE);
}

            

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.

Source code

                public function afterFind()
{
    $this->trigger(self::EVENT_AFTER_FIND);
}

            

This method is called when the AR object is refreshed.

The default implementation will trigger an EVENT_AFTER_REFRESH event. When overriding this method, make sure you call the parent implementation to ensure the event is triggered.

Source code

                public function afterRefresh()
{
    $this->trigger(self::EVENT_AFTER_REFRESH);
}

            

This method is called at the end of inserting or updating a record.

The default implementation will trigger an EVENT_AFTER_INSERT event when $insert is true, or an EVENT_AFTER_UPDATE event if $insert is false. The event class used is yii\db\AfterSaveEvent. When overriding this method, make sure you call the parent implementation so that the event is triggered.

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.

Source code

                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.

Source code

                public function afterValidate()
{
    $this->trigger(self::EVENT_AFTER_VALIDATE);
}

            

Source code

                public function attachBehavior($name, $behavior)
{
    $this->ensureBehaviors();
    return $this->attachBehaviorInternal($name, $behavior);
}

            

List of behaviors to be attached to the component

Source code

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

Source code

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

Source code

                public function attributeLabels()
{
    return [];
}

            

Defined in: yii\base\Model::attributes()

Returns the list of attribute names.

By default, this method returns all public non-static properties of the class. You may override this method to change the default behavior.

Source code

                public function attributes()
{
    $class = new ReflectionClass($this);
    $names = [];
    foreach ($class->getProperties(\ReflectionProperty::IS_PUBLIC) as $property) {
        if (!$property->isStatic()) {
            $names[] = $property->getName();
        }
    }
    return $names;
}

            

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;
}

Source code

                public function beforeDelete()
{
    $event = new ModelEvent();
    $this->trigger(self::EVENT_BEFORE_DELETE, $event);
    return $event->isValid;
}

            

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.

Source code

                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.

Source code

                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).

Source code

                public function behaviors()
{
    return [];
}

            

Returns a value indicating whether a property can be read.

A property can be read if:

• the class has a getter method associated with the specified name (in this case, property name is case-insensitive);
• the class has a member variable with the specified name (when $checkVars is true);
• an attached behavior has a readable property of the given name (when $checkBehaviors is true).

The property name

Whether to treat member variables as properties

Whether to treat behaviors' properties as properties of this component

Whether the property can be read

Source code

                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;
    }
}

            

Source code

                public function canSetOldAttribute($name)
{
    return (isset($this->_oldAttributes[$name]) || $this->hasAttribute($name));
}

            

Returns a value indicating whether a property can be set.

A property can be written if:

• the class has a setter method associated with the specified name (in this case, property name is case-insensitive);
• the class has a member variable with the specified name (when $checkVars is true);
• an attached behavior has a writable property of the given name (when $checkBehaviors is true).

The property name

Whether to treat member variables as properties

Whether to treat behaviors' properties as properties of this component

Whether the property can be written

Source code

                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.

Source code

                public static function className()
{
    return get_called_class();
}

            

Attribute name. Use null to remove errors for all attributes.

Source code

                public function clearErrors($attribute = null)
{
    if ($attribute === null) {
        $this->_errors = [];
    } else {
        unset($this->_errors[$attribute]);
    }
}

            

Creates a query instance for has-one or has-many relation.

See also:

• hasOne()
• hasMany()

Source code

                protected function createRelationQuery($class, $link, $multiple)
{
    
    
    $query = $class::find();
    $query->primaryModel = $this;
    $query->link = $link;
    $query->multiple = $multiple;
    return $query;
}

            

Source code

                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:

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.

Source code

                public function delete()
{
    $result = false;
    if ($this->beforeDelete()) {
        
        
        $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->_oldAttributes = null;
        $this->afterDelete();
    }
    return $result;
}

            

Deletes rows in the table using the provided conditions.

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

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

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

Source code

                public static function deleteAll($condition = null)
{
    throw new NotSupportedException(__METHOD__ . ' is not supported.');
}

            

Source code

                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;
}

            

Source code

                public function detachBehaviors()
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $name => $behavior) {
        $this->detachBehavior($name);
    }
}

            

Source code

                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.

Source code

                public function equals($record)
{
    if ($this->getIsNewRecord() || $record->getIsNewRecord()) {
        return false;
    }
    return get_class($this) === get_class($record) && $this->getPrimaryKey() === $record->getPrimaryKey();
}

            

Returns the list of fields that should be returned by default by toArray() when no specific fields are specified.

The default implementation returns the names of the columns whose values have been populated into this record.

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 ($model) {
        return $model->first_name . ' ' . $model->last_name;
    },
];

In this method, you may also want to return different lists of fields based on some context information. For example, depending on $scenario or 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 attributes() indexed by the same attribute names.

The list of field names or field definitions.

Source code

                public function fields()
{
    $fields = array_keys($this->_attributes);
    return array_combine($fields, $fields);
}

            

Defined in: yii\db\ActiveRecordInterface::find()

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

Source code

                public static function find();

            

Returns a list of active record models that match the specified primary key value(s) or a set of column values.

The method accepts:

• a scalar value (integer or string): query by a single primary key value and return an array containing the corresponding record (or an empty array if not found).
• a non-associative array: query by a list of primary key values and return the corresponding records (or an empty array if none was found). Note that an empty condition will result in an empty result as it will be interpreted as a search for primary keys and not an empty WHERE condition.
• an associative array of name-value pairs: query by a set of attribute values and return an array of records matching all of them (or an empty array if none was 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 limted to simple filter conditions.
• a yii\db\Expression: The expression will be used directly. (@since 2.0.37)

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

An array of ActiveRecord instances, or an empty array if nothing matches.

Source code

                public static function findAll($condition)
{
    return static::findByCondition($condition)->all();
}

            

Returns a single active record model instance by a primary key or an array of column values.

The method accepts:

• a scalar value (integer or string): query by a single primary key value and return the corresponding record (or null if not found).
• a non-associative array: query by a list of primary key values and return the first record (or null if not found).
• an associative array of name-value pairs: query by a set of attribute values and return a single record matching all of them (or 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.
• a yii\db\Expression: The expression will be used directly. (@since 2.0.37)

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

ActiveRecord instance matching the condition, or null if nothing matches.

Source code

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

Source code

                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'.

Source code

                public function generateAttributeLabel($name)
{
    return Inflector::camel2words($name, true);
}

            

Source code

                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;
}

            

Returns the named attribute value.

If this record is the result of a query and the attribute is not loaded, null will be returned.

See also hasAttribute().

The attribute name

The attribute value. null if the attribute is not set or does not exist.

Source code

                public function getAttribute($name)
{
    return isset($this->_attributes[$name]) ? $this->_attributes[$name] : null;
}

            

Returns the text hint for the specified attribute.

If the attribute looks like relatedModel.attribute, then the attribute will be received from the related model.

See also attributeHints().

Source code

                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 '';
}

            

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:

• the label for 'relatedModel1.relatedModel2.attr' defined in attributeLabels() of this model;
• the label for 'relatedModel2.attr' defined in related model represented by relation 'relatedModel1' of this model;
• the label for 'attr' defined in related model represented by relation 'relatedModel2' of relation 'relatedModel1'. If no label definition was found then the value of $this->generateAttributeLabel('relatedModel1.relatedModel2.attr') will be returned.

See also:

• attributeLabels()
• generateAttributeLabel()

Source code

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

            

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.

List of attributes whose value should NOT be returned.

Attribute values (name => value).

Source code

                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;
}

            

Source code

                public function getBehavior($name)
{
    $this->ensureBehaviors();
    return isset($this->_behaviors[$name]) ? $this->_behaviors[$name] : null;
}

            

Source code

                public function getBehaviors()
{
    $this->ensureBehaviors();
    return $this->_behaviors;
}

            

The database connection used by this AR class.

Source code

                public static function getDb();

            

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.

The changed attribute values (name-value pairs)

Source code

                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;
}

            

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.

Errors for all attributes as a one-dimensional array. Empty array is returned if no error.

Source code

                public function getErrorSummary($showAllErrors)
{
    $lines = [];
    $errors = $showAllErrors ? $this->getErrors() : $this->getFirstErrors();
    foreach ($errors as $es) {
        $lines = array_merge($lines, (array)$es);
    }
    return $lines;
}

            

Attribute name. Use null to retrieve errors for all attributes.

Errors 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.',
    ]
]

Source code

                public function getErrors($attribute = null)
{
    if ($attribute === null) {
        return $this->_errors === null ? [] : $this->_errors;
    }
    return isset($this->_errors[$attribute]) ? $this->_errors[$attribute] : [];
}

            

Source code

                public function getFirstError($attribute)
{
    return isset($this->_errors[$attribute]) ? reset($this->_errors[$attribute]) : null;
}

            

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.

Source code

                public function getFirstErrors()
{
    if (empty($this->_errors)) {
        return [];
    }
    $errors = [];
    foreach ($this->_errors as $name => $es) {
        if (!empty($es)) {
            $errors[$name] = reset($es);
        }
    }
    return $errors;
}

            

Returns a value indicating whether the current record is new.

Source code

                public function getIsNewRecord()
{
    return $this->_oldAttributes === null;
}

            

Source code

                
public function getIterator()
{
    $attributes = $this->getAttributes();
    return new ArrayIterator($attributes);
}

            

Returns the old value of the named attribute.

If this record is the result of a query and the attribute is not loaded, null will be returned.

See also hasAttribute().

The attribute name

The old attribute value. null if the attribute is not loaded before or does not exist.

Source code

                public function getOldAttribute($name)
{
    return isset($this->_oldAttributes[$name]) ? $this->_oldAttributes[$name] : null;
}

            

Returns the old attribute values.

Source code

                public function getOldAttributes()
{
    return $this->_oldAttributes === null ? [] : $this->_oldAttributes;
}

            

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.

Whether 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

Source code

                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;
}

            

Returns the primary key value(s).

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).

Source code

                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;
}

            

Returns the relation object with the specified name.

A relation is defined by a getter method which returns an yii\db\ActiveQueryInterface object. It can be declared in either the Active Record class itself or one of its behaviors.

Source code

                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.

Source code

                public function getScenario()
{
    return $this->_scenario;
}

            

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;

Source code

                public function getValidators()
{
    if ($this->_validators === null) {
        $this->_validators = $this->createValidators();
    }
    return $this->_validators;
}

            

Returns a value indicating whether the model has an attribute with the specified name.

Source code

                public function hasAttribute($name)
{
    return isset($this->_attributes[$name]) || in_array($name, $this->attributes(), true);
}

            

Source code

                public function hasErrors($attribute = null)
{
    return $attribute === null ? !empty($this->_errors) : isset($this->_errors[$attribute]);
}

            

Source code

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

            

Declares a has-many relation.

The declaration is returned in terms of a relational yii\db\ActiveQuery instance through which the related record can be queried and retrieved back.

A has-many relation means that there are multiple related records matching the criteria set by this relation, e.g., a customer has many orders.

For example, to declare the orders relation for Customer class, we can write the following code in the Customer class:

public function getOrders()
{
    return $this->hasMany(Order::class, ['customer_id' => 'id']);
}

Note that in the above, the 'customer_id' key in the $link parameter refers to an attribute name in the related class Order, while the 'id' value refers to an attribute name in the current AR class.

Call methods declared in yii\db\ActiveQuery to further customize the relation.

The class name of the related record

The primary-foreign key constraint. The keys of the array refer to the attributes of the record associated with the $class model, while the values of the array refer to the corresponding attributes in this AR class.

The relational query object.

Source code

                public function hasMany($class, $link)
{
    return $this->createRelationQuery($class, $link, true);
}

            

Defined in: yii\base\Component::hasMethod()

Returns a value indicating whether a method is defined.

A method is defined if:

• the class has a method with the specified name
• an attached behavior has a method with the given name (when $checkBehaviors is true).

The property name

Whether to treat behaviors' methods as methods of this component

Whether the method is defined

Source code

                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;
}

            

Declares a has-one relation.

The declaration is returned in terms of a relational yii\db\ActiveQuery instance through which the related record can be queried and retrieved back.

A has-one relation means that there is at most one related record matching the criteria set by this relation, e.g., a customer has one country.

For example, to declare the country relation for Customer class, we can write the following code in the Customer class:

public function getCountry()
{
    return $this->hasOne(Country::class, ['id' => 'country_id']);
}

Note that in the above, the 'id' key in the $link parameter refers to an attribute name in the related class Country, while the 'country_id' value refers to an attribute name in the current AR class.

Call methods declared in yii\db\ActiveQuery to further customize the relation.

The class name of the related record

The primary-foreign key constraint. The keys of the array refer to the attributes of the record associated with the $class model, while the values of the array refer to the corresponding attributes in this AR class.

The relational query object.

Source code

                public function hasOne($class, $link)
{
    return $this->createRelationQuery($class, $link, false);
}

            

Defined in: yii\base\Component::hasProperty()

Returns a value indicating whether a property is defined for this component.

A property is defined if:

• the class has a getter or setter method associated with the specified name (in this case, property name is case-insensitive);
• the class has a member variable with the specified name (when $checkVars is true);
• an attached behavior has a property of the given name (when $checkBehaviors is true).

See also:

• canGetProperty()
• canSetProperty()

The property name

Whether to treat member variables as properties

Whether to treat behaviors' properties as properties of this component

Whether the property is defined

Source code

                public function hasProperty($name, $checkVars = true, $checkBehaviors = true)
{
    return $this->canGetProperty($name, $checkVars, $checkBehaviors) || $this->canSetProperty($name, false, $checkBehaviors);
}

            

Initializes the object.

This method is called at the end of the constructor. The default implementation will trigger an EVENT_INIT event.

Source code

                public function init()
{
    parent::init();
    $this->trigger(self::EVENT_INIT);
}

            

Defined in: yii\db\ActiveRecordInterface::insert()

Inserts the record into the database using the attribute values of this record.

Usage example:

$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.

Source code

                public function insert($runValidation = true, $attributes = null);

            

Whether to re-create static instance even, if it is already cached.

Class instance.

Source code

                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];
}

            

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.

Row data to be populated into the record.

The newly created active record

Source code

                public static function instantiate($row)
{
    return new static();
}

            

Source code

                public function isAttributeActive($attribute)
{
    return in_array($attribute, $this->activeAttributes(), true);
}

            

Returns a value indicating whether the named attribute has been changed.

The name of the attribute.

Whether 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

Source code

                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.

Source code

                public function isAttributeRequired($attribute)
{
    foreach ($this->getActiveValidators($attribute) as $validator) {
        if ($validator instanceof RequiredValidator && $validator->when === null) {
            return true;
        }
    }
    return false;
}

            

Source code

                public function isAttributeSafe($attribute)
{
    return in_array($attribute, $this->safeAttributes(), true);
}

            

Returns a value indicating whether the given set of attributes represents the primary key for this model.

The set of attributes to check

Whether the given set of attributes represents the primary key for this model

Source code

                public static function isPrimaryKey($keys)
{
    $pks = static::primaryKey();
    if (count($keys) === count($pks)) {
        return count(array_intersect($keys, $pks)) === count($pks);
    }
    return false;
}

            

Check whether the named relation has been populated with records.

See also getRelation().

The relation name, e.g. orders for a relation defined via getOrders() method (case-sensitive).

Whether relation has been populated with records.

Source code

                public function isRelationPopulated($name)
{
    return array_key_exists($name, $this->_related);
}

            

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.

Source code

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

The 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.

Whether load() found the expected form in $data.

Source code

                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;
}

            

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.

The 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.

Source code

                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;
}

            

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.

Whether to load each relation as an array or an object (if the relation itself does not specify that).

Source code

                public function loadRelations($relationNames, $asArray = false)
{
    $models = [$this];
    static::loadRelationsFor($models, $relationNames, $asArray);
}

            

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');
}

Source code

                public static function loadRelationsFor(&$models, $relationNames, $asArray = false)
{
    
    if (empty($models)) {
        return;
    }
    static::find()->asArray($asArray)->findWith((array)$relationNames, $models);
}

            

Marks an attribute dirty.

This method may be called to force updating a record when calling update(), even if there is no change being made to the record.

Source code

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

Event name

The event handler to be removed. If it is null, all handlers attached to the named event will be removed.

If a handler is found and detached

Source code

                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;
}

            

Returns whether there is an element at the specified offset.

This method is required by the interface ArrayAccess.

The offset to check on

Whether there is an element at the specified offset.

Source code

                
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.

The element at the offset, null if no element is found at the offset

Source code

                
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

The element value

Source code

                
public function offsetSet($offset, $value)
{
    $this->$offset = $value;
}

            

Sets the element value at the specified offset to null.

This method is required by the SPL interface ArrayAccess. It is implicitly called when you use something like unset($model[$offset]).

The offset to unset element

Source code

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

The event name

The event handler

The 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.

Whether 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.

Source code

                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.

The unsafe attribute name

The attribute value

Source code

                public function onUnsafeAttribute($name, $value)
{
    if (YII_DEBUG) {
        Yii::debug("Failed to set unsafe attribute '$name' in '" . get_class($this) . "'.", __METHOD__);
    }
}

            

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:

1. Create a column to store the version number of each row. The column type should be BIGINT DEFAULT 0. Override this method to return the name of this column.
2. Ensure the version value is submitted and loaded to your model before any update or delete. Or add OptimisticLockBehavior to your model class in order to automate the process.
3. In the Web form that collects the user input, add a hidden field that stores the lock version of the record being updated.
4. In the controller action that does the data updating, try to catch the yii\db\StaleObjectException and implement necessary business logic (e.g. merging the changes, prompting stated data) to resolve the conflict.

The column name that stores the lock version of a table row. If null is returned (default implemented), optimistic locking will not be supported.

Source code

                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.

Source code

                public static function populateRecord($record, $row)
{
    $columns = array_flip($record->attributes());
    foreach ($row as $name => $value) {
        if (isset($columns[$name])) {
            $record->_attributes[$name] = $value;
        } elseif ($record->canSetProperty($name)) {
            $record->$name = $value;
        }
    }
    $record->_oldAttributes = $record->_attributes;
    $record->_related = [];
    $record->_relationsDependencies = [];
}

            

Populates the named relation with the related records.

Note that this method does not check if the relation exists or not.

See also getRelation().

Source code

                public function populateRelation($name, $records)
{
    foreach ($this->_relationsDependencies as &$relationNames) {
        unset($relationNames[$name]);
    }
    $this->_related[$name] = $records;
}

            

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.

Whether 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.

Source code

                public function refresh()
{
    
    $record = static::findOne($this->getPrimaryKey(true));
    return $this->refreshInternal($record);
}

            

Repopulates this active record with the latest data from a newly fetched instance.

See also refresh().

Source code

                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;
}

            

The fields being requested for exporting

The additional fields being requested for exporting

The 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.

Source code

                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

• attribute list: required, specifies the attributes array to be validated, for single attribute you can pass a string;
• validator type: required, specifies the validator to be used. It can be a built-in validator name, a method name of the model class, an anonymous function, or a validator class name.
• on: optional, specifies the scenarios array in which the validation rule can be applied. If this option is not set, the rule will apply to all scenarios.
• additional name-value pairs can be specified to initialize the corresponding validator properties. Please refer to individual validator class API for possible properties.

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

Source code

                public function rules()
{
    return [];
}

            

Source code

                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;
}

            

Saves the current record.

This method will call insert() when $isNewRecord is true, or update() when $isNewRecord is false.

For example, to save a customer record:

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

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.

Whether the saving succeeded (i.e. no validation errors occurred).

in case update or insert failed.

Source code

                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.

A list of scenarios and the corresponding active attributes.

Source code

                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;
}

            

Source code

                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 . '".');
    }
}

            

Attribute values (name => value) to be assigned to the model.

Whether 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.

Source code

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

            

Source code

                public function setIsNewRecord($value)
{
    $this->_oldAttributes = $value ? null : $this->_attributes;
}

            

Source code

                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 . '".');
    }
}

            

Sets the old attribute values.

All existing old attribute values will be discarded.

Old attribute values to be set. If set to null this record is considered to be new.

Source code

                public function setOldAttributes($values)
{
    $this->_oldAttributes = $values;
}

            

Source code

                public function setScenario($value)
{
    $this->_scenario = $value;
}

            

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.

The array representation of the object

Source code

                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;
}

            

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.

Source code

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

            

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.

Whether 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

Source code

                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]);
            }
        }
    }
}

            

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

The 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.

Source code

                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:

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) {
    
} 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 attribute names 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.

if optimistic locking is enabled and the data being updated is outdated.

in case update failed.

Source code

                public function update($runValidation = true, $attributeNames = null)
{
    if ($runValidation && !$this->validate($attributeNames)) {
        return false;
    }
    return $this->updateInternal($attributeNames);
}

            

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

Source code

                public static function updateAll($attributes, $condition = '')
{
    throw new NotSupportedException(__METHOD__ . ' is not supported.');
}

            

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

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

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

Source code

                public static function updateAllCounters($counters, $condition = '')
{
    throw new NotSupportedException(__METHOD__ . ' is not supported.');
}

            

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.

Source code

                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;
}

            

Updates one or several counter columns for the current AR object.

Note that this method differs from updateAllCounters() in that it only saves counters for the current AR object.

An example usage is as follows:

$post = Post::findOne($id);
$post->updateCounters(['view_count' => 1]);

See also updateAllCounters().

The counters to be updated (attribute name => increment value) Use negative values if you want to decrement the counters.

Whether the saving is successful

Source code

                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;
}

            

Source code

                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:

• the rule must be associated with the attributes relevant to the current scenario;
• the rules must be effective for the current scenario.

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

Attribute 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.

Whether to call clearErrors() before performing validation

Whether the validation is successful without any error.

if the current scenario is unknown.

Source code

                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.

The models to be validated

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.

Whether all models are valid. False will be returned if one or multiple models have validation error.

Source code

                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