générateur de requêtes

Mise à jour

- Supprimer
- Verrouillage pessimiste
Introduction
Le générateur de requêtes de base de données de Laravel fournit une interface pratique pour créer et exécuter des requêtes de base de données. Il peut être utilisé pour effectuer la plupart des opérations de base de données dans une application et s'exécute sur tous les systèmes de bases de données pris en charge.
Le générateur de requêtes de Laravel utilise la liaison de paramètres PDO pour protéger votre application contre les attaques par injection SQL. Il n'est donc pas nécessaire de nettoyer la chaîne passée en liaison.
Obtenez des résultats
Obtenez toutes les lignes d'une table de données
Vous pouvez utiliser tableDB code facade > méthode pour démarrer la requête. La méthode table renvoie une instance du générateur de requêtes pour la table donnée, vous permettant d'enchaîner plus de contraintes sur la requête et enfin d'obtenir le résultat à l'aide de la méthode get : DB facade 上使用 table 方法来开始查询。该 table 方法为给定的表返回一个查询构造器实例，允许你在查询上链式调用更多的约束，最后使用 get 方法获取结果：
```
<?php
    namespace App\Http\Controllers;
    use Illuminate\Support\Facades\DB;
    use App\Http\Controllers\Controller;
    class UserController extends Controller{  
     /**
     * 显示所有应用程序的用户列表。
     *
     * @return Response
     */   
     public function index()   
      {     
        $users = DB::table('users')->get();        
        return view('user.index', ['users' => $users]);    
       }
   }
```
该 get 方法返回一个包含 IlluminateSupportCollection 的结果，其中每个结果都是 PHP StdClass 对象的一个实例。你可以访问字段作为对象的属性来访问每列的值：
```
foreach ($users as $user) { 
   echo $user->name;
  }
```
从数据表中获取单行或单列
如果你只需要从数据表中获取一行数据，你可以使用 first 方法。该方法返回一个 StdClass 对象：
```
$user = DB::table('users')->where('name', 'John')->first();
echo $user->name;
```
如果你甚至不需要整行数据，则可以使用 value 方法从记录中获取单个值。该方法将直接返回该字段的值：
```
$email = DB::table('users')->where('name', 'John')->value('email');
```
获取一列的值
如果你想获取包含单列值的集合，则可以使用 pluck
```
$titles = DB::table('roles')->pluck('title');
foreach ($titles as $title) { 
   echo $title;
 }
```
Le La méthode get renvoie un résultat contenant un IlluminateSupportCollection, dont chacun est un objet PHP StdClass. Une instance. Vous pouvez accéder aux champs en tant que propriétés de l'objet pour accéder à la valeur de chaque colonne :
```
$roles = DB::table('roles')->pluck('title', 'name');
foreach ($roles as $name => $title) {  
  echo $title;
 }
```
Obtenir une seule ligne ou colonne de la table de donnéesSi il vous suffit d'obtenir une seule ligne ou colonne de la table de données. Pour obtenir une ligne de données de la table, vous pouvez utiliser la méthode first. Cette méthode renvoie un objet StdClass :
```
DB::table('users')->orderBy('id')->chunk(100, function ($users) { 
   foreach ($users as $user) {     
      //   
     }
 });
```
Si vous n'avez même pas besoin de la ligne entière de données, vous pouvez utiliser la méthode value pour obtenir une seule valeur du enregistrer. Cette méthode renverra directement la valeur du champ :
```
DB::table('users')->orderBy('id')->chunk(100, function ($users) {   
 // Process the records...    
 return false;
});
```
🎜🎜Obtenir la valeur d'une colonne🎜🎜Si vous souhaitez obtenir une collection contenant une seule valeur de colonne , vous pouvez utiliser la méthode pluck. Dans l'exemple suivant, nous obtiendrons une collection de titres dans la table des rôles : 🎜
```
DB::table('users')->where('active', false) 
   ->chunkById(100, function ($users) {     
      foreach ($users as $user) {        
          DB::table('users')               
           ->where('id', $user->id)                
           ->update(['active' => true]);      
         }  
   });
```
🎜 Vous pouvez également spécifier des valeurs de clé personnalisées pour les champs de la collection renvoyée : 🎜
```
$users = DB::table('users')->count();
$price = DB::table('orders')->max('price');
```
🎜🎜🎜🎜🎜🎜
Résultats fragmentés
Si vous devez traiter des milliers d'enregistrements de base de données, vous pouvez envisager d'utiliser la méthode chunk. Cette méthode prend une petite partie du jeu de résultats à la fois et la transmet à la fonction closure pour traitement. Cette méthode est utile lors de l'écriture de commandes Artisan pour traiter des milliers de données. Par exemple, nous pouvons couper l'intégralité des données de la table users en un petit morceau qui traite 100 enregistrements à la fois : chunk 方法。该方法一次获取结果集的一小块，并将其传递给 闭包 函数进行处理。该方法在 Artisan 命令编写数千条处理数据的时候非常有用。例如，我们可以将全部 users 表数据切割成一次处理 100 条记录的一小块：
```
$price = DB::table('orders')             
   ->where('finalized', 1)                
   ->avg('price');
```
你可以通过在 闭包 中返回 false 来终止继续获取分块结果：
```
return DB::table('orders')->where('finalized', 1)->exists();
return DB::table('orders')->where('finalized', 1)->doesntExist();
```
如果要在分块结果时更新数据库记录，则块结果可能会和预计的返回结果不一致。因此，在分块更新记录时，最好使用 chunkById 方法。此方法将根据记录的主键自动对结果进行分页：
```
$users = DB::table('users')->select('name', 'email as user_email')->get();
```
{提示} 在块的回调里面更新或删除记录时，对主键或外键的任何更改都可能影响块查询。这可能会导致记录没有包含在分块结果中。
聚合
查询构造器还提供了各种聚合方法，比如 count, max，min， avg，还有 sum。你可以在构造查询后调用任何方法：
```
$users = DB::table('users')->distinct()->get();
```
当然，你也可以将这些聚合方法与其他的查询语句相结合：
```
$query = DB::table('users')->select('name');
$users = $query->addSelect('age')->get();
```
判断记录是否存在
除了通过 count 方法可以确定查询条件的结果是否存在之外，还可以使用 exists 和 doesntExist 方法：
```
$users = DB::table('users')               
      ->select(DB::raw('count(*) as user_count, status'))                     
      ->where('status', '<>', 1)                     
      ->groupBy('status')                    
       ->get();
```
Selects
指定一个 Select 语句
当然你可能并不总是希望从数据库表中获取所有列。使用 select 方法，你可以自定义一个 select 查询语句来查询指定的字段：
```
$orders = DB::table('orders')            
    ->selectRaw('price * ? as price_with_tax', [1.0825])                
    ->get();
```
distinct 方法会强制让查询返回的结果不重复：
```
$orders = DB::table('orders')          
      ->whereRaw('price > IF(state = "TX", ?, 100)', [200])                
      ->get();
```
如果你已经有了一个查询构造器实例，并且希望在现有的查询语句中加入一个字段，那么你可以使用 addSelect 方法：
```
$orders = DB::table('orders')         
       ->select('department', DB::raw('SUM(price) as total_sales'))                
       ->groupBy('department')                
       ->havingRaw('SUM(price) > ?', [2500])                
       ->get();
```
原生表达式
有时候你可能需要在查询中使用原生表达式。你可以使用 DB::raw 创建一个原生表达式：
```
$orders = DB::table('orders')            
    ->orderByRaw('updated_at - created_at DESC')                
    ->get();
```
{提示} 原生表达式将会被当做字符串注入到查询中，因此你应该小心使用，避免创建 SQL 注入的漏洞。
原生方法
可以使用以下方法代替 DB::raw
```
$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();
```
Vous pouvez le faire en renvoyant false dans une closure< /code> pour mettre fin à l'acquisition continue des résultats fragmentés : $users = DB::table('users') ->leftJoin('posts', 'users.id', '=', 'posts.user_id') ->get(); $users = DB::table('users') ->rightJoin('posts', 'users.id', '=', 'posts.user_id') ->get(); Si vous souhaitez mettre à jour l'enregistrement de la base de données lors du fractionnement des résultats, les résultats fragmentés peuvent être incohérents avec les résultats de retour attendus. Par conséquent, lors de la mise à jour des enregistrements par morceaux, il est préférable d'utiliser la méthode chunkById. Cette méthode pagine automatiquement les résultats en fonction de la clé primaire de l'enregistrement : 🎜$users = DB::table('sizes') ->crossJoin('colours') ->get(); 🎜{Tip} Lors de la mise à jour ou de la suppression d'enregistrements dans le rappel d'un bloc, toute modification apportée à la clé primaire ou étrangère peut affecter la requête de bloc. Cela peut avoir pour conséquence que les enregistrements ne soient pas inclus dans les résultats fragmentés. 🎜 🎜🎜🎜🎜Agrégation🎜🎜Le générateur de requêtes fournit également diverses méthodes d'agrégation, par exemple , count, max, min, avg et sum. Vous pouvez appeler n'importe quelle méthode après avoir construit la requête : 🎜DB::table('users') ->join('contacts', function ($join) { $join->on('users.id', '=', 'contacts.user_id')->orOn(...); }) ->get(); 🎜Bien sûr, vous pouvez également combiner ces méthodes d'agrégation avec d'autres instructions de requête : 🎜DB::table('users') ->join('contacts', function ($join) { $join->on('users.id', '=', 'contacts.user_id') ->where('contacts.user_id', '>', 5); }) ->get(); 🎜Determine si l'enregistrement existe 🎜En plus d'utiliser la méthode count pour déterminer si le résultat de la condition de requête existe, vous pouvez également utiliser exists et DoesntExist Méthode : 🎜$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($join) { $join->on('users.id', '=', 'latest_posts.user_id'); }) ->get(); 🎜🎜🎜Sélections 🎜Spécifiez une instruction Select 🎜Bien sûr, vous ne souhaiterez peut-être pas toujours obtenir toutes les colonnes de la table de base de données. À l'aide de la méthode select, vous pouvez personnaliser une instruction de requête select pour interroger le champ spécifié : 🎜$first = DB::table('users') ->whereNull('first_name');$users = DB::table('users') ->whereNull('last_name') ->union($first) ->get(); 🎜La méthode distinct forcera la requête à return Les résultats ne sont pas dupliqués : 🎜$users = DB::table('users')->where('votes', '=', 100)->get(); 🎜 Si vous disposez déjà d'une instance du générateur de requêtes et souhaitez ajouter un champ à l'instruction de requête existante, vous pouvez utiliser la méthode addSelect : 🎜$users = DB::table('users')->where('votes', 100)->get(); 🎜🎜🎜Expressions brutes 🎜Parfois, vous devrez peut-être utiliser des expressions brutes dans l'expression des requêtes . Vous pouvez créer une expression brute en utilisant DB::raw : 🎜$users = DB::table('users') ->where('votes', '>=', 100) ->get();$users = DB::table('users') ->where('votes', '<>', 100) ->get();$users = DB::table('users') ->where('name', 'like', 'T%') ->get(); 🎜{Tip} Une expression brute sera injectée dans la requête sous forme de chaîne, vous devez donc l'utiliser avec prudence et éviter Crée une vulnérabilité d'injection SQL. 🎜 🎜🎜🎜🎜Méthodes natives🎜🎜Vous pouvez utiliser les méthodes suivantes au lieu de DB::raw, insère des expressions brutes dans différentes parties de la requête. 🎜🎜🎜La méthode selectRaw selectRawselectRaw 方法可以代替 select(DB::raw(...))。该方法的第二个参数是可选项，值是一个绑定参数的数组： $users = DB::table('users')->where([ ['status', '=', '1'], ['subscribed', '<>', '1'], ])->get(); whereRaw / orWhereRaw whereRaw 和 orWhereRaw 方法将原生的 where 注入到你的查询中。这两个方法的第二个参数还是可选项，值还是绑定参数的数组： $users = DB::table('users') ->where('votes', '>', 100) ->orWhere('name', 'John') ->get(); havingRaw / orHavingRaw havingRaw 和 orHavingRaw 方法可以用于将原生字符串设置为 having 语句的值： $users = DB::table('users') ->whereBetween('votes', [1, 100])->get(); orderByRaw orderByRaw 方法可用于将原生字符串设置为 order by 子句的值： $users = DB::table('users') ->whereNotBetween('votes', [1, 100]) ->get(); Joins Inner Join Clause 查询构造器也可以编写 join 方法。若要执行基本的「内链接」，你可以在查询构造器实例上使用 join 方法。传递给 join 方法的第一个参数是你需要连接的表的名称，而其他参数则使用指定连接的字段约束。你还可以在单个查询中连接多个数据表： $users = DB::table('users') ->whereIn('id', [1, 2, 3]) ->get(); Left Join 语句如果你想使用「左连接」或者「右连接」代替「内连接」，可以使用 leftJoin 或者 rightJoin 方法。这两个方法与 join 方法用法相同： $users = DB::table('users') ->whereNotIn('id', [1, 2, 3]) ->get(); Cross Join 语句使用 crossJoin 方法和你想要连接的表名做「交叉连接」。交叉连接在第一个表和被连接的表之间会生成笛卡尔积： $users = DB::table('users') ->whereNull('updated_at') ->get(); 高级 Join 语句你可以指定更高级的 join 语句。比如传递一个闭包作为 join 方法的第二个参数。此闭包接收一个 JoinClause 对象，从而指定 join 语句中指定的约束： $users = DB::table('users') ->whereNotNull('updated_at') ->get(); 如果你想要在连接上使用「where」风格的语句，你可以在连接上使用 where 和 orWhere 方法。这些方法会将列和值进行比较，而不是列和列进行比较： $users = DB::table('users') ->whereDate('created_at', '2018-09-08') ->get(); 子连接查询你可以使用 joinSub，leftJoinSub 和 rightJoinSubselectRaw peut remplacer select(DB::raw(...)). Le deuxième paramètre de cette méthode est facultatif et la valeur est un tableau de paramètres liés : $users = DB::table('users') ->whereMonth('created_at', '9') ->get(); whereRaw / orWhereRaw< / h4>Les méthodes whereRaw et orWhereRaw injectent du where natif dans votre requête. Le deuxième paramètre de ces deux méthodes est toujours facultatif, et la valeur est toujours un tableau de paramètres liés : $users = DB::table('users') ->whereDay('created_at', '8') ->get(); havingRaw / orHavingRaw 🎜Les méthodes havingRaw et orHavingRaw peuvent être utilisées pour définir une chaîne brute comme valeur d'une instruction having : 🎜$users = DB::table('users') ->whereYear('created_at', '2018') ->get(); < div name= "db09f9" data-unique="db09f9">🎜🎜orderByRaw🎜La méthode orderByRaw peut être utilisée pour définir une chaîne brute sur clause order by : 🎜 $users = DB::table('users') ->whereTime('created_at', '=', '11:20:45') ->get(); 🎜🎜🎜🎜Joins🎜🎜Clause de jointure interne🎜Le générateur de requêtes peut également écrire la méthode join. Pour effectuer des "liens internes" de base, vous pouvez utiliser la méthode join sur l'instance du générateur de requêtes. Le premier paramètre passé à la méthode join est le nom de la table que vous souhaitez rejoindre, tandis que les autres paramètres utilisent les contraintes de champ qui spécifient la jointure. Vous pouvez également joindre plusieurs tables de données en une seule requête : 🎜 $users = DB::table('users') ->whereColumn('first_name', 'last_name') ->get();🎜🎜Instruction Left Join🎜Si vous souhaitez utiliser "left join" ou " "Right Join" au lieu de "Inner Join", vous pouvez utiliser la méthode leftJoin ou rightJoin. Ces deux méthodes sont utilisées de la même manière que la méthode join : 🎜$users = DB::table('users') ->whereColumn('updated_at', '>', 'created_at') ->get();🎜🎜Instruction Cross Join🎜Utilisez crossJoin< /code> et le nom de la table que vous souhaitez connecter pour effectuer une "connexion croisée". Une jointure croisée générera un produit cartésien entre la première table et la table jointe : 🎜$users = DB::table('users') ->whereColumn([ ['first_name', '=', 'last_name'], ['updated_at', '>', 'created_at'] ])->get();🎜🎜Instruction de jointure avancée🎜Vous pouvez spécifier une jointure plus avancée déclarations. Par exemple, transmettez un closure comme deuxième paramètre de la méthode join. Cette Closure reçoit un objet JoinClause, spécifiant ainsi les contraintes spécifiées dans l'instruction join : 🎜DB::table('users') ->where('name', '=', 'John') ->where(function ($query) { $query->where('votes', '>', 100) ->orWhere('title', '=', 'Admin'); }) ->get(); 🎜Si vous souhaitez To Si vous utilisez des instructions de style "where" sur les connexions, vous pouvez utiliser les méthodes where et orWhere sur les connexions. Ces méthodes comparent les colonnes aux valeurs, plutôt que les colonnes aux colonnes : 🎜select * from users where name = 'John' and (votes > 100 or title = 'Admin')🎜🎜Requête de sous-jointure🎜Vous pouvez utiliser joinSub, les méthodes leftJoinSub et rightJoinSub rejoignent une requête en tant que sous-requête. Chacune de leurs méthodes reçoit trois paramètres : une sous-requête, un alias de table et une fermeture qui définit les champs associés : 🎜DB::table('users') ->whereExists(function ($query) { $query->select(DB::raw(1)) ->from('orders') ->whereRaw('orders.user_id = users.id'); }) ->get(); 🎜🎜🎜🎜🎜🎜Unions Le générateur de requêtes fournit également un raccourci pour « union » deux requêtes. Par exemple, vous pouvez d'abord créer une requête, puis l'unir avec une deuxième requête en utilisant la méthode union : union 方法将其和第二个查询进行联合： select * from users where exists ( select 1 from orders where orders.user_id = users.id) {提示} 你也可以使用 unionAll 方法，用法 union 方法是的一样。 Where 语句简单的 Where 语句在构造 where 查询实例的中，你可以使用 where 方法。调用 where 最基本的方式是需要传递三个参数：第一个参数是列名，第二个参数是任意一个数据库系统支持的运算符，第三个是该列要比较的值。例如，下面是一个要验证「votes」字段的值等于 100 的查询： $users = DB::table('users') ->where('options->language', 'en') ->get();$users = DB::table('users') ->where('preferences->dining->meal', 'salad') ->get(); 为了方便，如果你只是简单比较列值和给定数值是否相等，可以将数值直接作为 where 方法的第二个参数： $users = DB::table('users') ->whereJsonContains('options->languages', 'en') ->get(); 当然，你也可以使用其他的运算符来编写 where 子句： $users = DB::table('users') ->whereJsonContains('options->languages', ['en', 'de']) ->get(); 你还可以传递条件数组到 where 函数中： $users = DB::table('users') ->whereJsonLength('options->languages', 0) ->get();$users = DB::table('users') ->whereJsonLength('options->languages', '>', 1) ->get(); Or 语句你可以一起链式调用 where 约束，也可以在查询中添加 or 字句。 orWhere 方法和 where $users = DB::table('users') ->orderBy('name', 'desc') ->get(); {Tip} Vous pouvez également utiliser unionAll > Méthode, l'utilisation de la méthode union est la même. 🎜🎜🎜Instruction Where🎜🎜Instruction Where simple 🎜Pour construire une instance de requête where, vous pouvez utiliser la méthode where. La manière la plus simple d'appeler where est de transmettre trois paramètres : le premier paramètre est le nom de la colonne, le deuxième paramètre est tout opérateur pris en charge par le système de base de données et le troisième paramètre est la colonne à comparer. . valeur. 🎜🎜Par exemple, voici une requête pour vérifier que la valeur du champ "votes" est égale à 100 : 🎜$user = DB::table('users') ->latest() ->first(); 🎜Pour plus de commodité, si vous comparez simplement si la valeur de la colonne est égale à une valeur donnée, vous pouvez passer la valeur directement sous la forme where< Le deuxième paramètre de la méthode /code> : 🎜$randomUser = DB::table('users') ->inRandomOrder() ->first(); 🎜Bien sûr, vous pouvez également utiliser d'autres opérateurs pour écrire la clause where : 🎜$users = DB::table('users') ->groupBy('account_id') ->having('account_id', '>', 100) ->get(); 🎜Vous pouvez également passer le tableau conditionnel à where Dans la fonction : 🎜$users = DB::table('users') ->groupBy('first_name', 'status') ->having('account_id', '>', 100) ->get();🎜Instruction Ou 🎜Vous pouvez enchaîner les appels où contraintes ensemble, ou ajoutez-les dans la requête avec des mots ou. La méthode orWhere reçoit les mêmes paramètres que la méthode where : 🎜$users = DB::table('users')->skip(10)->take(5)->get(); 🎜🎜La méthode Autres instructions Where whereBetween whereBetween vérifie si la valeur du champ est comprise entre les deux valeurs données : whereBetween 方法验证字段值是否在给定的两个值之间： $users = DB::table('users') ->offset(10) ->limit(5) ->get(); whereNotBetween whereNotBetween 方法验证字段值是否在给定的两个值之外： $role = $request->input('role');$users = DB::table('users') ->when($role, function ($query, $role) { return $query->where('role_id', $role); }) ->get(); whereIn / whereNotIn whereIn 方法验证字段的值必须存在指定的数组里，: $sortBy = null;$users = DB::table('users') ->when($sortBy, function ($query, $sortBy) { return $query->orderBy($sortBy); }, function ($query) { return $query->orderBy('name'); }) ->get(); whereNotIn 方法验证字段的值必须不存在于指定的数组里: DB::table('users')->insert( ['email' => 'john@example.com', 'votes' => 0]); whereNull / whereNotNull whereNull 方法验证指定的字段必须是 NULL: DB::table('users')->insert([ ['email' => 'taylor@example.com', 'votes' => 0], ['email' => 'dayle@example.com', 'votes' => 0] ]); whereNotNull 方法验证指定的字段必须不是 NULL: $id = DB::table('users')->insertGetId( ['email' => 'john@example.com', 'votes' => 0] ); whereDate / whereMonth / whereDay / whereYear / whereTime whereDate 方法用于比较字段值与给定的日期: DB::table('users') ->where('id', 1) ->update(['votes' => 1]); whereMonth 方法用于比较字段值与一年中指定的月份: DB::table('users') ->updateOrInsert( ['email' => 'john@example.com', 'name' => 'John'], ['votes' => '2'] ); whereDay 方法用于比较字段值与一月中指定的日期: DB::table('users') ->where('id', 1) ->update(['options->enabled' => true]); whereYear 方法用于比较字段值与指定的年份: DB::table('users')->increment('votes'); DB::table('users')->increment('votes', 5); DB::table('users')->decrement('votes'); DB::table('users')->decrement('votes', 5); whereTime 方法用于比较字段值与指定的时间（时分秒）: DB::table('users')->increment('votes', 1, ['name' => 'John']); whereColumn whereColumn 方法用于比较两个字段的值是否相等: DB::table('users')->delete(); DB::table('users')->where('votes', '>', 100)->delete(); 你也可以传入一个比较运算符: DB::table('users')->truncate(); whereColumn 你也可以传递数组用 and 运算符链接: DB::table('users')->where('votes', '>', 100)->sharedLock()->get(); 参数分组有时候你需要创建更高级的 where 子句，例如「where exists」或者嵌套的参数分组。 Laravel 的查询构造器也能够处理这些。下面，让我们看一个在括号中进行分组约束的例子: DB::table('users')->where('votes', '>', 100)->lockForUpdate()->get(); 你可以看到，通过一个 Closure 写入 where 方法构建一个查询构造器来约束一个分组。这个 Closure 接收一个查询实例，你可以使用这个实例来设置应该包含的约束。上面的例子将生成以下 SQL: rrreee{提示} 你应该用 orWhere 调用这个分组，以避免应用全局作用出现意外. Where Exists 语句 whereExists 方法允许你使用 where exists SQL 语句。 whereExists 方法接收一个 Closure 参数，该 whereExists 方法接受一个 Closure 参数，该闭包获取一个查询构建器实例从而允许你定义放置在 existsrrreee whereNotBetween whereNotBetween La méthode vérifie si la valeur du champ est en dehors des deux valeurs données : rrreee whereIn /whereNotIn 🎜🎜whereIn La méthode vérifie que la valeur du champ doit exister dans le tableau spécifié, :🎜rrreee🎜 La méthode < code>whereNotIn vérifie que la valeur du champ ne doit pas exister dans le tableau spécifié : 🎜rrreee🎜🎜whereNull /whereNotNull🎜🎜🎜whereNull vérifie que le champ spécifié doit être NULL :🎜rrreee🎜whereNotNull La méthode vérifie que le champ spécifié ne doit pas être NULL:🎜rrreee🎜🎜whereDate /whereMonth /whereDay /whereYear / La méthode WhereTime🎜🎜🎜whereDate est utilisée pour comparer la valeur du champ avec la date donnée : 🎜rrreee🎜La méthode whereMonth est utilisée pour comparer la valeur du champ avec le mois spécifié de l'année : 🎜rrreee🎜whereDay La méthode est utilisée pour comparer la valeur du champ avec le jour spécifié en janvier : 🎜rrreee🎜whereYear La méthode est utilisée pour comparer la valeur du champ avec l'année spécifiée : 🎜rrreee🎜whereTime La méthode est utilisée pour comparer la valeur du champ avec l'heure spécifiée (heures, minutes et secondes) : 🎜rrreee🎜🎜whereColumn🎜🎜🎜whereColumn< /code> La méthode est utilisée pour comparer si les valeursde deux champs sont égales : 🎜rrreee🎜Vous pouvez également passer un opérateur de comparaison : 🎜rrreee🎜whereColumn Vous pouvez également transmettre des tableaux en utilisant la chaîne d'opérateurs et : 🎜rrreee🎜🎜 🎜🎜Regroupement de paramètres< /h3>🎜Parfois, vous devez créer des clauses Where plus avancées, telles que « où existe » ou un regroupement de paramètres imbriqués. Le générateur de requêtes de Laravel peut également gérer cela. Ensuite, regardons un exemple de regroupement de contraintes entre parenthèses : 🎜rrreee🎜 Vous pouvez le voir en écrivant une Closure dans la méthode where pour créer un générateur de requêtes Contraindre un groupe . Cette Closure reçoit une instance de requête que vous pouvez utiliser pour définir les contraintes qui doivent être incluses. L'exemple ci-dessus générera le SQL suivant :🎜rrreee🎜{Tip} Vous devez utiliser orWhere pour appeler ce groupe afin d'éviter l'application accidentelle d'effets globaux.🎜 🎜🎜🎜🎜Clause Where Exists 🎜La méthode whereExists vous permet de utilisez l'instruction SQL < code>where exist. La méthode whereExists accepte un paramètre Closure. La méthode whereExists accepte un paramètre Closure. La fermeture obtient une instance du générateur de requêtes vous permettant de définir une requête de placement. dans la phrase exists : 🎜rrreee🎜La requête ci-dessus générera l'instruction SQL suivante : 🎜rrreee🎜🎜🎜🎜🎜🎜Instruction JSON WhereLaravel prend également en charge l'interrogation des champs de type JSON (uniquement sur les bases de données prenant en charge le type JSON). Actuellement, cette fonctionnalité ne prend en charge que MySQL 5.7, PostgreSQL, SQL Server 2016 et SQLite 3.9.0 (avec l'extension JSON1). Utilisez l'opérateur -> pour interroger les données JSON : -> 操作符查询 JSON 数据： rrreee你也可以使用 whereJsonContains 来查询 JSON 数组： rrreeeMySQL 和 PostgreSQL 的 whereJsonContains 可以支持多个值： rrreee你可以使用 whereJsonLength 来查询 JSON 数组的长度： rrreee Ordering, Grouping, Limit, & Offset orderBy orderBy 方法允许你通过给定字段对结果集进行排序。 orderBy 的第一个参数应该是你希望排序的字段，第二个参数控制排序的方向，可以是 asc 或 desc： rrreee latest / oldest latest 和 oldest 方法可以使你轻松地通过日期排序。它默认使用 created_at 列作为排序依据。当然，你也可以传递自定义的列名： rrreee inRandomOrder inRandomOrder 方法被用来将结果随机排序。例如，你可以使用此方法随机找到一个用户。 rrreee groupBy / having groupBy 和 having 方法可以将结果分组。 having 方法的使用与 where 方法十分相似： rrreee你可以向 groupBy 方法传递多个参数： rrreee对于更高级的 having 语法，参见 havingRaw 方法。 skip / take 要限制结果的返回数量，或跳过指定数量的结果，你可以使用 skip 和 take 方法： rrreee或者你也可以使用 limit 和 offsetrrreee Vous pouvez également utiliser whereJsonContains pour interroger les tableaux JSON : rrreeeMySQL et whereJsonContains de PostgreSQL. code> code> peut prendre en charge plusieurs valeurs : rrreee Vous pouvez utiliser whereJsonLength pour interroger la longueur du tableau JSON : rrreee 🎜🎜 🎜Ordre, regroupement, limite et décalage🎜 La méthode orderBy 🎜orderBy vous permet de trier le résultat défini par un champ donné. Le premier paramètre de orderBy doit être le champ que vous souhaitez trier, et le deuxième paramètre contrôle le sens du tri, qui peut être asc ou desc : 🎜rrreee🎜dernier / plus ancien 🎜Les méthodes latest et oldest autorisent vous pouvez facilement trier par date. Il utilise la colonne created_at comme tri par défaut. Bien sûr, vous pouvez également transmettre des noms de colonnes personnalisés : 🎜rrreee🎜inRandomOrder 🎜La méthode inRandomOrder est utilisée pour trier les résultats au hasard. Par exemple, vous pouvez utiliser cette méthode pour rechercher un utilisateur aléatoire. 🎜rrreee🎜groupBy / have 🎜Les méthodes groupBy et having peuvent convertir le Groupe de résultats. L'utilisation de la méthode having est très similaire à la méthode where : 🎜rrreee🎜Vous pouvez passer plusieurs paramètres à la méthode groupBy : 🎜rrreee 🎜Pour plus de détails sur la syntaxe having, voir la méthode havingRaw🎜. 🎜🎜skip / take 🎜Pour limiter le nombre de résultats renvoyés ou ignorer un nombre spécifié de résultats, vous pouvez utiliser méthodes skip et take : 🎜rrreee🎜 Ou vous pouvez également utiliser les méthodes limit et offset : 🎜rrreee🎜🎜🎜🎜🎜 🎜Déclarations conditionnelles Parfois, vous souhaiterez peut-être qu'une clause exécute une requête uniquement si une certaine condition est vraie. Par exemple, vous pouvez appliquer une instruction where uniquement si une valeur donnée existe dans la requête. Vous pouvez le faire en utilisant la méthode when : where 语句。你可以通过使用 when 方法： rrreeewhen 方法只有在第一个参数为 true 的时候才执行给的的闭包。如果第一个参数为 false ，那么这个闭包将不会被执行你可以传递另一个闭包作为 when 方法的第三个参数。该闭包会在第一个参数为 false 的情况下执行。为了说明如何使用这个特性，我们来配置一个查询的默认排序： rrreee 插入查询构造器还提供了 insert 方法用于插入记录到数据库中。 insert 方法接收数组形式的字段名和字段值进行插入操作： rrreee你甚至可以将数组传递给 insert 方法，将多个记录插入到表中 rrreee 自增 ID 如果数据表有自增 ID ，使用 insertGetId 方法来插入记录并返回 ID 值 rrreee{注意} 当使用 PostgreSQL 时， insertGetId 方法将默认把 id 作为自动递增字段的名称。如果你要从其他「序列」来获取 ID ，则可以将字段名称作为第二个参数传递给 insertGetId 方法。更新当然，除了插入记录到数据库中，查询构造器也可以通过 update 方法更新已有的记录。 update 方法和 insert 方法一样，接受包含要更新的字段及值的数组。你可以通过 where 子句对 update 查询进行约束： rrreee 更新或者新增有时您可能希望更新数据库中的现有记录，或者如果不存在匹配记录则创建它。在这种情况下，可以使用 updateOrInsert 方法。 updateOrInsert 方法接受两个参数：一个用于查找记录的条件数组，以及一个包含要更该记录的键值对数组。 updateOrInsertrrreee La méthode when n'exécute la fermeture donnée que lorsque le premier paramètre est true . Si le premier paramètre est false, alors cette fermeture ne sera pas exécutéeVous pouvez passer une autre fermeture comme troisième paramètre de la méthode when. Cette fermeture sera exécutée si le premier paramètre est false. Pour illustrer comment utiliser cette fonctionnalité, configurons l'ordre par défaut pour une requête : rrreee 🎜🎜insert🎜🎜 query Le constructeur fournit également la méthode insert pour insérer des enregistrements dans la base de données. La méthode insert reçoit les noms de champs et les valeurs de champs sous forme de tableaux pour les opérations d'insertion : 🎜rrreee🎜Vous pouvez même passer un tableau à la méthode insert pour insérer plusieurs enregistrements dans la table🎜 rrreee🎜ID d'incrémentation automatique 🎜Si la table de données a un ID d'incrémentation automatique, utilisez le méthode insertGetId pour insérer des enregistrements et renvoyer la valeur de l'ID🎜rrreee🎜{Note} Lors de l'utilisation de PostgreSQL, la méthode insertGetId sera par défaut id comme nom du champ d’auto-incrémentation. Si vous souhaitez obtenir l'ID d'une autre "séquence", vous pouvez transmettre le nom du champ comme deuxième paramètre à la méthode insertGetId. 🎜 🎜🎜🎜🎜🎜Mises à jour🎜🎜Bien sûr, en plus d'insérer des enregistrements dans la base de données, la requête Le constructeur peut également mettre à jour les enregistrements existants via la méthode update. La méthode update, comme la méthode insert, accepte un tableau contenant les champs et valeurs à mettre à jour. Vous pouvez contraindre la requête update via la clause where : 🎜rrreee🎜update ou new ADD 🎜Parfois, vous souhaiterez peut-être mettre à jour un enregistrement existant dans la base de données, ou créer un enregistrement correspondant s'il n'en existe pas. Dans ce cas, la méthode updateOrInsert peut être utilisée. La méthode updateOrInsert accepte deux paramètres : un tableau de critères pour trouver l'enregistrement et un tableau de paires clé-valeur contenant l'enregistrement à mettre à jour. La méthode 🎜🎜updateOrInsert tentera d'abord de trouver un enregistrement de base de données correspondant en utilisant la paire clé et valeur du premier paramètre. Si l'enregistrement existe, utilisez la valeur du deuxième paramètre pour mettre à jour l'enregistrement. Si l'enregistrement n'est pas trouvé, un nouvel enregistrement sera inséré et les données mises à jour sont une collection de deux tableaux : 🎜rrreee🎜🎜🎜🎜🎜🎜Mettre à jour le champ JSON Lors de la mise à jour d'un champ JSON, vous pouvez utiliser la syntaxe -> pour accéder à la valeur correspondante dans l'objet JSON. Cette opération ne prend en charge que MySQL 5.7+ : -> 语法访问 JSON 对象中相应的值，此操作只能支持 MySQL 5.7+： rrreee 自增与自减查询构造器还为给定字段的递增或递减提供了方便的方法。此方法提供了一个比手动编写 update 语句更具表达力且更精练的接口。这两种方法都至少接收一个参数：需要修改的列。第二个参数是可选的，用于控制列递增或递减的量： rrreee你也可以在操作过程中指定要更新的字段： rrreee 删除查询构造器也可以使用 delete 方法从表中删除记录。在使用 delete 前，可以添加 where 子句来约束 delete 语法： rrreee如果你需要清空表，你可以使用 truncate 方法，它将删除所有行，并重置自增 ID 为零： rrreee 悲观锁查询构造器也包含一些可以帮助你在 select 语法上实现「悲观锁定」的函数。若想在查询中实现一个「共享锁」，你可以使用 sharedLock 方法。共享锁可防止选中的数据列被篡改，直到事务被提交为止： rrreee或者，你可以使用 lockForUpdaterrreee Incrément et décrémentation 🎜Le générateur de requêtes fournit également des méthodes pratiques pour incrémenter ou décrémenter un champ donné. Cette méthode fournit une interface plus expressive et concise que l'écriture manuelle des instructions update. 🎜🎜Les deux méthodes reçoivent au moins un paramètre : la colonne qui doit être modifiée. Le deuxième paramètre est facultatif et contrôle le montant dont la colonne est incrémentée ou décrémentée : 🎜rrreee🎜 Vous pouvez également spécifier les champs à mettre à jour lors de l'opération : 🎜rrreee🎜🎜🎜🎜Supprimer 🎜Le générateur de requêtes peut également supprimer des enregistrements de la table à l'aide de la méthode delete. Avant d'utiliser delete, vous pouvez ajouter une clause where pour contraindre delete Syntaxe : 🎜rrreee🎜Si vous devez vider la table, vous pouvez utiliser Méthode truncate, qui supprimera toutes les lignes et réinitialisera l'ID auto-incrémenté à zéro : 🎜rrreee🎜🎜🎜🎜Verrouillage pessimiste 🎜Le générateur de requêtes contient également des fonctions qui peuvent vous aider à implémenter un "verrouillage pessimiste" sur la syntaxe select. Si vous souhaitez implémenter un « verrou partagé » dans une requête, vous pouvez utiliser la méthode sharedLock. Les verrous partagés empêchent la falsification des colonnes de données sélectionnées jusqu'à ce que la transaction soit validée : 🎜rrreee🎜 Vous pouvez également utiliser la méthode lockForUpdate. Utilisez le verrou « mise à jour » pour empêcher les lignes d'être modifiées ou sélectionnées par d'autres verrous partagés : 🎜rrreee🎜Cet article a été publié pour la première fois sur le site Web 🎜LearnKu.com🎜. 🎜🎜 ← Démarrage rapide Pagination → soumettre MaisonvidéosQuestions et réponsesMon Site Web PHP chinois MaisonCoursArticleQuestions et réponsesDictionnaireManuelTéléchargerrecherche APPTélécharger

générateur de requêtes

Introduction

Obtenez des résultats

Obtenez toutes les lignes d'une table de données

从数据表中获取单行或单列

获取一列的值

Résultats fragmentés

聚合

判断记录是否存在

Selects

指定一个 Select 语句

原生表达式

原生方法

Determine si l'enregistrement existe

Sélections

Spécifiez une instruction Select

Expressions brutes

La méthode selectRaw

whereRaw / orWhereRaw

havingRaw / orHavingRaw

orderByRaw

Joins

Inner Join Clause

Left Join 语句

Cross Join 语句

高级 Join 语句

子连接查询

Joins

Unions

Where 语句

简单的 Where 语句

Or 语句

Instruction Where simple

Instruction Ou

Autres instructions Where

参数分组

Where Exists 语句

Clause Where Exists

Instruction JSON Where

Ordering, Grouping, Limit, & Offset

orderBy

latest / oldest

inRandomOrder

groupBy / having

skip / take

Ordre, regroupement, limite et décalage

orderBy

dernier / plus ancien

inRandomOrder

groupBy / have

skip / take

Déclarations conditionnelles

插入

自增 ID

更新

更新或者新增

ID d'incrémentation automatique

update ou new ADD

Mettre à jour le champ JSON

自增与自减

删除

悲观锁

Supprimer

Verrouillage pessimiste

Site Web PHP chinois

La méthode `selectRaw`

`whereRaw / orWhereRaw`

`havingRaw / orHavingRaw`

`orderByRaw`