# Çakışma Yönetimi

Birleştirmenin iki tarafı aynı veriyi uyumsuz şekillerde değiştirdiğinde çakışma oluşur. merql dört çakışma türünü algılar ve otomatik ya da manuel çözüm stratejileri sunar.

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

## Çakışma türleri

### update_update

Her iki taraf da aynı satırın aynı sütununu farklı değerlere değiştirdi. Bu, en yaygın çakışma türüdür.

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

Çakışma şu bilgileri bildirir: tablo `posts`, satır anahtarı `42`, sütun `title`, ours değeri `Welcome`, theirs değeri `Greetings`, base değeri `Hello`.

### update_delete

Taraflardan biri satırı güncelledi, diğeri sildi. merql güncellemenin mi yoksa silme işleminin mi geçerli olması gerektiğini belirleyemez.

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

Çakışma şu bilgileri bildirir: tablo `posts`, satır anahtarı `42`, tür `update_delete`. Ours değeri güncellenmiş satırın tamamını içerir. Theirs değeri `null` olur.

### delete_update

update_delete'in tersi. Theirs satırı güncelledi, ours sildi.

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

Çakışma şu bilgiyi bildirir: tür `delete_update`. Ours değeri `null` olur; theirs değeri güncellenmiş satırın tamamını içerir.

### insert_insert

Her iki taraf da aynı birincil anahtarla satır ekledi. Her iki satır da yeni olduğundan (base'de bulunmadığından) merql bunları birleştiremez.

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

Çakışma şu bilgiyi bildirir: tür `insert_insert`. Ours değeri ours satır verilerini, theirs değeri theirs satır verilerini içerir.

## Conflict sınıfı

Her çakışma, şu erişim yöntemlerine sahip salt okunur bir nesnedir:

```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()` yöntemi, `update_update` çakışmalarında sütun adını; yapısal çakışmalarda (`update_delete`, `delete_update`, `insert_insert`) `null` değerini döndürür.

### Birincil anahtarı çözümleme

Satır anahtarı kodlanmış bir dizedir. Adlandırılmış birincil anahtar dizisi elde etmek için kimlik sütunlarını iletin:

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

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

## ConflictPolicy ile otomatik çözümleme

`ConflictResolver`, tüm çakışmaları bir kerede çözmek için bir ilke uygular:

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

| Değer | Davranış |
|---|---|
| `OursWins` | update_update için ours değeri kullanılır. update_delete için güncelleme korunur. delete_update için silme korunur. insert_insert için ours eklemesi kullanılır. |
| `TheirsWins` | update_update için theirs değeri kullanılır. update_delete için silinir. delete_update için güncelleme korunur. insert_insert için theirs eklemesi kullanılır. |
| `Manual` | Sonuç değiştirilmeden döndürülür. Tüm çakışmalar çözülmemiş kalır. |

### Çözümleme nasıl çalışır

`update_update` çakışmalarında çözümleyici, o satırın mevcut birleştirme işlemini yamalar ve çakışan sütun değerini kazanan tarafın değeriyle değiştirir.

Yapısal çakışmalarda (`update_delete`, `delete_update`, `insert_insert`) çözümleyici sonuca yeni bir işlem ekler:

- `update_delete` ile `OursWins` bir UPDATE işlemi ekler.
- `update_delete` ile `TheirsWins` bir DELETE işlemi ekler.
- `delete_update` ile `OursWins` bir DELETE işlemi ekler.
- `delete_update` ile `TheirsWins` bir UPDATE işlemi ekler.
- `insert_insert` kazanan tarafın satır değerlerini kullanır.

Çözümlenmiş `MergeResult` boş bir çakışma listesine sahiptir ve doğrudan uygulanabilir.

## Manuel çözümleme

Ayrıntılı denetim için her çakışmayı inceleyin ve kendi çözümünüzü oluşturun:

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

## Çözülmemiş çakışmalarla uygulama

`Applier`, çözülmemiş çakışmaları olan bir birleştirme sonucunu uygulamayı reddeder. Bir `ConflictException` fırlatır:

```php
use Merql\Exceptions\ConflictException;

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

Uygulamadan önce çakışmaları daima `ConflictResolver::resolve()` ile veya temiz bir `MergeResult` öğesini manuel olarak oluşturarak çözün.