Bdf\Prime\Query\Query

Complexity

Total Complexity

68

Size/Duplication

Total Lines	608
Duplicated Lines	0 %

Test Coverage

Coverage

85.88%

Importance

Changes	1
Bugs	0	Features	0

39 Methods

Rating	Name	Duplication	Size	Complexity
A	min()	0	3	1
A	execute()	0	9	2
A	insert()	0	9	2
A	executeUpdate()	0	11	2
A	values()	0	8	1
A	raw()	0	3	1
A	replace()	0	5	1
A	update()	0	10	2
A	max()	0	3	1
A	paginationCount()	0	17	1
A	count()	0	3	1
A	distinct()	0	7	1
A	getBindings()	0	3	1
A	quoteIdentifier()	0	3	1
A	cacheKey()	0	3	1
A	__construct()	0	20	2
A	avg()	0	3	1
A	quote()	0	3	1
A	getPaginationColumns()	0	21	5
A	ignore()	0	5	1
A	aggregate()	0	14	2
A	delete()	0	3	1
A	sum()	0	3	1
A	orHaving()	0	5	1
A	orHavingNull()	0	3	1
A	group()	0	7	2
A	havingNotNull()	0	5	1
A	orHavingNotNull()	0	3	1
A	from()	0	17	3
A	fromAlias()	0	12	1
A	orHavingRaw()	0	3	1
B	addCommand()	0	41	10
A	__toString()	0	3	1
A	toSql()	0	3	1
A	addGroup()	0	7	2
B	toRawSql()	0	28	7
A	havingNull()	0	5	1
A	having()	0	5	1
A	havingRaw()	0	5	1

<?php

namespace Bdf\Prime\Query;

use Bdf\Prime\Connection\ConnectionInterface;
use Bdf\Prime\Exception\PrimeException;
use Bdf\Prime\Query\Compiler\Preprocessor\DefaultPreprocessor;
use Bdf\Prime\Query\Compiler\Preprocessor\PreprocessorInterface;
use Bdf\Prime\Query\Contract\Paginable;
use Bdf\Prime\Query\Contract\ReadOperation;
use Bdf\Prime\Query\Contract\WriteOperation;
use Bdf\Prime\Query\Expression\Raw;
use Bdf\Prime\Query\Extension\EntityJoinTrait;
use Bdf\Prime\Query\Extension\LimitableTrait;
use Bdf\Prime\Query\Extension\LockableTrait;
use Bdf\Prime\Query\Extension\OrderableTrait;
use Bdf\Prime\Query\Extension\PaginableTrait;
use Bdf\Prime\Query\Extension\SimpleJoinTrait;
use Doctrine\DBAL\Query\Expression\CompositeExpression;

/**
 * Sql Query
 * 
 * @package Bdf\Prime\Query

@package tag is not allowed in class comment

 * 
 * @todo comment reset un statement (ex ecraser les orders). Prendre en compte le reset du compiler

Comment refers to a TODO task

@todo tag is not allowed in class comment

 */
class Query extends AbstractQuery implements SqlQueryInterface, Paginable
{
    use EntityJoinTrait;
    use PaginableTrait;
    use LimitableTrait;
    use OrderableTrait;
    use SimpleJoinTrait;
    use LockableTrait;

    /**
     * Initializes a new <tt>Query</tt>.
     *
     * @param ConnectionInterface $connection The DBAL Connection.
     * @param PreprocessorInterface|null $preprocessor
     */
    public function __construct(ConnectionInterface $connection, PreprocessorInterface $preprocessor = null)
    {
        parent::__construct($connection, $preprocessor ?: new DefaultPreprocessor());

Inline shorthand IF statement requires brackets around comparison

        $this->statements = [
            'ignore'     => null,
            'replace'    => null,
            'values'     => [],
            'columns'    => [],
            'distinct'   => null,
            'tables'     => [],
            'joins'      => [],
            'where'      => [],
            'groups'     => [],
            'having'     => [],
            'orders'     => [],
            'limit'      => null,
            'offset'     => null,
            'aggregate'  => null,
            'lock'       => null,
        ];
    }

    /**
     * {@inheritdoc}
     */
    public function getBindings()
    {
        return $this->compiler->getBindings($this);
    }

    /**

Parameter $sql should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function raw($sql)
    {
        return new Raw($sql);
    }

    /**

Parameter $value should have a doc-comment as per coding-style.

Parameter $type should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function quote($value, $type = null)
    {
        return $this->compiler->quote($value, $type);

The method quote() does not exist on Bdf\Prime\Query\Compiler\CompilerInterface. It seems like you code against a sub-type of Bdf\Prime\Query\Compiler\CompilerInterface such as Bdf\Prime\Query\Compiler\SqlCompiler.

    }

    /**

Parameter $column should have a doc-comment as per coding-style.

     * {@inheritdoc}
     *
     * @todo Utile ?

Comment refers to a TODO task

     */
    public function quoteIdentifier($column)
    {
        return $this->compiler->quoteIdentifier($this, $column);
    }

    /**
     * {@inheritdoc}
     */
    #[WriteOperation]

67% of this comment could be valid code. Did you maybe forget this after debugging?

Perl-style comments are not allowed; use "// Comment" instead

Perl-style comments are not allowed. Use "// Comment." or "/* comment */" instead.

    public function delete()

You must use "/**" style comments for a function comment

    {
        return $this->executeUpdate(self::TYPE_DELETE);
    }

    /**
     * {@inheritdoc}
     */
    #[WriteOperation]

67% of this comment could be valid code. Did you maybe forget this after debugging?

Perl-style comments are not allowed; use "// Comment" instead

Perl-style comments are not allowed. Use "// Comment." or "/* comment */" instead.

    public function update(array $data = [], array $types = [])

You must use "/**" style comments for a function comment

    {
        if ($data) {

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

            $this->statements['values'] = [
                'data'   => $data,
                'types'  => $types,
            ];
        }
        
        return $this->executeUpdate(self::TYPE_UPDATE);
    }

    /**
     * {@inheritdoc}
     */
    #[WriteOperation]

67% of this comment could be valid code. Did you maybe forget this after debugging?

Perl-style comments are not allowed; use "// Comment" instead

Perl-style comments are not allowed. Use "// Comment." or "/* comment */" instead.

    public function insert(array $data = [])

You must use "/**" style comments for a function comment

    {
        if ($data) {

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

            $this->statements['values'] = [
                'data'   => $data,
            ];
        }
        
        return $this->executeUpdate(self::TYPE_INSERT);
    }

    /**

Parameter $flag should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function ignore($flag = true)
    {
        $this->statements['ignore'] = (bool)$flag;

Expected 1 space(s) after cast statement; 0 found

        
        return $this;
    }

    /**
     * {@inheritdoc}
     */
    #[WriteOperation]

67% of this comment could be valid code. Did you maybe forget this after debugging?

Perl-style comments are not allowed; use "// Comment" instead

Perl-style comments are not allowed. Use "// Comment." or "/* comment */" instead.

    public function replace(array $values = [])

You must use "/**" style comments for a function comment

    {
        $this->statements['replace'] = true;

        return $this->insert($values);
    }

    /**
     * Set values to insert or update
     *
     * @todo Remonter sur une interface ?

Comment refers to a TODO task

     *
     * <code>
     * // Perform a INSERT INTO ... SELECT ... query
     * $query
     *     ->from('users_bck')
     *     ->values($connection->builder()->from('users'))
     *     ->insert()
     * ;
     *
     * // Perform a REPLACE INTO ... SELECT ... with column mapping
     * $query
     *     ->from('users_bck')
     *     ->values(
     *         $connection->builder()
     *             ->from('users')
     *             ->select([
     *                 'backup_name' => 'name', // Map "name" column from select table to "backup_name" column to insert table
     *                 'id'                     // Use "id" column without mapping other than ORM data mapping
     *             ])
     *     )
     *     ->replace() // Replace can also be used
     * ;
     *
     * // Simple UPDATE query
     * $query->values(['foo' => 'bar'])->update();
     * </code>
     *
     * @param QueryInterface|array $data The values, in form [column] => [value], or the SELECT query

Parameter tags must be defined first in a doc comment

     * @param array $types The binding types Do not works with INSERT INTO SELECT query
     *
     * @return $this
     */
    public function values($data = [], array $types = [])
    {
        $this->statements['values'] = [
            'data' => $data,
            'type' => $types

A comma should follow the last multiline array item. Found: $types

        ];

        return $this;
    }

    /**
     * Executes this query as an update query
     *
     * @param string $type The query type
     *
     * @return int The number of updated rows

Expected "integer" but found "int" for function return type

     *
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function executeUpdate($type)
    {
        $this->setType($type);

        $nb = $this->connection->execute($this)->count();

        if ($nb > 0) {
            $this->clearCacheOnWrite();
        }

        return $nb;
    }

    /**
     * {@inheritdoc}
     *
     * @todo Return statement instead of array ?

Comment refers to a TODO task

     */
    #[ReadOperation]

67% of this comment could be valid code. Did you maybe forget this after debugging?

Perl-style comments are not allowed; use "// Comment" instead

Perl-style comments are not allowed. Use "// Comment." or "/* comment */" instead.

    public function execute($columns = null)

You must use "/**" style comments for a function comment

    {
        if (!empty($columns)) {
            $this->select($columns);
        }

        $this->setType(self::TYPE_SELECT);

        return $this->executeCached();
    }

    /**
     * {@inheritdoc}
     */
    protected function cacheKey()
    {
        return sha1($this->toSql().'-'.serialize($this->getBindings()));
    }

    /**
     * {@inheritdoc}
     */
    #[ReadOperation]

67% of this comment could be valid code. Did you maybe forget this after debugging?

Perl-style comments are not allowed; use "// Comment" instead

Perl-style comments are not allowed. Use "// Comment." or "/* comment */" instead.

    public function paginationCount($columns = null)

You must use "/**" style comments for a function comment

    {
        $statements = $this->statements;

        $this->compilerState->invalidate(['columns', 'orders']);

        $this->statements['orders'] = [];
        $this->statements['limit'] = null;
        $this->statements['offset'] = null;
        $this->statements['aggregate'] = ['pagination', $this->getPaginationColumns($columns)];

        $count = (int)$this->execute()[0]['aggregate'];

Expected 1 space(s) after cast statement; 0 found

        $this->compilerState->invalidate(['columns', 'orders']);
        $this->statements = $statements;

        return $count;
    }

    /**
     * Get the column to count for pagination
     * @todo Voir pour count sur PK quand une entité est liée ?

Comment refers to a TODO task

There must be exactly one blank line before the tags in a doc comment

     *
     * @param array|string|null $column

Parameter tags must be defined first in a doc comment

     *
     * @return string
     */
    protected function getPaginationColumns($column)
    {
        if (!empty($column)) {
            return $column;

The expression return $column also could return the type array which is incompatible with the documented return type string.

        }

        // If distinct is on and no column are given, we use the current column
        if ($this->statements['distinct'] && !empty($this->statements['columns'])) {
            return $this->statements['columns'][0]['column'];
        }

        // If group by we use the columns of the group by
        if ($this->statements['groups']) {
            $this->statements['distinct'] = true;
            $column = $this->statements['groups'][0];
            $this->statements['groups'] = [];

            return $column;
        }

        return '*';
    }

    /**
     * {@inheritdoc}
     */
    #[ReadOperation]

67% of this comment could be valid code. Did you maybe forget this after debugging?

Perl-style comments are not allowed; use "// Comment" instead

Perl-style comments are not allowed. Use "// Comment." or "/* comment */" instead.

    public function count($column = null)

You must use "/**" style comments for a function comment

    {
        return (int)$this->aggregate(__FUNCTION__, $column);

Expected 1 space(s) after cast statement; 0 found

    }

    /**
     * {@inheritdoc}
     */
    #[ReadOperation]

67% of this comment could be valid code. Did you maybe forget this after debugging?

Perl-style comments are not allowed; use "// Comment" instead

Perl-style comments are not allowed. Use "// Comment." or "/* comment */" instead.

    public function avg($column = null)

You must use "/**" style comments for a function comment

    {
        return (float)$this->aggregate(__FUNCTION__, $column);

Expected 1 space(s) after cast statement; 0 found

    }

    /**
     * {@inheritdoc}
     */
    #[ReadOperation]

67% of this comment could be valid code. Did you maybe forget this after debugging?

Perl-style comments are not allowed; use "// Comment" instead

Perl-style comments are not allowed. Use "// Comment." or "/* comment */" instead.

    public function min($column = null)

You must use "/**" style comments for a function comment

    {
        return (float)$this->aggregate(__FUNCTION__, $column);

Expected 1 space(s) after cast statement; 0 found

    }

    /**
     * {@inheritdoc}
     */
    #[ReadOperation]

67% of this comment could be valid code. Did you maybe forget this after debugging?

Perl-style comments are not allowed; use "// Comment" instead

Perl-style comments are not allowed. Use "// Comment." or "/* comment */" instead.

    public function max($column = null)

You must use "/**" style comments for a function comment

    {
        return (float)$this->aggregate(__FUNCTION__, $column);

Expected 1 space(s) after cast statement; 0 found

    }

    /**
     * {@inheritdoc}
     */
    #[ReadOperation]

67% of this comment could be valid code. Did you maybe forget this after debugging?

Perl-style comments are not allowed; use "// Comment" instead

Perl-style comments are not allowed. Use "// Comment." or "/* comment */" instead.

    public function sum($column = null)

You must use "/**" style comments for a function comment

    {
        return (float)$this->aggregate(__FUNCTION__, $column);

Expected 1 space(s) after cast statement; 0 found

    }

    /**
     * {@inheritdoc}
     */
    #[ReadOperation]

67% of this comment could be valid code. Did you maybe forget this after debugging?

Perl-style comments are not allowed; use "// Comment" instead

Perl-style comments are not allowed. Use "// Comment." or "/* comment */" instead.

    public function aggregate($function, $column = null)

You must use "/**" style comments for a function comment

    {
        $statements = $this->statements;

        $this->compilerState->invalidate('columns');

        $this->statements['aggregate'] = [$function, $column ?: '*'];

The value of a comparison must not be assigned to a variable

Inline shorthand IF statement requires brackets around comparison

        $aggregate = $this->execute()[0]['aggregate'];

        $this->compilerState->invalidate('columns');
        $this->statements = $statements;

        return $aggregate;
    }

    /**

Parameter $flag should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function distinct($flag = true)
    {
        $this->compilerState->invalidate('columns');
        
        $this->statements['distinct'] = (bool)$flag;

Expected 1 space(s) after cast statement; 0 found

        
        return $this;
    }

    /**

Parameter $from should have a doc-comment as per coding-style.

Parameter $alias should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function from($from, $alias = null)
    {
        $this->compilerState->invalidate('from');

        $table = [
            'table' => $from,
            'alias' => $alias,
        ];
        $key = $alias ?: $from;

The value of a comparison must not be assigned to a variable

Inline shorthand IF statement requires brackets around comparison

        if (is_string($key)) {
            $this->statements['tables'][$key] = $table;
        } else {
            $this->statements['tables'][] = $table;
        }

        return $this;
    }

    /**
     * Change a FROM alias for a table (or previously defined alias)
     *
     * Usage:
     * <code>
     * // Change alias of the current table : FROM my_table as my_alias
     * $query->from('my_table')->fromAlias('my_alias');
     *
     * // Change alias of the foo table : FROM foo as my_alias, bar
     * $query->from('foo')->from('bar')->fromAlias('my_alias', 'foo');
     *
     * // Redefine alias of foo : FROM foo as my_alias, bar
     * $query->from('foo', 'f')->from('bar')->fromAlias('my_alias', 'f');
     * </code>
     *
     * @param string $alias The new alias name
     * @param string|null $table The last alias / table name. If null, will define the last table
     *
     * @return $this
     */
    public function fromAlias(string $alias, ?string $table = null)
    {
        $this->compilerState->invalidate('from');

        $table = $table ?? key($this->statements['tables']);

Operation must be bracketed

        $this->statements['tables'][$alias] = $this->statements['tables'][$table];
        $this->statements['tables'][$alias]['alias'] = $alias;

        unset($this->statements['tables'][$table]);

        return $this;
    }

    /**

Parameter $column should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function group($column)
    {
        $this->compilerState->invalidate('groups');
        
        $this->statements['groups'] = is_array($column) ? $column : func_get_args();
        
        return $this;
    }

    /**

Parameter $column should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function addGroup($column)
    {
        $this->compilerState->invalidate('groups');
        
        $this->statements['groups'] = array_merge($this->statements['groups'], is_array($column) ? $column : func_get_args());
        
        return $this;
    }

    /**

Parameter $column should have a doc-comment as per coding-style.

Parameter $operator should have a doc-comment as per coding-style.

Parameter $value should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function having($column, $operator = null, $value = null)
    {
        $this->compilerState->invalidate('having');

        return $this->buildClause('having', $column, $operator, $value);
    }

    /**

Parameter $column should have a doc-comment as per coding-style.

Parameter $operator should have a doc-comment as per coding-style.

Parameter $value should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function orHaving($column, $operator = null, $value = null)
    {
        $this->compilerState->invalidate('having');

        return $this->buildClause('having', $column, $operator, $value, CompositeExpression::TYPE_OR);
    }

    /**

Parameter $column should have a doc-comment as per coding-style.

Parameter $type should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function havingNull($column, $type = CompositeExpression::TYPE_AND)
    {
        $this->compilerState->invalidate('having');

        return $this->buildClause('having', $column, '=', null, $type);
    }

    /**

Parameter $column should have a doc-comment as per coding-style.

Parameter $type should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function havingNotNull($column, $type = CompositeExpression::TYPE_AND)
    {
        $this->compilerState->invalidate('having');

        return $this->buildClause('having', $column, '!=', null, $type);
    }

    /**

Parameter $column should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function orHavingNull($column)
    {
        return $this->havingNull($column, CompositeExpression::TYPE_OR);
    }

    /**

Parameter $column should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function orHavingNotNull($column)
    {
        return $this->havingNotNull($column, CompositeExpression::TYPE_OR);
    }

    /**

Parameter $raw should have a doc-comment as per coding-style.

Parameter $type should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function havingRaw($raw, $type = CompositeExpression::TYPE_AND)
    {
        $this->compilerState->invalidate('having');

        return $this->buildRaw('having', $raw, $type);
    }

    /**

Parameter $raw should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function orHavingRaw($raw)
    {
        return $this->havingRaw($raw, CompositeExpression::TYPE_OR);
    }

    /**

Parameter $command should have a doc-comment as per coding-style.

Parameter $value should have a doc-comment as per coding-style.

     * {@inheritdoc}
     */
    public function addCommand($command, $value)
    {
        switch ($command) {
            case ':limit':
                if (is_array($value)) {
                    $this->limit($value[0], $value[1]);
                } else {
                    $this->limit($value);
                }
                break;

Case breaking statement indented incorrectly; expected 14 spaces, found 16

            
            case ':limitPage':
                if (is_array($value)) {
                    $this->limitPage($value[0], $value[1]);
                } else {
                    $this->limitPage($value);
                }
                break;

Case breaking statement indented incorrectly; expected 14 spaces, found 16

            
            case ':offset':
                $this->offset($value);
                break;

Case breaking statement indented incorrectly; expected 14 spaces, found 16

            
            case ':order':
                $this->order($value);
                break;

Case breaking statement indented incorrectly; expected 14 spaces, found 16

            
            case ':distinct':
                $this->distinct($value);
                break;

Case breaking statement indented incorrectly; expected 14 spaces, found 16

                
            case ':group':
                $this->group($value);
                break;

Case breaking statement indented incorrectly; expected 14 spaces, found 16

            
            case ':having':
                $this->having($value);
                break;

Case breaking statement indented incorrectly; expected 14 spaces, found 16

        }

End comment for long condition not found; expected "//end switch"

        
        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function toSql()
    {
        return $this->compile();
    }

    /**
     * {@inheritdoc}
     * @todo A reprendre: utiliser les types des bindings

Comment refers to a TODO task

There must be exactly one blank line before the tags in a doc comment

     */
    public function toRawSql()
    {
        $keys   = [];
        $sql    = $this->toSql();
        $values = $this->compiler->getBindings($this);

        # build a regular expression for each parameter

Perl-style comments are not allowed; use "// Comment" instead

Perl-style comments are not allowed. Use "// Comment." or "/* comment */" instead.

        foreach ($values as $key => $value) {
            if (is_string($key)) {
                $keys[] = '/:' . $key . '/';
            } else {
                $keys[] = '/[?]/';
            }
            
            if (is_array($value)) {
                $values[$key] = implode(',', $this->connection->quote($value));

The method quote() does not exist on Bdf\Prime\Connection\ConnectionInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Bdf\Prime\Connection\ConnectionInterface.

            } elseif (is_null($value)) {

Usage of ELSEIF not allowed; use ELSE IF instead

                $values[$key] = 'NULL';
            } elseif ($value instanceof \DateTimeInterface) {

Usage of ELSEIF not allowed; use ELSE IF instead

                $values[$key] = $value->format($this->connection->platform()->grammar()->getDateTimeFormatString());
            } elseif (is_string($value)) {

Usage of ELSEIF not allowed; use ELSE IF instead

                $values[$key] = $this->connection->quote($value);
            } else {
                $values[$key] = $value;
            }
        }
        
        return preg_replace($keys, $values, $sql, 1);
    }
    
    /**
     * Gets a string representation of this Query which corresponds to
     * the final SQL query being constructed.

Doc comment short description must be on a single line, further text should be a separate paragraph

     *
     * @return string The string representation of this Query.
     */
    public function __toString()
    {
        return $this->toSql();
    }
}