pembina pertanyaan

Kemas kini .

Pengenalan

Pembina pertanyaan pangkalan data Laravel menyediakan antara muka yang mudah untuk mencipta dan menjalankan pertanyaan pangkalan data. Ia boleh digunakan untuk melaksanakan kebanyakan operasi pangkalan data dalam aplikasi dan berjalan pada semua sistem pangkalan data yang disokong.

Pembina pertanyaan Laravel menggunakan pengikatan parameter PDO untuk melindungi aplikasi anda daripada serangan suntikan SQL. Jadi tidak perlu membersihkan rentetan yang diluluskan sebagai pengikat.

Dapatkan hasil

Dapatkan semua baris daripada jadual data

Anda boleh menggunakan jadualDB fasad kod > kaedah untuk memulakan pertanyaan. Kaedah jadual mengembalikan contoh pembina pertanyaan untuk jadual yang diberikan, membolehkan anda merantai lebih banyak kekangan pada pertanyaan dan akhirnya memperoleh keputusan menggunakan kaedah 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;
 }

The Kaedah get mengembalikan hasil yang mengandungi IlluminateSupportCollection, setiap satunya ialah objek PHP StdClass Satu contoh. Anda boleh mengakses medan sebagai sifat objek untuk mengakses nilai setiap lajur:

$roles = DB::table('roles')->pluck('title', 'name');
foreach ($roles as $name => $title) {  
  echo $title;
 }

Dapatkan satu baris atau lajur daripada jadual dataJika anda hanya perlu mendapatkan satu baris atau lajur daripada jadual data Untuk mendapatkan satu baris data daripada jadual, anda boleh menggunakan kaedah first. Kaedah ini mengembalikan objek StdClass:

DB::table('users')->orderBy('id')->chunk(100, function ($users) { 
   foreach ($users as $user) {     
      //   
     }
 });

Jika anda tidak memerlukan keseluruhan baris data, anda boleh menggunakan kaedah value untuk mendapatkan satu nilai daripada rekod. Kaedah ini secara langsung akan mengembalikan nilai medan:

DB::table('users')->orderBy('id')->chunk(100, function ($users) {   
 // Process the records...    
 return false;
});

🎜🎜Dapatkan nilai lajur🎜🎜Jika anda ingin mendapatkan koleksi yang mengandungi nilai lajur tunggal , anda boleh menggunakan kaedah pluck. Dalam contoh berikut, kami akan mendapat koleksi tajuk dalam jadual peranan: 🎜

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

🎜 Anda juga boleh menentukan nilai kunci tersuai untuk medan dalam koleksi yang dikembalikan: 🎜

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

🎜🎜🎜🎜🎜🎜

Hasil terpotong

Jika anda perlu memproses beribu-ribu rekod pangkalan data, anda boleh mempertimbangkan untuk menggunakan kaedah chunk. Kaedah ini mengambil sebahagian kecil hasil yang ditetapkan pada satu masa dan menghantarnya ke fungsi closure untuk diproses. Kaedah ini berguna semasa menulis perintah Artisan untuk memproses beribu-ribu keping data. Sebagai contoh, kita boleh memotong keseluruhan data jadual pengguna menjadi sekeping kecil yang memproses 100 rekod pada satu masa: 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();

Anda boleh melakukan ini dengan mengembalikan

false dalam closure< /code>  untuk menamatkan pemerolehan berterusan keputusan chunked: $users = DB::table('users')  
       ->leftJoin('posts', 'users.id', '=', 'posts.user_id')            
       ->get();     $users = DB::table('users')            
       ->rightJoin('posts', 'users.id', '=', 'posts.user_id')            
       ->get();
Jika anda ingin mengemas kini rekod pangkalan data semasa chunking keputusan, keputusan chunked mungkin tidak konsisten dengan hasil pulangan yang dijangkakan. Oleh itu, apabila mengemas kini rekod dalam ketulan, sebaiknya gunakan kaedah chunkById. Kaedah ini akan menomborkan hasil secara automatik berdasarkan kunci utama rekod: 🎜$users = DB::table('sizes')         
   ->crossJoin('colours')            
   ->get();
🎜{Tip} Apabila mengemas kini atau memadamkan rekod dalam panggilan balik blok, sebarang perubahan pada kunci utama atau asing boleh menjejaskan pertanyaan blok. Ini mungkin menyebabkan rekod tidak disertakan dalam keputusan terkumpul. 🎜
🎜🎜

🎜🎜Aggregation🎜🎜Pembina pertanyaan juga menyediakan pelbagai kaedah pengagregatan, Contohnya , kira, maks, min, avg dan sum. Anda boleh memanggil sebarang kaedah selepas membina pertanyaan: 🎜

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

🎜Sudah tentu, anda juga boleh menggabungkan kaedah pengagregatan ini dengan pernyataan pertanyaan lain: 🎜

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

🎜

Tentukan sama ada rekod itu wujud

🎜Selain menggunakan kaedah count untuk menentukan sama ada hasil keadaan pertanyaan wujud, anda juga boleh menggunakan wujud dan

 doesntExist Kaedah: 🎜$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();
🎜🎜🎜Pilihan
🎜Nyatakan penyataan Pilih
🎜Sudah tentu anda mungkin tidak sentiasa mahu mendapatkan semua lajur daripada jadual pangkalan data. Menggunakan kaedah select, anda boleh menyesuaikan pernyataan pertanyaan select untuk menanyakan medan yang ditentukan: 🎜$first = DB::table('users')         
   ->whereNull('first_name');$users = DB::table('users')            
   ->whereNull('last_name')            
   ->union($first)            
   ->get();
🎜Kaedah distinct akan memaksa pertanyaan itu untuk return Keputusan tidak diduplikasi: 🎜$users = DB::table('users')->where('votes', '=', 100)->get();
🎜 Jika anda sudah mempunyai contoh pembina pertanyaan dan ingin menambah medan pada pernyataan pertanyaan sedia ada, maka anda boleh menggunakan kaedah addSelect: 🎜$users = DB::table('users')->where('votes', 100)->get();
🎜🎜🎜Ungkapan mentah
🎜Kadangkala anda mungkin perlu menggunakan ungkapan mentah dalam ungkapan pertanyaan . Anda boleh mencipta ungkapan mentah menggunakan 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} Ungkapan mentah akan disuntik ke dalam pertanyaan sebagai rentetan, jadi anda harus menggunakannya dengan berhati-hati untuk mengelakkan Mencipta kelemahan suntikan SQL. 🎜
🎜🎜🎜🎜Kaedah asli🎜🎜Anda boleh menggunakan kaedah berikut dan bukannya  DB::raw, memasukkan ungkapan mentah ke dalam pelbagai bahagian pertanyaan. 🎜🎜🎜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 kaedah boleh menggantikan select(DB::raw(...)). Parameter kedua kaedah ini adalah pilihan dan nilainya ialah tatasusunan parameter terikat: 
$users = DB::table('users')          
      ->whereMonth('created_at', '9')                
      ->get();
whereRaw / orWhereRaw< / h4>Kaedah whereRaw dan orWhereRaw menyuntik where
 asli ke dalam pertanyaan anda. Parameter kedua bagi kedua-dua kaedah ini masih pilihan dan nilainya masih dalam tatasusunan parameter terikat: 
  $users = DB::table('users')           
       ->whereDay('created_at', '8')                
       ->get();
havingRaw / orHavingRaw 🎜havingRaw dan orHavingRaw kaedah boleh digunakan untuk menetapkan rentetan mentah sebagai nilai pernyataan having: 🎜$users = DB::table('users')           
     ->whereYear('created_at', '2018')                
     ->get();
< div name= "db09f9" data-unique="db09f9">🎜🎜orderByRaw🎜orderByRaw kaedah boleh digunakan untuk menetapkan rentetan mentah kepada  susunan mengikut klausa: 🎜     $users = DB::table('users')              
       ->whereTime('created_at', '=', '11:20:45')                
       ->get();
🎜🎜🎜🎜Sertai🎜🎜Klausa Sertaan Dalam🎜Pembina pertanyaan juga boleh menulis kaedah menyertai. Untuk melaksanakan 
 "pemautan dalaman" asas, anda boleh menggunakan kaedah sertai pada contoh pembina pertanyaan. Parameter pertama yang dihantar kepada kaedah join ialah nama jadual yang anda mahu sertai, manakala parameter lain menggunakan kekangan medan yang menentukan gabungan. Anda juga boleh menyertai berbilang jadual data dalam satu pertanyaan: 🎜        $users = DB::table('users')             
           ->whereColumn('first_name', 'last_name')                
           ->get();🎜🎜Kenyataan Sertai Kiri🎜Jika anda mahu menggunakan "gabungan kiri" atau " "Right Join" dan bukannya "Inner Join", anda boleh menggunakan kaedah leftJoin atau rightJoin. Kedua-dua kaedah ini digunakan sama seperti kaedah join: 🎜$users = DB::table('users')             
   ->whereColumn('updated_at', '>', 'created_at')                
   ->get();🎜🎜Cross Join statement🎜Gunakan  kaedah crossJoin< /code> dan nama jadual yang anda ingin sambungkan untuk melakukan "sambungan silang". Cantuman silang akan menjana produk Cartesian antara jadual pertama dan jadual yang dicantum: 🎜$users = DB::table('users')             
   ->whereColumn([                
       ['first_name', '=', 'last_name'],                    
       ['updated_at', '>', 'created_at']              
  ])->get();🎜🎜Pernyataan Sertaan Lanjutan🎜Anda boleh menentukan Sambungan lebih lanjut kenyataan. Sebagai contoh, lulus penutupan sebagai parameter kedua kaedah sertai. Penutupan ini menerima objek 
JoinClause, dengan itu menyatakan kekangan yang dinyatakan dalam pernyataan join: 🎜DB::table('users')        
    ->where('name', '=', 'John')            
    ->where(function ($query) {               
     $query->where('votes', '>', 100)                   
        ->orWhere('title', '=', 'Admin');           
     })          
   ->get();
🎜Jika anda mahu Untuk gunakan pernyataan gaya "di mana" pada sambungan, anda boleh menggunakan kaedah where dan or Where pada sambungan. Kaedah ini membandingkan lajur dengan nilai, bukannya lajur dengan lajur: 🎜select * from users where name = 'John' and (votes > 100 or title = 'Admin')🎜🎜Subjoin pertanyaan🎜Anda boleh menggunakan joinSub, leftJoinSub dan rightJoinSub kaedah menyertai pertanyaan sebagai subkueri. Setiap kaedah mereka menerima tiga parameter: subkueri, alias jadual dan penutupan yang mentakrifkan medan yang berkaitan: 🎜DB::table('users')         
   ->whereExists(function ($query) {             
      $query->select(DB::raw(1))                    
        ->from('orders')                      
        ->whereRaw('orders.user_id = users.id');          
    })            
    ->get();
🎜🎜🎜🎜🎜🎜Kesatuan
Pembina pertanyaan juga menyediakan jalan pintas untuk "menggabungkan" dua pertanyaan. Contohnya, anda boleh membuat pertanyaan dahulu dan kemudian menggabungkannya dengan pertanyaan kedua menggunakan kaedah 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} Anda juga boleh menggunakan unionAll > Kaedah, kaedah penggunaan union adalah sama. 
🎜🎜🎜Where statement🎜🎜Pernyataan Simple Where
🎜Dalam membina contoh pertanyaan where, anda boleh menggunakan kaedah where. Cara paling asas untuk memanggil di mana ialah dengan lulus tiga parameter: parameter pertama ialah nama lajur, parameter kedua ialah mana-mana operator yang disokong oleh sistem pangkalan data dan parameter ketiga ialah lajur untuk dibandingkan . 🎜🎜Sebagai contoh, berikut ialah pertanyaan untuk mengesahkan bahawa nilai medan "undi" adalah sama dengan 100: 🎜$user = DB::table('users')              
  ->latest()                
  ->first();
🎜Untuk kemudahan, jika anda hanya membandingkan sama ada nilai lajur adalah sama dengan nilai yang diberikan, anda boleh lulus nilai secara langsung sebagai where< Parameter kedua kaedah /code>: 🎜$randomUser = DB::table('users')          
      ->inRandomOrder()                
      ->first();
🎜Sudah tentu, anda juga boleh menggunakan operator lain untuk menulis klausa where: 🎜$users = DB::table('users')             
   ->groupBy('account_id')                
   ->having('account_id', '>', 100)                
   ->get();
🎜Anda juga boleh hantar tatasusunan bersyarat ke di mana  Dalam fungsi: 🎜$users = DB::table('users')             
   ->groupBy('first_name', 'status')                
   ->having('account_id', '>', 100)                
   ->get();🎜Atau kenyataan
🎜Anda boleh membuat panggilan berantai di mana kekangan bersama-sama, atau tambahkannya dalam pertanyaan atau perkataan. Kaedah orWhere menerima parameter yang sama seperti kaedah where: 🎜$users = DB::table('users')->skip(10)->take(5)->get();
🎜🎜Other Where penyataan
whereBetween
whereBetween kaedah mengesahkan sama ada nilai medan berada di antara dua nilai yang diberikan: 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
>KaedahBetween mengesahkan sama ada nilai medan berada di luar dua nilai yang diberikan: 
rrreee
whereIn / whereNotIn🎜🎜🎜whereIn Kaedah mengesahkan bahawa nilai medan mesti wujud dalam tatasusunan yang ditentukan, :🎜rrreee🎜 Kaedah < code>whereNotIn mengesahkan bahawa nilai medan tidak boleh wujud dalam tatasusunan yang ditentukan: 🎜rrreee🎜🎜whereNull / whereNotNull🎜🎜🎜whereNull kaedah mengesahkan bahawa medan yang dinyatakan mestilah NULL :🎜rrreee🎜whereNotNull Kaedah mengesahkan bahawa medan yang dinyatakan mestilah bukan NULL:🎜rrreee🎜🎜whereDate / whereMonth / whereDay / whereYear / whereTime🎜🎜🎜whereDate kaedah digunakan untuk membandingkan nilai medan dengan tarikh yang diberikan: 🎜rrreee🎜whereMonth kaedah digunakan untuk membandingkan nilai medan dengan bulan yang ditentukan tahun: 🎜rrreee🎜whereDay  Kaedah digunakan untuk membandingkan nilai medan dengan hari yang ditentukan pada bulan Januari: 🎜rrreee🎜whereYear Kaedah digunakan untuk membandingkan nilai medan dengan tahun yang ditentukan: 🎜rrreee🎜whereTime Kaedah digunakan untuk membandingkan nilai medan dengan masa yang ditentukan (jam, minit dan saat): 🎜rrreee🎜🎜whereColumn🎜🎜🎜whereColumn< /code> Kaedah ini digunakan untuk membandingkan sama ada nilai bagi dua medan adalah sama: 🎜rrreee🎜Anda juga boleh Lulus dalam operator perbandingan: 🎜rrreee🎜whereColumn Anda juga boleh lulus tatasusunan menggunakan rantai operator dan: 🎜rrreee🎜🎜 🎜🎜Parameter grouping< /h3>🎜Kadangkala anda perlu mencipta klausa tempat yang lebih maju, seperti "di mana wujud" atau kumpulan parameter bersarang . Pembina pertanyaan Laravel boleh mengendalikan ini juga. Seterusnya, mari lihat contoh kekangan pengelompokan dalam kurungan: 🎜rrreee🎜 Anda boleh melihatnya dengan menulis Penutupan kepada kaedah di mana untuk membina pembina pertanyaan Mengekang kumpulan . Penutupan ini menerima contoh pertanyaan yang boleh anda gunakan untuk menetapkan kekangan yang harus disertakan. Contoh di atas akan menghasilkan SQL berikut:🎜rrreee🎜{Tip} Anda harus menggunakan orWhere untuk memanggil kumpulan ini untuk mengelakkan penggunaan kesan global secara tidak sengaja.🎜
🎜🎜🎜🎜Where Exists clause
🎜whereExists kaedah membolehkan anda gunakan < code>di mana wujud pernyataan SQL. Kaedah whereExists menerima parameter Closure Kaedah whereExists menerima parameter Closure dalam ayat wujud: 🎜rrreee🎜Pertanyaan di atas akan menghasilkan pernyataan SQL berikut: 🎜rrreee🎜🎜🎜🎜🎜🎜JSON Where statementLaravel juga menyokong pertanyaan medan jenis JSON (hanya pada pangkalan data yang menyokong jenis JSON). Pada masa ini, ciri ini hanya menyokong MySQL 5.7, PostgreSQL, SQL Server 2016 dan SQLite 3.9.0 (dengan sambungan JSON1). Gunakan operator -> untuk menanyakan data 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
Anda juga boleh menggunakan whereJsonContains untuk menanyakan tatasusunan JSON: rrreeeMySQL dan PostgreSQL's whereJsonContains kod> boleh menyokong berbilang nilai: rrreee
Anda boleh menggunakan whereJsonLength untuk menanyakan panjang tatasusunan JSON: rrreee
🎜🎜 🎜Pemesanan, Pengumpulan, Had & Offset🎜 Kaedah  orderBy
🎜orderBy membolehkan anda mengisih hasil yang ditetapkan mengikut medan tertentu. Parameter pertama orderBy hendaklah medan yang anda mahu isih dan parameter kedua mengawal arah pengisihan, yang boleh menjadi asc atau desc: 🎜rrreee🎜terkini / tertua
🎜terkini dan terlama kaedah membenarkan anda untuk Isih mengikut tarikh dengan mudah. Ia menggunakan lajur created_at sebagai isihan secara lalai. Sudah tentu, anda juga boleh menghantar nama lajur tersuai: 🎜rrreee🎜inRandomOrder
🎜inRandomOrder kaedah digunakan untuk menyusun keputusan secara rawak. Sebagai contoh, anda boleh menggunakan kaedah ini untuk mencari pengguna rawak. 🎜rrreee🎜groupBy / having
🎜groupBy dan having kaedah boleh menukar keputusan Kumpulan. Penggunaan kaedah mempunyai sangat serupa dengan kaedah where: 🎜rrreee🎜Anda boleh menghantar berbilang parameter ke kaedah groupBy: 🎜rrreee 🎜Untuk lebih lanjut Untuk sintaks mempunyai, lihat kaedah havingRaw🎜. 🎜🎜langkau / ambil
🎜Untuk mengehadkan bilangan hasil yang dikembalikan atau langkau bilangan keputusan yang ditentukan, anda boleh menggunakan  langkau kaedah  dan take: 🎜rrreee🎜 Atau anda juga boleh menggunakan kaedah limit dan offset: 🎜rrreee🎜🎜🎜🎜 🎜🎜Pernyataan Bersyarat
Kadangkala anda mungkin mahu klausa hanya melaksanakan pertanyaan jika syarat tertentu adalah benar. Sebagai contoh, anda hanya boleh menggunakan pernyataan where jika nilai yang diberikan wujud dalam permintaan. Anda boleh melakukan ini dengan menggunakan kaedah bila: 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
 Kaedah bila hanya melaksanakan penutupan yang diberikan apabila parameter pertama adalah true . Jika parameter pertama adalah false, maka penutupan ini tidak akan dilaksanakanAnda boleh melepasi penutupan lain sebagai parameter ketiga kaedah bila. Penutupan ini akan dilaksanakan jika parameter pertama adalah false. Untuk menggambarkan cara menggunakan ciri ini, mari kita konfigurasikan susunan lalai untuk pertanyaan: rrreee
🎜🎜insert🎜🎜 pertanyaan Pembina juga menyediakan kaedah insert untuk memasukkan rekod ke dalam pangkalan data. Kaedah insert menerima nama medan dan nilai medan dalam bentuk tatasusunan untuk operasi sisipan: 🎜rrreee🎜Anda juga boleh menghantar tatasusunan kepada kaedah insert untuk memasukkan berbilang rekod ke dalam jadual🎜 rrreee🎜ID autokenaikan
🎜Jika jadual data mempunyai ID autokenaikan, gunakan  kaedah insertGetId untuk memasukkan rekod dan Mengembalikan nilai ID🎜rrreee🎜{Nota} Apabila menggunakan PostgreSQL, kaedah insertGetId akan lalai kepada id sebagai nama medan autokenaikan. Jika anda ingin mendapatkan ID daripada "jujukan" lain, anda boleh menghantar nama medan sebagai parameter kedua kepada kaedah insertGetId. 🎜
🎜🎜🎜🎜🎜Updates🎜🎜Sudah tentu, selain memasukkan rekod ke dalam pangkalan data, pertanyaan pembina juga boleh Kemas kini rekod sedia ada melalui kaedah kemas kini. Kaedah kemas kini, seperti kaedah insert, menerima tatasusunan yang mengandungi medan dan nilai untuk dikemas kini. Anda boleh mengekang pertanyaan kemas kini melalui klausa where: 🎜rrreee🎜kemas kini atau ADD baharu 
🎜Kadangkala anda mungkin ingin mengemas kini rekod sedia ada dalam pangkalan data, atau mencipta rekod yang sepadan jika tidak wujud. Dalam kes ini, kaedah updateOrInsert boleh digunakan. Kaedah updateOrInsert menerima dua parameter: tatasusunan kriteria untuk mencari rekod dan tatasusunan pasangan nilai kunci yang mengandungi rekod yang akan dikemas kini. Kaedah 🎜🎜updateOrInsert mula-mula akan cuba mencari rekod pangkalan data yang sepadan menggunakan pasangan kunci dan nilai bagi parameter pertama. Jika rekod wujud, gunakan nilai dalam parameter kedua untuk mengemas kini rekod. Jika rekod tidak ditemui, rekod baharu akan dimasukkan dan data yang dikemas kini ialah himpunan dua tatasusunan: 🎜rrreee🎜🎜🎜🎜🎜🎜Kemas kini medan JSON
Apabila mengemas kini medan JSON, anda boleh menggunakan sintaks -> untuk mengakses nilai yang sepadan dalam objek JSON Operasi ini hanya menyokong MySQL 5.7+: -> 语法访问 JSON 对象中相应的值，此操作只能支持 MySQL 5.7+：
rrreee
自增与自减
查询构造器还为给定字段的递增或递减提供了方便的方法。此方法提供了一个比手动编写 update 语句更具表达力且更精练的接口。
这两种方法都至少接收一个参数：需要修改的列。第二个参数是可选的，用于控制列递增或递减的量：
rrreee你也可以在操作过程中指定要更新的字段：
rrreee
删除
查询构造器也可以使用 delete 方法从表中删除记录。 在使用 delete 前，可以添加 where 子句来约束 delete 语法：
rrreee如果你需要清空表，你可以使用 truncate 方法，它将删除所有行，并重置自增 ID 为零：
rrreee
悲观锁
查询构造器也包含一些可以帮助你在 select 语法上实现「悲观锁定」的函数。若想在查询中实现一个「共享锁」， 你可以使用 sharedLock 方法。 共享锁可防止选中的数据列被篡改，直到事务被提交为止 ：
rrreee或者，你可以使用 lockForUpdaterrreee
Increment and Decrement
🎜Pembina pertanyaan juga menyediakan kaedah yang mudah untuk menambah atau mengurangkan medan tertentu . Kaedah ini menyediakan antara muka yang lebih ekspresif dan ringkas daripada menulis kenyataan kemas kini secara manual. 🎜🎜Kedua-dua kaedah menerima sekurang-kurangnya satu parameter: lajur yang perlu diubah suai. Parameter kedua adalah pilihan dan mengawal amaun di mana lajur itu dinaikkan atau dikurangkan: 🎜rrreee🎜 Anda juga boleh menentukan medan yang akan dikemas kini semasa operasi: 🎜rrreee🎜🎜🎜🎜Padam
🎜Pembina pertanyaan juga boleh memadamkan rekod daripada jadual menggunakan kaedah delete. Sebelum menggunakan delete, anda boleh menambah klausa where untuk mengekang delete Sintaks: 🎜rrreee🎜Jika anda perlu mengosongkan jadual, anda boleh menggunakan Kaedah truncate, yang akan memadamkan semua baris dan menetapkan semula ID yang ditambah secara automatik kepada sifar: 🎜rrreee🎜🎜🎜🎜Penguncian Pesimis
🎜Pembina pertanyaan juga mengandungi beberapa fungsi yang boleh membantu anda melaksanakan "penguncian pesimis" pada sintaks pilih. Jika anda ingin melaksanakan "kunci kongsi" dalam pertanyaan, anda boleh menggunakan kaedah sharedLock. Kunci yang dikongsi menghalang lajur data yang dipilih daripada diganggu sehingga transaksi dilakukan: 🎜rrreee🎜 Sebagai alternatif, anda boleh menggunakan kaedah lockForUpdate. Gunakan kunci "kemas kini" untuk mengelakkan baris daripada diubah suai atau dipilih oleh kunci kongsi lain: 🎜rrreee🎜Artikel ini pertama kali diterbitkan di tapak web 🎜LearnKu.com🎜. 🎜🎜
← Permulaan cepat
penomboran →
serahkan
RumahvideoSoal Jawabsaya
Laman web PHP Cina
RumahKursusArtikelSoal JawabKamusManualMuat turuncari APPMuat turun