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

namespace Illuminate\Database\Eloquent\Concerns;

use BadMethodCallException;
use Closure;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\RelationNotFoundException;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\MorphTo;
use Illuminate\Database\Eloquent\Relations\Relation;
use Illuminate\Database\Query\Builder as QueryBuilder;
use Illuminate\Database\Query\Expression;
use Illuminate\Support\Str;

trait QueriesRelationships
{
    /**
     * Add a relationship count / exists condition to the query.
     *
     * @param  \Illuminate\Database\Eloquent\Relations\Relation|string  $relation
     * @param  string  $operator
     * @param  int  $count
     * @param  string  $boolean
     * @param  \Closure|null  $callback
     * @return \Illuminate\Database\Eloquent\Builder|static
     *
     * @throws \RuntimeException
     */
    public function has($relation, $operator = '&gt;=', $count = 1, $boolean = 'and', Closure $callback = null)
    {
        if (is_string($relation)) {
            if (strpos($relation, '.') !== false) {
                return $this-&gt;hasNested($relation, $operator, $count, $boolean, $callback);
            }

            $relation = $this-&gt;getRelationWithoutConstraints($relation);
        }

        if ($relation instanceof MorphTo) {
            return $this-&gt;hasMorph($relation, ['*'], $operator, $count, $boolean, $callback);
        }

        // If we only need to check for the existence of the relation, then we can optimize
        // the subquery to only run a &quot;where exists&quot; clause instead of this full &quot;count&quot;
        // clause. This will make these queries run much faster compared with a count.
        $method = $this-&gt;canUseExistsForExistenceCheck($operator, $count)
                        ? 'getRelationExistenceQuery'
                        : 'getRelationExistenceCountQuery';

        $hasQuery = $relation-&gt;{$method}(
            $relation-&gt;getRelated()-&gt;newQueryWithoutRelationships(), $this
        );

        // Next we will call any given callback as an &quot;anonymous&quot; scope so they can get the
        // proper logical grouping of the where clauses if needed by this Eloquent query
        // builder. Then, we will be ready to finalize and return this query instance.
        if ($callback) {
            $hasQuery-&gt;callScope($callback);
        }

        return $this-&gt;addHasWhere(
            $hasQuery, $relation, $operator, $count, $boolean
        );
    }

    /**
     * Add nested relationship count / exists conditions to the query.
     *
     * Sets up recursive call to whereHas until we finish the nested relation.
     *
     * @param  string  $relations
     * @param  string  $operator
     * @param  int  $count
     * @param  string  $boolean
     * @param  \Closure|null  $callback
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    protected function hasNested($relations, $operator = '&gt;=', $count = 1, $boolean = 'and', $callback = null)
    {
        $relations = explode('.', $relations);

        $doesntHave = $operator === '&lt;' &amp;&amp; $count === 1;

        if ($doesntHave) {
            $operator = '&gt;=';
            $count = 1;
        }

        $closure = function ($q) use (&amp;$closure, &amp;$relations, $operator, $count, $callback) {
            // In order to nest &quot;has&quot;, we need to add count relation constraints on the
            // callback Closure. We'll do this by simply passing the Closure its own
            // reference to itself so it calls itself recursively on each segment.
            count($relations) &gt; 1
                ? $q-&gt;whereHas(array_shift($relations), $closure)
                : $q-&gt;has(array_shift($relations), $operator, $count, 'and', $callback);
        };

        return $this-&gt;has(array_shift($relations), $doesntHave ? '&lt;' : '&gt;=', 1, $boolean, $closure);
    }

    /**
     * Add a relationship count / exists condition to the query with an &quot;or&quot;.
     *
     * @param  string  $relation
     * @param  string  $operator
     * @param  int  $count
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function orHas($relation, $operator = '&gt;=', $count = 1)
    {
        return $this-&gt;has($relation, $operator, $count, 'or');
    }

    /**
     * Add a relationship count / exists condition to the query.
     *
     * @param  string  $relation
     * @param  string  $boolean
     * @param  \Closure|null  $callback
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function doesntHave($relation, $boolean = 'and', Closure $callback = null)
    {
        return $this-&gt;has($relation, '&lt;', 1, $boolean, $callback);
    }

    /**
     * Add a relationship count / exists condition to the query with an &quot;or&quot;.
     *
     * @param  string  $relation
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function orDoesntHave($relation)
    {
        return $this-&gt;doesntHave($relation, 'or');
    }

    /**
     * Add a relationship count / exists condition to the query with where clauses.
     *
     * @param  string  $relation
     * @param  \Closure|null  $callback
     * @param  string  $operator
     * @param  int  $count
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function whereHas($relation, Closure $callback = null, $operator = '&gt;=', $count = 1)
    {
        return $this-&gt;has($relation, $operator, $count, 'and', $callback);
    }

    /**
     * Add a relationship count / exists condition to the query with where clauses and an &quot;or&quot;.
     *
     * @param  string  $relation
     * @param  \Closure|null  $callback
     * @param  string  $operator
     * @param  int  $count
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function orWhereHas($relation, Closure $callback = null, $operator = '&gt;=', $count = 1)
    {
        return $this-&gt;has($relation, $operator, $count, 'or', $callback);
    }

    /**
     * Add a relationship count / exists condition to the query with where clauses.
     *
     * @param  string  $relation
     * @param  \Closure|null  $callback
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function whereDoesntHave($relation, Closure $callback = null)
    {
        return $this-&gt;doesntHave($relation, 'and', $callback);
    }

    /**
     * Add a relationship count / exists condition to the query with where clauses and an &quot;or&quot;.
     *
     * @param  string  $relation
     * @param  \Closure|null  $callback
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function orWhereDoesntHave($relation, Closure $callback = null)
    {
        return $this-&gt;doesntHave($relation, 'or', $callback);
    }

    /**
     * Add a polymorphic relationship count / exists condition to the query.
     *
     * @param  \Illuminate\Database\Eloquent\Relations\MorphTo|string  $relation
     * @param  string|array  $types
     * @param  string  $operator
     * @param  int  $count
     * @param  string  $boolean
     * @param  \Closure|null  $callback
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function hasMorph($relation, $types, $operator = '&gt;=', $count = 1, $boolean = 'and', Closure $callback = null)
    {
        if (is_string($relation)) {
            $relation = $this-&gt;getRelationWithoutConstraints($relation);
        }

        $types = (array) $types;

        if ($types === ['*']) {
            $types = $this-&gt;model-&gt;newModelQuery()-&gt;distinct()-&gt;pluck($relation-&gt;getMorphType())-&gt;filter()-&gt;all();
        }

        foreach ($types as &amp;$type) {
            $type = Relation::getMorphedModel($type) ?? $type;
        }

        return $this-&gt;where(function ($query) use ($relation, $callback, $operator, $count, $types) {
            foreach ($types as $type) {
                $query-&gt;orWhere(function ($query) use ($relation, $callback, $operator, $count, $type) {
                    $belongsTo = $this-&gt;getBelongsToRelation($relation, $type);

                    if ($callback) {
                        $callback = function ($query) use ($callback, $type) {
                            return $callback($query, $type);
                        };
                    }

                    $query-&gt;where($this-&gt;qualifyColumn($relation-&gt;getMorphType()), '=', (new $type)-&gt;getMorphClass())
                                -&gt;whereHas($belongsTo, $callback, $operator, $count);
                });
            }
        }, null, null, $boolean);
    }

    /**
     * Get the BelongsTo relationship for a single polymorphic type.
     *
     * @param  \Illuminate\Database\Eloquent\Relations\MorphTo  $relation
     * @param  string  $type
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    protected function getBelongsToRelation(MorphTo $relation, $type)
    {
        $belongsTo = Relation::noConstraints(function () use ($relation, $type) {
            return $this-&gt;model-&gt;belongsTo(
                $type,
                $relation-&gt;getForeignKeyName(),
                $relation-&gt;getOwnerKeyName()
            );
        });

        $belongsTo-&gt;getQuery()-&gt;mergeConstraintsFrom($relation-&gt;getQuery());

        return $belongsTo;
    }

    /**
     * Add a polymorphic relationship count / exists condition to the query with an &quot;or&quot;.
     *
     * @param  \Illuminate\Database\Eloquent\Relations\MorphTo|string  $relation
     * @param  string|array  $types
     * @param  string  $operator
     * @param  int  $count
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function orHasMorph($relation, $types, $operator = '&gt;=', $count = 1)
    {
        return $this-&gt;hasMorph($relation, $types, $operator, $count, 'or');
    }

    /**
     * Add a polymorphic relationship count / exists condition to the query.
     *
     * @param  \Illuminate\Database\Eloquent\Relations\MorphTo|string  $relation
     * @param  string|array  $types
     * @param  string  $boolean
     * @param  \Closure|null  $callback
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function doesntHaveMorph($relation, $types, $boolean = 'and', Closure $callback = null)
    {
        return $this-&gt;hasMorph($relation, $types, '&lt;', 1, $boolean, $callback);
    }

    /**
     * Add a polymorphic relationship count / exists condition to the query with an &quot;or&quot;.
     *
     * @param  \Illuminate\Database\Eloquent\Relations\MorphTo|string  $relation
     * @param  string|array  $types
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function orDoesntHaveMorph($relation, $types)
    {
        return $this-&gt;doesntHaveMorph($relation, $types, 'or');
    }

    /**
     * Add a polymorphic relationship count / exists condition to the query with where clauses.
     *
     * @param  \Illuminate\Database\Eloquent\Relations\MorphTo|string  $relation
     * @param  string|array  $types
     * @param  \Closure|null  $callback
     * @param  string  $operator
     * @param  int  $count
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function whereHasMorph($relation, $types, Closure $callback = null, $operator = '&gt;=', $count = 1)
    {
        return $this-&gt;hasMorph($relation, $types, $operator, $count, 'and', $callback);
    }

    /**
     * Add a polymorphic relationship count / exists condition to the query with where clauses and an &quot;or&quot;.
     *
     * @param  \Illuminate\Database\Eloquent\Relations\MorphTo|string  $relation
     * @param  string|array  $types
     * @param  \Closure|null  $callback
     * @param  string  $operator
     * @param  int  $count
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function orWhereHasMorph($relation, $types, Closure $callback = null, $operator = '&gt;=', $count = 1)
    {
        return $this-&gt;hasMorph($relation, $types, $operator, $count, 'or', $callback);
    }

    /**
     * Add a polymorphic relationship count / exists condition to the query with where clauses.
     *
     * @param  \Illuminate\Database\Eloquent\Relations\MorphTo|string  $relation
     * @param  string|array  $types
     * @param  \Closure|null  $callback
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function whereDoesntHaveMorph($relation, $types, Closure $callback = null)
    {
        return $this-&gt;doesntHaveMorph($relation, $types, 'and', $callback);
    }

    /**
     * Add a polymorphic relationship count / exists condition to the query with where clauses and an &quot;or&quot;.
     *
     * @param  \Illuminate\Database\Eloquent\Relations\MorphTo|string  $relation
     * @param  string|array  $types
     * @param  \Closure|null  $callback
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function orWhereDoesntHaveMorph($relation, $types, Closure $callback = null)
    {
        return $this-&gt;doesntHaveMorph($relation, $types, 'or', $callback);
    }

    /**
     * Add a basic where clause to a relationship query.
     *
     * @param  string  $relation
     * @param  \Closure|string|array|\Illuminate\Database\Query\Expression  $column
     * @param  mixed  $operator
     * @param  mixed  $value
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function whereRelation($relation, $column, $operator = null, $value = null)
    {
        return $this-&gt;whereHas($relation, function ($query) use ($column, $operator, $value) {
            $query-&gt;where($column, $operator, $value);
        });
    }

    /**
     * Add an &quot;or where&quot; clause to a relationship query.
     *
     * @param  string  $relation
     * @param  \Closure|string|array|\Illuminate\Database\Query\Expression  $column
     * @param  mixed  $operator
     * @param  mixed  $value
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function orWhereRelation($relation, $column, $operator = null, $value = null)
    {
        return $this-&gt;orWhereHas($relation, function ($query) use ($column, $operator, $value) {
            $query-&gt;where($column, $operator, $value);
        });
    }

    /**
     * Add a polymorphic relationship condition to the query with a where clause.
     *
     * @param  \Illuminate\Database\Eloquent\Relations\MorphTo|string  $relation
     * @param  string|array  $types
     * @param  \Closure|string|array|\Illuminate\Database\Query\Expression  $column
     * @param  mixed  $operator
     * @param  mixed  $value
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function whereMorphRelation($relation, $types, $column, $operator = null, $value = null)
    {
        return $this-&gt;whereHasMorph($relation, $types, function ($query) use ($column, $operator, $value) {
            $query-&gt;where($column, $operator, $value);
        });
    }

    /**
     * Add a polymorphic relationship condition to the query with an &quot;or where&quot; clause.
     *
     * @param  \Illuminate\Database\Eloquent\Relations\MorphTo|string  $relation
     * @param  string|array  $types
     * @param  \Closure|string|array|\Illuminate\Database\Query\Expression  $column
     * @param  mixed  $operator
     * @param  mixed  $value
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function orWhereMorphRelation($relation, $types, $column, $operator = null, $value = null)
    {
        return $this-&gt;orWhereHasMorph($relation, $types, function ($query) use ($column, $operator, $value) {
            $query-&gt;where($column, $operator, $value);
        });
    }

    /**
     * Add a morph-to relationship condition to the query.
     *
     * @param  \Illuminate\Database\Eloquent\Relations\MorphTo|string  $relation
     * @param  \Illuminate\Database\Eloquent\Model|string  $model
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function whereMorphedTo($relation, $model, $boolean = 'and')
    {
        if (is_string($relation)) {
            $relation = $this-&gt;getRelationWithoutConstraints($relation);
        }

        if (is_string($model)) {
            $morphMap = Relation::morphMap();

            if (! empty($morphMap) &amp;&amp; in_array($model, $morphMap)) {
                $model = array_search($model, $morphMap, true);
            }

            return $this-&gt;where($relation-&gt;getMorphType(), $model, null, $boolean);
        }

        return $this-&gt;where(function ($query) use ($relation, $model) {
            $query-&gt;where($relation-&gt;getMorphType(), $model-&gt;getMorphClass())
                -&gt;where($relation-&gt;getForeignKeyName(), $model-&gt;getKey());
        }, null, null, $boolean);
    }

    /**
     * Add a morph-to relationship condition to the query with an &quot;or where&quot; clause.
     *
     * @param  \Illuminate\Database\Eloquent\Relations\MorphTo|string  $relation
     * @param  \Illuminate\Database\Eloquent\Model|string  $model
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function orWhereMorphedTo($relation, $model)
    {
        return $this-&gt;whereMorphedTo($relation, $model, 'or');
    }

    /**
     * Add a &quot;belongs to&quot; relationship where clause to the query.
     *
     * @param  \Illuminate\Database\Eloquent\Model  $related
     * @param  string  $relationship
     * @param  string  $boolean
     * @return $this
     *
     * @throws \RuntimeException
     */
    public function whereBelongsTo($related, $relationshipName = null, $boolean = 'and')
    {
        if ($relationshipName === null) {
            $relationshipName = Str::camel(class_basename($related));
        }

        try {
            $relationship = $this-&gt;model-&gt;{$relationshipName}();
        } catch (BadMethodCallException $exception) {
            throw RelationNotFoundException::make($this-&gt;model, $relationshipName);
        }

        if (! $relationship instanceof BelongsTo) {
            throw RelationNotFoundException::make($this-&gt;model, $relationshipName, BelongsTo::class);
        }

        $this-&gt;where(
            $relationship-&gt;getQualifiedForeignKeyName(),
            '=',
            $related-&gt;getAttributeValue($relationship-&gt;getOwnerKeyName()),
            $boolean,
        );

        return $this;
    }

    /**
     * Add an &quot;BelongsTo&quot; relationship with an &quot;or where&quot; clause to the query.
     *
     * @param  \Illuminate\Database\Eloquent\Model  $related
     * @param  string  $relationship
     * @return $this
     *
     * @throws \RuntimeException
     */
    public function orWhereBelongsTo($related, $relationshipName = null)
    {
        return $this-&gt;whereBelongsTo($related, $relationshipName, 'or');
    }

    /**
     * Add subselect queries to include an aggregate value for a relationship.
     *
     * @param  mixed  $relations
     * @param  string  $column
     * @param  string  $function
     * @return $this
     */
    public function withAggregate($relations, $column, $function = null)
    {
        if (empty($relations)) {
            return $this;
        }

        if (is_null($this-&gt;query-&gt;columns)) {
            $this-&gt;query-&gt;select([$this-&gt;query-&gt;from.'.*']);
        }

        $relations = is_array($relations) ? $relations : [$relations];

        foreach ($this-&gt;parseWithRelations($relations) as $name =&gt; $constraints) {
            // First we will determine if the name has been aliased using an &quot;as&quot; clause on the name
            // and if it has we will extract the actual relationship name and the desired name of
            // the resulting column. This allows multiple aggregates on the same relationships.
            $segments = explode(' ', $name);

            unset($alias);

            if (count($segments) === 3 &amp;&amp; Str::lower($segments[1]) === 'as') {
                [$name, $alias] = [$segments[0], $segments[2]];
            }

            $relation = $this-&gt;getRelationWithoutConstraints($name);

            if ($function) {
                $hashedColumn = $this-&gt;getQuery()-&gt;from === $relation-&gt;getQuery()-&gt;getQuery()-&gt;from
                                            ? &quot;{$relation-&gt;getRelationCountHash(false)}.$column&quot;
                                            : $column;

                $wrappedColumn = $this-&gt;getQuery()-&gt;getGrammar()-&gt;wrap(
                    $column === '*' ? $column : $relation-&gt;getRelated()-&gt;qualifyColumn($hashedColumn)
                );

                $expression = $function === 'exists' ? $wrappedColumn : sprintf('%s(%s)', $function, $wrappedColumn);
            } else {
                $expression = $column;
            }

            // Here, we will grab the relationship sub-query and prepare to add it to the main query
            // as a sub-select. First, we'll get the &quot;has&quot; query and use that to get the relation
            // sub-query. We'll format this relationship name and append this column if needed.
            $query = $relation-&gt;getRelationExistenceQuery(
                $relation-&gt;getRelated()-&gt;newQuery(), $this, new Expression($expression)
            )-&gt;setBindings([], 'select');

            $query-&gt;callScope($constraints);

            $query = $query-&gt;mergeConstraintsFrom($relation-&gt;getQuery())-&gt;toBase();

            // If the query contains certain elements like orderings / more than one column selected
            // then we will remove those elements from the query so that it will execute properly
            // when given to the database. Otherwise, we may receive SQL errors or poor syntax.
            $query-&gt;orders = null;
            $query-&gt;setBindings([], 'order');

            if (count($query-&gt;columns) &gt; 1) {
                $query-&gt;columns = [$query-&gt;columns[0]];
                $query-&gt;bindings['select'] = [];
            }

            // Finally, we will make the proper column alias to the query and run this sub-select on
            // the query builder. Then, we will return the builder instance back to the developer
            // for further constraint chaining that needs to take place on the query as needed.
            $alias = $alias ?? Str::snake(
                preg_replace('/[^[:alnum:][:space:]_]/u', '', &quot;$name $function $column&quot;)
            );

            if ($function === 'exists') {
                $this-&gt;selectRaw(
                    sprintf('exists(%s) as %s', $query-&gt;toSql(), $this-&gt;getQuery()-&gt;grammar-&gt;wrap($alias)),
                    $query-&gt;getBindings()
                )-&gt;withCasts([$alias =&gt; 'bool']);
            } else {
                $this-&gt;selectSub(
                    $function ? $query : $query-&gt;limit(1),
                    $alias
                );
            }
        }

        return $this;
    }

    /**
     * Add subselect queries to count the relations.
     *
     * @param  mixed  $relations
     * @return $this
     */
    public function withCount($relations)
    {
        return $this-&gt;withAggregate(is_array($relations) ? $relations : func_get_args(), '*', 'count');
    }

    /**
     * Add subselect queries to include the max of the relation's column.
     *
     * @param  string|array  $relation
     * @param  string  $column
     * @return $this
     */
    public function withMax($relation, $column)
    {
        return $this-&gt;withAggregate($relation, $column, 'max');
    }

    /**
     * Add subselect queries to include the min of the relation's column.
     *
     * @param  string|array  $relation
     * @param  string  $column
     * @return $this
     */
    public function withMin($relation, $column)
    {
        return $this-&gt;withAggregate($relation, $column, 'min');
    }

    /**
     * Add subselect queries to include the sum of the relation's column.
     *
     * @param  string|array  $relation
     * @param  string  $column
     * @return $this
     */
    public function withSum($relation, $column)
    {
        return $this-&gt;withAggregate($relation, $column, 'sum');
    }

    /**
     * Add subselect queries to include the average of the relation's column.
     *
     * @param  string|array  $relation
     * @param  string  $column
     * @return $this
     */
    public function withAvg($relation, $column)
    {
        return $this-&gt;withAggregate($relation, $column, 'avg');
    }

    /**
     * Add subselect queries to include the existence of related models.
     *
     * @param  string|array  $relation
     * @return $this
     */
    public function withExists($relation)
    {
        return $this-&gt;withAggregate($relation, '*', 'exists');
    }

    /**
     * Add the &quot;has&quot; condition where clause to the query.
     *
     * @param  \Illuminate\Database\Eloquent\Builder  $hasQuery
     * @param  \Illuminate\Database\Eloquent\Relations\Relation  $relation
     * @param  string  $operator
     * @param  int  $count
     * @param  string  $boolean
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    protected function addHasWhere(Builder $hasQuery, Relation $relation, $operator, $count, $boolean)
    {
        $hasQuery-&gt;mergeConstraintsFrom($relation-&gt;getQuery());

        return $this-&gt;canUseExistsForExistenceCheck($operator, $count)
                ? $this-&gt;addWhereExistsQuery($hasQuery-&gt;toBase(), $boolean, $operator === '&lt;' &amp;&amp; $count === 1)
                : $this-&gt;addWhereCountQuery($hasQuery-&gt;toBase(), $operator, $count, $boolean);
    }

    /**
     * Merge the where constraints from another query to the current query.
     *
     * @param  \Illuminate\Database\Eloquent\Builder  $from
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function mergeConstraintsFrom(Builder $from)
    {
        $whereBindings = $from-&gt;getQuery()-&gt;getRawBindings()['where'] ?? [];

        // Here we have some other query that we want to merge the where constraints from. We will
        // copy over any where constraints on the query as well as remove any global scopes the
        // query might have removed. Then we will return ourselves with the finished merging.
        return $this-&gt;withoutGlobalScopes(
            $from-&gt;removedScopes()
        )-&gt;mergeWheres(
            $from-&gt;getQuery()-&gt;wheres, $whereBindings
        );
    }

    /**
     * Add a sub-query count clause to this query.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  string  $operator
     * @param  int  $count
     * @param  string  $boolean
     * @return $this
     */
    protected function addWhereCountQuery(QueryBuilder $query, $operator = '&gt;=', $count = 1, $boolean = 'and')
    {
        $this-&gt;query-&gt;addBinding($query-&gt;getBindings(), 'where');

        return $this-&gt;where(
            new Expression('('.$query-&gt;toSql().')'),
            $operator,
            is_numeric($count) ? new Expression($count) : $count,
            $boolean
        );
    }

    /**
     * Get the &quot;has relation&quot; base query instance.
     *
     * @param  string  $relation
     * @return \Illuminate\Database\Eloquent\Relations\Relation
     */
    protected function getRelationWithoutConstraints($relation)
    {
        return Relation::noConstraints(function () use ($relation) {
            return $this-&gt;getModel()-&gt;{$relation}();
        });
    }

    /**
     * Check if we can run an &quot;exists&quot; query to optimize performance.
     *
     * @param  string  $operator
     * @param  int  $count
     * @return bool
     */
    protected function canUseExistsForExistenceCheck($operator, $count)
    {
        return ($operator === '&gt;=' || $operator === '&lt;') &amp;&amp; $count === 1;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>