<form method="POST">
    <h3>Editing: BelongsTo.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

namespace Illuminate\Database\Eloquent\Relations;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\Concerns\ComparesRelatedModels;
use Illuminate\Database\Eloquent\Relations\Concerns\InteractsWithDictionary;
use Illuminate\Database\Eloquent\Relations\Concerns\SupportsDefaultModels;

class BelongsTo extends Relation
{
    use ComparesRelatedModels,
        InteractsWithDictionary,
        SupportsDefaultModels;

    /**
     * The child model instance of the relation.
     *
     * @var \Illuminate\Database\Eloquent\Model
     */
    protected $child;

    /**
     * The foreign key of the parent model.
     *
     * @var string
     */
    protected $foreignKey;

    /**
     * The associated key on the parent model.
     *
     * @var string
     */
    protected $ownerKey;

    /**
     * The name of the relationship.
     *
     * @var string
     */
    protected $relationName;

    /**
     * Create a new belongs to relationship instance.
     *
     * @param  \Illuminate\Database\Eloquent\Builder  $query
     * @param  \Illuminate\Database\Eloquent\Model  $child
     * @param  string  $foreignKey
     * @param  string  $ownerKey
     * @param  string  $relationName
     * @return void
     */
    public function __construct(Builder $query, Model $child, $foreignKey, $ownerKey, $relationName)
    {
        $this-&gt;ownerKey = $ownerKey;
        $this-&gt;relationName = $relationName;
        $this-&gt;foreignKey = $foreignKey;

        // In the underlying base relationship class, this variable is referred to as
        // the &quot;parent&quot; since most relationships are not inversed. But, since this
        // one is we will create a &quot;child&quot; variable for much better readability.
        $this-&gt;child = $child;

        parent::__construct($query, $child);
    }

    /**
     * Get the results of the relationship.
     *
     * @return mixed
     */
    public function getResults()
    {
        if (is_null($this-&gt;child-&gt;{$this-&gt;foreignKey})) {
            return $this-&gt;getDefaultFor($this-&gt;parent);
        }

        return $this-&gt;query-&gt;first() ?: $this-&gt;getDefaultFor($this-&gt;parent);
    }

    /**
     * Set the base constraints on the relation query.
     *
     * @return void
     */
    public function addConstraints()
    {
        if (static::$constraints) {
            // For belongs to relationships, which are essentially the inverse of has one
            // or has many relationships, we need to actually query on the primary key
            // of the related models matching on the foreign key that's on a parent.
            $table = $this-&gt;related-&gt;getTable();

            $this-&gt;query-&gt;where($table.'.'.$this-&gt;ownerKey, '=', $this-&gt;child-&gt;{$this-&gt;foreignKey});
        }
    }

    /**
     * Set the constraints for an eager load of the relation.
     *
     * @param  array  $models
     * @return void
     */
    public function addEagerConstraints(array $models)
    {
        // We'll grab the primary key name of the related models since it could be set to
        // a non-standard name and not &quot;id&quot;. We will then construct the constraint for
        // our eagerly loading query so it returns the proper models from execution.
        $key = $this-&gt;related-&gt;getTable().'.'.$this-&gt;ownerKey;

        $whereIn = $this-&gt;whereInMethod($this-&gt;related, $this-&gt;ownerKey);

        $this-&gt;query-&gt;{$whereIn}($key, $this-&gt;getEagerModelKeys($models));
    }

    /**
     * Gather the keys from an array of related models.
     *
     * @param  array  $models
     * @return array
     */
    protected function getEagerModelKeys(array $models)
    {
        $keys = [];

        // First we need to gather all of the keys from the parent models so we know what
        // to query for via the eager loading query. We will add them to an array then
        // execute a &quot;where in&quot; statement to gather up all of those related records.
        foreach ($models as $model) {
            if (! is_null($value = $model-&gt;{$this-&gt;foreignKey})) {
                $keys[] = $value;
            }
        }

        sort($keys);

        return array_values(array_unique($keys));
    }

    /**
     * Initialize the relation on a set of models.
     *
     * @param  array  $models
     * @param  string  $relation
     * @return array
     */
    public function initRelation(array $models, $relation)
    {
        foreach ($models as $model) {
            $model-&gt;setRelation($relation, $this-&gt;getDefaultFor($model));
        }

        return $models;
    }

    /**
     * Match the eagerly loaded results to their parents.
     *
     * @param  array  $models
     * @param  \Illuminate\Database\Eloquent\Collection  $results
     * @param  string  $relation
     * @return array
     */
    public function match(array $models, Collection $results, $relation)
    {
        $foreign = $this-&gt;foreignKey;

        $owner = $this-&gt;ownerKey;

        // First we will get to build a dictionary of the child models by their primary
        // key of the relationship, then we can easily match the children back onto
        // the parents using that dictionary and the primary key of the children.
        $dictionary = [];

        foreach ($results as $result) {
            $attribute = $this-&gt;getDictionaryKey($result-&gt;getAttribute($owner));

            $dictionary[$attribute] = $result;
        }

        // Once we have the dictionary constructed, we can loop through all the parents
        // and match back onto their children using these keys of the dictionary and
        // the primary key of the children to map them onto the correct instances.
        foreach ($models as $model) {
            $attribute = $this-&gt;getDictionaryKey($model-&gt;{$foreign});

            if (isset($dictionary[$attribute])) {
                $model-&gt;setRelation($relation, $dictionary[$attribute]);
            }
        }

        return $models;
    }

    /**
     * Associate the model instance to the given parent.
     *
     * @param  \Illuminate\Database\Eloquent\Model|int|string|null  $model
     * @return \Illuminate\Database\Eloquent\Model
     */
    public function associate($model)
    {
        $ownerKey = $model instanceof Model ? $model-&gt;getAttribute($this-&gt;ownerKey) : $model;

        $this-&gt;child-&gt;setAttribute($this-&gt;foreignKey, $ownerKey);

        if ($model instanceof Model) {
            $this-&gt;child-&gt;setRelation($this-&gt;relationName, $model);
        } else {
            $this-&gt;child-&gt;unsetRelation($this-&gt;relationName);
        }

        return $this-&gt;child;
    }

    /**
     * Dissociate previously associated model from the given parent.
     *
     * @return \Illuminate\Database\Eloquent\Model
     */
    public function dissociate()
    {
        $this-&gt;child-&gt;setAttribute($this-&gt;foreignKey, null);

        return $this-&gt;child-&gt;setRelation($this-&gt;relationName, null);
    }

    /**
     * Alias of &quot;dissociate&quot; method.
     *
     * @return \Illuminate\Database\Eloquent\Model
     */
    public function disassociate()
    {
        return $this-&gt;dissociate();
    }

    /**
     * Add the constraints for a relationship query.
     *
     * @param  \Illuminate\Database\Eloquent\Builder  $query
     * @param  \Illuminate\Database\Eloquent\Builder  $parentQuery
     * @param  array|mixed  $columns
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function getRelationExistenceQuery(Builder $query, Builder $parentQuery, $columns = ['*'])
    {
        if ($parentQuery-&gt;getQuery()-&gt;from == $query-&gt;getQuery()-&gt;from) {
            return $this-&gt;getRelationExistenceQueryForSelfRelation($query, $parentQuery, $columns);
        }

        return $query-&gt;select($columns)-&gt;whereColumn(
            $this-&gt;getQualifiedForeignKeyName(), '=', $query-&gt;qualifyColumn($this-&gt;ownerKey)
        );
    }

    /**
     * Add the constraints for a relationship query on the same table.
     *
     * @param  \Illuminate\Database\Eloquent\Builder  $query
     * @param  \Illuminate\Database\Eloquent\Builder  $parentQuery
     * @param  array|mixed  $columns
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function getRelationExistenceQueryForSelfRelation(Builder $query, Builder $parentQuery, $columns = ['*'])
    {
        $query-&gt;select($columns)-&gt;from(
            $query-&gt;getModel()-&gt;getTable().' as '.$hash = $this-&gt;getRelationCountHash()
        );

        $query-&gt;getModel()-&gt;setTable($hash);

        return $query-&gt;whereColumn(
            $hash.'.'.$this-&gt;ownerKey, '=', $this-&gt;getQualifiedForeignKeyName()
        );
    }

    /**
     * Determine if the related model has an auto-incrementing ID.
     *
     * @return bool
     */
    protected function relationHasIncrementingId()
    {
        return $this-&gt;related-&gt;getIncrementing() &amp;&amp;
            in_array($this-&gt;related-&gt;getKeyType(), ['int', 'integer']);
    }

    /**
     * Make a new related instance for the given model.
     *
     * @param  \Illuminate\Database\Eloquent\Model  $parent
     * @return \Illuminate\Database\Eloquent\Model
     */
    protected function newRelatedInstanceFor(Model $parent)
    {
        return $this-&gt;related-&gt;newInstance();
    }

    /**
     * Get the child of the relationship.
     *
     * @return \Illuminate\Database\Eloquent\Model
     */
    public function getChild()
    {
        return $this-&gt;child;
    }

    /**
     * Get the foreign key of the relationship.
     *
     * @return string
     */
    public function getForeignKeyName()
    {
        return $this-&gt;foreignKey;
    }

    /**
     * Get the fully qualified foreign key of the relationship.
     *
     * @return string
     */
    public function getQualifiedForeignKeyName()
    {
        return $this-&gt;child-&gt;qualifyColumn($this-&gt;foreignKey);
    }

    /**
     * Get the key value of the child's foreign key.
     *
     * @return mixed
     */
    public function getParentKey()
    {
        return $this-&gt;child-&gt;{$this-&gt;foreignKey};
    }

    /**
     * Get the associated key of the relationship.
     *
     * @return string
     */
    public function getOwnerKeyName()
    {
        return $this-&gt;ownerKey;
    }

    /**
     * Get the fully qualified associated key of the relationship.
     *
     * @return string
     */
    public function getQualifiedOwnerKeyName()
    {
        return $this-&gt;related-&gt;qualifyColumn($this-&gt;ownerKey);
    }

    /**
     * Get the value of the model's associated key.
     *
     * @param  \Illuminate\Database\Eloquent\Model  $model
     * @return mixed
     */
    protected function getRelatedKeyFrom(Model $model)
    {
        return $model-&gt;{$this-&gt;ownerKey};
    }

    /**
     * Get the name of the relationship.
     *
     * @return string
     */
    public function getRelationName()
    {
        return $this-&gt;relationName;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>