duxet\Rethinkdb\Query\Builder

Complexity

Total Complexity

51

Size/Duplication

Total Lines	495
Duplicated Lines	3.64 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	from()	0	9	2
B	getFresh()	0	31	9
A	runSelect()	0	4	1
A	compileOrders()	0	21	5
A	insert()	0	7	1
A	insertGetId()	0	14	3
A	update()	0	4	1
A	performUpdate()	0	11	2
A	delete()	0	12	2
A	compileWheres()	0	16	2
A	buildFilter()	0	6	1
A	truncate()	0	6	1
A	push()	0	11	2
A	pull()	0	9	1
A	distinct()	0	10	2
A	count()	0	7	1
A	sum()	0	7	1
A	min()	9	9	1
A	max()	9	9	1
A	avg()	0	8	1
A	drop()	0	13	2
A	groupBy()	0	10	2
A	orderBy()	0	8	3
A	whereBetween()	0	7	1
A	__call()	0	8	2

<?php

namespace duxet\Rethinkdb\Query;

use duxet\Rethinkdb\Connection;
use duxet\Rethinkdb\Query;
use duxet\Rethinkdb\RQL\FilterBuilder;
use Illuminate\Database\Query\Builder as QueryBuilder;
use r;

class Builder extends QueryBuilder
{
    /**
     * The query instance.
     *
     * @var Query
     */
    protected $query;

    /**
     * The r\Table instance.
     *
     * @var r\Table
     */
    protected $table;

    /**
     * All of the available clause operators.
     *
     * @var array
     */
    public $operators = [
        '=', '<', '>', '<=', '>=', '<>', '!=',
        'like', 'not like', 'between', 'ilike',
        '&', '|', '^', '<<', '>>',
        'rlike', 'regexp', 'not regexp',
        '~', '~*', '!~', '!~*',
        'contains', 'exists', 'type', 'mod', 'size',
    ];

    /**
     * Create a new query builder instance.
     *
     * @param Connection $connection
     */
    public function __construct(Connection $connection)
    {
        $this->connection = $connection;
        $this->grammar = $connection->getQueryGrammar();
        $this->processor = $connection->getPostProcessor();
        $this->query = new Query($this->connection);
    }

    /**
     * Set the collection which the query is targeting.
     *
     * @param string $table
     *
     * @return Builder
     */
    public function from($table)
    {
        if ($table) {
            $this->table = r\table($table);

It seems like \r\table($table) of type object<r\Queries\Tables\Table> is incompatible with the declared type object<r\table> of property $table.

            $this->query->table($table);

The method table does not exist on object<duxet\Rethinkdb\Query>? Since you implemented __call, maybe consider adding a @method annotation.

        }

        return parent::from($table);
    }

    /**
     * Execute the query as a fresh "select" statement.
     *
     * @param array $columns
     *
     * @return array|static[]
     */
    public function getFresh($columns = [])
    {
        $this->compileOrders();
        $this->compileWheres();

        if ($this->offset) {
            $this->query->skip($this->offset);

The method skip does not exist on object<duxet\Rethinkdb\Query>? Since you implemented __call, maybe consider adding a @method annotation.

        }
        if ($this->limit) {
            $this->query->limit($this->limit);

The method limit does not exist on object<duxet\Rethinkdb\Query>? Since you implemented __call, maybe consider adding a @method annotation.

        }
        if ($this->columns) {

The expression $this->columns 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.

            $columns = $this->columns;
        }

        if (!empty($columns) && $columns[0] != '*') {
            $this->query->pluck($columns);

The method pluck does not exist on object<duxet\Rethinkdb\Query>? Since you implemented __call, maybe consider adding a @method annotation.

        }

        $results = $this->query->run();
        if (is_object($results)) {
            $results = $results->toArray();
        }

        if (isset($results['$reql_type$'])
            && $results['$reql_type$'] === 'GROUPED_DATA') {
            return $results['data'];
        }

        return $results;
    }

    /**
     * Run the query as a "select" statement against the connection.
     *
     * @return array
     */
    protected function runSelect()
    {
        return $this->getFresh();
    }

    /**
     * Compile orders into query.
     */
    public function compileOrders()
    {
        if (!$this->orders) {

The expression $this->orders 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.

            return;
        }

        foreach ($this->orders as $order) {
            $column = $order['column'];
            $direction = $order['direction'];

            $compiled = strtolower($direction) == 'asc'
                ? r\asc($column) : r\desc($column);

            // Use index as field if needed
            if ($order['index']) {
                $compiled = ['index' => $compiled];
            }

            $this->query->orderBy($compiled);

The method orderBy does not exist on object<duxet\Rethinkdb\Query>? Since you implemented __call, maybe consider adding a @method annotation.

        }
    }

    /**
     * Insert a new record into the database.
     *
     * @param array $values
     *
     * @return bool
     */
    public function insert(array $values)
    {
        $this->compileWheres();
        $result = $this->query->insert($values);

The method insert does not exist on object<duxet\Rethinkdb\Query>? Since you implemented __call, maybe consider adding a @method annotation.

        return 0 == (int) $result['errors'];
    }

    /**
     * Insert a new record and get the value of the primary key.
     *
     * @param array  $values
     * @param string $sequence
     *
     * @return int
     */
    public function insertGetId(array $values, $sequence = null)
    {
        $this->compileWheres();
        $result = $this->query->insert($values);

The method insert does not exist on object<duxet\Rethinkdb\Query>? Since you implemented __call, maybe consider adding a @method annotation.

        if (0 == (int) $result['errors']) {
            if (isset($values['id'])) {
                return $values['id'];
            }

            // Return id
            return current($result['generated_keys']);
        }
    }

    /**
     * Update a record in the database.
     *
     * @param array $values
     * @param array $options
     *
     * @return int
     */
    public function update(array $values, array $options = [])
    {
        return $this->performUpdate($values, $options);
    }

    /**
     * Perform an update query.
     *
     * @param array $query
     * @param array $options
     *
     * @return int
     */
    protected function performUpdate($query, array $options = [])

The parameter $options is not used and could be removed.

    {
        $this->compileWheres();
        $result = $this->query->update($query)->run();

The method update does not exist on object<duxet\Rethinkdb\Query>? Since you implemented __call, maybe consider adding a @method annotation.

        if (0 == (int) $result['errors']) {
            return $result['replaced'];
        }

        return 0;
    }

    /**
     * Delete a record from the database.
     *
     * @param mixed $id
     *
     * @return int
     */
    public function delete($id = null)
    {
        // If an ID is passed to the method, we will set the where clause to check
        // the ID to allow developers to simply and quickly remove a single row
        // from their database without manually specifying the where clauses.
        if (!is_null($id)) {
            $this->where('id', '=', $id);
        }
        $this->compileWheres();

        return $this->query->delete()->run();

The method delete does not exist on object<duxet\Rethinkdb\Query>? Since you implemented __call, maybe consider adding a @method annotation.

    }

    /**
     * Compile the where array to filter chain.
     *
     * @return array
     */
    protected function compileWheres()
    {
        // Wheres to compile
        $wheres = $this->wheres;

        // If there is nothing to do, then return
        if (!$wheres) {

The expression $wheres 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.

            return;
        }

        $this->query->filter(function ($document) use ($wheres) {

The method filter does not exist on object<duxet\Rethinkdb\Query>? Since you implemented __call, maybe consider adding a @method annotation.

            $builder = new FilterBuilder($document);

            return $builder->compileWheres($wheres);
        });
    }

    public function buildFilter($document)
    {
        $builder = new FilterBuilder($document);

        return $builder->compileWheres($this->wheres);
    }

    /**
     * Run a truncate statement on the table.
     *
     * @return void
     */
    public function truncate()
    {
        $result = $this->query->delete()->run();

The method delete does not exist on object<duxet\Rethinkdb\Query>? Since you implemented __call, maybe consider adding a @method annotation.

        return 0 == (int) $result['errors'];
    }

    /**
     * Append one or more values to an array.
     *
     * @param mixed $column
     * @param mixed $value
     * @param bool  $unique
     *
     * @return bool
     */
    public function push($column, $value = null, $unique = false)
    {
        $operation = $unique ? 'merge' : 'append';

        $this->compileWheres();
        $result = $this->query->update([

The method update does not exist on object<duxet\Rethinkdb\Query>? Since you implemented __call, maybe consider adding a @method annotation.

            $column => r\row($column)->{$operation}($value),
        ])->run();

        return 0 == (int) $result['errors'];
    }

    /**
     * Remove one or more values from an array.
     *
     * @param mixed $column
     * @param mixed $value
     *
     * @return bool
     */
    public function pull($column, $value = null)
    {
        $this->compileWheres();
        $result = $this->query->update([

The method update does not exist on object<duxet\Rethinkdb\Query>? Since you implemented __call, maybe consider adding a @method annotation.

            $column => r\row($column)->difference([$value]),
        ])->run();

        return 0 == (int) $result['errors'];
    }

    /**
     * Force the query to only return distinct results.
     *
     * @var string|null
     *
     * @return Builder
     */
    public function distinct($column = null)
    {
        if ($column) {
            $column = ['index' => $column];
        }

        $this->query = $this->query->distinct($column);

The method distinct does not exist on object<duxet\Rethinkdb\Query>? Since you implemented __call, maybe consider adding a @method annotation.

        return $this;
    }

    /**
     * Retrieve the "count" result of the query.
     *
     * @param string $columns
     *
     * @return int
     */
    public function count($columns = null)
    {
        $this->compileWheres();
        $result = $this->query->count();

The method count does not exist on object<duxet\Rethinkdb\Query>? Since you implemented __call, maybe consider adding a @method annotation.

        return (int) $result;
    }

    /**
     * Retrieve the sum of the values of a given column.
     *
     * @param string $column
     *
     * @return mixed
     */
    public function sum($column)
    {
        $this->compileWheres();
        $result = $this->query->sum($column);

The method sum does not exist on object<duxet\Rethinkdb\Query>? Since you implemented __call, maybe consider adding a @method annotation.

        return $result;
    }

    /**
     * Retrieve the minimum value of a given column.
     *
     * @param string $column
     *
     * @return mixed
     */
    public function min($column)

This method seems to be duplicated in your project.

    {
        $this->compileWheres();
        $result = $this->query->min($column)

The method min does not exist on object<duxet\Rethinkdb\Query>? Since you implemented __call, maybe consider adding a @method annotation.

            ->getField($column)->rDefault(null)
            ->run();

        return $result;
    }

    /**
     * Retrieve the maximum value of a given column.
     *
     * @param string $column
     *
     * @return mixed
     */
    public function max($column)

This method seems to be duplicated in your project.

    {
        $this->compileWheres();
        $result = $this->query->max($column)

The method max does not exist on object<duxet\Rethinkdb\Query>? Since you implemented __call, maybe consider adding a @method annotation.

            ->getField($column)->rDefault(null)
            ->run();

        return $result;
    }

    /**
     * Retrieve the average of the values of a given column.
     *
     * @param string $column
     *
     * @return mixed
     */
    public function avg($column)
    {
        $this->compileWheres();
        $result = $this->query->avg($column)

The method avg does not exist on object<duxet\Rethinkdb\Query>? Since you implemented __call, maybe consider adding a @method annotation.

            ->rDefault(null)->run();

        return $result;
    }

    /**
     * Remove one or more fields.
     *
     * @param mixed $columns
     *
     * @return int
     */
    public function drop($columns)
    {
        if (!is_array($columns)) {
            $columns = [$columns];
        }

        $this->compileWheres();
        $result = $this->query->replace(function ($doc) use ($columns) {

The method replace does not exist on object<duxet\Rethinkdb\Query>? Since you implemented __call, maybe consider adding a @method annotation.

            return $doc->without($columns);
        })->run();

        return 0 == (int) $result['errors'];
    }

    /**
     * Add a "group by" clause to the query.
     *
     * @param array|string $column,...

There is no parameter named $column,.... Was it maybe removed?

     *
     * @return $this
     */
    public function groupBy(...$groups)

The parameter $groups is not used and could be removed.

    {
        foreach (func_get_args() as $arg) {
            $this->query->group($arg)->ungroup()->map(function ($doc) {

The method group does not exist on object<duxet\Rethinkdb\Query>? Since you implemented __call, maybe consider adding a @method annotation.

                return $doc('reduction')->nth(0);
            });
        }

        return $this;
    }

    /**
     * Add an "order by" clause to the query.
     *
     * @param string $column
     * @param string $direction
     * @param bool   $index
     *
     * @return $this
     */
    public function orderBy($column, $direction = 'asc', $index = false)
    {
        $property = $this->unions ? 'unionOrders' : 'orders';
        $direction = strtolower($direction) == 'asc' ? 'asc' : 'desc';
        $this->{$property}[] = compact('column', 'direction', 'index');

        return $this;
    }

    /**
     * Add a where between statement to the query.
     *
     * @param string $column
     * @param array  $values
     * @param string $boolean
     * @param bool   $not
     *
     * @return Builder
     */
    public function whereBetween($column, array $values, $boolean = 'and', $not = false)
    {
        $type = 'between';
        $this->wheres[] = compact('column', 'type', 'boolean', 'values', 'not');

        return $this;
    }

    /**
     * Handle dynamic method calls into the method.
     *
     * @param string $method
     * @param array  $parameters
     *
     * @return mixed
     */
    public function __call($method, $parameters)
    {
        if ($method == 'unset') {
            return call_user_func_array([$this, 'drop'], $parameters);
        }

        return parent::__call($method, $parameters);
    }
}