JClaveau\LogicalFilter\Converter\InlineSqlMinimalConverter

Complexity

Total Complexity

32

Size/Duplication

Total Lines	168
Duplicated Lines	7.74 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

87.38%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	addParameter()	0	16	3
A	convert()	0	11	2
A	onOpenOr()	0	4	1
A	onCloseOr()	0	5	1
D	onAndPossibility()	13	86	23
A	getLastOrOperandKey()	0	5	1
A	appendToLastOrOperandKey()	0	5	1

<?php
/**
 * InlineSqlMinimalConverter
 *
 * @package php-logical-filter
 * @author  Jean Claveau
 */
namespace JClaveau\LogicalFilter\Converter;

use       JClaveau\LogicalFilter\LogicalFilter;
use       JClaveau\LogicalFilter\Rule\EqualRule;
use       JClaveau\LogicalFilter\Rule\NotEqualRule;
use       JClaveau\LogicalFilter\Rule\AboveRule;
use       JClaveau\LogicalFilter\Rule\BelowRule;
use       JClaveau\LogicalFilter\Rule\RegexpRule;
use       JClaveau\LogicalFilter\Rule\InRule;
use       JClaveau\LogicalFilter\Rule\NotInRule;
use       JClaveau\LogicalFilter\Rule\AboveOrEqualRule;
use       JClaveau\LogicalFilter\Rule\BelowOrEqualRule;

/**
 * This class implements a converter for MySQL.
 */
class InlineSqlMinimalConverter extends MinimalConverter
{
    /** @var array $output */
    protected $output = [];

    /** @var array $parameters */
    protected $parameters = [];

    /**
     * @return string parameter id

Should the return type not be integer|double|string?

     */
    public function addParameter($value)
    {
        if (is_numeric($value)) {
            return $value;
        }

        $uid = 'param_'.hash('crc32b', serialize($value));

        if (isset($this->parameters[$uid])) {
            return ':'.$uid;
        }

        $this->parameters[$uid] = $value;

        return ':'.$uid;
    }

    /**
     * @param LogicalFilter $filter
     */
    public function convert( LogicalFilter $filter )
    {
        $this->output = [];
        parent::convert($filter);
        return [

The return type of return array('sql' => !$this->output ? '1' : '(' . implode(') OR (', $this->output) . ')', 'parameters' => $this->parameters); (array<string,string|array>) is incompatible with the return type of the parent method JClaveau\LogicalFilter\Converter\MinimalConverter::convert of type JClaveau\LogicalFilter\Converter\MinimalConverter|null.

            'sql' => ! $this->output
                   ? '1' // True
                   : '('.implode(') OR (', $this->output).')',
            'parameters' => $this->parameters,
        ];
    }

    /**
     */
    public function onOpenOr()
    {
        $this->output[] = [];
    }

    /**
     */
    public function onCloseOr()
    {
        $last_key                  = $this->getLastOrOperandKey();
        $this->output[ $last_key ] = implode(' AND ', $this->output[ $last_key ]);
    }

    /**
     * Pseudo-event called while for each And operand of the root Or.
     * These operands must be only atomic Rules.
     */
    public function onAndPossibility($field, $operator, $rule, array $allOperandsByField)
    {
        if ($rule instanceof EqualRule) {
            $value = $rule->getValue();
        }
        elseif ($rule instanceof InRule) {

This code seems to be duplicated across your project.

            $value = $rule->getPossibilities();
            if (is_object($value) && method_exists('toArray', $value)) {
                $value = $value->toArray();
            }
        }
        elseif ($rule instanceof NotInRule) {

This code seems to be duplicated across your project.

            $operator = 'NOT IN';

Consider using a different name than the parameter $operator. This often makes code more readable.

            $value    = $rule->getPossibilities();
            if (is_object($value) && method_exists('toArray', $value)) {
                $value = $value->toArray();
            }
        }
        elseif ($rule instanceof AboveRule) {
            $value = $rule->getLowerLimit();
        }
        elseif ($rule instanceof BelowRule) {
            $value = $rule->getUpperLimit();
        }
        elseif ($rule instanceof AboveOrEqualRule) {
            $value = $rule->getMinimum();
        }
        elseif ($rule instanceof BelowOrEqualRule) {
            $value = $rule->getMaximum();
        }
        elseif ($rule instanceof NotEqualRule) {
            $value = $rule->getValue();
        }
        elseif ($rule instanceof RegexpRule) {
            $value = RegexpRule::php2mariadbPCRE( $rule->getPattern() );
        }
        else {
            throw new \InvalidArgumentException(
                "Unhandled operator '$operator' during SQL query generation"
            );
        }

        if ('integer' == gettype($value)) {
        }
        elseif ('double' == gettype($value)) {
            // TODO disable locale to handle separators
        }
        elseif ($value instanceof \DateTime) {
            $value = "'" . $value->format('Y-m-d H:i:s') . "'";
        }
        elseif ('string' == gettype($value)) {
            $value = $this->addParameter($value);
        }
        elseif ('array' == gettype($value)) {
            $sql_part = [];
            foreach ($value as $possibility) {
                $sql_part[] = $this->addParameter($possibility);
            }
            $value = '(' . implode(', ', $sql_part) . ')';
        }
        elseif (null === $value) {
            $value = "NULL";
            if ($rule instanceof EqualRule) {
                $operator = 'IS';

Consider using a different name than the parameter $operator. This often makes code more readable.

            }
            elseif ($rule instanceof NotEqualRule) {
                $operator = 'IS NOT';

Consider using a different name than the parameter $operator. This often makes code more readable.

            }
            else {
                throw new \InvalidArgumentException(
                    "NULL is only handled for equality / difference"
                );
            }
        }
        else {
            throw new \InvalidArgumentException(
                "Unhandled type of value: ".gettype($value). ' | ' .var_export($value, true)
            );
        }

        $operator = strtoupper($operator);

Consider using a different name than the parameter $operator. This often makes code more readable.

        $new_rule = "$field $operator $value";

        $this->appendToLastOrOperandKey($new_rule);
    }

    /**
     */
    protected function getLastOrOperandKey()
    {
        end($this->output);
        return key($this->output);
    }

    /**
     * @param string $rule
     */
    protected function appendToLastOrOperandKey($rule)
    {
        $last_key                    = $this->getLastOrOperandKey();
        $this->output[ $last_key ][] = $rule;
    }

    /**/
}