Datenbanknutzung (basierend auf dem Laravel-Datenbankkomponenten)

Alle Zeilen abrufen

<?php
namespace app\controller;

use support\Request;
use support\Db;

class UserController
{
    public function all(Request $request)
    {
        $users = Db::table('users')->get();
        return view('user/all', ['users' => $users]);
    }
}

Bestimmte Spalten abrufen

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

Eine Zeile abrufen

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

Eine Spalte abrufen

$titles = Db::table('roles')->pluck('title');

Den Wert des angegebenen id-Feldes als Index verwenden

$roles = Db::table('roles')->pluck('title', 'id');

foreach ($roles as $id => $title) {
    echo $title;
}

Einzelnen Wert (Feld) abrufen

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

Duplikate entfernen

$email = Db::table('user')->select('nickname')->distinct()->get();

Chunk-Ergebnisse

Wenn du mit Tausenden von Datenbankeinträgen arbeiten musst, kann es sehr zeitaufwendig sein, all diese Daten auf einmal zu lesen, und es kann leicht zu einer Überschreitung des Speichers führen. In diesem Fall kannst du die Methode chunkById verwenden. Diese Methode erhält jeweils einen kleinen Teil des Ergebnisses und übergibt ihn an eine Closure Funktion zur Verarbeitung. Zum Beispiel können wir alle Daten der Tabelle users in kleine Teile von jeweils 100 Datensätzen aufteilen:

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

Du kannst die Chunk-Ergebnisse stoppen, indem du in der Closure false zurückgibst.

Db::table('users')->orderBy('id')->chunkById(100, function ($users) {
    // Verarbeite die Datensätze...

    return false;
});

Hinweis: Lösche keine Daten in der Rückruffunktion, da dies dazu führen kann, dass einige Datensätze nicht im Ergebnis enthalten sind.

Aggregation

Der Abfrage-Builder bietet auch verschiedene Aggregationsmethoden wie count, max, min, avg, sum usw.

$users = Db::table('users')->count();
$price = Db::table('orders')->max('price');
$price = Db::table('orders')->where('finalized', 1)->avg('price');

Überprüfen, ob Datensätze existieren

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

Native Ausdrücke

Prototyp

selectRaw($expression, $bindings = [])

Manchmal musst du native Ausdrücke in der Abfrage verwenden. Du kannst selectRaw() verwenden, um einen nativen Ausdruck zu erstellen:

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

Ebenso stehen die Methoden whereRaw(), orWhereRaw(), havingRaw(), orHavingRaw(), orderByRaw(), groupByRaw() für native Ausdrücke zur Verfügung.

Db::raw($value) wird ebenfalls verwendet, um einen nativen Ausdruck zu erstellen, jedoch hat es keine Bindungsparameterfunktion, weshalb bei der Verwendung vorsichtig mit SQL-Injection-Problemen umgegangen werden muss.

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

Join-Anweisung

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

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

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

// crossJoin    
$users = Db::table('sizes')
            ->crossJoin('colors')
            ->get();

Union-Anweisung

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

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

Where-Anweisung

Prototyp

where($column, $operator = null, $value = null)

Der erste Parameter ist der Spaltenname, der zweite Parameter ist ein beliebiger von Datenbanksystemen unterstützter Operator, der dritte der Wert, mit dem die Spalte verglichen werden soll.

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

// Wenn der Operator ein Gleichheitszeichen ist, kann dieser weggelassen werden, die Ausdruck ist also gleich der vorherigen Anfrage
$users = Db::table('users')->where('votes', 100)->get();

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

Du kannst auch Bedingungsarrays an die where-Funktion übergeben:

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

Die Methode orWhere akzeptiert die gleichen Parameter wie die Methode where:

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

Du kannst eine Closure als ersten Parameter an die orWhere-Methode übergeben:

// SQL: select * from users where votes > 100 or (name = 'Abigail' and votes > 50)
$users = Db::table('users')
            ->where('votes', '>', 100)
            ->orWhere(function($query) {
                $query->where('name', 'Abigail')
                      ->where('votes', '>', 50);
            })
            ->get();

whereBetween / orWhereBetween-Methoden überprüfen, ob der Feldwert zwischen zwei gegebenen Werten liegt:

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

whereNotBetween / orWhereNotBetween-Methoden überprüfen, ob der Feldwert außerhalb der zwei gegebenen Werte liegt:

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

whereIn / whereNotIn / orWhereIn / orWhereNotIn-Methoden überprüfen, ob der Wert des Feldes in einem angegebenen Array vorhanden sein muss:

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

whereNull / whereNotNull / orWhereNull / orWhereNotNull-Methoden überprüfen, ob das angegebene Feld NULL sein muss:

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

whereNotNull-Methoden überprüfen, ob das angegebene Feld nicht NULL sein darf:

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

whereDate / whereMonth / whereDay / whereYear / whereTime-Methoden werden verwendet, um den Feldwert mit einem gegebenen Datum zu vergleichen:

$users = Db::table('users')
                ->whereDate('created_at', '2016-12-31')
                ->get();

whereColumn / orWhereColumn-Methoden werden verwendet, um zu überprüfen, ob die Werte von zwei Feldern gleich sind:

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

// Du kannst auch einen Vergleichsoperator übergeben
$users = Db::table('users')
                ->whereColumn('updated_at', '>', 'created_at')
                ->get();

// Die whereColumn-Methode kann auch ein Array übergeben
$users = Db::table('users')
                ->whereColumn([
                    ['first_name', '=', 'last_name'],
                    ['updated_at', '>', 'created_at'],
                ])->get();

Parametergruppierung

// select * from users where name = 'John' and (votes > 100 or title = 'Admin')
$users = Db::table('users')
           ->where('name', '=', 'John')
           ->where(function ($query) {
               $query->where('votes', '>', 100)
                     ->orWhere('title', '=', 'Admin');
           })
           ->get();

whereExists

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

orderBy

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

Zufällige Anordnung

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

Die zufällige Anordnung kann die Serverleistung erheblich beeinträchtigen, daher wird von deren Verwendung abgeraten.

groupBy / having

$users = Db::table('users')
                ->groupBy('account_id')
                ->having('account_id', '>', 100)
                ->get();
// Du kannst mehrere Parameter an die groupBy-Methode übergeben
$users = Db::table('users')
                ->groupBy('first_name', 'status')
                ->having('account_id', '>', 100)
                ->get();

offset / limit

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

Einfügen

Einzelnes Datenelement einfügen

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

Mehrere Datensätze einfügen

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

Automatisch inkrementierende ID

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

Hinweis: Wenn du PostgreSQL verwendest, wird dieinsertGetId-Methode standardmäßig das id-Feld als automatisch inkrementiertes Feld interpretieren. Wenn du die ID von einer anderen „Sequenz“ abrufen möchtest, kannst du den Feldnamen als zweiten Parameter aninsertGetId übergeben.

Aktualisieren

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

Aktualisieren oder Einfügen

Manchmal möchtest du vorhandene Datensätze in der Datenbank aktualisieren oder, wenn keine übereinstimmenden Datensätze vorhanden sind, sie erstellen:

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

Die MethodeupdateOrInsert versucht zunächst, übereinstimmende Datenbankdatensätze anhand der Schlüssel-Werte-Paare des ersten Parameters zu finden. Wenn der Datensatz vorhanden ist, werden die Werte aus dem zweiten Parameter verwendet, um den Datensatz zu aktualisieren. Wenn kein Datensatz gefunden wird, wird ein neuer Datensatz eingefügt, dessen Daten eine Kombination aus beiden Arrays ist.

Inkrementieren & Dekrementieren

Beide Methoden erhalten mindestens einen Parameter: die zu ändernde Spalte. Der zweite Parameter ist optional und dient zur Steuerung der Menge, um die die Spalte erhöht oder verringert wird:

Db::table('users')->increment('votes');

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

Db::table('users')->decrement('votes');

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

Du kannst auch angeben, welche Felder während des Vorgangs aktualisiert werden sollen:

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

Löschen

Db::table('users')->delete();

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

Wenn du die Tabelle leeren möchtest, kannst du die truncate-Methode verwenden, die alle Zeilen löscht und die automatisch inkrementierte ID auf null zurücksetzt:

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

Transaktionen

Siehe Datenbanktransaktionen

Pessimistische Sperre

Der Abfrage-Builder enthält auch einige Funktionen, die dir helfen, in der select-Syntax „pessimistische Sperren“ zu implementieren. Um in einer Abfrage eine „geteilte Sperre“ zu implementieren, kannst du die sharedLock-Methode verwenden. Eine geteilte Sperre verhindert, dass die ausgewählten Datenzeilen geändert werden, bis die Transaktion abgeschlossen ist:

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

Alternativ kannst du die lockForUpdate-Methode verwenden. Die Verwendung einer „Update“-Sperre verhindert, dass Zeilen von anderen geteilten Sperren geändert oder ausgewählt werden:

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

Debuggen

Du kannst die dd- oder dump-Methode verwenden, um das Abfrageergebnis oder die SQL-Anweisung auszugeben. Die dd-Methode zeigt Debugging-Informationen an und stoppt dann die Ausführung der Anfrage. Die dump-Methode zeigt ebenfalls Debugging-Informationen an, stoppt jedoch nicht die Ausführung der Anfrage:

Db::table('users')->where('votes', '>', 100)->dd();
Db::table('users')->where('votes', '>', 100)->dump();

Hinweis
Für das Debugging musssymfony/var-dumper installiert werden, der Befehl lautetcomposer require symfony/var-dumper