Lar*el：利用子查询实现按“一对多中之一”关系模型排序

新闻中心 NEWS CENTER

您当前位置：首页 > 新闻中心 > 网络学院

Lar*el：利用子查询实现按“一对多中之一”关系模型排序

2025-12-02

浏览次数：次

返回列表

laravel：利用子查询实现按“一对多中之一”关系模型排序

本文详细介绍了在 Lar*el 中如何根据“一对多中之一”（Has One Of Many）关系对主模型进行排序。针对客户模型需要按其最新联系记录进行排序的场景，文章演示了如何通过构建一个子查询来获取每个客户的最新联系时间，并将其作为连接条件与主表关联，最终实现高效且无重复地按关联模型字段排序，避免了传统 JOIN 方式带来的数据冗余问题。

Lar*el 中按关联模型字段排序的挑战与解决方案

在 Lar*el 应用开发中，我们经常会遇到需要根据关联模型的特定字段对主模型进行排序的需求。一个典型的场景是，我们有一个 Customer 模型，它拥有多个 Contact 记录，并且我们希望按照每个客户的“最新联系时间”来显示客户列表。虽然 Lar*el 的“一对多中之一”（Has One Of Many）关系（如 latestContact()）能够方便地获取单个最新关联记录，但直接使用此关系进行主查询的排序操作却并非直观。

场景描述与模型定义

假设我们有以下两个模型：Customer 和 Contact。一个客户可以有多个联系记录，每个联系记录都有一个 contacted_at 时间戳。

Customer 模型

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\HasOne;

class Customer extends Model
{
    use HasFactory;

    /**
     * 获取客户的所有联系记录
     */
    public function contacts(): HasMany
    {
        return $this->hasMany(Contact::class);
    }

    /**
     * 获取客户的最新联系记录
     * 使用 Has One Of Many 关系
     */
    public function latestContact(): HasOne
    {
        return $this->hasOne(Contact::class)->ofMany('contacted_at', 'max')->withDefault();
    }
}

Contact 模型

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;

class Contact extends Model
{
    use HasFactory;

    protected $casts = [
        'contacted_at' => 'datetime',
    ];

    /**
     * 获取此联系记录所属的客户
     */
    public function customer(): BelongsTo
    {
        return $this->belongsTo(Customer::class);
    }
}

contacts 表迁移

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateContactsTable extends Migration
{
    public function up()
    {
        Schema::create('contacts', function (Blueprint $table) {
            $table->id();
            $table->timestamps();
            $table->softDeletes();

            $table->foreignId('customer_id')->constrained()->onDelete('cascade');
            $table->string('type');
            $table->dateTime('contacted_at');
        });
    }

    public function down()
    {
        Schema::dropIfExists('contacts');
    }
}

我们的目标是获取所有客户，并按照他们各自的最新联系时间（即 latestContact 关系的 contacted_at 字段）进行排序。

传统 JOIN 的局限性

初学者可能会尝试使用 join 方法来解决这个问题：

$query = Customer::select('customers.*', 'contacts.contacted_at as latest_contact_at')
    ->join('contacts', 'customers.id', '=', 'contacts.customer_id')
    ->orderBy('contacts.contacted_at', 'desc') // 或 'asc'
    ->get();

然而，这种方法会导致一个问题：由于一个客户可以有多个联系记录，直接 JOIN 会使得每个客户在结果集中出现多次，这并非我们所期望的。我们需要的是每个客户只出现一次，并且根据其唯一的最新联系时间进行排序。

Scenario

一个AI生成游戏资产的工具

56 查看详情 Scenario

解决方案：利用子查询 JOIN

解决此问题的最简洁和推荐方式是使用 Lar*el 的子查询 JOIN 功能。其核心思想是：

构建一个子查询：这个子查询的作用是找出每个 customer_id 对应的最大 contacted_at 时间。
将子查询作为表进行 JOIN：将这个聚合后的子查询结果作为一张临时表，与 customers 表进行连接。
基于子查询结果进行排序：最后，根据子查询中得到的最新联系时间对 customers 表进行排序。

以下是实现此逻辑的 Lar*el 代码：

use Illuminate\Support\Facades\DB;

// 1. 构建子查询：获取每个客户的最新联系时间
$latestContactsSubquery = Contact::select('customer_id', DB::raw('MAX(contacted_at) as latest_contact_at'))
                                 ->groupBy('customer_id');

// 2. 将子查询作为临时表与 customers 表进行 JOIN
$customers = Customer::select('customers.*', 'latest_contacts.latest_contact_at')
                     ->joinSub($latestContactsSubquery, 'latest_contacts', function ($join) {
                         $join->on('customers.id', '=', 'latest_contacts.customer_id');
                     })
                     // 3. 根据最新联系时间进行排序
                     ->orderBy('latest_contacts.latest_contact_at', 'desc')
                     ->get();

// 此时 $customers 集合中的每个 Customer 模型都包含一个 'latest_contact_at' 属性
// 并且已经按照这个属性进行了排序。
foreach ($customers as $customer) {
    echo "客户 ID: " . $customer->id . ", 最新联系时间: " . $customer->latest_contact_at . "\n";
}

代码详解

Contact::select('customer_id', DB::raw('MAX(contacted_at) as latest_contact_at'))->groupBy('customer_id'):
- 这是一个 Eloquent 查询构建器，用于从 contacts 表中选择 customer_id。
- DB::raw('MAX(contacted_at) as latest_contact_at') 使用 MAX 聚合函数为每个客户找到其最新的 contacted_at 时间，并将其命名为 latest_contact_at。
- groupBy('customer_id') 确保 MAX 函数是针对每个唯一的 customer_id 进行计算的。
- 这个查询构建器本身不会立即执行，它代表了一个 SQL 子查询。
*`Customer::select('customers.', 'latest_contacts.latest_contact_at')`**:
- 这是主查询，从 customers 表中选择所有列 (customers.*)。
- 同时，我们也选择子查询中计算出的 latest_contact_at 字段，以便在主查询结果中可见并用于排序。
->joinSub($latestContactsSubquery, 'latest_contacts', function ($join) { ... }):
- joinSub 是 Lar*el 提供的一个方法，用于将一个查询构建器作为子查询（临时表）与当前查询进行 JOIN。
- $latestContactsSubquery 是我们之前构建的子查询。
- 'latest_contacts' 是为这个子查询结果起的别名，在后续的 on 条件和 orderBy 中会用到。
- function ($join) { $join->on('customers.id', '=', 'latest_contacts.customer_id'); } 定义了 JOIN 的连接条件，即 customers 表的 id 列与 latest_contacts 临时表中的 customer_id 列相等。
->orderBy('latest_contacts.latest_contact_at', 'desc'):
- 最后，我们根据 latest_contacts 临时表中的 latest_contact_at 字段进行降序排序，从而实现按最新联系时间对客户进行排序。

优点与注意事项

数据准确性：这种方法确保每个客户只出现一次，并且排序依据是其真正的最新联系时间，避免了传统 JOIN 带来的数据重复问题。
性能优化：数据库系统通常能够高效地处理子查询和 JOIN 操作。对于大规模数据集，确保 contacts 表的 customer_id 和 contacted_at 字段有适当的索引可以进一步提升性能。
代码可读性：Lar*el 的 joinSub 方法使得子查询的集成变得非常直观和易于理解。
与 hasOneOfMany 关系结合：虽然 latestContact() 关系本身不能直接用于排序主查询，但它在获取单个客户的最新联系记录时仍然非常有用。子查询 JOIN 解决了在列表层面对主模型进行排序的问题，两者可以互补使用。