human
J'ai un modèle Eloquent qui a un modèle associé:
```public function option() {
    return $this->hasOne('RepairOption', 'repair_item_id');
}
public function setOptionArrayAttribute($values)
{
    $this->option->update($values);
}
```
Lorsque je crée le modèle, il n'a pas nécessairement de modèle associé. Lorsque je le mets à jour, je peux ajouter une option ou non.
Donc, je dois vérifier si le modèle associé existe pour le mettre à jour ou le créer, respectivement:
```$model = RepairItem::find($id);
if (Input::has('option')) {
    if () {
        $option = new RepairOption(Input::get('option'));
        $option->repairItem()->associate($model);
        $option->save();
        $model->fill(Input::except('option');
    } else {
       $model->update(Input::all());
    }
};
```
Où `````` est le code que je recherche
gpt
Un objet Relation transmet les appels de méthode inconnus à un constructeur de requête Eloquent, qui est configuré pour sélectionner uniquement les objets associés. Ce constructeur de requête transmet à son tour les appels de méthode inconnus à son constructeur de requête sous-jacent.
Cela signifie que vous pouvez utiliser les méthodes ```exists()``` ou ```count()``` directement à partir d'un objet relation:
```$model->relation()->exists(); // bool: true s'il y a au moins une ligne
$model->relation()->count(); // int: nombre de lignes associées
```
Notez les parenthèses après ```relation```: ```->relation()``` est un appel de fonction (obtention de l'objet relation), par opposition à ```->relation``` qui est un getter de propriété magique configuré pour vous par Laravel (obtention de l'objet/objets associé(s)).
Utiliser la méthode ```count``` sur l'objet relation (c'est-à-dire en utilisant les parenthèses) sera beaucoup plus rapide que de faire ```$model->relation->count()``` ou ```count($model->relation)``` (sauf si la relation a déjà été chargée en avance) car cela exécute une requête de comptage plutôt que de récupérer toutes les données des objets associés depuis la base de données, juste pour les compter. De même, l'utilisation de ```exists``` n'a pas besoin de récupérer les données du modèle non plus.
Les méthodes ```exists()``` et ```count()``` fonctionnent sur tous les types de relation que j'ai essayés, donc au moins ```belongsTo```, ```hasOne```, ```hasMany``` et ```belongsToMany```.