Bdf\Prime\Query\Compiler\SqlCompiler

Complexity

Total Complexity

183

Size/Duplication

Total Lines	1086
Duplicated Lines	0 %

Test Coverage

Coverage

95.44%

Importance

Changes	1
Bugs	0	Features	0

38 Methods

Rating	Name	Duplication	Size	Complexity
A	compileInsertValues()	0	21	3
A	quoteIdentifier()	0	7	2
B	compileColumns()	0	29	7
A	quoteIdentifiers()	0	7	2
A	compileInsertSelect()	0	22	5
A	isComplexAggregate()	0	3	3
A	compileComplexAggregate()	0	8	2
A	doCompileDelete()	0	7	1
A	doCompileInsert()	0	17	6
F	doCompileSelect()	0	58	11
B	compileAggregate()	0	29	11
A	compileInsertData()	0	10	2
A	doCompileUpdate()	0	10	1
A	compileUpdateValues()	0	15	2
A	quote()	0	3	1
C	compileInExpression()	0	39	12
A	compileFrom()	0	17	3
A	getDatabaseNamePrefix()	0	7	4
B	compileCompilableClauses()	0	44	8
A	compileIntoExpression()	0	11	2
F	compileExpression()	0	121	45
A	addQueryBindings()	0	7	2
A	bindRaw()	0	5	1
A	compileWhere()	0	7	2
A	compileGroup()	0	13	3
A	compileRawValue()	0	11	3
A	compileExpressionColumn()	0	22	6
A	bindTyped()	0	3	1
A	compileExpressionValue()	0	11	4
A	compileTableAndAliasClause()	0	23	4
A	mergeBindings()	0	15	4
A	compileJoins()	0	13	3
A	compileLock()	0	18	5
A	getBindings()	0	3	1
A	compileTypedValue()	0	11	3
A	compileSubQuery()	0	12	2
A	compileHaving()	0	7	2
A	compileOrder()	0	19	4

<?php

namespace Bdf\Prime\Query\Compiler;

use Bdf\Prime\Exception\PrimeException;
use Bdf\Prime\Query\CommandInterface;
use Bdf\Prime\Query\CompilableClause;
use Bdf\Prime\Query\Expression\ExpressionInterface;
use Bdf\Prime\Query\Expression\ExpressionTransformerInterface;
use Bdf\Prime\Query\QueryInterface;
use Bdf\Prime\Types\TypeInterface;
use Doctrine\DBAL\LockMode;
use Doctrine\DBAL\Query\Expression\CompositeExpression;
use UnexpectedValueException;

/**
 * SqlCompiler
 *
 * @author seb

@author tag is not allowed in class comment

The tag in position 1 should be the @package tag

Content of the @author tag must be in the form "Display Name <username@example.com>"

 * @package Bdf\Prime\Query\Compiler

@package tag is not allowed in class comment

 */
class SqlCompiler extends AbstractCompiler
{
    /**
     * Quote a value
     * 
     * @param mixed $value
     *
     * @return string
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    public function quote($value)

Expected 1 blank line before function; 0 found

    {
        return $this->connection->quote($this->autoConvertValue($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.

    }
    
    /**

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

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

     * {@inheritdoc}
     */
    public function quoteIdentifier(CompilableClause $query, $column)
    {
        if (!$query->isQuoteIdentifier()) {
            return $column;
        }

        return $this->platform()->grammar()->quoteIdentifier($column);
    }
    
    /**
     * Quote a identifier on multiple columns
     *
     * @param CompilableClause $query
     * @param array $columns
     *
     * @return array
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    public function quoteIdentifiers(CompilableClause $query, array $columns)
    {
        if (!$query->isQuoteIdentifier()) {
            return $columns;
        }

        return array_map([$this->platform()->grammar(), 'quoteIdentifier'], $columns);
    }
    
    /**

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

     * {@inheritdoc}
     */
    protected function doCompileInsert(CompilableClause $query)
    {
        $query->state()->currentPart = 0;

        if ($query->statements['ignore'] && $this->platform()->grammar()->getReservedKeywordsList()->isKeyword('IGNORE')) {
            if ($this->platform()->grammar()->getName() === 'sqlite') {
                $insert = 'INSERT OR IGNORE INTO ';
            } else {
                $insert = 'INSERT IGNORE INTO ';
            }
        } elseif ($query->statements['replace'] && $this->platform()->grammar()->getReservedKeywordsList()->isKeyword('REPLACE')) {

Usage of ELSEIF not allowed; use ELSE IF instead

            $insert = 'REPLACE INTO ';
        } else {
            $insert = 'INSERT INTO ';
        }

        return $query->state()->compiled = $insert.$this->quoteIdentifier($query, $query->statements['tables'][0]['table']).$this->compileInsertData($query);

Assignments must be the first block of code on a line

    }

    /**
     * Compile the data part of the insert query
     *
     * @param CompilableClause $query
     *
     * @return string
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function compileInsertData(CompilableClause $query)
    {
        // @todo Do not use QueryInterface

Comments for TODO tasks are often forgotten in the code; it might be better to use a dedicated issue tracker.

        if ($query->statements['values']['data'] instanceof QueryInterface) {
            return $this->compileInsertSelect($query);
        }

        list($columns, $values) = $this->compileInsertValues($query);

        return ' ('.implode(', ', $columns).') VALUES('.implode(', ', $values).')';
    }

    /**
     * Compile an INSERT INTO ... SELECT ... query
     *
     * @param CompilableClause $query
     *
     * @return string
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function compileInsertSelect(CompilableClause $query)
    {
        $select = clone $query->statements['values']['data']; // Clone the query for ensure that it'll not be modified

Comments may not appear after statements

        $columns = [];

        // Columns are defined on the select query
        // Alias of the selected columns will be concidered as the INSERT table columns
        if ($select->statements['columns'] && $select->statements['columns'][0]['column'] !== '*') {
            foreach ($select->statements['columns'] as &$column) {
                $alias = $query->preprocessor()->field($column['alias'] ?? $column['column']);

Operation must be bracketed

                // Modify the column alias to match with the INSERT column
                $column['alias'] = $alias;

                $columns[] = $this->quoteIdentifier($query, $alias);
            }
        }

        $sql = ' '.$this->compileSelect($select); // @todo Ensure that the query is sql compilable

Comments for TODO tasks are often forgotten in the code; it might be better to use a dedicated issue tracker.

Comments may not appear after statements

        $this->addQueryBindings($query, $select);

        return empty($columns) ? $sql : ' ('.implode(', ', $columns).')'.$sql;
    }

    /**
     * Compile columns and values to insert
     *
     * @param CompilableClause $query
     *
     * @return array
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function compileInsertValues(CompilableClause $query)
    {
        $data = $query->statements['values'];

        $columns = [];
        $values = [];

        foreach ($data['data'] as $column => $value) {
            $type = $data['types'][$column] ?? true;

Operation must be bracketed

            $column = $query->preprocessor()->field($column, $type);

            // The type cannot be resolved by preprocessor
            if ($type === true) {
                $type = null;
            }

            $columns[] = $this->quoteIdentifier($query, $column);
            $values[]  = $this->compileTypedValue($query, $value, $type);
        }

        return [$columns, $values];
    }

    /**

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

     * {@inheritdoc}
     */
    protected function doCompileUpdate(CompilableClause $query)
    {
        $query->state()->currentPart = 0;

        $values = $this->compileUpdateValues($query);

        return $query->state()->compiled = 'UPDATE '

Assignments must be the first block of code on a line

            . $this->quoteIdentifier($query, $query->statements['tables'][0]['table'])
            . ' SET ' . implode(', ', $values)
            . $this->compileWhere($query);
    }

    /**
     * Compile columns and values to update
     *
     * @param CompilableClause $query
     *
     * @return array
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function compileUpdateValues(CompilableClause $query)
    {
        $data = $query->statements['values'];
        $values = [];

        foreach ($data['data'] as $column => $value) {
            $type = $data['types'][$column] ?? true;

Operation must be bracketed

            $column = $query->preprocessor()->field($column, $type);

            $values[] = $this->quoteIdentifier($query, $column)
                . ' = '
                . $this->compileTypedValue($query, $value, $type);
        }

        return $values;
    }

    /**

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

     * {@inheritdoc}
     */
    protected function doCompileDelete(CompilableClause $query)
    {
        $query->state()->currentPart = 0;

        return $query->state()->compiled = 'DELETE FROM '

Assignments must be the first block of code on a line

            . $this->quoteIdentifier($query, $query->statements['tables'][0]['table'])
            . $this->compileWhere($query);
    }
    
    /**

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

     * {@inheritdoc}
     */
    protected function doCompileSelect(CompilableClause $query)
    {
        if ($this->isComplexAggregate($query)) {
            return $query->state()->compiled = $this->compileComplexAggregate($query);

Assignments must be the first block of code on a line

        }

        if (!isset($query->state()->compiledParts['columns'])) {
            $query->state()->currentPart = 'columns';
            $query->state()->compiledParts['columns'] = $this->compileColumns($query);
        }

        if (!isset($query->state()->compiledParts['from'])) {
            $query->state()->compiledParts['from'] = $this->compileFrom($query);
        }

        if (!isset($query->state()->compiledParts['groups'])) {
            $query->state()->currentPart = 'groups';
            $query->state()->compiledParts['groups'] = $this->compileGroup($query);
        }

        if (!isset($query->state()->compiledParts['having'])) {
            $query->state()->currentPart = 'having';
            $query->state()->compiledParts['having'] = $this->compileHaving($query);
        }

        if (!isset($query->state()->compiledParts['orders'])) {
            $query->state()->currentPart = 'orders';
            $query->state()->compiledParts['orders'] = $this->compileOrder($query);
        }

        if (!isset($query->state()->compiledParts['where'])) {
            $query->state()->currentPart = 'where';
            $query->state()->compiledParts['where'] = $this->compileWhere($query);
        }

        if (!isset($query->state()->compiledParts['joins'])) {
            $query->state()->currentPart = 'joins';
            $query->state()->compiledParts['joins'] = $this->compileJoins($query);
        }

        if (!isset($query->state()->compiledParts['lock'])) {
            $query->state()->currentPart = 'lock';
            $query->state()->compiledParts['lock'] = $this->compileLock($query);
        }

        $sql = $query->state()->compiledParts['columns']
                .$query->state()->compiledParts['from']
                .$query->state()->compiledParts['joins']
                .$query->state()->compiledParts['where']
                .$query->state()->compiledParts['groups']
                .$query->state()->compiledParts['having']
                .$query->state()->compiledParts['orders'];

        if ($query->isLimitQuery()) {

The method isLimitQuery() does not exist on Bdf\Prime\Query\CompilableClause. It seems like you code against a sub-type of Bdf\Prime\Query\CompilableClause such as Bdf\Prime\Query\AbstractReadCommand.

            $sql = $this->platform()->grammar()->modifyLimitQuery($sql, $query->statements['limit'], $query->statements['offset']);
        }

        return $query->state()->compiled = $sql.$query->state()->compiledParts['lock'];

Assignments must be the first block of code on a line

    }

    /**
     * Check if the the query is an aggregate which requires to execute the query as temporary table
     * A temporary table is required for DISTINT aggregate with wildcard "*" column

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

     *
     * @param CompilableClause $query
     *
     * @return bool

Expected "boolean" but found "bool" for function return type

     */
    protected function isComplexAggregate(CompilableClause $query)
    {
        return isset($query->statements['aggregate']) && $query->statements['aggregate'][1] === '*' && $query->statements['distinct'];

Boolean operators are not allowed outside of control structure conditions

    }

    /**
     * Compile the complexe aggregate query
     * Will generate a query in form : "SELECT [aggregate](*) FROM ([query])"

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

     *
     * @param CompilableClause $query
     *
     * @return string
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function compileComplexAggregate(CompilableClause $query)
    {
        list($function, $column) = $query->statements['aggregate'];

        $query->statements['aggregate'] = null;
        $query->statements['columns'] = $column === '*' ? [] : [['column' => $column, 'alias' => null]];

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

Inline shorthand IF statement requires brackets around comparison

        return 'SELECT '.$this->compileAggregate($query, $function, '*', false).' FROM ('.$this->doCompileSelect($query).') as derived_query';
    }

    /**
     * @param CompilableClause $query
     *
     * @return string
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function compileColumns(CompilableClause $query)
    {
        if (!empty($query->statements['aggregate'])) {
            return 'SELECT '.$this->compileAggregate($query, $query->statements['aggregate'][0], $query->statements['aggregate'][1], $query->statements['distinct']);
        }

        if ($query->statements['distinct'] && $this->platform()->grammar()->getReservedKeywordsList()->isKeyword('DISTINCT')) {
            $select = 'SELECT DISTINCT ';
        } else {
            $select = 'SELECT ';
        }
        
        if (empty($query->statements['columns'])) {
            $root = $query->preprocessor()->root();

            if ($root) {
                $select .= $this->quoteIdentifier($query, $root).'.';
            }

            return $select.'*';
        }

        $sql = [];
        
        foreach ($query->statements['columns'] as $column) {
            $sql[] = $this->compileExpressionColumn($query, $column['column'], $column['alias']);
        }
        
        return $select.implode(', ', $sql);
    }

    /**
     * Compile a SQL function
     *
     * @param CompilableClause $query
     * @param string $function  The sql function
     * @param string $column    The column to aggregate
     * @param bool   $distinct  The distinct status

Expected "boolean" but found "bool" for parameter type

     *
     * @return string
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function compileAggregate(CompilableClause $query, $function, $column, $distinct)
    {
        if ($column !== '*') {
            $column = $query->preprocessor()->field($column);
            $column = $this->quoteIdentifier($query, $column);

            if ($distinct && $this->platform()->grammar()->getReservedKeywordsList()->isKeyword('DISTINCT')) {
                // Le count ne compte pas les fields qui ont une valeur NULL.
                // Pour une pagination, il est important de compter les valeurs null sachant qu'elles seront sélectionnées.
                // La pagination utilise une column que pour le distinct.
                if ($function === 'pagination') {
                    $column = 'IFNULL('.$column.',"___null___")';
                }

                $column = 'DISTINCT '.$column;
            }
        }

        switch ($function) {
            case 'avg'  :      return $this->platform()->grammar()->getAvgExpression($column).' AS aggregate';

There must be no space before the colon in a CASE statement

The case body in a switch statement must start on the line following the statement.

Case breaking statements must be followed by a single blank line

Terminating statement must be on a line by itself

            case 'count':      return $this->platform()->grammar()->getCountExpression($column).' AS aggregate';

The case body in a switch statement must start on the line following the statement.

Case breaking statements must be followed by a single blank line

Terminating statement must be on a line by itself

            case 'max'  :      return $this->platform()->grammar()->getMaxExpression($column).' AS aggregate';

There must be no space before the colon in a CASE statement

The case body in a switch statement must start on the line following the statement.

Case breaking statements must be followed by a single blank line

Terminating statement must be on a line by itself

            case 'min'  :      return $this->platform()->grammar()->getMinExpression($column).' AS aggregate';

There must be no space before the colon in a CASE statement

The case body in a switch statement must start on the line following the statement.

Case breaking statements must be followed by a single blank line

Terminating statement must be on a line by itself

            case 'pagination': return $this->platform()->grammar()->getCountExpression($column).' AS aggregate';

The case body in a switch statement must start on the line following the statement.

Case breaking statements must be followed by a single blank line

Terminating statement must be on a line by itself

            case 'sum'  :      return $this->platform()->grammar()->getSumExpression($column).' AS aggregate';

There must be no space before the colon in a CASE statement

The case body in a switch statement must start on the line following the statement.

Terminating statement must be on a line by itself

            default:
                $method = 'get'.ucfirst($function).'Expression';
                return $this->platform()->grammar()->{$method}($column).' AS aggregate';

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

        }
    }

    /**
     * Compile expression column
     *
     * @param CompilableClause $query
     * @param mixed $column
     * @param string $alias
     * 
     * @return string
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function compileExpressionColumn(CompilableClause $query, $column, $alias = null)
    {
        if ($column instanceof QueryInterface) {
            return $this->compileSubQuery($query, $column, $alias);
        }
        
        if ($column instanceof ExpressionInterface) {
            return $alias !== null
                ? $column->build($query, $this).' as '.$this->quoteIdentifier($query, $alias)

Inline shorthand IF statement must be declared on a single line

                : $column->build($query, $this)

Space after closing parenthesis of function call prohibited

            ;

Space found before semicolon; expected ");" but found ")
;"

        }

        $column = $query->preprocessor()->field($column);
        
        if (strpos($column, '*') !== false) {
            return $column;
        }
        
        return $alias !== null
            ? $this->quoteIdentifier($query, $column).' as '.$this->quoteIdentifier($query, $alias)

Inline shorthand IF statement must be declared on a single line

            : $this->quoteIdentifier($query, $column)

Space after closing parenthesis of function call prohibited

        ;

Space found before semicolon; expected ");" but found ")
;"

    }
    
    /**
     * @param CompilableClause $query
     *
     * @return string
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function compileFrom(CompilableClause $query)
    {
        $sql = ' FROM ';
        $isFirst = true;

        // Loop through all FROM clauses
        foreach ($this->compileTableAndAliasClause($query, $query->statements['tables']) as $from) {
            if (!$isFirst) {
                $sql .= ', ';
            } else {
                $isFirst = false;
            }

            $sql .= $from['sql'];
        }

        return $sql;
    }

    /**
     * @param CompilableClause $query
     *
     * @return string
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function compileJoins(CompilableClause $query)
    {
        if (empty($query->statements['joins'])) {
            return '';
        }

        $sql = '';

        foreach ($this->compileTableAndAliasClause($query, $query->statements['joins']) as $join) {
            $sql .= ' '.$join['type'].' JOIN '.$join['sql'].' ON '.$this->compileCompilableClauses($query, $join['on']);
        }

        return $sql;
    }

    /**
     * Compile clauses with 'table' and 'alias' keys
     *
     * The table name will be resolved, quoted, and generate the alias if present
     * Duplicate table name or aliases will also be removed from result

Doc comment long description must end with a full stop

     *
     * The compiled table expression will be returned into the 'sql' key
     * All input parameter will be kept on the return value
     *
     * @param CompilableClause $query
     * @param array $clauses
     *
     * @return array
     *
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function compileTableAndAliasClause(CompilableClause $query, array $clauses): array
    {
        $databasePrefix = $this->getDatabaseNamePrefix($query);
        $compiled = [];

        foreach ($clauses as $from) {
            if ($from['table'] instanceof QueryInterface) {
                $from['sql'] = $this->compileSubQuery($query, $from['table'], $from['alias']);
                $compiled[] = $from;
            } else {
                $from = $query->preprocessor()->table($from);

                if ($from['alias'] === null) {
                    $from['sql'] = $this->quoteIdentifier($query, $databasePrefix.$from['table']);
                    $compiled[$from['table']] = $from;
                } else {
                    $from['sql'] = $this->quoteIdentifier($query, $databasePrefix.$from['table']) . ' ' . $this->quoteIdentifier($query, $from['alias']);
                    $compiled[$from['alias']] = $from;
                }
            }
        }

        return $compiled;
    }

    /**
     * Adding database prefix for sub query x-db
     *
     * @param CompilableClause $query
     *
     * @return string
     */
    protected function getDatabaseNamePrefix(CompilableClause $query): string
    {
        if ($query instanceof CommandInterface && $query->compiler() !== $this && $query->connection()->getDatabase() !== $this->connection->getDatabase()) {
            return $query->connection()->getDatabase().'.';
        }

        return '';
    }

    /**
     * Compile Where sql
     * 
     * @param CompilableClause $query
     * 
     * @return string
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function compileWhere(CompilableClause $query)
    {
        if (empty($query->statements['where'])) {
            return '';
        }
        
        return ' WHERE '.$this->compileCompilableClauses($query, $query->statements['where']);
    }

    /**
     * Compile having sql
     * 
     * @param CompilableClause $query
     * 
     * @return string
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function compileHaving(CompilableClause $query)
    {
        if (empty($query->statements['having'])) {
            return '';
        }
        
        return ' HAVING '.$this->compileCompilableClauses($query, $query->statements['having']);
    }

    /**
     * @param CompilableClause $query
     * @param array $clauses
     *
     * @return string
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function compileCompilableClauses(CompilableClause $query, array &$clauses)
    {
        $sql = [];
        $i = 0;

        // Permet de retirer le niveau du nested
        if (count($clauses) === 1 && isset($clauses[0]['nested'])) {
            $result = $this->compileCompilableClauses($query, $clauses[0]['nested']);
            /*

Empty line required before block comment

             * We check he if where expression has added constraints (from relation).

Unnecessarily gendered language in a comment

             * If we still have one clause, we return the compiled sql
             * Otherwise we start the loop of clauses.
             */

Empty line required after block comment

            if (count($clauses) === 1) {
                return $result;
            }

            // Add the nested level
            $sql[] = '('.$result.')';
            $i = 1;
        }

        $clauses[0]['glue'] = null;

        //Cannot use foreach because where expression can add new relations with constraints

No space found before comment text; expected "// Cannot use foreach because where expression can add new relations with constraints" but found "//Cannot use foreach because where expression can add new relations with constraints"

        for (; isset($clauses[$i]); ++$i) {
            $part = $clauses[$i];

            if ($part['glue'] !== null) {
                $part['glue'] .= ' ';
            }

            $part = $query->preprocessor()->expression($part);
            
            if (isset($part['nested'])) {
                $sql[] = $part['glue'].'('.$this->compileCompilableClauses($query, $part['nested']).')';
            } elseif (!isset($part['raw'])) {

Usage of ELSEIF not allowed; use ELSE IF instead

                $sql[] = $part['glue'].$this->compileExpression($query, $part['column'], $part['operator'], $part['value'], $part['converted'] ?? false);

Operation must be bracketed

            } else {
                $sql[] = $part['glue'].$this->compileRawValue($query, $part['raw']);
            }
        }
        
        return implode(' ', $sql);
    }

    /**
     * Determine which operator to use based on custom and standard syntax
     *
     * @param CompilableClause $query
     * @param string $column
     * @param string $operator
     * @param mixed  $value
     * @param bool $converted

Expected "boolean" but found "bool" for parameter type

     * 
     * @return string  operator found
     * 
     * @throws UnexpectedValueException

Comment missing for @throws tag in function comment

     * @throws PrimeException

Comment missing for @throws tag in function comment

     */

Expected 1 @throws tag(s) in function comment; 2 found

    protected function compileExpression(CompilableClause $query, $column, $operator, $value, $converted)
    {
        if ($value instanceof ExpressionTransformerInterface) {
            $value->setContext($this, $column, $operator);

            $column    = $value->getColumn();
            $operator  = $value->getOperator();
            $value     = $value->getValue();
            $converted = true;
        }

        switch ($operator) {
            case '<':
            case ':lt':
                if (is_array($value)) {
                    return $this->compileIntoExpression($query, $value, $column, '<', $converted);
                }
                return $this->quoteIdentifier($query, $column).' < '.$this->compileExpressionValue($query, $value, $converted);

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

            case '<=':
            case ':lte':
                if (is_array($value)) {
                    return $this->compileIntoExpression($query, $value, $column, '<=', $converted);
                }
                return $this->quoteIdentifier($query, $column).' <= '.$this->compileExpressionValue($query, $value, $converted);

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

            case '>':
            case ':gt':
                if (is_array($value)) {
                    return $this->compileIntoExpression($query, $value, $column, '>', $converted);
                }
                return $this->quoteIdentifier($query, $column).' > '.$this->compileExpressionValue($query, $value, $converted);

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

            case '>=':
            case ':gte':
                if (is_array($value)) {
                    return $this->compileIntoExpression($query, $value, $column, '>=', $converted);
                }
                return $this->quoteIdentifier($query, $column).' >= '.$this->compileExpressionValue($query, $value, $converted);

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

            // REGEX matching
            case '~=':
            case '=~':
            case ':regex':
                if (is_array($value)) {
                    return $this->compileIntoExpression($query, $value, $column, 'REGEXP', $converted);
                }
                return $this->quoteIdentifier($query, $column).' REGEXP '.$this->compileExpressionValue($query, (string)$value, $converted);

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

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

            // LIKE
            case ':like':
                if (is_array($value)) {
                    return $this->compileIntoExpression($query, $value, $column, 'LIKE', $converted);
                }
                return $this->quoteIdentifier($query, $column).' LIKE '.$this->compileExpressionValue($query, $value, $converted);

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

            // NOT LIKE
            case ':notlike':
            case '!like':
                if (is_array($value)) {
                    return $this->compileIntoExpression($query, $value, $column, 'NOT LIKE', $converted, CompositeExpression::TYPE_AND);
                }
                return $this->quoteIdentifier($query, $column).' NOT LIKE '.$this->compileExpressionValue($query, $value, $converted);

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

            // In
            case 'in':
            case ':in':
                if (empty($value)) {
                    return $this->platform()->grammar()->getIsNullExpression($this->quoteIdentifier($query, $column));
                }
                return $this->compileInExpression($query, $value, $column, 'IN', $converted);

It seems like $value can also be of type string; however, parameter $values of Bdf\Prime\Query\Compiler\SqlCompiler::compileInExpression() does only seem to accept Bdf\Prime\Query\Expression\ExpressionInterface|Bdf\Prime\Query\QueryInterface|array, maybe add an additional type check?

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

            // Not in
            case 'notin':
            case '!in':
            case ':notin':
                if (empty($value)) {
                    return $this->platform()->grammar()->getIsNotNullExpression($this->quoteIdentifier($query, $column));
                }
                return $this->compileInExpression($query, $value, $column, 'NOT IN', $converted);

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

            // Between
            case 'between':
            case ':between':
                if (is_array($value)) {
                    return $this->platform()->grammar()->getBetweenExpression($this->quoteIdentifier($query, $column), $this->compileExpressionValue($query, $value[0], $converted), $this->compileExpressionValue($query, $value[1], $converted));
                }
                return $this->platform()->grammar()->getBetweenExpression($this->quoteIdentifier($query, $column), 0, $this->compileExpressionValue($query, $value, $converted));

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

            // Not between
            case '!between':
            case ':notbetween':
                return $this->platform()->grammar()->getNotExpression($this->compileExpression($query, $column, ':between', $value, $converted));

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

            // Not equal
            case '<>':
            case '!=':
            case ':ne':
            case ':not':
                if (is_null($value)) {
                    return $this->platform()->grammar()->getIsNotNullExpression($this->quoteIdentifier($query, $column));
                }

No blank line found after control structure

                if (is_array($value)) {
                    return $this->compileExpression($query, $column, ':notin', $value, $converted);
                }
                return $this->quoteIdentifier($query, $column).' != '.$this->compileExpressionValue($query, $value, $converted);

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

            // Equals
            case '=':
            case ':eq':
                if (is_null($value)) {
                    return $this->platform()->grammar()->getIsNullExpression($this->quoteIdentifier($query, $column));
                }

No blank line found after control structure

                if (is_array($value)) {
                    return $this->compileExpression($query, $column, ':in', $value, $converted);
                }
                return $this->quoteIdentifier($query, $column).' = '.$this->compileExpressionValue($query, $value, $converted);

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

                
            // Unsupported operator
            default:
                throw new UnexpectedValueException("Unsupported operator '" . $operator . "' in WHERE clause");

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

        }

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

    }

    /**
     * Compile expression value
     *
     * @param CompilableClause $query
     * @param mixed $value
     * @param bool $converted Does the value is already converted to database ?

Expected "boolean" but found "bool" for parameter type

     * 
     * @return string
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function compileExpressionValue(CompilableClause $query, $value, bool $converted)
    {
        if ($value instanceof QueryInterface) {
            return $this->compileSubQuery($query, $value);
        }

        if ($value instanceof ExpressionInterface) {
            return $value->build($query, $this);
        }

        return $converted ? $this->bindRaw($query, $value) : $this->bindTyped($query, $value, null);

Inline shorthand IF statement requires brackets around comparison

    }

    /**
     * Compile expression value with type
     *
     * @param CompilableClause $query
     * @param mixed $value
     * @param TypeInterface|null $type The type. If null it will be resolved from value
     *
     * @return string
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function compileTypedValue(CompilableClause $query, $value, ?TypeInterface $type)
    {
        if ($value instanceof QueryInterface) {
            return $this->compileSubQuery($query, $value);
        }

        if ($value instanceof ExpressionInterface) {
            return $value->build($query, $this);
        }

        return $this->bindTyped($query, $value, $type);
    }

    /**
     * Compile raw expression value
     *
     * @param CompilableClause $query
     * @param mixed $value
     * 
     * @return string
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function compileRawValue(CompilableClause $query, $value)
    {
        if ($value instanceof QueryInterface) {
            return $this->compileSubQuery($query, $value);
        }
        
        if ($value instanceof ExpressionInterface) {
            return $value->build($query, $this);
        }
            
        return $value;
    }

    /**
     * Add sub query bindings.
     *
     * @param CompilableClause $clause
     * @param QueryInterface $query The sub query.
     * @param string $alias
     *
     * @return string  The sub query sql
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function compileSubQuery(CompilableClause $clause, QueryInterface $query, $alias = null)
    {
        //TODO les alias peuvent etre les memes. Ne gene pas MySQL, voir à regénérer ceux de la subquery

Comments for TODO tasks are often forgotten in the code; it might be better to use a dedicated issue tracker.

No space found before comment text; expected "// TODO les alias peuvent etre les memes. Ne gene pas MySQL, voir à regénérer ceux de la subquery" but found "//TODO les alias peuvent etre les memes. Ne gene pas MySQL, voir à regénérer ceux de la subquery"

        $sql = '('.$this->compileSelect($query).')';
        
        if ($alias) {
            $sql = $sql . ' as ' . $this->quoteIdentifier($clause, $alias);
        }
        
        $this->addQueryBindings($clause, $query);

        return $sql;
    }
    
    /**
     * Compile IN or NOT IN expression
     *
     * @param CompilableClause $query
     * @param array|QueryInterface|ExpressionInterface  $values
     * @param string $column
     * @param string $operator
     * @param boolean $converted

Expected "bool" but found "boolean" for parameter type

     * 
     * @return string
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function compileInExpression(CompilableClause $query, $values, string $column, string $operator = 'IN', bool $converted = false)
    {
        if (is_array($values)) {
            $hasNullValue = null;
            foreach ($values as $index => &$value) {
                if ($value === null) {
                    unset($values[$index]);
                    $hasNullValue = true;
                } else {
                    $value = $converted ? $this->bindRaw($query, $value) : $this->bindTyped($query, $value, null);

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

Inline shorthand IF statement requires brackets around comparison

                }
            }

            // If the collection has a null value we add the null expression
            if ($hasNullValue) {
                if ($values) {

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

                    $expression = '('.$this->quoteIdentifier($query, $column).' '.$operator.' ('.implode(',', $values).')';

                    if ($operator === 'IN') {
                        return $expression.' OR '.$this->compileExpression($query, $column, 'in', null, $converted).')';
                    } else {
                        return $expression.' AND '.$this->compileExpression($query, $column, '!in', null, $converted).')';
                    }
                }

                return $this->compileExpression($query, $column, $operator === 'IN' ? 'in' : '!in', null, $converted);

Inline shorthand IF statement requires brackets around comparison

            }

            $values = '('.implode(',', $values).')';
        } elseif ($values instanceof QueryInterface) {

Usage of ELSEIF not allowed; use ELSE IF instead

            $values = $this->compileSubQuery($query, $values);
        } elseif ($values instanceof ExpressionInterface) {

$values is always a sub-type of Bdf\Prime\Query\Expression\ExpressionInterface.

Usage of ELSEIF not allowed; use ELSE IF instead

            $values = '('.$values->build($query, $this).')';
        } else {
            $values = $converted ? $this->bindRaw($query, $values) : $this->bindTyped($query, $values, null);

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

Inline shorthand IF statement requires brackets around comparison

            $values = '('.$values.')'; // @todo utile ?

Comments for TODO tasks are often forgotten in the code; it might be better to use a dedicated issue tracker.

Comments may not appear after statements

        }

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

        return $this->quoteIdentifier($query, $column).' '.$operator.' '.$values;
    }

    /**
     * Compile into expression
     * Multiple OR expression

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

     *
     * @param CompilableClause $query
     * @param array $values
     * @param string $column
     * @param string $operator
     * @param bool $converted True if the value is already converted, or false to convert into bind()

Expected "boolean" but found "bool" for parameter type

     * @param string $separator The expressions separators. By default set to OR, but should be AND on negative (NOT) expressions. See CompositeExpression
     *
     * @return string
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    public function compileIntoExpression(CompilableClause $query, array $values, $column, $operator, $converted, $separator = CompositeExpression::TYPE_OR)
    {
        $into = [];

        $column = $this->quoteIdentifier($query, $column);

        foreach ($values as $value) {
            $into[] = $column.' '.$operator.' '.$this->compileExpressionValue($query, $value, $converted);
        }

        return '('.implode(' '.$separator.' ', $into).')';
    }

    /**
     * Compile group by expression
     * 
     * @param CompilableClause $query
     * 
     * @return string
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function compileGroup(CompilableClause $query)
    {
        if (empty($query->statements['groups'])) {
            return '';
        }

        $fields = array_map([$query->preprocessor(), 'field'], $query->statements['groups']);

        if ($query->isQuoteIdentifier()) {
            $fields = $this->quoteIdentifiers($query, $fields);
        }
        
        return ' GROUP BY '.implode(', ', $fields);
    }

    /**
     * Compile order by expression
     * 
     * @param CompilableClause $query
     * 
     * @return string
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function compileOrder(CompilableClause $query)
    {
        if (empty($query->statements['orders'])) {
            return '';
        }
        
        $sql = [];

        foreach ($query->statements['orders'] as $part) {
            if ($part['sort'] instanceof ExpressionInterface) {
                $part['sort'] = $part['sort']->build($query, $this);
            } else {
                $part['sort'] = $this->quoteIdentifier($query, $query->preprocessor()->field($part['sort']));
            }
            
            $sql[] = $part['sort'].' '.$part['order'];
        }

        return ' ORDER BY '.implode(', ', $sql);
    }

    /**
     * Compile the lock expression
     *
     * Does not support system that use hint like SqlServer

Doc comment long description must end with a full stop

     *
     * @param CompilableClause $query
     *
     * @return string
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function compileLock(CompilableClause $query)
    {
        $lock = $query->statements['lock'];

        // The lock should not be applied on aggregate function
        if ($lock !== null && !$query->statements['aggregate']) {
            // Lock for update
            if ($lock === LockMode::PESSIMISTIC_WRITE) {
                return ' ' . $this->platform()->grammar()->getWriteLockSQL();
            }

            // Shared Lock: other process can read the row but not update it.
            if ($lock === LockMode::PESSIMISTIC_READ) {
                return ' ' . $this->platform()->grammar()->getReadLockSQL();
            }
        }

        return '';
    }

    /**
     * Add sub query bindings.
     *
     * @param CompilableClause $clause The main query
     * @param QueryInterface $subQuery The sub query.
     *
     * @return $this This compiler instance.
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function addQueryBindings(CompilableClause $clause, $subQuery)

Type hint "QueryInterface" missing for $subQuery

    {
        foreach ($subQuery->getBindings() as $binding) {
            $this->bindRaw($clause, $binding); // Types are already converted on compilation

Comments may not appear after statements

        }

        return $this;
    }

    /**
     * Creates a new positional parameter and bind the given value to it.
     * The value will be converted according to the given type. If the type is not defined, it will be resolved from PHP value.

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

     *
     * Attention: If you are using positional parameters with the query builder you have
     * to be very careful to bind all parameters in the order they appear in the SQL
     * statement , otherwise they get bound in the wrong order which can lead to serious
     * bugs in your code.
     *
     * @param CompilableClause $query
     * @param mixed $value
     * @param TypeInterface|null $type The type to bind, or null to resolve
     *
     * @return string
     * @throws PrimeException

Comment missing for @throws tag in function comment

     */
    protected function bindTyped(CompilableClause $query, $value, ?TypeInterface $type)
    {
        return $this->bindRaw($query, $this->platform()->types()->toDatabase($value, $type));
    }

    /**
     * Creates a new positional parameter and bind the given value to it.
     * The value will not be converted here

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

     *
     * Attention: If you are using positional parameters with the query builder you have
     * to be very careful to bind all parameters in the order they appear in the SQL
     * statement , otherwise they get bound in the wrong order which can lead to serious
     * bugs in your code.
     *
     * @param CompilableClause $query
     * @param mixed $value Raw database value : must be converted before
     *
     * @return string
     */
    protected function bindRaw(CompilableClause $query, $value)
    {
        $query->state()->bind($value);

        return '?';
    }

    /**
     * @param CompilableClause $query
     *
     * @return array
     */
    public function getBindings(CompilableClause $query)
    {
        return $this->mergeBindings($query->state()->bindings);
    }

    /**
     * Merge algo for bindings and binding types
     * 
     * @param array $bindings
     *
     * @return array
     */
    protected function mergeBindings($bindings)

Type hint "array" missing for $bindings

    {
        $mergedBindings = [];

        if (isset($bindings[0])) {
            $mergedBindings = $bindings[0];
        } else {
            foreach (['columns', 'joins', 'where', 'groups', 'having', 'orders'] as $part) {
                if (isset($bindings[$part])) {
                    $mergedBindings = array_merge($mergedBindings, $bindings[$part]);
                }
            }
        }

        return $mergedBindings;
    }
}