数据库：查询构造器
- 简介
- 运行数据库查询
- Select 语句
- 原始表达式
- Joins
- Unions
- 基本 Where 子句
- 高级 Where 子句
- 排序、分组、限制和偏移
- 条件子句
- Insert 语句
- Update 语句
- Delete 语句
- 悲观锁
- 调试
简介
Laravel 的数据库查询构造器提供了一个方便、流畅的接口来创建和运行数据库查询。它可用于在您的应用程序中执行大多数数据库操作，并且与 Laravel 支持的所有数据库系统完美配合。
Laravel 查询构造器使用 PDO 参数绑定来保护您的应用程序免受 SQL 注入攻击。无需清理或清理传递给查询构造器的字符串作为查询绑定。
PDO 不支持绑定列名。因此，您永远不应允许用户输入来指定查询引用的列名，包括“order by”列。
运行数据库查询
从表中检索所有行
您可以使用 DB 外观模式提供的 table 方法来开始查询。table 方法为给定的表返回一个流畅的查询构造器实例，允许您将更多约束链接到查询上，然后最终使用 get 方法检索查询结果
1<?php 2 3namespace App\Http\Controllers; 4 5use Illuminate\Support\Facades\DB; 6use Illuminate\View\View; 7 8class UserController extends Controller 9{10 /**11 * Show a list of all of the application's users.12 */13 public function index(): View14 {15 $users = DB::table('users')->get();16 17 return view('user.index', ['users' => $users]);18 }19}get 方法返回一个 Illuminate\Support\Collection 实例，其中包含查询结果，每个结果都是 PHP stdClass 对象的实例。您可以通过访问列作为对象的属性来访问每个列的值
1use Illuminate\Support\Facades\DB;2 3$users = DB::table('users')->get();4 5foreach ($users as $user) {6 echo $user->name;7}Laravel 集合提供了各种极其强大的方法来映射和减少数据。有关 Laravel 集合的更多信息，请查看集合文档。
从表中检索单行/列
如果您只需要从数据库表中检索单行，则可以使用 DB 外观模式的 first 方法。此方法将返回单个 stdClass 对象
1$user = DB::table('users')->where('name', 'John')->first();2 3return $user->email;如果您想从数据库表中检索单行，但如果未找到匹配的行，则抛出 Illuminate\Database\RecordNotFoundException 异常，则可以使用 firstOrFail 方法。如果 RecordNotFoundException 未被捕获，则会自动将 404 HTTP 响应发送回客户端
1$user = DB::table('users')->where('name', 'John')->firstOrFail();如果您不需要整行，则可以使用 value 方法从记录中提取单个值。此方法将直接返回列的值
1$email = DB::table('users')->where('name', 'John')->value('email');要按其 id 列值检索单行，请使用 find 方法
1$user = DB::table('users')->find(3);检索列值列表
如果您想检索包含单列值的 Illuminate\Support\Collection 实例，则可以使用 pluck 方法。在此示例中，我们将检索用户标题的集合
1use Illuminate\Support\Facades\DB;2 3$titles = DB::table('users')->pluck('title');4 5foreach ($titles as $title) {6 echo $title;7}您可以通过向 pluck 方法提供第二个参数来指定结果集合应使用哪个列作为其键
1$titles = DB::table('users')->pluck('title', 'name');2 3foreach ($titles as $name => $title) {4 echo $title;5}分块结果
如果您需要处理数千条数据库记录，请考虑使用 DB 外观模式提供的 chunk 方法。此方法一次检索一小块结果，并将每个块馈送到闭包以进行处理。例如，让我们一次检索 100 条记录的整个 users 表
1use Illuminate\Support\Collection;2use Illuminate\Support\Facades\DB;3 4DB::table('users')->orderBy('id')->chunk(100, function (Collection $users) {5 foreach ($users as $user) {6 // ...7 }8});您可以通过从闭包返回 false 来停止进一步处理块
1DB::table('users')->orderBy('id')->chunk(100, function (Collection $users) {2 // Process the records...3 4 return false;5});如果您在分块结果时更新数据库记录，则您的分块结果可能会以意想不到的方式更改。如果您计划在分块时更新检索到的记录，则最好始终使用 chunkById 方法。此方法将根据记录的主键自动分页结果
1DB::table('users')->where('active', false)2 ->chunkById(100, function (Collection $users) {3 foreach ($users as $user) {4 DB::table('users')5 ->where('id', $user->id)6 ->update(['active' => true]);7 }8 });由于 chunkById 和 lazyById 方法将它们自己的“where”条件添加到正在执行的查询中，因此您通常应该在闭包中逻辑分组您自己的条件
1DB::table('users')->where(function ($query) {2 $query->where('credits', 1)->orWhere('credits', 2);3})->chunkById(100, function (Collection $users) {4 foreach ($users as $user) {5 DB::table('users')6 ->where('id', $user->id)7 ->update(['credits' => 3]);8 }9});在块回调中更新或删除记录时，对主键或外键的任何更改都可能影响块查询。这可能会导致记录未包含在分块结果中。
惰性流式处理结果
lazy 方法的工作方式类似于chunk 方法，因为它以块的形式执行查询。但是，lazy() 方法不是将每个块传递到回调中，而是返回一个LazyCollection，允许您将结果作为单个流进行交互
1use Illuminate\Support\Facades\DB;2 3DB::table('users')->orderBy('id')->lazy()->each(function (object $user) {4 // ...5});再次，如果您计划在迭代检索到的记录时更新它们，则最好使用 lazyById 或 lazyByIdDesc 方法。这些方法将根据记录的主键自动分页结果
1DB::table('users')->where('active', false)2 ->lazyById()->each(function (object $user) {3 DB::table('users')4 ->where('id', $user->id)5 ->update(['active' => true]);6 });在迭代记录时更新或删除记录时，对主键或外键的任何更改都可能影响块查询。这可能会导致记录未包含在结果中。
聚合
查询构造器还提供了多种方法来检索聚合值，如 count、max、min、avg 和 sum。您可以在构造查询后调用这些方法中的任何一种
1use Illuminate\Support\Facades\DB;2 3$users = DB::table('users')->count();4 5$price = DB::table('orders')->max('price');当然，您可以将这些方法与其他子句结合使用，以微调聚合值的计算方式
1$price = DB::table('orders')2 ->where('finalized', 1)3 ->avg('price');确定记录是否存在
您可以使用 exists 和 doesntExist 方法，而不是使用 count 方法来确定是否存在与查询约束匹配的任何记录
1if (DB::table('orders')->where('finalized', 1)->exists()) {2 // ...3}4 5if (DB::table('orders')->where('finalized', 1)->doesntExist()) {6 // ...7}Select 语句
指定 Select 子句
您可能并不总是想从数据库表中选择所有列。使用 select 方法，您可以为查询指定自定义的“select”子句
1use Illuminate\Support\Facades\DB;2 3$users = DB::table('users')4 ->select('name', 'email as user_email')5 ->get();distinct 方法允许您强制查询返回不同的结果
1$users = DB::table('users')->distinct()->get();如果您已经有一个查询构造器实例，并且希望向其现有的 select 子句添加列，则可以使用 addSelect 方法
1$query = DB::table('users')->select('name');2 3$users = $query->addSelect('age')->get();原始表达式
有时您可能需要在查询中插入任意字符串。要创建原始字符串表达式，可以使用 DB 外观模式提供的 raw 方法
1$users = DB::table('users')2 ->select(DB::raw('count(*) as user_count, status'))3 ->where('status', '<>', 1)4 ->groupBy('status')5 ->get();原始语句将作为字符串注入到查询中，因此您应格外小心，避免创建 SQL 注入漏洞。
原始方法
除了使用 DB::raw 方法之外，您还可以使用以下方法将原始表达式插入到查询的各个部分。请记住，Laravel 无法保证任何使用原始表达式的查询都能防止 SQL 注入漏洞。
selectRaw
selectRaw 方法可以代替 addSelect(DB::raw(/* ... */)) 使用。此方法接受可选的绑定数组作为其第二个参数
1$orders = DB::table('orders')2 ->selectRaw('price * ? as price_with_tax', [1.0825])3 ->get();whereRaw / orWhereRaw
whereRaw 和 orWhereRaw 方法可用于将原始“where”子句注入到您的查询中。这些方法接受可选的绑定数组作为其第二个参数
1$orders = DB::table('orders')2 ->whereRaw('price > IF(state = "TX", ?, 100)', [200])3 ->get();havingRaw / orHavingRaw
havingRaw 和 orHavingRaw 方法可用于提供原始字符串作为“having”子句的值。这些方法接受可选的绑定数组作为其第二个参数
1$orders = DB::table('orders')2 ->select('department', DB::raw('SUM(price) as total_sales'))3 ->groupBy('department')4 ->havingRaw('SUM(price) > ?', [2500])5 ->get();orderByRaw
orderByRaw 方法可用于提供原始字符串作为“order by”子句的值
1$orders = DB::table('orders')2 ->orderByRaw('updated_at - created_at DESC')3 ->get();groupByRaw
groupByRaw 方法可用于提供原始字符串作为 group by 子句的值
1$orders = DB::table('orders')2 ->select('city', 'state')3 ->groupByRaw('city, state')4 ->get();Joins
Inner Join 子句
查询构造器还可用于向查询添加 join 子句。要执行基本的“inner join”，您可以在查询构造器实例上使用 join 方法。传递给 join 方法的第一个参数是您需要加入的表的名称，而其余参数指定 join 的列约束。您甚至可以在单个查询中连接多个表
1use Illuminate\Support\Facades\DB;2 3$users = DB::table('users')4 ->join('contacts', 'users.id', '=', 'contacts.user_id')5 ->join('orders', 'users.id', '=', 'orders.user_id')6 ->select('users.*', 'contacts.phone', 'orders.price')7 ->get();Left Join / Right Join 子句
如果您想要执行“左连接”或“右连接”而不是“内连接”，请使用 leftJoin 或 rightJoin 方法。这些方法与 join 方法具有相同的签名。
1$users = DB::table('users')2 ->leftJoin('posts', 'users.id', '=', 'posts.user_id')3 ->get();4 5$users = DB::table('users')6 ->rightJoin('posts', 'users.id', '=', 'posts.user_id')7 ->get();交叉连接子句
您可以使用 crossJoin 方法来执行“交叉连接”。交叉连接会在第一个表和连接的表之间生成笛卡尔积。
1$sizes = DB::table('sizes')2 ->crossJoin('colors')3 ->get();高级连接子句
您还可以指定更高级的连接子句。要开始使用，请将一个闭包作为第二个参数传递给 join 方法。闭包将接收一个 Illuminate\Database\Query\JoinClause 实例，您可以使用它来指定“连接”子句的约束。
1DB::table('users')2 ->join('contacts', function (JoinClause $join) {3 $join->on('users.id', '=', 'contacts.user_id')->orOn(/* ... */);4 })5 ->get();如果您想在连接上使用“where”子句，可以使用 JoinClause 实例提供的 where 和 orWhere 方法。与比较两列不同，这些方法会将列与一个值进行比较。
1DB::table('users')2 ->join('contacts', function (JoinClause $join) {3 $join->on('users.id', '=', 'contacts.user_id')4 ->where('contacts.user_id', '>', 5);5 })6 ->get();子查询连接
您可以使用 joinSub、leftJoinSub 和 rightJoinSub 方法将查询连接到子查询。这些方法都接收三个参数：子查询、其表别名以及定义相关列的闭包。在本例中，我们将检索一个用户集合，其中每个用户记录还包含用户最近发布的博客文章的 created_at 时间戳。
1$latestPosts = DB::table('posts')2 ->select('user_id', DB::raw('MAX(created_at) as last_post_created_at'))3 ->where('is_published', true)4 ->groupBy('user_id');5 6$users = DB::table('users')7 ->joinSub($latestPosts, 'latest_posts', function (JoinClause $join) {8 $join->on('users.id', '=', 'latest_posts.user_id');9 })->get();横向连接
PostgreSQL、MySQL >= 8.0.14 和 SQL Server 当前支持横向连接。
您可以使用 joinLateral 和 leftJoinLateral 方法对子查询执行“横向连接”。这些方法都接收两个参数：子查询及其表别名。连接条件应在给定子查询的 where 子句中指定。横向连接为每一行进行评估，并且可以引用子查询之外的列。
在本例中，我们将检索一个用户集合以及用户最近的三篇博客文章。每个用户可以在结果集中生成最多三行：每篇最近的博客文章一行。连接条件在子查询中使用 whereColumn 子句指定，引用当前用户行。
1$latestPosts = DB::table('posts')2 ->select('id as post_id', 'title as post_title', 'created_at as post_created_at')3 ->whereColumn('user_id', 'users.id')4 ->orderBy('created_at', 'desc')5 ->limit(3);6 7$users = DB::table('users')8 ->joinLateral($latestPosts, 'latest_posts')9 ->get();Unions
查询构建器还提供了一个方便的方法来“联合”两个或多个查询。例如，您可以创建一个初始查询，并使用 union 方法将其与更多查询联合起来。
1use Illuminate\Support\Facades\DB;2 3$first = DB::table('users')4 ->whereNull('first_name');5 6$users = DB::table('users')7 ->whereNull('last_name')8 ->union($first)9 ->get();除了 union 方法外，查询构建器还提供了 unionAll 方法。使用 unionAll 方法组合的查询不会删除重复的结果。unionAll 方法与 union 方法具有相同的方法签名。
基本 Where 子句
Where 子句
您可以使用查询构建器的 where 方法向查询添加“where”子句。对 where 方法最基本的调用需要三个参数。第一个参数是列的名称。第二个参数是运算符，可以是数据库支持的任何运算符。第三个参数是要与列的值进行比较的值。
例如，以下查询检索 votes 列的值等于 100 且 age 列的值大于 35 的用户。
1$users = DB::table('users')2 ->where('votes', '=', 100)3 ->where('age', '>', 35)4 ->get();为了方便起见，如果您想验证列是否 = 于给定值，您可以将该值作为第二个参数传递给 where 方法。Laravel 会假定您想使用 = 运算符。
1$users = DB::table('users')->where('votes', 100)->get();如前所述，您可以使用数据库系统支持的任何运算符。
1$users = DB::table('users') 2 ->where('votes', '>=', 100) 3 ->get(); 4 5$users = DB::table('users') 6 ->where('votes', '<>', 100) 7 ->get(); 8 9$users = DB::table('users')10 ->where('name', 'like', 'T%')11 ->get();您还可以将条件数组传递给 where 函数。数组的每个元素都应该是一个数组，其中包含通常传递给 where 方法的三个参数。
1$users = DB::table('users')->where([2 ['status', '=', '1'],3 ['subscribed', '<>', '1'],4])->get();PDO 不支持绑定列名。因此，您永远不应允许用户输入来指定查询引用的列名，包括“order by”列。
MySQL 和 MariaDB 在字符串-数字比较中会自动将字符串强制转换为整数。在此过程中，非数字字符串将转换为 0，这可能会导致意外的结果。例如，如果您的表有一个值为 aaa 的 secret 列，并且您运行 User::where('secret', 0)，则将返回该行。为了避免这种情况，请确保在查询中使用所有值之前将其强制转换为适当的类型。
Or Where 子句
当链式调用查询构建器的 where 方法时，“where”子句将使用 and 运算符连接在一起。但是，您可以使用 orWhere 方法使用 or 运算符将子句连接到查询。orWhere 方法接受与 where 方法相同的参数。
1$users = DB::table('users')2 ->where('votes', '>', 100)3 ->orWhere('name', 'John')4 ->get();如果您需要在括号内对“or”条件进行分组，您可以将闭包作为第一个参数传递给 orWhere 方法。
1$users = DB::table('users')2 ->where('votes', '>', 100)3 ->orWhere(function (Builder $query) {4 $query->where('name', 'Abigail')5 ->where('votes', '>', 50);6 })7 ->get();上面的示例将生成以下 SQL。
1select * from users where votes > 100 or (name = 'Abigail' and votes > 50)您应该始终对 orWhere 调用进行分组，以避免在应用全局作用域时出现意外行为。
Where Not 子句
whereNot 和 orWhereNot 方法可用于否定给定的查询约束组。例如，以下查询排除了正在清仓销售或价格低于十的产品。
1$products = DB::table('products')2 ->whereNot(function (Builder $query) {3 $query->where('clearance', true)4 ->orWhere('price', '<', 10);5 })6 ->get();Where Any / All / None 子句
有时您可能需要将相同的查询约束应用于多个列。例如，您可能想要检索给定列表中任何列 LIKE 给定值的所有记录。您可以使用 whereAny 方法来实现此目的。
1$users = DB::table('users')2 ->where('active', true)3 ->whereAny([4 'name',5 'email',6 'phone',7 ], 'like', 'Example%')8 ->get();上面的查询将产生以下 SQL。
1SELECT *2FROM users3WHERE active = true AND (4 name LIKE 'Example%' OR5 email LIKE 'Example%' OR6 phone LIKE 'Example%'7)类似地，whereAll 方法可用于检索其中所有给定列都匹配给定约束的记录。
1$posts = DB::table('posts')2 ->where('published', true)3 ->whereAll([4 'title',5 'content',6 ], 'like', '%Laravel%')7 ->get();上面的查询将产生以下 SQL。
1SELECT *2FROM posts3WHERE published = true AND (4 title LIKE '%Laravel%' AND5 content LIKE '%Laravel%'6)whereNone 方法可用于检索其中没有给定列匹配给定约束的记录。
1$posts = DB::table('albums')2 ->where('published', true)3 ->whereNone([4 'title',5 'lyrics',6 'tags',7 ], 'like', '%explicit%')8 ->get();上面的查询将产生以下 SQL。
1SELECT *2FROM albums3WHERE published = true AND NOT (4 title LIKE '%explicit%' OR5 lyrics LIKE '%explicit%' OR6 tags LIKE '%explicit%'7)JSON Where 子句
Laravel 还支持在提供 JSON 列类型支持的数据库上查询 JSON 列类型。目前，这包括 MariaDB 10.3+、MySQL 8.0+、PostgreSQL 12.0+、SQL Server 2017+ 和 SQLite 3.39.0+。要查询 JSON 列，请使用 -> 运算符。
1$users = DB::table('users')2 ->where('preferences->dining->meal', 'salad')3 ->get();您可以使用 whereJsonContains 查询 JSON 数组。
1$users = DB::table('users')2 ->whereJsonContains('options->languages', 'en')3 ->get();如果您的应用程序使用 MariaDB、MySQL 或 PostgreSQL 数据库，您可以将值数组传递给 whereJsonContains 方法。
1$users = DB::table('users')2 ->whereJsonContains('options->languages', ['en', 'de'])3 ->get();您可以使用 whereJsonLength 方法按长度查询 JSON 数组。
1$users = DB::table('users')2 ->whereJsonLength('options->languages', 0)3 ->get();4 5$users = DB::table('users')6 ->whereJsonLength('options->languages', '>', 1)7 ->get();附加 Where 子句
whereLike / orWhereLike / whereNotLike / orWhereNotLike
whereLike 方法允许您向查询添加“LIKE”子句以进行模式匹配。这些方法提供了一种与数据库无关的方式来执行字符串匹配查询，并能够切换大小写敏感性。默认情况下，字符串匹配是不区分大小写的。
1$users = DB::table('users')2 ->whereLike('name', '%John%')3 ->get();您可以通过 caseSensitive 参数启用区分大小写的搜索。
1$users = DB::table('users')2 ->whereLike('name', '%John%', caseSensitive: true)3 ->get();orWhereLike 方法允许您添加带有 LIKE 条件的“or”子句。
1$users = DB::table('users')2 ->where('votes', '>', 100)3 ->orWhereLike('name', '%John%')4 ->get();whereNotLike 方法允许您添加“NOT LIKE”子句到您的查询中。
1$users = DB::table('users')2 ->whereNotLike('name', '%John%')3 ->get();类似地，您可以使用 orWhereNotLike 添加带有 NOT LIKE 条件的 “or” 子句。
1$users = DB::table('users')2 ->where('votes', '>', 100)3 ->orWhereNotLike('name', '%John%')4 ->get();whereLike 区分大小写的搜索选项目前在 SQL Server 上不受支持。
whereIn / whereNotIn / orWhereIn / orWhereNotIn
whereIn 方法验证给定列的值是否包含在给定的数组中。
1$users = DB::table('users')2 ->whereIn('id', [1, 2, 3])3 ->get();whereNotIn 方法验证给定列的值是否不包含在给定的数组中。
1$users = DB::table('users')2 ->whereNotIn('id', [1, 2, 3])3 ->get();您还可以提供一个查询对象作为 whereIn 方法的第二个参数。
1$activeUsers = DB::table('users')->select('id')->where('is_active', 1);2 3$users = DB::table('comments')4 ->whereIn('user_id', $activeUsers)5 ->get();上面的示例将生成以下 SQL。
1select * from comments where user_id in (2 select id3 from users4 where is_active = 15)如果您要向查询添加大量整数绑定，则可以使用 whereIntegerInRaw 或 whereIntegerNotInRaw 方法来大大减少内存使用量。
whereBetween / orWhereBetween
whereBetween 方法验证列的值是否在两个值之间。
1$users = DB::table('users')2 ->whereBetween('votes', [1, 100])3 ->get();whereNotBetween / orWhereNotBetween
whereNotBetween 方法验证列的值是否在两个值之外。
1$users = DB::table('users')2 ->whereNotBetween('votes', [1, 100])3 ->get();whereBetweenColumns / whereNotBetweenColumns / orWhereBetweenColumns / orWhereNotBetweenColumns
whereBetweenColumns 方法验证列的值是否在同一表行中两列的两个值之间。
1$patients = DB::table('patients')2 ->whereBetweenColumns('weight', ['minimum_allowed_weight', 'maximum_allowed_weight'])3 ->get();whereNotBetweenColumns 方法验证列的值是否在同一表行中两列的两个值之外。
1$patients = DB::table('patients')2 ->whereNotBetweenColumns('weight', ['minimum_allowed_weight', 'maximum_allowed_weight'])3 ->get();whereNull / whereNotNull / orWhereNull / orWhereNotNull
whereNull 方法验证给定列的值是否为 NULL。
1$users = DB::table('users')2 ->whereNull('updated_at')3 ->get();whereNotNull 方法验证列的值是否不为 NULL。
1$users = DB::table('users')2 ->whereNotNull('updated_at')3 ->get();whereDate / whereMonth / whereDay / whereYear / whereTime
whereDate 方法可用于将列的值与日期进行比较。
1$users = DB::table('users')2 ->whereDate('created_at', '2016-12-31')3 ->get();whereMonth 方法可用于将列的值与特定月份进行比较。
1$users = DB::table('users')2 ->whereMonth('created_at', '12')3 ->get();whereDay 方法可用于将列的值与月份的特定日期进行比较。
1$users = DB::table('users')2 ->whereDay('created_at', '31')3 ->get();whereYear 方法可用于将列的值与特定年份进行比较。
1$users = DB::table('users')2 ->whereYear('created_at', '2016')3 ->get();whereTime 方法可用于将列的值与特定时间进行比较。
1$users = DB::table('users')2 ->whereTime('created_at', '=', '11:20:45')3 ->get();wherePast / whereFuture / whereToday / whereBeforeToday / whereAfterToday
wherePast 和 whereFuture 方法可用于确定列的值是在过去还是将来。
1$invoices = DB::table('invoices')2 ->wherePast('due_at')3 ->get();4 5$invoices = DB::table('invoices')6 ->whereFuture('due_at')7 ->get();whereNowOrPast 和 whereNowOrFuture 方法可用于确定列的值是在过去还是将来，包括当前日期和时间。
1$invoices = DB::table('invoices')2 ->whereNowOrPast('due_at')3 ->get();4 5$invoices = DB::table('invoices')6 ->whereNowOrFuture('due_at')7 ->get();whereToday、whereBeforeToday 和 whereAfterToday 方法可分别用于确定列的值是今天、今天之前还是今天之后。
1$invoices = DB::table('invoices') 2 ->whereToday('due_at') 3 ->get(); 4 5$invoices = DB::table('invoices') 6 ->whereBeforeToday('due_at') 7 ->get(); 8 9$invoices = DB::table('invoices')10 ->whereAfterToday('due_at')11 ->get();类似地，whereTodayOrBefore 和 whereTodayOrAfter 方法可用于确定列的值是在今天之前还是今天之后，包括今天的日期。
1$invoices = DB::table('invoices')2 ->whereTodayOrBefore('due_at')3 ->get();4 5$invoices = DB::table('invoices')6 ->whereTodayOrAfter('due_at')7 ->get();whereColumn / orWhereColumn
whereColumn 方法可用于验证两列是否相等。
1$users = DB::table('users')2 ->whereColumn('first_name', 'last_name')3 ->get();您还可以将比较运算符传递给 whereColumn 方法。
1$users = DB::table('users')2 ->whereColumn('updated_at', '>', 'created_at')3 ->get();您还可以将列比较数组传递给 whereColumn 方法。这些条件将使用 and 运算符连接在一起。
1$users = DB::table('users')2 ->whereColumn([3 ['first_name', '=', 'last_name'],4 ['updated_at', '>', 'created_at'],5 ])->get();逻辑分组
有时您可能需要在括号内对多个“where”子句进行分组，以实现查询所需的逻辑分组。实际上，您通常应该始终在括号中对 orWhere 调用进行分组，以避免出现意外的查询行为。为了实现这一点，您可以将闭包传递给 where 方法。
1$users = DB::table('users')2 ->where('name', '=', 'John')3 ->where(function (Builder $query) {4 $query->where('votes', '>', 100)5 ->orWhere('title', '=', 'Admin');6 })7 ->get();如您所见，将闭包传递到 where 方法会指示查询构建器开始一个约束组。闭包将接收一个查询构建器实例，您可以使用它来设置应包含在括号组内的约束。上面的示例将生成以下 SQL。
1select * from users where name = 'John' and (votes > 100 or title = 'Admin')您应该始终对 orWhere 调用进行分组，以避免在应用全局作用域时出现意外行为。
高级 Where 子句
Where Exists 子句
whereExists 方法允许您编写 “where exists” SQL 子句。whereExists 方法接受一个闭包，该闭包将接收一个查询构建器实例，允许您定义应放置在 “exists” 子句内的查询。
1$users = DB::table('users')2 ->whereExists(function (Builder $query) {3 $query->select(DB::raw(1))4 ->from('orders')5 ->whereColumn('orders.user_id', 'users.id');6 })7 ->get();或者，您可以向 whereExists 方法提供查询对象而不是闭包。
1$orders = DB::table('orders')2 ->select(DB::raw(1))3 ->whereColumn('orders.user_id', 'users.id');4 5$users = DB::table('users')6 ->whereExists($orders)7 ->get();以上两个示例都将生成以下 SQL。
1select * from users2where exists (3 select 14 from orders5 where orders.user_id = users.id6)子查询 Where 子句
有时您可能需要构造一个 “where” 子句，该子句将子查询的结果与给定值进行比较。您可以通过将闭包和一个值传递给 where 方法来实现此目的。例如，以下查询将检索所有具有给定类型的最新 “membership” 的用户；
1use App\Models\User; 2use Illuminate\Database\Query\Builder; 3 4$users = User::where(function (Builder $query) { 5 $query->select('type') 6 ->from('membership') 7 ->whereColumn('membership.user_id', 'users.id') 8 ->orderByDesc('membership.start_date') 9 ->limit(1);10}, 'Pro')->get();或者，您可能需要构造一个 “where” 子句，该子句将列与子查询的结果进行比较。您可以通过将列、运算符和闭包传递给 where 方法来实现此目的。例如，以下查询将检索所有金额小于平均值的收入记录；
1use App\Models\Income;2use Illuminate\Database\Query\Builder;3 4$incomes = Income::where('amount', '<', function (Builder $query) {5 $query->selectRaw('avg(i.amount)')->from('incomes as i');6})->get();全文 Where 子句
MariaDB、MySQL 和 PostgreSQL 当前支持全文 where 子句。
whereFullText 和 orWhereFullText 方法可用于为具有 全文索引 的列向查询添加全文 “where” 子句。这些方法将被 Laravel 转换为底层数据库系统的适当 SQL。例如，对于使用 MariaDB 或 MySQL 的应用程序，将生成 MATCH AGAINST 子句。
1$users = DB::table('users')2 ->whereFullText('bio', 'web developer')3 ->get();排序、分组、限制和偏移
排序
orderBy 方法
orderBy 方法允许您按给定的列对查询结果进行排序。orderBy 方法接受的第一个参数应该是您希望排序的列，而第二个参数确定排序方向，可以是 asc 或 desc。
1$users = DB::table('users')2 ->orderBy('name', 'desc')3 ->get();要按多个列排序，您可以根据需要多次调用 orderBy。
1$users = DB::table('users')2 ->orderBy('name', 'desc')3 ->orderBy('email', 'asc')4 ->get();latest 和 oldest 方法
latest 和 oldest 方法允许您轻松地按日期对结果进行排序。默认情况下，结果将按表的 created_at 列排序。或者，您可以传递要排序的列名。
1$user = DB::table('users')2 ->latest()3 ->first();随机排序
inRandomOrder 方法可用于随机排序查询结果。例如，您可以使用此方法获取随机用户。
1$randomUser = DB::table('users')2 ->inRandomOrder()3 ->first();移除现有排序
reorder 方法移除所有先前应用于查询的 “order by” 子句。
1$query = DB::table('users')->orderBy('name');2 3$unorderedUsers = $query->reorder()->get();您可以在调用 reorder 方法时传递列和方向，以便删除所有现有的 “order by” 子句，并对查询应用全新的排序。
1$query = DB::table('users')->orderBy('name');2 3$usersOrderedByEmail = $query->reorder('email', 'desc')->get();分组
groupBy 和 having 方法
正如您可能预期的那样，groupBy 和 having 方法可用于对查询结果进行分组。having 方法的签名与 where 方法的签名类似。
1$users = DB::table('users')2 ->groupBy('account_id')3 ->having('account_id', '>', 100)4 ->get();您可以使用 havingBetween 方法来过滤给定范围内的结果。
1$report = DB::table('orders')2 ->selectRaw('count(id) as number_of_orders, customer_id')3 ->groupBy('customer_id')4 ->havingBetween('number_of_orders', [5, 15])5 ->get();您可以将多个参数传递给 groupBy 方法，以按多个列进行分组。
1$users = DB::table('users')2 ->groupBy('first_name', 'status')3 ->having('account_id', '>', 100)4 ->get();要构建更高级的 having 语句，请参阅 havingRaw 方法。
限制和偏移
skip 和 take 方法
您可以使用 skip 和 take 方法来限制从查询返回的结果数量，或跳过查询中给定数量的结果。
1$users = DB::table('users')->skip(10)->take(5)->get();或者，您可以使用 limit 和 offset 方法。这些方法在功能上分别等同于 take 和 skip 方法。
1$users = DB::table('users')2 ->offset(10)3 ->limit(5)4 ->get();条件子句
有时您可能希望某些查询子句根据另一个条件应用于查询。例如，您可能只想在传入的 HTTP 请求中存在给定的输入值时才应用 where 语句。您可以使用 when 方法来实现此目的。
1$role = $request->input('role');2 3$users = DB::table('users')4 ->when($role, function (Builder $query, string $role) {5 $query->where('role_id', $role);6 })7 ->get();仅当第一个参数为 true 时，when 方法才会执行给定的闭包。如果第一个参数为 false，则不会执行闭包。因此，在上面的示例中，只有当 role 字段存在于传入的请求中并评估为 true 时，才会调用传递给 when 方法的闭包。
您可以将另一个闭包作为第三个参数传递给 when 方法。仅当第一个参数评估为 false 时，此闭包才会执行。为了说明如何使用此功能，我们将使用它来配置查询的默认排序。
1$sortByVotes = $request->boolean('sort_by_votes');2 3$users = DB::table('users')4 ->when($sortByVotes, function (Builder $query, bool $sortByVotes) {5 $query->orderBy('votes');6 }, function (Builder $query) {7 $query->orderBy('name');8 })9 ->get();Insert 语句
查询构建器还提供了一个 insert 方法，可用于将记录插入到数据库表中。insert 方法接受列名和值的数组。
1DB::table('users')->insert([3 'votes' => 04]);你可以通过传递数组的数组一次性插入多条记录。每个数组代表一条应该被插入到表中的记录。
1DB::table('users')->insert([4]);insertOrIgnore 方法在向数据库中插入记录时会忽略错误。当使用此方法时，你应该意识到重复记录错误将被忽略，并且其他类型的错误也可能被忽略，具体取决于数据库引擎。例如，insertOrIgnore 将 绕过 MySQL 的严格模式
1DB::table('users')->insertOrIgnore([4]);insertUsing 方法将使用子查询来确定应该插入的数据，并将新记录插入到表中。
1DB::table('pruned_users')->insertUsing([2 'id', 'name', 'email', 'email_verified_at'3], DB::table('users')->select(4 'id', 'name', 'email', 'email_verified_at'5)->where('updated_at', '<=', now()->subMonth()));自增 ID
如果表有一个自增 ID，请使用 insertGetId 方法插入记录，然后检索 ID。
1$id = DB::table('users')->insertGetId(3);当使用 PostgreSQL 时，insertGetId 方法期望自增列被命名为 id。 如果你想从不同的 “序列” 中检索 ID，你可以将列名作为第二个参数传递给 insertGetId 方法。
Upserts
upsert 方法将插入不存在的记录，并使用你可能指定的新值更新已存在的记录。该方法的第一个参数包含要插入或更新的值，而第二个参数列出唯一标识关联表中记录的列。该方法的第三个也是最后一个参数是一个列数组，如果数据库中已存在匹配的记录，则应更新这些列。
1DB::table('flights')->upsert(2 [3 ['departure' => 'Oakland', 'destination' => 'San Diego', 'price' => 99],4 ['departure' => 'Chicago', 'destination' => 'New York', 'price' => 150]5 ],6 ['departure', 'destination'],7 ['price']8);在上面的例子中，Laravel 将尝试插入两条记录。如果已存在具有相同 departure 和 destination 列值的记录，Laravel 将更新该记录的 price 列。
除了 SQL Server 之外的所有数据库都要求 upsert 方法的第二个参数中的列具有 “主” 或 “唯一” 索引。此外，MariaDB 和 MySQL 数据库驱动程序会忽略 upsert 方法的第二个参数，并始终使用表的 “主” 和 “唯一” 索引来检测现有记录。
Update 语句
除了向数据库中插入记录之外，查询构建器还可以使用 update 方法更新现有记录。update 方法，就像 insert 方法一样，接受一个列和值对的数组，指示要更新的列。update 方法返回受影响的行数。你可以使用 where 子句约束 update 查询。
1$affected = DB::table('users')2 ->where('id', 1)3 ->update(['votes' => 1]);更新或插入
有时你可能想要更新数据库中已存在的记录，或者在没有匹配记录的情况下创建它。在这种情况下，可以使用 updateOrInsert 方法。updateOrInsert 方法接受两个参数：一个用于查找记录的条件数组，以及一个指示要更新的列的列和值对的数组。
updateOrInsert 方法将尝试使用第一个参数的列和值对来定位匹配的数据库记录。如果记录存在，它将使用第二个参数中的值进行更新。如果找不到记录，则将插入一条新记录，其中包含两个参数的合并属性。
1DB::table('users')2 ->updateOrInsert(4 ['votes' => '2']5 );你可以为 updateOrInsert 方法提供一个闭包，以根据匹配记录的存在情况自定义更新或插入到数据库中的属性。
1DB::table('users')->updateOrInsert( 2 ['user_id' => $user_id], 3 fn ($exists) => $exists ? [ 4 'name' => $data['name'], 5 'email' => $data['email'], 6 ] : [ 7 'name' => $data['name'], 8 'email' => $data['email'], 9 'marketable' => true,10 ],11);更新 JSON 列
当更新 JSON 列时，你应该使用 -> 语法来更新 JSON 对象中的相应键。此操作在 MariaDB 10.3+、MySQL 5.7+ 和 PostgreSQL 9.5+ 上受支持。
1$affected = DB::table('users')2 ->where('id', 1)3 ->update(['options->enabled' => true]);递增和递减
查询构建器还提供了便捷的方法来递增或递减给定列的值。 这两种方法都至少接受一个参数：要修改的列。 可以提供第二个参数来指定列应递增或递减的量。
1DB::table('users')->increment('votes');2 3DB::table('users')->increment('votes', 5);4 5DB::table('users')->decrement('votes');6 7DB::table('users')->decrement('votes', 5);如果需要，你还可以在递增或递减操作期间指定要更新的其他列。
1DB::table('users')->increment('votes', 1, ['name' => 'John']);此外，你可以使用 incrementEach 和 decrementEach 方法一次递增或递减多个列。
1DB::table('users')->incrementEach([2 'votes' => 5,3 'balance' => 100,4]);Delete 语句
查询构建器的 delete 方法可用于从表中删除记录。delete 方法返回受影响的行数。 你可以通过在调用 delete 方法之前添加 “where” 子句来约束 delete 语句。
1$deleted = DB::table('users')->delete();2 3$deleted = DB::table('users')->where('votes', '>', 100)->delete();悲观锁
查询构建器还包括一些函数，以帮助你在执行 select 语句时实现 “悲观锁”。 要使用 “共享锁” 执行语句，你可以调用 sharedLock 方法。 共享锁可防止在你的事务提交之前修改所选行。
1DB::table('users')2 ->where('votes', '>', 100)3 ->sharedLock()4 ->get();或者，你可以使用 lockForUpdate 方法。“for update” 锁可防止所选记录被修改或被另一个共享锁选中。
1DB::table('users')2 ->where('votes', '>', 100)3 ->lockForUpdate()4 ->get();虽然不是强制性的，但建议将悲观锁包装在 事务 中。 这确保了检索到的数据在整个操作完成之前在数据库中保持不变。 如果发生故障，事务将回滚任何更改并自动释放锁。
1DB::transaction(function () { 2 $sender = DB::table('users') 3 ->lockForUpdate() 4 ->find(1); 5 6 $receiver = DB::table('users') 7 ->lockForUpdate(); 8 ->find(2); 9 10 if ($sender->balance < 100) {11 throw new RuntimeException('Balance too low.');12 }13 14 DB::table('users')15 ->where('id', $sender->id)16 ->update([17 'balance' => $sender->balance - 10018 ]);19 20 DB::table('users')21 ->where('id', $receiver->id)22 ->update([23 'balance' => $receiver->balance + 10024 ]);25});调试
你可以在构建查询时使用 dd 和 dump 方法来转储当前的查询绑定和 SQL。 dd 方法将显示调试信息，然后停止执行请求。 dump 方法将显示调试信息，但允许请求继续执行。
1DB::table('users')->where('votes', '>', 100)->dd();2 3DB::table('users')->where('votes', '>', 100)->dump();可以在查询上调用 dumpRawSql 和 ddRawSql 方法，以转储查询的 SQL，其中所有参数绑定都已正确替换。
1DB::table('users')->where('votes', '>', 100)->dumpRawSql();2 3DB::table('users')->where('votes', '>', 100)->ddRawSql();