Yii 2.0 ActiveRecord Explained

Yii 2.0 ActiveRecord: A Deep Dive into Object-Relational Mapping

Yii 2.0's ActiveRecord provides a robust Object-Relational Mapping (ORM) interface, simplifying database interactions. This approach, common in frameworks like Laravel and Ruby on Rails, offers features like mass assignment, validation, and scenario-based behavior. Let's explore its capabilities and advanced features.

Core Functionality (Inherited from yiibaseModel):

• Attributes: Model data is stored in publicly accessible attributes. Mass assignment is facilitated by assigning arrays to the attributes property, leveraging the __set() and setAttributes() methods inherited from yiibaseComponent. Attribute retrieval similarly uses __get() and getAttributes(). Attribute labels, crucial for user interfaces, are defined for display purposes.

• Validation: The rules() method defines validation rules for attributes, ensuring data integrity. By default, only "safe" attributes (those with defined validation rules) are mass-assignable.

• Scenarios: Scenarios allow defining different validation and data handling rules depending on the context (e.g., registration vs. login). This enhances flexibility and maintainability.

Creating an ActiveRecord Model:

The example uses a simple blog structure (see image above). The Articles model, generated using Gii, demonstrates the basic structure:

namespace app\models;

use Yii;

class Articles extends \yii\db\ActiveRecord
{
    // ... (tableName(), rules(), attributeLabels() as shown in the original text) ...

    public function getAuthors()
    {
        return $this->hasOne(Authors::className(), ['ID' => 'AuthorsID']);
    }

    public function getArticlestags()
    {
        return $this->hasMany(Articlestags::className(), ['ArticlesID' => 'ID']);
    }

    public function getTags()
    {
        return $this->hasMany(Tags::className(), ['ID' => 'TagsID'])
                    ->viaTable(Articlestags::tableName(), ['ArticlesID' => 'ID']);
    }
}

Note the addition of the getTags() method, which defines the many-to-many relationship with Tags via the Articlestags junction table.

Advanced Usage:

Yii 2.0 ActiveRecord enhances the base functionality with several advanced features:

• Dirty Attributes: Track changes to model attributes using getDirtyAttributes(), isAttributeChanged(), and markAttributeDirty(). This is invaluable for efficiently updating database records.

• Arrayable: The toArray() method, inherited via the Arrayable trait, converts the model to an array. fields() and extraFields() allow customizing the array's content, including calculated fields. For example, adding a comma-separated string of tags:

namespace app\models;

use Yii;

class Articles extends \yii\db\ActiveRecord
{
    // ... (tableName(), rules(), attributeLabels() as shown in the original text) ...

    public function getAuthors()
    {
        return $this->hasOne(Authors::className(), ['ID' => 'AuthorsID']);
    }

    public function getArticlestags()
    {
        return $this->hasMany(Articlestags::className(), ['ArticlesID' => 'ID']);
    }

    public function getTags()
    {
        return $this->hasMany(Tags::className(), ['ID' => 'TagsID'])
                    ->viaTable(Articlestags::tableName(), ['ArticlesID' => 'ID']);
    }
}

• Events: ActiveRecord triggers events at various stages of its lifecycle (e.g., beforeValidate(), afterSave()). These allow customizing behavior without modifying core model code. For example, automatically updating LastEdited:

public function extraFields()
{
    return [
        'tagsString' => function () {
            return implode(', ', array_map(function ($tag) { return $tag->Tag; }, $this->tags));
        },
    ];
}

• Behaviors: Behaviors add functionality to models without modifying their code. Yii provides built-in behaviors like BlameableBehavior (tracking creators/updaters) and TimestampBehavior (automatic timestamps). Attaching these behaviors:

public function beforeValidate()
{
    $this->LastEdited = new \yii\db\Expression('NOW()');
    return parent::beforeValidate();
}

• Transactional Operations: The transactions() method defines which operations should be wrapped in database transactions, ensuring data consistency.

Conclusion:

Yii 2.0 ActiveRecord provides a powerful and flexible ORM, significantly simplifying database interactions. The advanced features, including dirty attributes, events, behaviors, and transactional operations, enhance its capabilities and adaptability to complex scenarios. This detailed exploration highlights its strengths and demonstrates how to leverage its full potential.

The above is the detailed content of Yii 2.0 ActiveRecord Explained. For more information, please follow other related articles on the PHP Chinese website!