# Obravnavanje sporov

Spor nastane, kadar obe strani združitve iste podatke spremenita na nezdružljiva načina. merql zazna štiri vrste sporov ter ponuja samodejne in ročne načine razreševanja.

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

## Vrste sporov

### update_update

Obe strani sta isti stolpec iste vrstice spremenili na različni vrednosti. To je najpogostejša vrsta spora.

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

Spor navaja: tabelo `posts`, ključ vrstice `42`, stolpec `title`, našo vrednost `Welcome`, njihovo vrednost `Greetings`, osnovno vrednost `Hello`.

### update_delete

Ena stran je vrstico posodobila, druga pa izbrisala. merql ne more določiti, ali naj prevlada posodobitev ali izbris.

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

Spor navaja: tabelo `posts`, ključ vrstice `42`, vrsto `update_delete`. Naša vrednost vsebuje celotno posodobljeno vrstico. Njihova vrednost je `null`.

### delete_update

Obratno od spora update_delete. Oni so vrstico posodobili, mi pa izbrisali.

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

Spor navaja: vrsto `delete_update`. Naša vrednost je `null`, njihova pa vsebuje celotno posodobljeno vrstico.

### insert_insert

Obe strani sta vstavili vrstico z istim primarnim ključem. Ker sta obe vrstici novi (v osnovi ne obstajata), ju merql ne more združiti.

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

Spor navaja: vrsto `insert_insert`. Naša vrednost vsebuje podatke naše vrstice, njihova vrednost pa podatke njihove vrstice.

## Razred Conflict

Vsak spor je objekt samo za branje z naslednjimi dostopnimi metodami:

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

Metoda `column()` vrne ime stolpca pri sporih `update_update`, pri strukturnih sporih pa `null` (`update_delete`, `delete_update`, `insert_insert`).

### Dekodiranje primarnega ključa

Ključ vrstice je kodiran niz. Če želite dobiti polje z imeni primarnih ključev, posredujte stolpce identitete:

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

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

## Samodejno razreševanje z ConflictPolicy

`ConflictResolver` uporabi pravilo za razrešitev vseh sporov hkrati:

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

### Naštevanje ConflictPolicy

| Vrednost | Delovanje |
|---|---|
| `OursWins` | Pri update_update uporabi našo vrednost. Pri update_delete ohrani posodobitev. Pri delete_update ohrani izbris. Pri insert_insert uporabi naš vstavek. |
| `TheirsWins` | Pri update_update uporabi njihovo vrednost. Pri update_delete izbriše. Pri delete_update ohrani posodobitev. Pri insert_insert uporabi njihov vstavek. |
| `Manual` | Vrne nespremenjen rezultat. Vsi spori ostanejo nerazrešeni. |

### Kako deluje razreševanje

Pri sporih `update_update` razreševalnik popravi obstoječo operacijo združitve za vrstico in sporno vrednost stolpca zamenja z vrednostjo zmagovalne strani.

Pri strukturnih sporih (`update_delete`, `delete_update`, `insert_insert`) razreševalnik rezultatu doda novo operacijo:

- `update_delete` z `OursWins` doda operacijo UPDATE.
- `update_delete` z `TheirsWins` doda operacijo DELETE.
- `delete_update` z `OursWins` doda operacijo DELETE.
- `delete_update` z `TheirsWins` doda operacijo UPDATE.
- `insert_insert` uporabi vrednosti vrstice zmagovalne strani.

Razrešeni `MergeResult` ima prazen seznam sporov in ga lahko neposredno uveljavite.

## Ročno razreševanje

Za natančen nadzor preglejte vsak spor in ustvarite lastno razrešitev:

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

## Uveljavljanje z nerazrešenimi spori

`Applier` ne dovoli uveljavitve rezultata združitve z nerazrešenimi spori. Sproži izjemo `ConflictException`:

```php
use Merql\Exceptions\ConflictException;

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

Pred uveljavitvijo vedno razrešite spore, bodisi z `ConflictResolver::resolve()` bodisi tako, da ročno ustvarite čist `MergeResult`.