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

namespace Illuminate\Database\Eloquent\Relations;

use Illuminate\Contracts\Support\Arrayable;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use Illuminate\Database\Eloquent\Relations\Concerns\InteractsWithDictionary;
use Illuminate\Database\Eloquent\SoftDeletes;

class HasManyThrough extends Relation
{
    use InteractsWithDictionary;

    /**
     * The &quot;through&quot; parent model instance.
     *
     * @var \Illuminate\Database\Eloquent\Model
     */
    protected $throughParent;

    /**
     * The far parent model instance.
     *
     * @var \Illuminate\Database\Eloquent\Model
     */
    protected $farParent;

    /**
     * The near key on the relationship.
     *
     * @var string
     */
    protected $firstKey;

    /**
     * The far key on the relationship.
     *
     * @var string
     */
    protected $secondKey;

    /**
     * The local key on the relationship.
     *
     * @var string
     */
    protected $localKey;

    /**
     * The local key on the intermediary model.
     *
     * @var string
     */
    protected $secondLocalKey;

    /**
     * Create a new has many through relationship instance.
     *
     * @param  \Illuminate\Database\Eloquent\Builder  $query
     * @param  \Illuminate\Database\Eloquent\Model  $farParent
     * @param  \Illuminate\Database\Eloquent\Model  $throughParent
     * @param  string  $firstKey
     * @param  string  $secondKey
     * @param  string  $localKey
     * @param  string  $secondLocalKey
     * @return void
     */
    public function __construct(Builder $query, Model $farParent, Model $throughParent, $firstKey, $secondKey, $localKey, $secondLocalKey)
    {
        $this-&gt;localKey = $localKey;
        $this-&gt;firstKey = $firstKey;
        $this-&gt;secondKey = $secondKey;
        $this-&gt;farParent = $farParent;
        $this-&gt;throughParent = $throughParent;
        $this-&gt;secondLocalKey = $secondLocalKey;

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

    /**
     * Set the base constraints on the relation query.
     *
     * @return void
     */
    public function addConstraints()
    {
        $localValue = $this-&gt;farParent[$this-&gt;localKey];

        $this-&gt;performJoin();

        if (static::$constraints) {
            $this-&gt;query-&gt;where($this-&gt;getQualifiedFirstKeyName(), '=', $localValue);
        }
    }

    /**
     * Set the join clause on the query.
     *
     * @param  \Illuminate\Database\Eloquent\Builder|null  $query
     * @return void
     */
    protected function performJoin(Builder $query = null)
    {
        $query = $query ?: $this-&gt;query;

        $farKey = $this-&gt;getQualifiedFarKeyName();

        $query-&gt;join($this-&gt;throughParent-&gt;getTable(), $this-&gt;getQualifiedParentKeyName(), '=', $farKey);

        if ($this-&gt;throughParentSoftDeletes()) {
            $query-&gt;withGlobalScope('SoftDeletableHasManyThrough', function ($query) {
                $query-&gt;whereNull($this-&gt;throughParent-&gt;getQualifiedDeletedAtColumn());
            });
        }
    }

    /**
     * Get the fully qualified parent key name.
     *
     * @return string
     */
    public function getQualifiedParentKeyName()
    {
        return $this-&gt;parent-&gt;qualifyColumn($this-&gt;secondLocalKey);
    }

    /**
     * Determine whether &quot;through&quot; parent of the relation uses Soft Deletes.
     *
     * @return bool
     */
    public function throughParentSoftDeletes()
    {
        return in_array(SoftDeletes::class, class_uses_recursive($this-&gt;throughParent));
    }

    /**
     * Indicate that trashed &quot;through&quot; parents should be included in the query.
     *
     * @return $this
     */
    public function withTrashedParents()
    {
        $this-&gt;query-&gt;withoutGlobalScope('SoftDeletableHasManyThrough');

        return $this;
    }

    /**
     * Set the constraints for an eager load of the relation.
     *
     * @param  array  $models
     * @return void
     */
    public function addEagerConstraints(array $models)
    {
        $whereIn = $this-&gt;whereInMethod($this-&gt;farParent, $this-&gt;localKey);

        $this-&gt;query-&gt;{$whereIn}(
            $this-&gt;getQualifiedFirstKeyName(), $this-&gt;getKeys($models, $this-&gt;localKey)
        );
    }

    /**
     * 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;related-&gt;newCollection());
        }

        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)
    {
        $dictionary = $this-&gt;buildDictionary($results);

        // Once we have the dictionary we can simply spin through the parent models to
        // link them up with their children using the keyed dictionary to make the
        // matching very convenient and easy work. Then we'll just return them.
        foreach ($models as $model) {
            if (isset($dictionary[$key = $this-&gt;getDictionaryKey($model-&gt;getAttribute($this-&gt;localKey))])) {
                $model-&gt;setRelation(
                    $relation, $this-&gt;related-&gt;newCollection($dictionary[$key])
                );
            }
        }

        return $models;
    }

    /**
     * Build model dictionary keyed by the relation's foreign key.
     *
     * @param  \Illuminate\Database\Eloquent\Collection  $results
     * @return array
     */
    protected function buildDictionary(Collection $results)
    {
        $dictionary = [];

        // First we will create a dictionary of models keyed by the foreign key of the
        // relationship as this will allow us to quickly access all of the related
        // models without having to do nested looping which will be quite slow.
        foreach ($results as $result) {
            $dictionary[$result-&gt;laravel_through_key][] = $result;
        }

        return $dictionary;
    }

    /**
     * Get the first related model record matching the attributes or instantiate it.
     *
     * @param  array  $attributes
     * @return \Illuminate\Database\Eloquent\Model
     */
    public function firstOrNew(array $attributes)
    {
        if (is_null($instance = $this-&gt;where($attributes)-&gt;first())) {
            $instance = $this-&gt;related-&gt;newInstance($attributes);
        }

        return $instance;
    }

    /**
     * Create or update a related record matching the attributes, and fill it with values.
     *
     * @param  array  $attributes
     * @param  array  $values
     * @return \Illuminate\Database\Eloquent\Model
     */
    public function updateOrCreate(array $attributes, array $values = [])
    {
        $instance = $this-&gt;firstOrNew($attributes);

        $instance-&gt;fill($values)-&gt;save();

        return $instance;
    }

    /**
     * Add a basic where clause to the query, and return the first result.
     *
     * @param  \Closure|string|array  $column
     * @param  mixed  $operator
     * @param  mixed  $value
     * @param  string  $boolean
     * @return \Illuminate\Database\Eloquent\Model|static
     */
    public function firstWhere($column, $operator = null, $value = null, $boolean = 'and')
    {
        return $this-&gt;where($column, $operator, $value, $boolean)-&gt;first();
    }

    /**
     * Execute the query and get the first related model.
     *
     * @param  array  $columns
     * @return mixed
     */
    public function first($columns = ['*'])
    {
        $results = $this-&gt;take(1)-&gt;get($columns);

        return count($results) &gt; 0 ? $results-&gt;first() : null;
    }

    /**
     * Execute the query and get the first result or throw an exception.
     *
     * @param  array  $columns
     * @return \Illuminate\Database\Eloquent\Model|static
     *
     * @throws \Illuminate\Database\Eloquent\ModelNotFoundException
     */
    public function firstOrFail($columns = ['*'])
    {
        if (! is_null($model = $this-&gt;first($columns))) {
            return $model;
        }

        throw (new ModelNotFoundException)-&gt;setModel(get_class($this-&gt;related));
    }

    /**
     * Find a related model by its primary key.
     *
     * @param  mixed  $id
     * @param  array  $columns
     * @return \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection|null
     */
    public function find($id, $columns = ['*'])
    {
        if (is_array($id) || $id instanceof Arrayable) {
            return $this-&gt;findMany($id, $columns);
        }

        return $this-&gt;where(
            $this-&gt;getRelated()-&gt;getQualifiedKeyName(), '=', $id
        )-&gt;first($columns);
    }

    /**
     * Find multiple related models by their primary keys.
     *
     * @param  \Illuminate\Contracts\Support\Arrayable|array  $ids
     * @param  array  $columns
     * @return \Illuminate\Database\Eloquent\Collection
     */
    public function findMany($ids, $columns = ['*'])
    {
        $ids = $ids instanceof Arrayable ? $ids-&gt;toArray() : $ids;

        if (empty($ids)) {
            return $this-&gt;getRelated()-&gt;newCollection();
        }

        return $this-&gt;whereIn(
            $this-&gt;getRelated()-&gt;getQualifiedKeyName(), $ids
        )-&gt;get($columns);
    }

    /**
     * Find a related model by its primary key or throw an exception.
     *
     * @param  mixed  $id
     * @param  array  $columns
     * @return \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection
     *
     * @throws \Illuminate\Database\Eloquent\ModelNotFoundException
     */
    public function findOrFail($id, $columns = ['*'])
    {
        $result = $this-&gt;find($id, $columns);

        $id = $id instanceof Arrayable ? $id-&gt;toArray() : $id;

        if (is_array($id)) {
            if (count($result) === count(array_unique($id))) {
                return $result;
            }
        } elseif (! is_null($result)) {
            return $result;
        }

        throw (new ModelNotFoundException)-&gt;setModel(get_class($this-&gt;related), $id);
    }

    /**
     * Get the results of the relationship.
     *
     * @return mixed
     */
    public function getResults()
    {
        return ! is_null($this-&gt;farParent-&gt;{$this-&gt;localKey})
                ? $this-&gt;get()
                : $this-&gt;related-&gt;newCollection();
    }

    /**
     * Execute the query as a &quot;select&quot; statement.
     *
     * @param  array  $columns
     * @return \Illuminate\Database\Eloquent\Collection
     */
    public function get($columns = ['*'])
    {
        $builder = $this-&gt;prepareQueryBuilder($columns);

        $models = $builder-&gt;getModels();

        // If we actually found models we will also eager load any relationships that
        // have been specified as needing to be eager loaded. This will solve the
        // n + 1 query problem for the developer and also increase performance.
        if (count($models) &gt; 0) {
            $models = $builder-&gt;eagerLoadRelations($models);
        }

        return $this-&gt;related-&gt;newCollection($models);
    }

    /**
     * Get a paginator for the &quot;select&quot; statement.
     *
     * @param  int|null  $perPage
     * @param  array  $columns
     * @param  string  $pageName
     * @param  int  $page
     * @return \Illuminate\Contracts\Pagination\LengthAwarePaginator
     */
    public function paginate($perPage = null, $columns = ['*'], $pageName = 'page', $page = null)
    {
        $this-&gt;query-&gt;addSelect($this-&gt;shouldSelect($columns));

        return $this-&gt;query-&gt;paginate($perPage, $columns, $pageName, $page);
    }

    /**
     * Paginate the given query into a simple paginator.
     *
     * @param  int|null  $perPage
     * @param  array  $columns
     * @param  string  $pageName
     * @param  int|null  $page
     * @return \Illuminate\Contracts\Pagination\Paginator
     */
    public function simplePaginate($perPage = null, $columns = ['*'], $pageName = 'page', $page = null)
    {
        $this-&gt;query-&gt;addSelect($this-&gt;shouldSelect($columns));

        return $this-&gt;query-&gt;simplePaginate($perPage, $columns, $pageName, $page);
    }

    /**
     * Paginate the given query into a cursor paginator.
     *
     * @param  int|null  $perPage
     * @param  array  $columns
     * @param  string  $cursorName
     * @param  string|null  $cursor
     * @return \Illuminate\Contracts\Pagination\CursorPaginator
     */
    public function cursorPaginate($perPage = null, $columns = ['*'], $cursorName = 'cursor', $cursor = null)
    {
        $this-&gt;query-&gt;addSelect($this-&gt;shouldSelect($columns));

        return $this-&gt;query-&gt;cursorPaginate($perPage, $columns, $cursorName, $cursor);
    }

    /**
     * Set the select clause for the relation query.
     *
     * @param  array  $columns
     * @return array
     */
    protected function shouldSelect(array $columns = ['*'])
    {
        if ($columns == ['*']) {
            $columns = [$this-&gt;related-&gt;getTable().'.*'];
        }

        return array_merge($columns, [$this-&gt;getQualifiedFirstKeyName().' as laravel_through_key']);
    }

    /**
     * Chunk the results of the query.
     *
     * @param  int  $count
     * @param  callable  $callback
     * @return bool
     */
    public function chunk($count, callable $callback)
    {
        return $this-&gt;prepareQueryBuilder()-&gt;chunk($count, $callback);
    }

    /**
     * Chunk the results of a query by comparing numeric IDs.
     *
     * @param  int  $count
     * @param  callable  $callback
     * @param  string|null  $column
     * @param  string|null  $alias
     * @return bool
     */
    public function chunkById($count, callable $callback, $column = null, $alias = null)
    {
        $column = $column ?? $this-&gt;getRelated()-&gt;getQualifiedKeyName();

        $alias = $alias ?? $this-&gt;getRelated()-&gt;getKeyName();

        return $this-&gt;prepareQueryBuilder()-&gt;chunkById($count, $callback, $column, $alias);
    }

    /**
     * Get a generator for the given query.
     *
     * @return \Generator
     */
    public function cursor()
    {
        return $this-&gt;prepareQueryBuilder()-&gt;cursor();
    }

    /**
     * Execute a callback over each item while chunking.
     *
     * @param  callable  $callback
     * @param  int  $count
     * @return bool
     */
    public function each(callable $callback, $count = 1000)
    {
        return $this-&gt;chunk($count, function ($results) use ($callback) {
            foreach ($results as $key =&gt; $value) {
                if ($callback($value, $key) === false) {
                    return false;
                }
            }
        });
    }

    /**
     * Query lazily, by chunks of the given size.
     *
     * @param  int  $chunkSize
     * @return \Illuminate\Support\LazyCollection
     */
    public function lazy($chunkSize = 1000)
    {
        return $this-&gt;prepareQueryBuilder()-&gt;lazy($chunkSize);
    }

    /**
     * Query lazily, by chunking the results of a query by comparing IDs.
     *
     * @param  int  $chunkSize
     * @param  string|null  $column
     * @param  string|null  $alias
     * @return \Illuminate\Support\LazyCollection
     */
    public function lazyById($chunkSize = 1000, $column = null, $alias = null)
    {
        $column = $column ?? $this-&gt;getRelated()-&gt;getQualifiedKeyName();

        $alias = $alias ?? $this-&gt;getRelated()-&gt;getKeyName();

        return $this-&gt;prepareQueryBuilder()-&gt;lazyById($chunkSize, $column, $alias);
    }

    /**
     * Prepare the query builder for query execution.
     *
     * @param  array  $columns
     * @return \Illuminate\Database\Eloquent\Builder
     */
    protected function prepareQueryBuilder($columns = ['*'])
    {
        $builder = $this-&gt;query-&gt;applyScopes();

        return $builder-&gt;addSelect(
            $this-&gt;shouldSelect($builder-&gt;getQuery()-&gt;columns ? [] : $columns)
        );
    }

    /**
     * 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);
        }

        if ($parentQuery-&gt;getQuery()-&gt;from === $this-&gt;throughParent-&gt;getTable()) {
            return $this-&gt;getRelationExistenceQueryForThroughSelfRelation($query, $parentQuery, $columns);
        }

        $this-&gt;performJoin($query);

        return $query-&gt;select($columns)-&gt;whereColumn(
            $this-&gt;getQualifiedLocalKeyName(), '=', $this-&gt;getQualifiedFirstKeyName()
        );
    }

    /**
     * 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;from($query-&gt;getModel()-&gt;getTable().' as '.$hash = $this-&gt;getRelationCountHash());

        $query-&gt;join($this-&gt;throughParent-&gt;getTable(), $this-&gt;getQualifiedParentKeyName(), '=', $hash.'.'.$this-&gt;secondKey);

        if ($this-&gt;throughParentSoftDeletes()) {
            $query-&gt;whereNull($this-&gt;throughParent-&gt;getQualifiedDeletedAtColumn());
        }

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

        return $query-&gt;select($columns)-&gt;whereColumn(
            $parentQuery-&gt;getQuery()-&gt;from.'.'.$this-&gt;localKey, '=', $this-&gt;getQualifiedFirstKeyName()
        );
    }

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

        $query-&gt;join($table, $hash.'.'.$this-&gt;secondLocalKey, '=', $this-&gt;getQualifiedFarKeyName());

        if ($this-&gt;throughParentSoftDeletes()) {
            $query-&gt;whereNull($hash.'.'.$this-&gt;throughParent-&gt;getDeletedAtColumn());
        }

        return $query-&gt;select($columns)-&gt;whereColumn(
            $parentQuery-&gt;getQuery()-&gt;from.'.'.$this-&gt;localKey, '=', $hash.'.'.$this-&gt;firstKey
        );
    }

    /**
     * Get the qualified foreign key on the related model.
     *
     * @return string
     */
    public function getQualifiedFarKeyName()
    {
        return $this-&gt;getQualifiedForeignKeyName();
    }

    /**
     * Get the foreign key on the &quot;through&quot; model.
     *
     * @return string
     */
    public function getFirstKeyName()
    {
        return $this-&gt;firstKey;
    }

    /**
     * Get the qualified foreign key on the &quot;through&quot; model.
     *
     * @return string
     */
    public function getQualifiedFirstKeyName()
    {
        return $this-&gt;throughParent-&gt;qualifyColumn($this-&gt;firstKey);
    }

    /**
     * Get the foreign key on the related model.
     *
     * @return string
     */
    public function getForeignKeyName()
    {
        return $this-&gt;secondKey;
    }

    /**
     * Get the qualified foreign key on the related model.
     *
     * @return string
     */
    public function getQualifiedForeignKeyName()
    {
        return $this-&gt;related-&gt;qualifyColumn($this-&gt;secondKey);
    }

    /**
     * Get the local key on the far parent model.
     *
     * @return string
     */
    public function getLocalKeyName()
    {
        return $this-&gt;localKey;
    }

    /**
     * Get the qualified local key on the far parent model.
     *
     * @return string
     */
    public function getQualifiedLocalKeyName()
    {
        return $this-&gt;farParent-&gt;qualifyColumn($this-&gt;localKey);
    }

    /**
     * Get the local key on the intermediary model.
     *
     * @return string
     */
    public function getSecondLocalKeyName()
    {
        return $this-&gt;secondLocalKey;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>