> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Zeilensperren ohne Blockieren von Fremdschlüsselprüfungen mit lockForNoKeyUpdate

> Erfahren Sie anhand des Quellcodes, wie lockForNoKeyUpdate aus Laravel 13.x funktioniert, einschließlich des Zeilensperrmodus von PostgreSQL und des Fallbacks anderer Datenbank-Grammars.

Wenn Sie Update-Konflikte auf Zielzeilen steuern möchten, ohne Fremdschlüsselprüfungen zu blockieren, verwenden Sie `lockForNoKeyUpdate`. Diese Methode wurde dem Query Builder von Laravel 13.x hinzugefügt und erzeugt für PostgreSQL `FOR NO KEY UPDATE`.

> [!NOTE]
>
> Diese Seite basiert auf der [Implementierung von Laravel Framework 13.x](https://github.com/laravel/framework/tree/13.x). Prüfen Sie, ob die Funktion aus dem Branch `13.x` in der von Ihnen verwendeten Release enthalten ist.

## Unterschied zu `lockForUpdate`

Die offizielle Laravel-Dokumentation beschreibt pessimistisches Sperren mit `sharedLock` und `lockForUpdate`. `lockForNoKeyUpdate` fügt einen weiteren Sperrmodus hinzu, der über die gemeinsame API des Query Builders ausgewählt werden kann.

| Query-Builder-Methode | Von PostgreSQL erzeugte Sperre | Typischer Einsatz |
| - | - | - |
| `sharedLock()` | `FOR SHARE` | Lesen mit gemeinsamer Sperre |
| `lockForNoKeyUpdate()` | `FOR NO KEY UPDATE` | Update-Sperre, die Fremdschlüsselprüfungen nicht blockiert |
| `lockForUpdate()` | `FOR UPDATE` | Stärkere Sperre für zu aktualisierende Zeilen |

`FOR NO KEY UPDATE` bedeutet nicht, dass alle Operationen ohne Blockierung ablaufen. Verwenden Sie es nur, wenn die schwächere Update-Sperre angemessen ist, und prüfen Sie die Transaktionsgrenzen und das Sperrverhalten der Datenbank, die Sie tatsächlich einsetzen.

## Innerhalb einer Transaktion verwenden

Erwerben Sie die pessimistische Sperre und führen Sie das Update in derselben Transaktion aus. Im folgenden Beispiel bleibt die Benutzerzeile gesperrt, während die Aktualisierung des Guthabens vorbereitet und geschrieben wird.

```php theme={null}
<?php

use Illuminate\Support\Facades\DB;

DB::transaction(function () use ($userId): void {
    $user = DB::table('users')
        ->where('id', $userId)
        ->lockForNoKeyUpdate()
        ->first();

    if ($user === null) {
        return;
    }

    DB::table('users')
        ->where('id', $user->id)
        ->update([
            'balance' => $user->balance + 100,
        ]);
});
```

Wie die offizielle Dokumentation es für `lockForUpdate` empfiehlt, bleiben die abgerufenen Daten durch das Einschließen in eine Transaktion geschützt, bis die Operation abgeschlossen ist. `DB::transaction` committet, wenn der Callback normal zurückkehrt, und führt ein Rollback aus, wenn der Callback eine Exception wirft.

`lockForNoKeyUpdate` fügt der `select`-Abfrage nur eine Sperrklausel hinzu. Es führt weder automatisch ein Update aus noch deaktiviert es Fremdschlüssel-Constraints.

## Erzeugtes SQL je Datenbank

Der Query Builder fragt die Grammar der Verbindung nach dem Sperrwert. In der Implementierung von Laravel Framework 13.x gibt nur die PostgreSQL-Grammar `for no key update` zurück.

| Datenbank | Erzeugte Sperrklausel | Verhalten der Implementierung |
| - | - | - |
| PostgreSQL | `for no key update` | Verwendet `FOR NO KEY UPDATE` |
| MySQL | `for update` | Fällt auf die normale Update-Sperre zurück |
| SQL Server | `with(rowlock,updlock,holdlock)` | Fällt auf dieselben Hints wie `lockForUpdate` zurück |
| SQLite | Keine Sperrklausel | `SQLiteGrammar` gibt keine Sperrklausel aus |
| Andere oder eigene Grammars | Abhängig von der Grammar | Die Basis-Grammar gibt `true` zurück, was der normalen Update-Sperre entspricht |

Eine PostgreSQL-Verbindung erzeugt zum Beispiel folgendes SQL. Bindings funktionieren wie bei jeder anderen Query-Builder-Abfrage.

```php theme={null}
$query = DB::connection('pgsql')
    ->table('users')
    ->where('id', $userId)
    ->lockForNoKeyUpdate();

$sql = $query->toSql();
// select * from "users" where "id" = ? for no key update
```

Der Aufruf von `lockForNoKeyUpdate` auf einer Nicht-PostgreSQL-Verbindung schlägt selbst nicht fehl. Er hat jedoch nicht dieselbe Bedeutung wie `FOR NO KEY UPDATE` in PostgreSQL: MySQL und SQL Server kompilieren ihn zu ihrer normalen Update-Sperre, während SQLite keine Sperrklausel ausgibt.

## Interne Verarbeitung im Framework

Die Methode überlässt die Wahl der Sperre der Grammar der Verbindung, statt im Query Builder nach Datenbanktreibern zu verzweigen.

1. `Builder::lockForNoKeyUpdate()` ruft `grammar->getNoKeyUpdateLock()` auf.
2. Die Basisklasse `Grammar` gibt `true` zurück, was den Fallback auf die normale Update-Sperre darstellt.
3. `PostgresGrammar` gibt den String `for no key update` zurück.
4. `compileLock` übernimmt String-Werte unverändert; jede Grammar entscheidet selbst, wie sie den booleschen Fallback kompiliert.

So muss Anwendungscode kein datenbankspezifisches SQL enthalten. Gleichzeitig hängt die Bedeutung der Sperre von der Datenbank ab, daher darf Code, der mehrere Treiber unterstützt, kein PostgreSQL-spezifisches Verhalten voraussetzen.

## Von bestehenden pessimistischen Sperren migrieren

Wenn Sie einen bestehenden Aufruf von `lockForUpdate` ersetzen, ändern Sie nicht nur den Methodennamen. Prüfen Sie Folgendes:

* Die Operation benötigt wirklich eine Sperre, die Fremdschlüsselprüfungen nicht blockiert.
* Die Produktionsverbindung verwendet PostgreSQL.
* Der Fallback auf eine normale Update-Sperre ist unter MySQL oder SQL Server akzeptabel.
* Erwerb der Sperre, Update und Commit erfolgen in einer Transaktion.
* Die Reihenfolge, in der bestehende Sperren auf mehrere Zeilen erworben werden, bleibt konsistent.

Wenn ein Paket diese API verwendet, setzen Sie entweder eine Laravel-Version voraus, die die Methode enthält, oder entwerfen Sie einen expliziten Fallback für ältere Versionen. Eine reine `method_exists`-Prüfung kann eine Bedeutungsänderung verbergen: Ein Benutzer erwartet vielleicht das PostgreSQL-Verhalten, während ein anderer Treiber eine normale `FOR UPDATE`-Sperre ausführt.

## Verwendete Primärquellen

* [Offizielle Laravel-Datenbankdokumentation: Pessimistic Locking](https://github.com/laravel/docs/blob/13.x/queries.md#pessimistic-locking)
* [Implementierung von `Builder::lockForNoKeyUpdate`](https://github.com/laravel/framework/blob/13.x/src/Illuminate/Database/Query/Builder.php)
* [Implementierung von `Grammar::getNoKeyUpdateLock`](https://github.com/laravel/framework/blob/13.x/src/Illuminate/Database/Query/Grammars/Grammar.php)
* [Implementierung von `PostgresGrammar::getNoKeyUpdateLock`](https://github.com/laravel/framework/blob/13.x/src/Illuminate/Database/Query/Grammars/PostgresGrammar.php)
* [Implementierung von `SQLiteGrammar::compileLock`](https://github.com/laravel/framework/blob/13.x/src/Illuminate/Database/Query/Grammars/SQLiteGrammar.php)
* [Offizielle Tests für das von jedem Treiber erzeugte SQL](https://github.com/laravel/framework/blob/13.x/tests/Database/DatabaseQueryBuilderTest.php)
* [Commit, mit dem die Funktion zu Laravel Framework hinzugefügt wurde](https://github.com/laravel/framework/commit/e60670a48433716006d965ea826daeda42142b59)


## Related topics

- [Weiterführende Themen](https://kawax.biz/de/advanced/index.md)
- [Laravel-Updates August 2026](https://kawax.biz/de/blog/changelog/202608.md)
- [Laravel-Updates Oktober 2026](https://kawax.biz/de/blog/changelog/202610.md)
- [Upgrade von Laravel 8 auf 9](https://kawax.biz/de/blog/upgrade-8-to-9.md)
- [Laravel-Updates September 2026](https://kawax.biz/de/blog/changelog/202609.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.