# Riešenie konfliktov

Konflikt nastane, keď obe strany zlúčenia zmenia tie isté údaje spôsobmi, ktoré sa nedajú zlúčiť. merql zisťuje štyri typy konfliktov a ponúka stratégie automatického aj ručného riešenia.

```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";
    }
}
```

## Typy konfliktov

### update_update

Obe strany zmenili ten istý stĺpec v tom istom riadku na rôzne hodnoty. Ide o najbežnejší typ konfliktu.

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

Konflikt uvádza: tabuľku `posts`, kľúč riadka `42`, stĺpec `title`, hodnotu ours `Welcome`, hodnotu theirs `Greetings` a hodnotu base `Hello`.

### update_delete

Jedna strana aktualizovala riadok, druhá ho odstránila. merql nedokáže určiť, či má zvíťaziť aktualizácia alebo odstránenie.

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

Konflikt uvádza: tabuľku `posts`, kľúč riadka `42` a typ `update_delete`. Hodnota ours obsahuje celý aktualizovaný riadok. Hodnota theirs je `null`.

### delete_update

Opak konfliktu update_delete. Theirs aktualizovalo riadok a ours ho odstránilo.

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

Konflikt uvádza: typ `delete_update`. Hodnota ours je `null`, hodnota theirs obsahuje celý aktualizovaný riadok.

### insert_insert

Obe strany vložili riadok s rovnakým primárnym kľúčom. Keďže oba riadky sú nové (v base neexistujú), merql ich nedokáže zlúčiť.

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

Konflikt uvádza: typ `insert_insert`. Hodnota ours obsahuje údaje riadka ours a hodnota theirs obsahuje údaje riadka theirs.

## Trieda Conflict

Každý konflikt je objekt iba na čítanie s týmito prístupovými metódami:

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

Metóda `column()` vracia názov stĺpca pri konfliktoch `update_update` a `null` pri štrukturálnych konfliktoch (`update_delete`, `delete_update`, `insert_insert`).

### Dekódovanie primárneho kľúča

Kľúč riadka je zakódovaný reťazec. Ak chcete získať pomenované pole primárneho kľúča, odovzdajte stĺpce identity:

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

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

## Automatické riešenie pomocou ConflictPolicy

`ConflictResolver` použije pravidlá na vyriešenie všetkých konfliktov naraz:

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

### Výčet ConflictPolicy

| Hodnota | Správanie |
|---|---|
| `OursWins` | Pri update_update použije našu hodnotu. Pri update_delete ponechá update. Pri delete_update ponechá delete. Pri insert_insert použije náš insert. |
| `TheirsWins` | Pri update_update použije ich hodnotu. Pri update_delete vykoná delete. Pri delete_update ponechá update. Pri insert_insert použije ich insert. |
| `Manual` | Vráti výsledok bez zmien. Všetky konflikty zostanú nevyriešené. |

### Ako funguje riešenie

Pri konfliktoch `update_update` resolver upraví existujúcu operáciu zlúčenia pre daný riadok a nahradí konfliktnú hodnotu stĺpca hodnotou víťaznej strany.

Pri štrukturálnych konfliktoch (`update_delete`, `delete_update`, `insert_insert`) resolver pridá do výsledku novú operáciu:

- `update_delete` s `OursWins` pridá operáciu UPDATE.
- `update_delete` s `TheirsWins` pridá operáciu DELETE.
- `delete_update` s `OursWins` pridá operáciu DELETE.
- `delete_update` s `TheirsWins` pridá operáciu UPDATE.
- `insert_insert` použije hodnoty riadka víťaznej strany.

Vyriešený `MergeResult` má prázdny zoznam konfliktov a možno ho priamo použiť.

## Manuálne riešenie

Ak chcete podrobnejšie riadiť proces, skontrolujte každý konflikt a vytvorte vlastné riešenie:

```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";
    }
}
```

## Použitie pri nevyriešených konfliktoch

`Applier` odmietne použiť výsledok zlúčenia, ktorý obsahuje nevyriešené konflikty. Vyhodí výnimku `ConflictException`:

```php
use Merql\Exceptions\ConflictException;

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

Pred použitím vždy vyriešte konflikty, a to buď pomocou `ConflictResolver::resolve()`, alebo manuálnym vytvorením čistého `MergeResult`.