版本：10.x

数据库：查询生成器

Laravel 的数据库查询生成器提供了一种便捷、流畅的接口来创建和运行数据库查询。它可用于执行应用程序中的大多数数据库操作，并与 Laravel 支持的所有数据库系统完美配合使用。

Laravel 查询生成器使用 PDO 参数绑定来保护你的应用程序免受 SQL 注入攻击。无需清理或净化传递给查询生成器的字符串作为查询绑定。

注意

PDO 不支持绑定列名。因此，你不应该允许用户输入来决定查询引用的列名，包括「order by」列名。

运行数据库查询

从表中检索所有行

你可以使用 DB facade 提供的 table 方法开始查询。table 方法为指定的表返回一个链式查询构造器实例，允许在查询上链接更多约束，最后使用 get 方法检索查询结果：

<?php

namespace App\Http\Controllers;

use App\Http\

Controllers\Controller;
use Illuminate\Support\Facades\DB;
use Illuminate\View\View;

class UserController extends Controller
{
    /**
     * 展示应用程序所有用户的列表
     */
    public function index(): View
    {
        $users = DB::table('users')->get();

        return view('user.index', ['users' => $users]);
    }
}

get 方法返回包含查询结果的 Illuminate\Support\Collection 实例，每个结果都是 PHP stdClass 实例。可以将列作为对象的属性来访问每列的值：

use Illuminate\Support\Facades\DB;

$users = DB::table('users')->get();

foreach ($users as $user) {
    echo $user->name;
}

提示

Laravel 集合提供了各种及其强大的方法来映射和裁剪数据。有关 Laravel 集合的更多信息，请查看集合文档 .

从表中检索单行或单列

如果只需要从数据表中检索单行，可以使用 DB facade 中的 first 方法。此方法将返回单个 stdClass 对象

$user = DB::table('users')->where('name', 'John')->first();

return $user->email;

如果不想要整行，可以使用 value 方法从纪录中提取单个值。此方法将直接返回列的值：

$email = DB::table(

'users')->where('name', 'John')->value('email');

如果要通过 id 字段值获取单行数据，可以使用 find 方法：

$user = DB::table('users')->find(3);

获取某一列的值

如果要获取包含单列值的 Illuminate\Support\Collection 实例，则可以使用 pluck 方法。在下面的例子中，我们将获取角色表中标题的集合：

use Illuminate\Support\Facades\DB;

$titles = DB::table('users')->pluck('title');

foreach ($titles as $title) {
    echo $title;
}

你可以通过向 pluck 方法提供第二个参数来指定结果集中要作为键的列：

$titles = DB::table('users')->pluck('title', 'name');

foreach ($titles as $name => $title) {
    echo $title;
}

分块结果

如果需要处理成千上万的数据库记录，请考虑使用 DB 提供的 chunk 方法。这个方法一次检索一小块结果，并将每个块反馈到闭包函数中进行处理。例如，让我们以一次 100 条记录的块为单位检索整个 users 表：

use Illuminate\Support\Collection;
use Illuminate\Support\Facades\DB;

DB::table('users')->orderBy('id')->chunk(100, function (Collection $users) {
    foreach ($users

 as $user) {
        // ...
    }
});

你可以通过从闭包中返回 false 来停止处理其余的块:

DB::table('users')->orderBy('id')->chunk(100, function (Collection $users) {
    // 处理分块...

    return false;
});

如果在对结果进行分块时更新数据库记录，那分块结果可能会以意想不到的方式更改。如果你打算在分块时更新检索到的记录，最好使用 chunkById 方法。此方法将根据记录的主键自动对结果进行分页:

DB::table('users')->where('active', false)
    ->chunkById(100, function (Collection $users) {
        foreach ($users as $user) {
            DB::table('users')
                ->where('id', $user->id)
                ->update(['active' => true]);
        }
    });

             
            

注意

当在更新或删除块回调中的记录时，对主键或外键的任何更改都可能影响块查询。这可能会导致记录未包含在分块结果中。

Lazily 流式传输结果

lazy 方法的工作方式类似于 chunk 方法，因为它以块的形式执行查询。但是， lazy() 方法不是将每个块传递给回调，而是返回一个 LazyCollection ，它可以让你与结果进行交互单个流：

use Illuminate\Support\Facades\DB;

DB::table('users')->orderBy('id')->lazy()->each(function (object $user) {
    // ...
});

再一次，如果你打算在迭代它们时更新检索到的记录，最好使用 lazyById 或 lazyByIdDesc 方法。这些方法将根据记录的主键自动对结果进行分页：

DB::table('users')->where('active', false)
    ->lazyById()->each(function (object $user) {
        DB::table('users')
            ->where('id', $user->id)
            ->update(['active' => true]);
    });

             
            

注意

在迭代记录时更新或删除记录时，对主键或外键的任何更改都可能影响块查询。这可能会导致记录不包含在结果中。

聚合函数

查询构建器还提供了多种检索聚合值的方法，例如 count ， max ， min ， avg 和 sum 。你可以在构建查询后调用这些方法中的任何一个：

use Illuminate\Support\Facades\DB;

$users = DB::table('users')->count();

$price = DB::table('orders')->max('price');

当然，你可以将这些方法与其他子句结合起来，以优化计算聚合值的方式：

$price = DB::table('orders')
                ->where('finalized', 1)
                ->avg('price');

判断记录是否存在

除了通过 count 方法可以确定查询条件的结果是否存在之外，还可以使用 exists 和 doesntExist 方法：

if (DB::table('orders')->where('finalized', 1)->

exists()) {
    // ...
}

if (DB::table('orders')->where('finalized', 1)->doesntExist()) {
    // ...
}

Select 语句

指定一个 Select 语句

可能你并不总是希望从数据库表中获取所有列。使用 select 方法，可以自定义一个「select」查询语句来查询指定的字段：

use Illuminate\Support\Facades\DB;

$users = DB::table('users')
            ->select('name', 'email as user_email')
            ->get();

distinct 方法会强制让查询返回的结果不重复：

$users = DB::table('users')->distinct()->get();

如果你已经有了一个查询构造器实例，并且希望在现有的查询语句中加入一个字段，那么你可以使用 addSelect 方法：

$query = DB::table('users')->select('name');

$users = $query->addSelect('age')->get();

原生表达式

当你需要在查询中插入任意的字符串时，你可以使用 DB 门面提供的 raw 方法以创建原生表达式。

$users = DB::table('users')
             ->select(DB::raw('count(*) as user_count, status'))
             ->where('status', '<>', 1)
             ->groupBy

('status')
             ->get();

注意

原生语句作为字符串注入到查询中，因此必须格外小心避免产生 SQL 注入漏洞。

原生方法。

可以使用以下方法代替 DB::raw ，将原生表达式插入查询的各个部分。 请记住，Laravel 无法保证所有使用原生表达式的查询都不受到 SQL 注入漏洞的影响。

`selectRaw`

selectRaw 方法可以用来代替 addSelect(DB::raw(/* ... */)) 。此方法接受一个可选的绑定数组作为其第二个参数：

$orders = DB::table('orders')
                ->selectRaw('price * ? as price_with_tax', [1.0825])
                ->get();

`whereRaw / orWhereRaw`

whereRaw 和 orWhereRaw 方法可用于将原始「where」子句注入你的查询。这些方法接受一个可选的绑定数组作为它们的第二个参数：

$orders = DB::table('orders')
                ->whereRaw('price > IF(state = "TX", ?, 100)', [200])
                ->get();

`havingRaw / orHavingRaw`

havingRaw 和 orHavingRaw 方法可用于提供原始字符串作为「having」子句的值。这些方法接受一个可选的绑定数组作为它们的第二个参数：

$orders = DB::table('orders')
                ->select('department', DB::raw('SUM(price) as total_sales'))
                ->groupBy('department')
                ->havingRaw('SUM(price) > ?', [2500])
                ->get();

             
            

`orderByRaw`

orderByRaw 方法可用于将原生字符串设置为「order by」子句的值：

$orders = DB::table('orders')
                ->orderByRaw('updated_at - created_at DESC')
                ->get();

`groupByRaw`

groupByRaw 方法可以用于将原生字符串设置为 group by 子句的值：

$orders = DB::table('orders')
                ->select('city', 'state')
                ->groupByRaw('city, state')
                ->get();

Joins

Inner Join 语句

查询构造器也还可用于向查询中添加连接子句。若要执行基本的「inner join」，你可以对查询构造器实例使用 join 方法。传递给 join 方法的第一个参数是需要你连接到的表的名称，而其余参数指定连接的列约束。你甚至还可以在一个查询中连接多个表：

use Illuminate\Support\Facades\DB;

$users = DB::table('users')
            ->join('contacts', 'users.id', '=', 'contacts.user_id')
            ->join('orders', 'users.id', '=', 'orders.user_id')
            ->select('users.*', 'contacts.phone', 'orders.price')
            ->get();

             
            

Left Join / Right Join 语句

如果你想使用「left join」或者「right join」代替「inner join」，可以使用 leftJoin 或者 rightJoin 方法。这两个方法与 join 方法用法相同：

$users = DB::table('users')
            ->leftJoin('posts', 'users.id', '=', 'posts.user_id')
            ->get();

$users = DB::table('users')
            ->rightJoin('posts', 'users.id', '=', 'posts.user_id')
            ->get();

             
            

Cross Join 语句

你可以使用 crossJoin 方法执行「交叉连接」。交叉连接在第一个表和被连接的表之间会生成笛卡尔积：

$sizes = DB::table('sizes')
            ->crossJoin('colors')
            ->get();

高级 Join 语句

你还可以指定更高级的联接子句。首先，将闭包作为第二个参数传递给 join 方法。闭包将收到一个 Illuminate\Database\Query\JoinClause 实例，该实例允许你指定对 join 子句的约束：

DB::table('users')
        ->join('contacts', function (JoinClause $join) {
            $join->on('users.id', '=', 'contacts.user_id')->orOn(/* ... */);
        })
        ->get();

             
            

如果你想要在连接上使用「where」风格的语句，你可以在连接上使用 JoinClause 实例中的 where 和 orWhere 方法。这些方法会将列和值进行比较，而不是列和列进行比较：

DB::table('users')
        ->join('contacts', function (JoinClause $join) {
            $join->on('users.id', '=', 'contacts.user_id')
                 ->where('contacts.user_id', '>', 5);
        })
        ->get();

             
            

子连接查询

你可以使用 joinSub ， leftJoinSub 和 rightJoinSub 方法关联一个查询作为子查询。他们每一种方法都会接收三个参数：子查询、表别名和定义关联字段的闭包。如下面这个例子，获取含有用户最近一次发布博客时的 created_at 时间戳的用户集合：

$latestPosts = DB::table('posts')
                   ->select('user_id', DB::raw('MAX(created_at) as last_post_created_at'))
                   ->where('is_published', true)
                   ->groupBy('user_id'

);

$users = DB::table('users')
        ->joinSub($latestPosts, 'latest_posts', function (JoinClause $join) {
            $join->on('users.id', '=', 'latest_posts.user_id');
        })->get();

查询构造器还提供了一种简洁的方式将两个或者多个查询「联合」在一起。例如，你可以先创建一个查询，然后使用 union 方法来连接更多的查询：

use Illuminate\Support\Facades\DB;

$first = DB::table('users')
            ->whereNull('first_name');

$users = DB::table('users')
            ->whereNull('last_name')
            ->union($first)
            ->get();

查询构造器不仅提供了 union 方法，还提供了一个 unionAll 方法。当查询结合 unionAll 方法使用时，将不会删除重复的结果。 unionAll 方法的用法和 union 方法一样。

基础的 Where 语句

Where 语句

你可以在 where 语句中使用查询构造器的 where 方法。调用 where 方法需要三个基本参数。第一个参数是字段的名称。第二个参数是一个操作符，它可以是数据库中支持的任意操作符。第三个参数是与字段比较的值。

例如。在 users 表中查询 votes 字段等于 100 并且 age 字段大于 35 的数据：

$users = DB::table('users')
                ->where('votes', '=', 100)
                ->where('age', '>', 35)
                ->get();

为了方便起见。如果你想要比较一个字段的值是否 等于 给定的值。你可以将这个给定的值作为第二个参数传递给 where 方法。那么，Laravel 会默认使用 = 操作符：

$users = DB::table('users')->where('votes', 100)->get();

运行数据库查询 ​

从表中检索所有行 ​

从表中检索单行或单列 ​

获取某一列的值 ​

分块结果 ​

Lazily 流式传输结果 ​

聚合函数 ​

判断记录是否存在 ​

Select 语句 ​

指定一个 Select 语句 ​

原生表达式 ​

原生方法。 ​

selectRaw ​

whereRaw / orWhereRaw ​

havingRaw / orHavingRaw ​

orderByRaw ​

groupByRaw ​

Joins ​

Inner Join 语句 ​

Left Join / Right Join 语句 ​

Cross Join 语句 ​

高级 Join 语句 ​

子连接查询 ​

基础的 Where 语句 ​

Where 语句 ​