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

# Rijvergrendeling zonder foreign key-controles te blokkeren met lockForNoKeyUpdate

> Leer aan de hand van de broncode hoe lockForNoKeyUpdate uit Laravel 13.x werkt, inclusief de rijvergrendelingsmodus van PostgreSQL en de terugval die de grammars van andere databases gebruiken.

Wanneer je updateconflicten op doelrijen wilt beheersen zonder foreign key-controles te blokkeren, gebruik je `lockForNoKeyUpdate`. Deze methode is toegevoegd aan de query builder van Laravel 13.x en genereert `FOR NO KEY UPDATE` voor PostgreSQL.

> [!NOTE]
>
> Deze pagina is gebaseerd op de [implementatie van Laravel Framework 13.x](https://github.com/laravel/framework/tree/13.x). Controleer of de functionaliteit die aan de branch `13.x` is toegevoegd, in de release zit die je gebruikt.

## Verschil met `lockForUpdate`

De officiële Laravel-documentatie beschrijft pessimistische vergrendeling met `sharedLock` en `lockForUpdate`. `lockForNoKeyUpdate` voegt een extra vergrendelingsmodus toe die je via de gemeenschappelijke API van de query builder kunt kiezen.

| Query builder-methode | Lock die PostgreSQL genereert | Typisch gebruik |
| - | - | - |
| `sharedLock()` | `FOR SHARE` | Lezen met een gedeelde lock |
| `lockForNoKeyUpdate()` | `FOR NO KEY UPDATE` | Update-lock die foreign key-controles niet blokkeert |
| `lockForUpdate()` | `FOR UPDATE` | Sterkere lock voor rijen die worden bijgewerkt |

`FOR NO KEY UPDATE` betekent niet dat elke bewerking zonder blokkering kan doorgaan. Gebruik het alleen wanneer de zwakkere update-lock geschikt is, en controleer de transactiegrenzen en het vergrendelingsgedrag van de database die je daadwerkelijk gebruikt.

## Gebruik het binnen een transactie

Verkrijg de pessimistische lock en voer de update uit in dezelfde transactie. In het volgende voorbeeld blijft de gebruikersrij vergrendeld terwijl de saldo-update wordt voorbereid en weggeschreven.

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

Zoals de officiële documentatie aanbeveelt voor `lockForUpdate`, blijven de opgehaalde gegevens beschermd tot de bewerking is voltooid wanneer je de bewerking in een transactie verpakt. `DB::transaction` commit wanneer de callback normaal terugkeert en voert een rollback uit wanneer de callback een exception gooit.

`lockForNoKeyUpdate` voegt alleen een lock-clausule toe aan de `select`-query. Het voert niet automatisch een update uit en schakelt geen foreign key-constraints uit.

## Gegenereerde SQL per database

De query builder vraagt de lock-waarde op bij de grammar van de verbinding. In de implementatie van Laravel Framework 13.x geeft alleen de PostgreSQL-grammar `for no key update` terug.

| Database | Gegenereerde lock-clausule | Gedrag van de implementatie |
| - | - | - |
| PostgreSQL | `for no key update` | Gebruikt `FOR NO KEY UPDATE` |
| MySQL | `for update` | Valt terug op de gewone update-lock |
| SQL Server | `with(rowlock,updlock,holdlock)` | Valt terug op dezelfde hints als `lockForUpdate` |
| SQLite | Geen lock-clausule | `SQLiteGrammar` geeft geen lock-clausule uit |
| Andere of eigen grammars | Afhankelijk van de grammar | De basisgrammar geeft `true` terug, wat de gewone update-lock voorstelt |

Een PostgreSQL-verbinding produceert bijvoorbeeld SQL zoals hieronder. Bindings werken net als bij elke andere query builder-query.

```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
```

`lockForNoKeyUpdate` aanroepen op een verbinding die geen PostgreSQL is, faalt op zich niet. Het heeft echter niet dezelfde betekenis als `FOR NO KEY UPDATE` in PostgreSQL: MySQL en SQL Server compileren het naar hun equivalent van de gewone update-lock, terwijl SQLite geen lock-clausule uitgeeft.

## Interne verwerking in het framework

De methode laat de keuze van de lock over aan de grammar van de verbinding, in plaats van in de query builder te vertakken op databasedriver.

1. `Builder::lockForNoKeyUpdate()` roept `grammar->getNoKeyUpdateLock()` aan.
2. De basisklasse `Grammar` geeft `true` terug, wat de terugval op de gewone update-lock voorstelt.
3. `PostgresGrammar` geeft de string `for no key update` terug.
4. `compileLock` neemt stringwaarden ongewijzigd over; elke grammar bepaalt zelf hoe de booleaanse terugval wordt gecompileerd.

Zo hoeft applicatiecode geen databasespecifieke SQL te bevatten. Tegelijk verschilt de betekenis van de lock per database, dus code die meerdere drivers ondersteunt, mag niet uitgaan van PostgreSQL-specifiek gedrag.

## Migreren vanaf bestaande pessimistische locks

Wanneer je een bestaande aanroep van `lockForUpdate` vervangt, verander dan niet alleen de methodenaam. Controleer al het volgende:

* De bewerking heeft echt een lock nodig die foreign key-controles niet blokkeert.
* De productieverbinding gebruikt PostgreSQL.
* Terugvallen op een gewone update-lock is acceptabel op MySQL of SQL Server.
* Het verkrijgen van de lock, de update en de commit gebeuren in één transactie.
* De volgorde waarin bestaande locks op meerdere rijen worden verkregen, blijft consistent.

Als een package deze API gebruikt, vereis dan een Laravel-versie die de methode bevat of ontwerp een expliciete terugval voor oudere versies. Alleen een `method_exists`-controle kan een betekenisverandering verbergen: een gebruiker verwacht misschien PostgreSQL-gedrag terwijl een andere driver een gewone `FOR UPDATE`-lock uitvoert.

## Geraadpleegde primaire bronnen

* [Officiële Laravel-databasedocumentatie: Pessimistic Locking](https://github.com/laravel/docs/blob/13.x/queries.md#pessimistic-locking)
* [Implementatie van `Builder::lockForNoKeyUpdate`](https://github.com/laravel/framework/blob/13.x/src/Illuminate/Database/Query/Builder.php)
* [Implementatie van `Grammar::getNoKeyUpdateLock`](https://github.com/laravel/framework/blob/13.x/src/Illuminate/Database/Query/Grammars/Grammar.php)
* [Implementatie van `PostgresGrammar::getNoKeyUpdateLock`](https://github.com/laravel/framework/blob/13.x/src/Illuminate/Database/Query/Grammars/PostgresGrammar.php)
* [Implementatie van `SQLiteGrammar::compileLock`](https://github.com/laravel/framework/blob/13.x/src/Illuminate/Database/Query/Grammars/SQLiteGrammar.php)
* [Officiële tests voor de SQL die elke driver genereert](https://github.com/laravel/framework/blob/13.x/tests/Database/DatabaseQueryBuilderTest.php)
* [Commit waarmee de functionaliteit aan Laravel Framework is toegevoegd](https://github.com/laravel/framework/commit/e60670a48433716006d965ea826daeda42142b59)


## Related topics

- [Databasemigraties](https://kawax.biz/nl/migrations.md)
- [Geavanceerde onderwerpen](https://kawax.biz/nl/advanced/index.md)
- [Laravel-updates van augustus 2026](https://kawax.biz/nl/blog/changelog/202608.md)
- [Laravel-updates van oktober 2026](https://kawax.biz/nl/blog/changelog/202610.md)
- [Eigen cachestores en contracten voor packages](https://kawax.biz/nl/advanced/package-cache-drivers.md)


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