# Ütközések kezelése

Ütközés akkor történik, ha az egyesítés két oldala összeférhetetlen módon módosítja ugyanazokat az adatokat. A merql négyféle ütközést észlel, és automatikus, valamint kézi feloldási stratégiákat kínál.

```php
$result = $merge->merge($base, $ours, $theirs);

if (!$result->isClean()) {
    foreach ($result->conflicts() as $conflict) {
        echo "{$conflict->table()}.{$conflict->column()}: "
           . "{$conflict->oursValue()} vs {$conflict->theirsValue()}\n";
    }
}
```

## Ütközéstípusok

### update_update

Mindkét oldal ugyanannak a sornak ugyanazt az oszlopát módosította eltérő értékre. Ez a leggyakoribb ütközéstípus.

```
Base:    posts #42  title = "Hello"
Ours:    posts #42  title = "Welcome"
Theirs:  posts #42  title = "Greetings"
```

Az ütközés a következőket tartalmazza: tábla: `posts`, sorkulcs: `42`, oszlop: `title`, az ours értéke: `Welcome`, a theirs értéke: `Greetings`, az alap értéke: `Hello`.

### update_delete

Az egyik oldal frissített egy sort, a másik törölte. A merql nem tudja eldönteni, hogy a frissítés vagy a törlés legyen érvényes.

```
Ours:    posts #42  title = "Updated Title"    (updated)
Theirs:  posts #42  (deleted)
```

Az ütközés a következőket tartalmazza: tábla: `posts`, sorkulcs: `42`, típus: `update_delete`. Az ours értéke a teljes frissített sort tartalmazza. A theirs értéke `null`.

### delete_update

Az update_delete fordítottja: a theirs frissítette a sort, az ours törölte.

```
Ours:    posts #42  (deleted)
Theirs:  posts #42  title = "Updated Title"    (updated)
```

Az ütközés a következőt jelzi: típus: `delete_update`. Az ours értéke `null`, a theirs értéke pedig a teljes frissített sort tartalmazza.

### insert_insert

Mindkét oldal ugyanazzal az elsődleges kulccsal szúrt be egy sort. Mivel mindkét sor új (az alapban nem szerepel), a merql nem tudja őket egyesíteni.

```
Base:    (no row #99)
Ours:    posts #99  { title: "My Post" }
Theirs:  posts #99  { title: "Their Post" }
```

Az ütközés a következőt jelzi: típus: `insert_insert`. Az ours értéke az ours sor adatait, a theirs értéke pedig a theirs sor adatait tartalmazza.

## A Conflict osztály

Minden ütközés egy csak olvasható objektum, amely a következő elérőket biztosítja:

```php
$conflict->table();      // string: table name
$conflict->rowKey();     // string: encoded row identity key
$conflict->type();       // string: "update_update"|"update_delete"|"delete_update"|"insert_insert"
$conflict->column();     // ?string: column name (null for structural conflicts)
$conflict->oursValue();  // mixed: our value (null for delete side, full row for structural)
$conflict->theirsValue(); // mixed: their value (null for delete side, full row for structural)
$conflict->baseValue();  // mixed: base value (null for inserts)
```

A `column()` metódus oszlopnevet ad vissza `update_update` ütközések esetén, szerkezeti ütközések esetén pedig `null` értéket (`update_delete`, `delete_update`, `insert_insert`).

### Az elsődleges kulcs dekódolása

A sorkulcs kódolt karakterlánc. Ahhoz, hogy megkapja az elnevezett elsődleges kulcs tömbjét, adja át az identitásoszlopokat:

```php
$pk = $conflict->primaryKey(['id']);
// ['id' => '42']

$pk = $conflict->primaryKey(['tenant_id', 'user_id']);
// ['tenant_id' => '1', 'user_id' => '99']
```

## Automatikus feloldás ConflictPolicy használatával

A `ConflictResolver` szabályzatot alkalmaz az összes ütközés egyidejű feloldására:

```php
use Merql\Merge\ConflictPolicy;
use Merql\Merge\ConflictResolver;

// One side wins everywhere.
$resolved = ConflictResolver::resolve($result, ConflictPolicy::OursWins);
$resolved = ConflictResolver::resolve($result, ConflictPolicy::TheirsWins);

// Manual: return the result unchanged (inspect conflicts yourself).
$resolved = ConflictResolver::resolve($result, ConflictPolicy::Manual);
```

### ConflictPolicy felsorolás

| Érték | Működés |
|---|---|
| `OursWins` | Az update_update esetén az ours értékét használja. Az update_delete esetén megtartja a frissítést. A delete_update esetén megtartja a törlést. Az insert_insert esetén az ours beszúrását használja. |
| `TheirsWins` | Az update_update esetén a theirs értékét használja. Az update_delete esetén töröl. A delete_update esetén megtartja a frissítést. Az insert_insert esetén a theirs beszúrását használja. |
| `Manual` | Változatlanul adja vissza az eredményt. Minden ütközés feloldatlan marad. |

### A feloldás működése

A `update_update` ütközések esetén a feloldó módosítja a sor meglévő egyesítési műveletét, és az ütköző oszlop értékét a győztes oldal értékére cseréli.

Szerkezeti ütközések (`update_delete`, `delete_update`, `insert_insert`) esetén a feloldó új műveletet ad az eredményhez:

- A(z) `update_delete` `OursWins` értékkel UPDATE műveletet ad hozzá.
- A(z) `update_delete` `TheirsWins` értékkel DELETE műveletet ad hozzá.
- A(z) `delete_update` `OursWins` értékkel DELETE műveletet ad hozzá.
- A(z) `delete_update` `TheirsWins` értékkel UPDATE műveletet ad hozzá.
- A(z) `insert_insert` a győztes oldal sorértékeit használja.

A feloldott `MergeResult` ütközéslistája üres, és közvetlenül alkalmazható.

## Kézi feloldás

A részletes vezérléshez vizsgálja meg az egyes ütközéseket, és állítsa össze saját feloldását:

```php
foreach ($result->conflicts() as $conflict) {
    echo "Table:  {$conflict->table()}\n";
    echo "Row:    {$conflict->rowKey()}\n";
    echo "Type:   {$conflict->type()}\n";

    if ($conflict->column() !== null) {
        echo "Column: {$conflict->column()}\n";
        echo "Base:   " . var_export($conflict->baseValue(), true) . "\n";
        echo "Ours:   " . var_export($conflict->oursValue(), true) . "\n";
        echo "Theirs: " . var_export($conflict->theirsValue(), true) . "\n";
    }
}
```

## Alkalmazás feloldatlan ütközésekkel

A `Applier` nem alkalmaz olyan egyesítési eredményt, amely feloldatlan ütközéseket tartalmaz. `ConflictException` kivételt dob:

```php
use Merql\Exceptions\ConflictException;

try {
    $applier->apply($result);
} catch (ConflictException $e) {
    echo $e->getMessage();
    // "Cannot apply merge with 3 unresolved conflicts"
}
```

Alkalmazás előtt mindig oldja fel az ütközéseket a(z) `ConflictResolver::resolve()` használatával, vagy állítson össze kézzel egy tiszta `MergeResult` példányt.