Einführung

Der Datenbankabfrage-Builder von Laravel bietet eine praktische Schnittstelle zum Erstellen und Ausführen von Datenbankabfragen. Es kann für die Ausführung der meisten Datenbankoperationen in einer Anwendung verwendet werden und läuft auf allen unterstützten Datenbanksystemen.

Der Abfrage-Builder von Laravel verwendet PDO-Parameterbindung, um Ihre Anwendung vor SQL-Injection-Angriffen zu schützen. Es besteht also keine Notwendigkeit, die als Bindung übergebene Zeichenfolge zu bereinigen.

Ergebnisse abrufen

Alle Zeilen aus einer Datentabelle abrufen

Sie können DB auf facade table verwenden Methode zum Starten der Abfrage. Die table-Methode gibt eine Abfrage-Builder-Instanz für die angegebene Tabelle zurück, sodass Sie weitere Einschränkungen für die Abfrage verketten und schließlich die get-Methode verwenden können, um das Ergebnis zu erhalten:

<?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]);    
       }
   }

theget The Die Methode gibt ein Ergebnis zurück, das IlluminateSupportCollection enthält, wobei jedes Ergebnis eine Instanz des PHP StdClass-Objekts ist. Sie können auf die Felder als Eigenschaften des Objekts zugreifen, um auf die Werte jeder Spalte zuzugreifen:

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

Eine einzelne Zeile oder Spalte aus der Datentabelle abrufen

if Sie müssen lediglich eine einzelne Zeile oder Spalte aus der Datentabelle abrufen. Um eine Datenzeile zu erhalten, können Sie die Methode first verwenden. Diese Methode gibt ein StdClass-Objekt zurück:

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

Wenn Sie nicht einmal die gesamte Datenzeile benötigen, können Sie die Methode value verwenden, um einen einzelnen Wert aus dem Datensatz abzurufen. Diese Methode gibt direkt den Wert des Feldes zurück:

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

Den Wert einer Spalte abrufen

Wenn Sie eine Sammlung erhalten möchten, die einen einzelnen Spaltenwert enthält, können Sie Folgendes tun kann die Methode pluck verwenden. Im folgenden Beispiel erhalten wir eine Sammlung von Titeln in der Rollentabelle:

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

Sie können auch benutzerdefinierte Schlüsselwerte für Felder in der zurückgegebenen Sammlung angeben:

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

Geteilte Ergebnisse

Wenn Sie Tausende von Datenbankeinträgen verarbeiten müssen, können Sie die Verwendung der chunk-Methode in Betracht ziehen. Diese Methode nimmt jeweils einen kleinen Teil des Ergebnissatzes und übergibt ihn zur Verarbeitung an die Funktion 闭包. Diese Methode ist nützlich, wenn Sie Artisan-Befehle schreiben, um Tausende von Daten zu verarbeiten. Beispielsweise können wir die gesamten users-Tabellendaten in kleine Blöcke schneiden, die jeweils 100 Datensätze verarbeiten:

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

Sie können die weitere Erfassung von Chunk-Ergebnissen beenden, indem Sie 闭包 in false zurückgeben:

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

Wenn Sie den Datenbankeintrag beim Aufteilen der Ergebnisse aktualisieren möchten, stimmen die aufgeschlüsselten Ergebnisse möglicherweise nicht mit den erwarteten Rückgabeergebnissen überein. Daher ist es beim Aktualisieren von Datensätzen in Blöcken am besten, die Methode chunkById zu verwenden. Diese Methode paginiert die Ergebnisse automatisch basierend auf dem Primärschlüssel des Datensatzes:

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

{Tipp} Beim Aktualisieren oder Löschen von Datensätzen innerhalb des Rückrufs eines Blocks können sich alle Änderungen am Primär- oder Fremdschlüssel auf die Blockabfrage auswirken . . Dies kann dazu führen, dass Datensätze nicht in die aufgeteilten Ergebnisse einbezogen werden.

Aggregation

Der Abfrage-Builder bietet auch verschiedene Aggregationsmethoden, wie z. B. count, max, min, avg und sum. Sie können nach dem Erstellen der Abfrage jede beliebige Methode aufrufen:

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

Natürlich können Sie diese Aggregationsmethoden auch mit anderen Abfrageanweisungen kombinieren:

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

Bestimmen Sie, ob der Datensatz vorhanden ist

Zusätzlich zur Verwendung der Methode count zur Bestimmung, ob das Ergebnis der Abfragebedingung vorhanden ist, können Sie auch exists und verwenden doesntExistMethode:

return DB::table('orders')->where('finalized', 1)->exists();
return DB::table('orders')->where('finalized', 1)->doesntExist();

Selects

Geben Sie eine Select-Anweisung an

Natürlich möchten Sie möglicherweise nicht immer alle Spalten aus einer Datenbanktabelle abrufen. Mit der select-Methode können Sie eine select-Abfrageanweisung anpassen, um das angegebene Feld abzufragen:

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

distinct Die Methode erzwingt, dass die von der Abfrage zurückgegebenen Ergebnisse nicht doppelt vorhanden sind:

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

Wenn Sie bereits über eine Abfrage-Builder-Instanz verfügen und der vorhandenen Abfrage ein Feld hinzufügen möchten, können Sie addSelect verwenden Methode:

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

Nativer Ausdruck

Manchmal müssen Sie möglicherweise einen nativen Ausdruck in einer Abfrage verwenden. Sie können einen nativen Ausdruck mit DB::raw erstellen:

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

{TIP} Ein nativer Ausdruck wird als Zeichenfolge in die Abfrage eingefügt. Sie sollten ihn daher mit Vorsicht verwenden, um die Entstehung von SQL-Injection-Lücken zu vermeiden .

Native Methoden

Sie können anstelle von DB::raw die folgende Methode verwenden, um native Ausdrücke einzufügen in die Abfrage verschiedene Teile von.

kann auch die Methode selectRaw

selectRawselect(DB::raw(...)) verwendet werden. Der zweite Parameter dieser Methode ist optional und der Wert ist ein Array gebundener Parameter:

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

whereRaw / orWhereRaw

whereRaw und orWhereRaw Methoden Inject native where
in Ihre Abfrage ein. Der zweite Parameter dieser beiden Methoden ist immer noch optional und der Wert ist immer noch ein Array gebundener Parameter:

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

havingRaw / orHavingRaw

havingRaw und orHavingRaw Methode kann verwendet werden, um die native Zeichenfolge auf having festzulegen Wert der Anweisung: Die Methode

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

orderByRaw

orderByRaw kann verwendet werden, um die native Zeichenfolge auf order by festzulegen Werte der Klauseln:

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

Joins

Inner Join Clause

Abfrageersteller können auch join Methoden schreiben. Um eine grundlegende
„interne Verlinkung“ durchzuführen, können Sie die join-Methode auf der Abfrage-Builder-Instanz verwenden. Der erste an die join-Methode übergebene Parameter ist der Name der Tabelle, die Sie verknüpfen müssen, während die anderen Parameter Feldeinschränkungen verwenden, die den Join angeben. Sie können auch mehrere Datentabellen in einer einzigen Abfrage verknüpfen:

$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-Anweisung

Wenn Sie stattdessen „Left-Join“ oder „Right-Join“ verwenden möchten " „Inner Join“, Sie können die Methode leftJoin oder rightJoin verwenden. Diese beiden Methoden haben die gleiche Verwendung wie die join-Methode:

$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-Anweisung

Verwenden Sie die crossJoin-Methode, um „Cross“ mit der Tabelle durchzuführen Geben Sie den Namen ein, dem Sie beitreten möchten. Ein Cross-Join erzeugt ein kartesisches Produkt zwischen der ersten Tabelle und der verbundenen Tabelle:

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

Erweiterte Join-Anweisung

Sie können erweiterte Join-Anweisungen angeben. Übergeben Sie beispielsweise einen 闭包 als zweiten Parameter der join-Methode. Dieses 闭包 akzeptiert ein
JoinClause-Objekt und gibt damit die in der join-Anweisung angegebenen Einschränkungen an:

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

Wenn Sie „where“-Stilanweisungen für die Verbindung verwenden möchten, können Sie Folgendes verwenden: die Methoden where und orWhere für Verbindungen. Diese Methoden vergleichen Spalten mit Werten statt Spalten mit Spalten:

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

Subjoin-Abfrage

Sie können die Methoden joinSub, leftJoinSub und rightJoinSub verwenden Ordnen Sie eine Abfrage als Unterabfrage zu. Jede ihrer Methoden erhält drei Parameter: eine Unterabfrage, einen Tabellenalias und einen Abschluss, der das zugehörige Feld definiert:

$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();

Vereinigungen

Der Abfrage-Generator bietet auch eine Verknüpfung zum „Vereinigung“ zweier Abfragen. Sie können beispielsweise zuerst eine Abfrage erstellen und diese dann mit der Methode union mit einer zweiten Abfrage verbinden:

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

{Tipp} Sie können auch die Methode unionAll verwenden, indem Sie <🎜 verwenden > Die Methode ist die gleiche. union

-Abfrageinstanz können Sie Folgendes verwenden where Methode. Die einfachste Art, where aufzurufen, besteht darin, drei Parameter zu übergeben: Der erste Parameter ist der Spaltenname, der zweite Parameter ist ein beliebiger vom Datenbanksystem unterstützter Operator und der dritte Parameter ist der Wert der zu vergleichenden Spalte. where

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

-Methode verwenden: where

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

-Klausel: where

$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();

-Funktion übergeben: where

$users = DB::table('users')->where([
    ['status', '=', '1'],   
     ['subscribed', '<>', '1'],
  ])->get();

-Wörter hinzufügen. Die or-Methode erhält die gleichen Parameter wie die orWhere-Methode: where

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

$users = DB::table('users')                 
   ->whereBetween('votes', [1, 100])->get();

$users = DB::table('users')          
       ->whereNotBetween('votes', [1, 100])                    
       ->get();

$users = DB::table('users')     
      ->whereIn('id', [1, 2, 3])                    
      ->get();

$users = DB::table('users')                 
   ->whereNotIn('id', [1, 2, 3])                    
   ->get();

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

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

        $users = DB::table('users')           
             ->whereDate('created_at', '2018-09-08')                
             ->get();

$users = DB::table('users')          
      ->whereMonth('created_at', '9')                
      ->get();

  $users = DB::table('users')           
       ->whereDay('created_at', '8')                
       ->get();

$users = DB::table('users')           
     ->whereYear('created_at', '2018')                
     ->get();

     $users = DB::table('users')              
       ->whereTime('created_at', '=', '11:20:45')                
       ->get();

        $users = DB::table('users')             
           ->whereColumn('first_name', 'last_name')                
           ->get();

$users = DB::table('users')             
   ->whereColumn('updated_at', '>', 'created_at')                
   ->get();

$users = DB::table('users')             
   ->whereColumn([                
       ['first_name', '=', 'last_name'],                    
       ['updated_at', '>', 'created_at']              
  ])->get();

DB::table('users')        
    ->where('name', '=', 'John')            
    ->where(function ($query) {               
     $query->where('votes', '>', 100)                   
        ->orWhere('title', '=', 'Admin');           
     })          
   ->get();

select * from users where name = 'John' and (votes > 100 or title = 'Admin')

DB::table('users')         
   ->whereExists(function ($query) {             
      $query->select(DB::raw(1))                    
        ->from('orders')                      
        ->whereRaw('orders.user_id = users.id');          
    })            
    ->get();

select * from users
where exists (
    select 1 from orders where orders.user_id = users.id)

$users = DB::table('users')            
    ->where('options->language', 'en')                
    ->get();$users = DB::table('users')                
    ->where('preferences->dining->meal', 'salad')                
    ->get();

$users = DB::table('users')          
      ->whereJsonContains('options->languages', 'en')                
      ->get();

$users = DB::table('users')           
     ->whereJsonContains('options->languages', ['en', 'de'])                
     ->get();

$users = DB::table('users')          
      ->whereJsonLength('options->languages', 0)                
      ->get();$users = DB::table('users')                
      ->whereJsonLength('options->languages', '>', 1)                
      ->get();

$users = DB::table('users')           
     ->orderBy('name', 'desc')                
     ->get();

$user = DB::table('users')              
  ->latest()                
  ->first();

$randomUser = DB::table('users')          
      ->inRandomOrder()                
      ->first();

$users = DB::table('users')             
   ->groupBy('account_id')                
   ->having('account_id', '>', 100)                
   ->get();

$users = DB::table('users')             
   ->groupBy('first_name', 'status')                
   ->having('account_id', '>', 100)                
   ->get();

$users = DB::table('users')->skip(10)->take(5)->get();

$users = DB::table('users')             
   ->offset(10)                
   ->limit(5)                
   ->get();

$role = $request->input('role');$users = DB::table('users')             
   ->when($role, function ($query, $role) {              
         return $query->where('role_id', $role);             
        })                
    ->get();

$sortBy = null;$users = DB::table('users')         
       ->when($sortBy, function ($query, $sortBy) {                
           return $query->orderBy($sortBy);               
          }, function ($query) {             
          return $query->orderBy('name');         
         })               
       ->get();

DB::table('users')->insert(    ['email' => 'john@example.com', 'votes' => 0]);

DB::table('users')->insert([
    ['email' => 'taylor@example.com', 'votes' => 0],    
    ['email' => 'dayle@example.com', 'votes' => 0]
  ]);

$id = DB::table('users')->insertGetId(
    ['email' => 'john@example.com', 'votes' => 0]
  );

DB::table('users')         
   ->where('id', 1)            
   ->update(['votes' => 1]);

DB::table('users')  
  ->updateOrInsert(      
    ['email' => 'john@example.com', 'name' => 'John'],        
    ['votes' => '2']   
  );

DB::table('users')       
     ->where('id', 1)            
     ->update(['options->enabled' => true]);

DB::table('users')->increment('votes');
DB::table('users')->increment('votes', 5);
DB::table('users')->decrement('votes');
DB::table('users')->decrement('votes', 5);

DB::table('users')->increment('votes', 1, ['name' => 'John']);

DB::table('users')->delete();
DB::table('users')->where('votes', '>', 100)->delete();

DB::table('users')->truncate();

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

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