How to perform ORM model association operations in ThinkPHP6?

ThinkPHP6 is a very popular PHP development framework that provides many convenient ORM (Object Relational Mapping) operation methods to simplify database operations, and has added richer ORM model association methods in the latest version, making development People can more easily perform associated query operations between database tables.

This article will introduce how to perform ORM model association operations in ThinkPHP6, including one-to-one, one-to-many, and many-to-many association operations. It will also explain the specific implementation mechanism of association operations.

One-to-one association operation

One-to-one association operation refers to an operation in which there is only one-to-one correspondence between two tables. For example, we have a user table (users) and a user details table (user_details). Each user corresponds to a user details record. There is a one-to-one relationship between the user table and the user details table.

First, define a one-to-one association in the model class:

namespace appmodel;

use thinkModel;

class User extends Model
{
    // 定义一对一关联方法
    public function detail()
    {
        return $this->hasOne('UserDetail');
    }
}

When defining the association, we use the hasOne method, which returns a BelongsTo object instance, representing the current model The class "has a" one-to-one relationship pointing to the UserDetail model class.

Then we define the reverse association method in the UserDetail model class:

namespace appmodel;

use thinkModel;

class UserDetail extends Model
{
    // 定义反向关联方法
    public function user()
    {
        return $this->belongsTo('User');
    }
}

In the UserDetail model class, we also use the belongsTo method, which will return a hasOne object instance to represent the current A one-to-one relationship where the model class "belongs" to the User model class.

Now we can perform one-to-one correlation query through the following method:

// 查询用户信息，包括其详细信息
$user = User::with(['detail'])->find(1);

// 查询用户信息，只包括其详细信息
$user = User::with(['detail' => function($query){
    $query->field('user_id, address');
}])->find(1);

In the above example, we use the with method to specify the correlation model, and use the find method to query user information. The related query results will be returned in the form of an array, and field filtering can be performed as needed.

One-to-many association operation

One-to-many association operation means that records in one table can correspond to multiple records in another table. For example, we have a course schedule (courses) and a student table (students). Each course can have multiple students taking electives. There is a one-to-many relationship between the course schedule and the students table.

First, define a one-to-many association relationship in the Course model class:

namespace appmodel;

use thinkModel;

class Course extends Model
{
    // 定义一对多关联方法
    public function students()
    {
        return $this->hasMany('Student');
    }
}

When defining the association relationship, we use the hasMany method, which will return a HasMany object instance to represent the current The model class "has multiple" points to a one-to-many association relationship with the Student model class.

Then we define the reverse association method in the Student model class:

namespace appmodel;

use thinkModel;

class Student extends Model
{
    // 定义反向关联方法
    public function course()
    {
        return $this->belongsTo('Course');
    }
}

In the Student model class, we also use the belongsTo method, which will return a hasOne object instance, indicating the current A one-to-many relationship where the model class "belongs" to the Course model class.

Now we can perform one-to-many correlation query through the following method:

// 查询课程信息，包括其选修学生信息
$course = Course::with(['students'])->find(1);

// 查询课程信息，只包括其选修学生姓名和年龄信息
$course = Course::with(['students' => function($query){
    $query->field('name, age');
}])->find(1);

In the above example, we use the with method to specify the correlation model, and use the find method to query course information. The related query results will be returned in the form of an array, and field filtering can be performed as needed.

Many-to-many association operation

Many-to-many association operation refers to the operation in which there is a many-to-many relationship between two tables. For example, we have a course schedule (courses) and a teacher table (teachers). Each course can be taught by multiple teachers, and each teacher can also teach multiple courses. There is a many-to-many relationship between the course schedule and the teacher table. .

First, define the many-to-many association relationship in the Course model class:

namespace appmodel;

use thinkModel;

class Course extends Model
{
    // 定义多对多关联方法
    public function teachers()
    {
        return $this->belongsToMany('Teacher', 'course_teacher');
    }
}

When defining the association relationship, we use the belongsToMany method, which will return a BelongsToMany object instance, representing the current The model class "belongs to many" points to the many-to-many association relationship of the Teacher model class. We also need to pass in the second parameter ‘course_teacher’, which represents the table name of the intermediate table.

Then we define the reverse association method in the Teacher model class:

namespace appmodel;

use thinkModel;

class Teacher extends Model
{
    // 定义反向关联方法
    public function courses()
    {
        return $this->belongsToMany('Course', 'course_teacher');
    }
}

In the Teacher model class, we also use the belongsToMany method, which will return a BelongsToMany object instance, representing the current The model class "contains many" points to a many-to-many relationship with the Course model class. You also need to pass in the second parameter ‘course_teacher’, which represents the table name of the intermediate table.

Now we can perform many-to-many correlation queries through the following methods:

// 查询课程信息，包括其授课老师信息
$course = Course::with(['teachers'])->find(1);

// 查询课程信息，只包括其授课老师姓名和职称信息
$course = Course::with(['teachers' => function($query){
    $query->field('name, title');
}])->find(1);

In the above example, we use the with method to specify the correlation model, and use the find method to query course information. The related query results will be returned in the form of an array, and field filtering can be performed as needed.

So far, we have learned how to perform ORM model association operations in ThinkPHP6, including one-to-one, one-to-many, and many-to-many association operations. ORM model association operations can simply complete association queries between database tables, greatly improving development efficiency and ensuring the correctness of database operations.

The above is the detailed content of How to perform ORM model association operations in ThinkPHP6?. For more information, please follow other related articles on the PHP Chinese website!