抽象類別 yii\db\BaseActiveRecord

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

            

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

            

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

            

                public function __unset($name)
{
    if ($this->hasAttribute($name)) {
        unset($this->_attributes[$name]);
        if (!empty($this->_relationsDependencies[$name])) {
            $this->resetDependentRelations($name);
        }
    } elseif (array_key_exists($name, $this->_related)) {
        unset($this->_related[$name]);
    } elseif ($this->getRelation($name, false) === null) {
        parent::__unset($name);
    }
}

            

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

            

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

            

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

            

                public function afterSave($insert, $changedAttributes)
{
    $this->trigger($insert ? self::EVENT_AFTER_INSERT : self::EVENT_AFTER_UPDATE, new AfterSaveEvent([
        'changedAttributes' => $changedAttributes,
    ]));
}

            

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

            

                public function beforeSave($insert)
{
    $event = new ModelEvent();
    $this->trigger($insert ? self::EVENT_BEFORE_INSERT : self::EVENT_BEFORE_UPDATE, $event);
    return $event->isValid;
}

            

                public function canGetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (parent::canGetProperty($name, $checkVars, $checkBehaviors)) {
        return true;
    }
    try {
        return $this->hasAttribute($name);
    } catch (\Exception $e) {
        // `hasAttribute()` may fail on base/abstract classes in case automatic attribute list fetching used
        return false;
    }
}

            

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

            

                public function canSetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (parent::canSetProperty($name, $checkVars, $checkBehaviors)) {
        return true;
    }
    try {
        return $this->hasAttribute($name);
    } catch (\Exception $e) {
        // `hasAttribute()` may fail on base/abstract classes in case automatic attribute list fetching used
        return false;
    }
}

            

                protected function createRelationQuery($class, $link, $multiple)
{
    /* @var $class ActiveRecordInterface */
    /* @var $query ActiveQuery */
    $query = $class::find();
    $query->primaryModel = $this;
    $query->link = $link;
    $query->multiple = $multiple;
    return $query;
}

            

                public function delete()
{
    $result = false;
    if ($this->beforeDelete()) {
        // we do not check the return value of deleteAll() because it's possible
        // the record is already deleted in the database and thus the method will return 0
        $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;
}

            

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

            

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

            

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

            

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

            

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

            

                public static function findOne($condition)
{
    return static::findByCondition($condition)->one();
}

            

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

            

                public function getAttributeHint($attribute)
{
    $hints = $this->attributeHints();
    if (isset($hints[$attribute])) {
        return $hints[$attribute];
    } elseif (strpos($attribute, '.')) {
        $attributeParts = explode('.', $attribute);
        $neededAttribute = array_pop($attributeParts);
        $relatedModel = $this;
        foreach ($attributeParts as $relationName) {
            if ($relatedModel->isRelationPopulated($relationName) && $relatedModel->$relationName instanceof self) {
                $relatedModel = $relatedModel->$relationName;
            } else {
                try {
                    $relation = $relatedModel->getRelation($relationName);
                } catch (InvalidParamException $e) {
                    return '';
                }
                /* @var $modelClass ActiveRecordInterface */
                $modelClass = $relation->modelClass;
                $relatedModel = $modelClass::instance();
            }
        }
        $hints = $relatedModel->attributeHints();
        if (isset($hints[$neededAttribute])) {
            return $hints[$neededAttribute];
        }
    }
    return '';
}

            

                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;
            }
            /* @var $modelClass ActiveRecordInterface */
            $modelClass = $relation->modelClass;
            $model = $modelClass::instance();
        }
    }
    return $this->generateAttributeLabel($attribute);
}

            

                public function getDirtyAttributes($names = null)
{
    if ($names === null) {
        $names = $this->attributes();
    }
    $names = array_flip($names);
    $attributes = [];
    if ($this->_oldAttributes === null) {
        foreach ($this->_attributes as $name => $value) {
            if (isset($names[$name])) {
                $attributes[$name] = $value;
            }
        }
    } else {
        foreach ($this->_attributes as $name => $value) {
            if (isset($names[$name]) && (!array_key_exists($name, $this->_oldAttributes) || $this->isValueDifferent($value, $this->_oldAttributes[$name]))) {
                $attributes[$name] = $value;
            }
        }
    }
    return $attributes;
}

            

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

            

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

            

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

            

                public function getOldPrimaryKey($asArray = false)
{
    $keys = static::primaryKey();
    if (empty($keys)) {
        throw new Exception(get_class($this) . ' does not have a primary key. You should either define a primary key for the corresponding table or override the primaryKey() method.');
    }
    if (!$asArray && count($keys) === 1) {
        return isset($this->_oldAttributes[$keys[0]]) ? $this->_oldAttributes[$keys[0]] : null;
    }
    $values = [];
    foreach ($keys as $name) {
        $values[$name] = isset($this->_oldAttributes[$name]) ? $this->_oldAttributes[$name] : null;
    }
    return $values;
}

            

                public function getPrimaryKey($asArray = false)
{
    $keys = static::primaryKey();
    if (!$asArray && count($keys) === 1) {
        return isset($this->_attributes[$keys[0]]) ? $this->_attributes[$keys[0]] : null;
    }
    $values = [];
    foreach ($keys as $name) {
        $values[$name] = isset($this->_attributes[$name]) ? $this->_attributes[$name] : null;
    }
    return $values;
}

            

                public function getRelatedRecords()
{
    return $this->_related;
}

            

                public function getRelation($name, $throwException = true)
{
    $getter = 'get' . $name;
    try {
        // the relation could be defined in a behavior
        $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)) {
        // relation name is case sensitive, trying to validate it when the relation is defined within this class
        $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;
}

            

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

            

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

            

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

            

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

            

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

            

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

            

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

            

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

            

                public function link($name, $model, $extraColumns = [])
{
    /* @var $relation ActiveQueryInterface|ActiveQuery */
    $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)) {
            /* @var $viaRelation ActiveQuery */
            list($viaName, $viaRelation) = $relation->via;
            $viaClass = $viaRelation->modelClass;
            // unset $viaName so that it can be reloaded to reflect the change
            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)) {
            /* @var $viaClass ActiveRecordInterface */
            /* @var $record ActiveRecordInterface */
            $record = Yii::createObject($viaClass);
            foreach ($columns as $column => $value) {
                $record->$column = $value;
            }
            $record->insert(false);
        } else {
            /* @var $viaTable string */
            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.');
        }
    }
    // update lazily loaded related objects
    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;
        }
    }
}

            

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

            

                public static function loadRelationsFor(&$models, $relationNames, $asArray = false)
{
    // ActiveQueryTrait::findWith() called below assumes $models array is non-empty.
    if (empty($models)) {
        return;
    }
    static::find()->asArray($asArray)->findWith((array)$relationNames, $models);
}

            

                public function markAttributeDirty($name)
{
    unset($this->_oldAttributes[$name]);
}

            

                #[\ReturnTypeWillChange]
public function offsetExists($offset)
{
    return $this->__isset($offset);
}

            

                public function offsetUnset($offset)
{
    if (property_exists($this, $offset)) {
        $this->$offset = null;
    } else {
        unset($this->$offset);
    }
}

            

                public function optimisticLock()
{
    return null;
}

            

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

            

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