Laravel-Backpack / CRUD

src/app/Library/CrudPanel/Traits/Query.php

<?php

namespace Backpack\CRUD\app\Library\CrudPanel\Traits;

use Illuminate\Contracts\Database\Query\Builder as QueryBuilder;
use Illuminate\Database\Eloquent\Builder;

trait Query
{
    /** @var Builder */
    public $query;

    /** @var Builder */
    public $totalQuery;

    // ----------------
    // ADVANCED QUERIES
    // ----------------

    /**
     * Add another clause to the query (for ex, a WHERE clause).
     *
     * Examples:
     * $this->crud->addClause('active');
     * $this->crud->addClause('type', 'car');
     * $this->crud->addClause('where', 'name', '=', 'car');
     * $this->crud->addClause('whereName', 'car');
     * $this->crud->addClause('whereHas', 'posts', function($query) {
     *     $query->activePosts();
     * });
     *
     * @param  callable|string  $function
     * @return mixed
     */
    public function addClause($function)
    {
        if ($function instanceof \Closure) {
            $function($this->query);

            return $this->query;
        }

        return call_user_func_array([$this->query, $function], array_slice(func_get_args(), 1));
    }

    /**
     * This function is an alias of `addClause` but also adds the query as a constrain
     * in the `totalQuery` property.
     *
     * @param  \Closure|string  $function
     * @return self
     */
    public function addBaseClause($function)
    {
        if ($function instanceof \Closure) {
            $function($this->query);
            $function($this->totalQuery);

            return $this;
        }
        call_user_func_array([$this->query, $function], array_slice(func_get_args(), 1));
        call_user_func_array([$this->totalQuery, $function], array_slice(func_get_args(), 1));

        return $this;
    }

    public function setQuery(QueryBuilder $query)
    {
        $this->query = $query;

$query is of type Illuminate\Contracts\Database\Query\Builder, but the property $query was declared to be of type Illuminate\Database\Eloquent\Builder. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

        return $this;
    }

    /**
     * Use eager loading to reduce the number of queries on the table view.
     *
     * @param  array|string  $entities
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function with($entities)
    {
        return $this->query->with($entities);
    }

    /**
     * Order the results of the query in a certain way.
     *
     * @param  string  $field
     * @param  string  $order
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function orderBy($field, $order = 'asc')
    {
        if ($this->getRequest()->has('order')) {

It seems like getRequest() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            return $this->query;
        }

        return $this->query->orderBy($field, $order);

The expression return $this->query->orderBy($field, $order) also could return the type Illuminate\Database\Query\Builder which is incompatible with the documented return type Illuminate\Database\Eloquent\Builder.

    }

    /**
     * Order results of the query in a custom way.
     *
     * @param  array  $column  Column array with all attributes
     * @param  string  $column_direction  ASC or DESC
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function customOrderBy($column, $columnDirection = 'asc')
    {
        if (! isset($column['orderLogic'])) {
            return $this->query;
        }

        $orderLogic = $column['orderLogic'];

        if ($orderLogic instanceof \Closure) {
            return $orderLogic($this->query, $column, $columnDirection);
        }

        return $this->query;
    }

    /**
     * Group the results of the query in a certain way.
     *
     * @param  string  $field
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function groupBy($field)
    {
        return $this->query->groupBy($field);

The expression return $this->query->groupBy($field) also could return the type Illuminate\Database\Query\Builder which is incompatible with the documented return type Illuminate\Database\Eloquent\Builder.

    }

    /**
     * Limit the number of results in the query.
     *
     * @param  int  $number
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function limit($number)
    {
        return $this->query->limit($number);

The expression return $this->query->limit($number) also could return the type Illuminate\Database\Query\Builder which is incompatible with the documented return type Illuminate\Database\Eloquent\Builder.

    }

    /**
     * Take a certain number of results from the query.
     *
     * @param  int  $number
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function take($number)
    {
        return $this->query->take($number);

The expression return $this->query->take($number) also could return the type Illuminate\Database\Query\Builder which is incompatible with the documented return type Illuminate\Database\Eloquent\Builder.

    }

    /**
     * Start the result set from a certain number.
     *
     * @param  int  $number
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function skip($number)
    {
        return $this->query->skip($number);

The expression return $this->query->skip($number) also could return the type Illuminate\Database\Query\Builder which is incompatible with the documented return type Illuminate\Database\Eloquent\Builder.

    }

    /**
     * Count the number of results.
     *
     * @return int
     */
    public function count()
    {
        return $this->query->count();

The expression return $this->query->count() also could return the type Illuminate\Database\Eloquent\Builder which is incompatible with the documented return type integer.

    }

    /**
     * Apply table prefix in the order clause if the query contains JOINS clauses.
     *
     * @param  string  $column_name
     * @param  string  $column_direction
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function orderByWithPrefix($column_name, $column_direction = 'asc')
    {
        $column_direction = strtolower($column_direction);

        if ($this->query->getQuery()->joins !== null) {
            return $this->query->orderBy("{$this->model->getTableWithPrefix()}.{$column_name}", $column_direction);

The expression return $this->query->orderBy($this->model->getTableWithPrefix().'.'.$column_name, $column_direction) also could return the type Illuminate\Database\Query\Builder which is incompatible with the documented return type Illuminate\Database\Eloquent\Builder.

        }

        return $this->query->orderBy($column_name, $column_direction);

The expression return $this->query->orderBy($column_name, $column_direction) also could return the type Illuminate\Database\Query\Builder which is incompatible with the documented return type Illuminate\Database\Eloquent\Builder.

    }

    /**
     * Get the entries count from `totalQuery`.
     *
     * @return int
     */
    public function getTotalQueryCount()
    {
        if (! $this->getOperationSetting('showEntryCount')) {

It seems like getOperationSetting() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            return 0;
        }

        return  $this->getOperationSetting('totalEntryCount') ??
                $this->getCountFromQuery($this->totalQuery);
    }

    /**
     * Get the entries count from the `query`.
     *
     * @return int
     */
    public function getQueryCount()
    {
        return $this->getCountFromQuery($this->query);
    }

    /**
     * Return the filtered query count or skip the counting when the `totalQuery` is the same as the filtered one.
     *
     * @return int|null
     */
    public function getFilteredQueryCount()
    {
        // check if the filtered query is different from total query, in case they are the same, skip the count
        $filteredQuery = $this->query->toBase()->cloneWithout(['orders', 'limit', 'offset']);

        return $filteredQuery->toSql() !== $this->totalQuery->toSql() ? $this->getQueryCount() : null;
    }

    /**
     * Do a separate query to get the total number of entries, in an optimized way.
     *
     * @param  Builder  $query
     * @return int
     */
    private function getCountFromQuery(Builder $query)
    {
        if (! $this->driverIsSql()) {

It seems like driverIsSql() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            return $query->count();

The expression return $query->count() also could return the type Illuminate\Database\Eloquent\Builder which is incompatible with the documented return type integer.

        }

        $crudQuery = $query->toBase()->clone();

        $modelTable = $this->model->getTable();

        // create an "outer" query, the one that is responsible to do the count of the "crud query".
        $outerQuery = $crudQuery->newQuery();

        // add the count query in the "outer" query.
        $outerQuery = $outerQuery->selectRaw('count(*) as total_rows');

        // Expression columns are hand-written by developers in ->selectRaw() and we can't exclude those statements reliably
        // so we just store them and re-use them in the sub-query too.
        $expressionColumns = [];

        foreach ($crudQuery->columns ?? [] as $column) {
            if (! is_string($column) && is_a($column, 'Illuminate\Database\Query\Expression')) {
                $expressionColumns[] = $column;
            }
        }
        // add the subquery from where the "outer query" will count the results.
        // this subquery is the "main crud query" without some properties:
        // - columns : we manually select the "minimum" columns possible from database.
        // - orders/limit/offset because we want the "full query count" where orders don't matter and limit/offset would break the total count
        $subQuery = $crudQuery->cloneWithout(['columns', 'orders', 'limit', 'offset']);

        // select minimum possible columns for the count
        $minimumColumns = ($crudQuery->groups || $crudQuery->havings) ? $modelTable.'.*' : $modelTable.'.'.$this->model->getKeyName();

The expression $crudQuery->groups of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

The expression $crudQuery->havings of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

        $subQuery->select($minimumColumns);

        // in case there are raw expressions we need to add them too.
        foreach ($expressionColumns as $expression) {
            $subQuery->selectRaw($expression);
        }

        // re-set the previous query bindings
        //dump($crudQuery->getColumns(), get_class($crudQuery), get_class($subQuery));
        foreach ($crudQuery->getRawBindings() as $type => $binding) {
            $subQuery->setBindings($binding, $type);
        }

        $outerQuery = $outerQuery->fromSub($subQuery, str_replace('.', '_', $modelTable).'_aggregator');

        return $outerQuery->cursor()->first()->total_rows;
    }
}