# Ristiriitojen käsittely

Ristiriita syntyy, kun yhdistämisen molemmat puolet muuttavat samoja tietoja yhteensopimattomilla tavoilla. merql havaitsee neljä ristiriitatyyppiä ja tarjoaa automaattisia ja manuaalisia ratkaisukeinoja.

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

## Ristiriitatyypit

### update_update

Molemmat puolet muuttivat saman rivin samaa saraketta eri arvoon. Tämä on yleisin ristiriitatyyppi.

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

Ristiriidasta ilmoitetaan: taulu `posts`, rivin avain `42`, sarake `title`, meidän arvo `Welcome`, heidän arvo `Greetings`, perusarvo `Hello`.

### update_delete

Toinen puoli päivitti rivin, toinen poisti sen. merql ei voi päätellä, pitäisikö päivityksen vai poiston voittaa.

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

Ristiriidasta ilmoitetaan: taulu `posts`, rivin avain `42`, tyyppi `update_delete`. Meidän arvomme sisältää koko päivitetyn rivin. Heidän arvonsa on `null`.

### delete_update

update_delete-tyypin käänteinen tapaus. He päivittivät rivin, me poistimme sen.

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

Ristiriidasta ilmoitetaan: tyyppi `delete_update`. Meidän arvomme on `null`, ja heidän arvonsa sisältää koko päivitetyn rivin.

### insert_insert

Molemmat puolet lisäsivät rivin samalla ensisijaisella avaimella. Koska molemmat rivit ovat uusia (eivät esiinny peruskannassa), merql ei voi yhdistää niitä.

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

Ristiriidasta ilmoitetaan: tyyppi `insert_insert`. Meidän arvomme sisältää meidän rivimme tiedot, heidän arvonsa heidän rivinsä tiedot.

## Conflict-luokka

Jokainen ristiriita on vain luku -olio, jossa on seuraavat käyttöoikeudet:

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

`column()`-metodi palauttaa sarakkeen nimen `update_update`-ristiriidoille ja `null` rakenteellisille ristiriidoille (`update_delete`, `delete_update`, `insert_insert`).

### Ensisijaisen avaimen purkaminen

Rivin avain on koodattu merkkijono. Saat nimetyn ensisijaisen avaimen taulukon antamalla identiteettisarakkeet:

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

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

## Automaattinen ratkaisu ConflictPolicy-luokalla

`ConflictResolver` soveltaa käytäntöä kaikkien ristiriitojen ratkaisemiseen kerralla:

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

| Arvo | Toiminta |
|---|---|
| `OursWins` | Käytä update_update-ristiriidassa meidän arvoamme. Säilytä päivitys update_delete-ristiriidassa. Säilytä poisto delete_update-ristiriidassa. Käytä meidän lisäystämme insert_insert-ristiriidassa. |
| `TheirsWins` | Käytä update_update-ristiriidassa heidän arvoaan. Poista update_delete-ristiriidassa. Säilytä päivitys delete_update-ristiriidassa. Käytä heidän lisäystään insert_insert-ristiriidassa. |
| `Manual` | Palauta tulos sellaisenaan. Kaikki ristiriidat jäävät ratkaisematta. |

### Ratkaisun toiminta

`update_update`-ristiriidoissa ratkaisija korjaa rivin olemassa olevaa yhdistämistoimintoa ja korvaa ristiriitaisen sarakkeen arvon voittavan puolen arvolla.

Rakenteellisissa ristiriidoissa (`update_delete`, `delete_update`, `insert_insert`) ratkaisija lisää tulokseen uuden toiminnon:

- `update_delete` yhdessä arvon `OursWins` kanssa lisää UPDATE-toiminnon.
- `update_delete` yhdessä arvon `TheirsWins` kanssa lisää DELETE-toiminnon.
- `delete_update` yhdessä arvon `OursWins` kanssa lisää DELETE-toiminnon.
- `delete_update` yhdessä arvon `TheirsWins` kanssa lisää UPDATE-toiminnon.
- `insert_insert` käyttää voittavan puolen riviarvoja.

Ratkaistun `MergeResult`-tuloksen ristiriitaluettelo on tyhjä, joten sen voi ottaa käyttöön suoraan.

## Manuaalinen ratkaisu

Voit hallita ratkaisua tarkemmin tarkastelemalla jokaista ristiriitaa ja rakentamalla oman ratkaisusi:

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

## Käyttöönotto ratkaisemattomien ristiriitojen kanssa

`Applier` kieltäytyy ottamasta käyttöön yhdistämistulosta, jossa on ratkaisemattomia ristiriitoja. Se heittää poikkeuksen `ConflictException`:

```php
use Merql\Exceptions\ConflictException;

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

Ratkaise ristiriidat aina ennen käyttöönottoa joko `ConflictResolver::resolve()`-toiminnolla tai rakentamalla itse puhdas `MergeResult`.