ClickHouseDB\Query\Degeneration\Bindings

Complexity

Total Complexity

22

Size/Duplication

Total Lines	136
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	escapeString()	0	3	1
A	bindParams()	0	5	2
B	formatParameter()	0	19	9
B	process()	0	39	6
A	formatStringParameter()	0	3	1
A	bindParam()	0	3	1
A	compile_binds()	0	9	2

<?php

declare(strict_types=1);

namespace ClickHouseDB\Query\Degeneration;

use ClickHouseDB\Exception\UnsupportedParameterType;
use ClickHouseDB\Query\Degeneration;
use DateTimeInterface;
use function array_map;
use function implode;
use function is_array;
use function is_bool;
use function is_callable;
use function is_float;
use function is_int;
use function is_string;
use function sprintf;

class Bindings implements Degeneration
{
    /**

Found multi-line comment for property \ClickHouseDB\Query\Degeneration\Bindings::$bindings with single line content, use one-line comment instead.

     * @var array

@var annotation of property \ClickHouseDB\Query\Degeneration\Bindings::$bindings does not specify type hint for its items.

     */
    protected $bindings = [];

    /**
     * @param array $bindings

@param annotation of method \ClickHouseDB\Query\Degeneration\Bindings::bindParams() does not specify type hint for items of its traversable parameter $bindings.

     */
    public function bindParams(array $bindings)

Method \ClickHouseDB\Query\Degeneration\Bindings::bindParams() does not have void return type hint.

    {
        $this->bindings = [];
        foreach ($bindings as $column => $value) {
            $this->bindParam($column, $value);
        }
    }

    /**
     * @param string $column
     * @param mixed  $value
     */
    public function bindParam($column, $value)

Method \ClickHouseDB\Query\Degeneration\Bindings::bindParam() does not have parameter type hint for its parameter $column but it should be possible to add it based on @param annotation "string".

Method \ClickHouseDB\Query\Degeneration\Bindings::bindParam() does not have void return type hint.

    {
        $this->bindings[$column] = $value;
    }

    /**
     * Escape an string
     *
     * @param string $value
     * @return string
     */
    private function escapeString($value)

Method \ClickHouseDB\Query\Degeneration\Bindings::escapeString() does not have parameter type hint for its parameter $value but it should be possible to add it based on @param annotation "string".

Method \ClickHouseDB\Query\Degeneration\Bindings::escapeString() does not have return type hint for its return value but it should be possible to add it based on @return annotation "string".

    {
        return addslashes($value);

Function addslashes() should not be referenced via a fallback global name, but via a use statement.

    }

    /**
     * Binds a list of values to the corresponding parameters.
     * This is similar to [[bindValue()]] except that it binds multiple values at a time.
     *
     * @param string $sql
     * @param array $binds

@param annotation of method \ClickHouseDB\Query\Degeneration\Bindings::compile_binds() does not specify type hint for items of its traversable parameter $binds.

Expected 2 spaces after parameter type; 1 found

     * @param string $pattern
     * @return string
     */
    public function compile_binds($sql, $binds,$pattern)

Method name "Bindings::compile_binds" is not in camel caps format

Method \ClickHouseDB\Query\Degeneration\Bindings::compile_binds() does not have parameter type hint for its parameter $sql but it should be possible to add it based on @param annotation "string".

Method \ClickHouseDB\Query\Degeneration\Bindings::compile_binds() does not have parameter type hint for its parameter $binds but it should be possible to add it based on @param annotation "array".

Method \ClickHouseDB\Query\Degeneration\Bindings::compile_binds() does not have parameter type hint for its parameter $pattern but it should be possible to add it based on @param annotation "string".

Method \ClickHouseDB\Query\Degeneration\Bindings::compile_binds() does not have return type hint for its return value but it should be possible to add it based on @return annotation "string".

Expected 1 space between comma and argument "$pattern"; 0 found

    {
        return preg_replace_callback($pattern, function($m) use ($binds){

Function preg_replace_callback() should not be referenced via a fallback global name, but via a use statement.

Expected 1 space after FUNCTION keyword; 0 found

Expected 1 space before opening brace; found 0

            if(isset($binds[$m[1]])){ // If it exists in our array

Expected 1 space(s) after IF keyword; 0 found

                return $binds[$m[1]]; // Then replace it from our array
            }

            return $m[0]; // Otherwise return the whole match (basically we won't change it)
        }, $sql);
    }

    /**
     * Compile Bindings
     *
     * @param string $sql
     * @return mixed
     */
    public function process($sql)

Method \ClickHouseDB\Query\Degeneration\Bindings::process() does not have parameter type hint for its parameter $sql but it should be possible to add it based on @param annotation "string".

    {
        $bindFormatted=[];

Equals sign not aligned with surrounding assignments; expected 1 space but found 0 spaces

        $bindRaw=[];

Equals sign not aligned with surrounding assignments; expected 7 spaces but found 0 spaces

        foreach ($this->bindings as $key => $value) {
            if (is_array($value)) {
                $valueSet = implode(', ', $value);

                $values = array_map(
                    function ($value) {
                        return $this->formatParameter($value);
                    },
                    $value
                );

                $formattedParameter = implode(',', $values);
            } else {
                $valueSet = $value;

Equals sign not aligned with surrounding assignments; expected 11 spaces but found 1 space

                $formattedParameter = $this->formatParameter($value);
            }

            if ($formattedParameter !== null) {
                $bindFormatted[$key]=$formattedParameter;

Equals sign not aligned correctly; expected 1 space but found 0 spaces

            }

            if ($valueSet !== null) {

Use early exit to reduce code nesting.

                $bindRaw[$key]=$valueSet;

Equals sign not aligned correctly; expected 1 space but found 0 spaces

            }
        }

        for ($loop=0;$loop<2;$loop++)

Expected 1 space after first semicolon of FOR loop; 0 found

Expected 1 space after second semicolon of FOR loop; 0 found

        {
            // dipping in binds
            // example ['A' => '{B}' , 'B'=>':C','C'=>123]
            $sql=$this->compile_binds($sql,$bindRaw,'#{([\w+]+)}#');

Equals sign not aligned correctly; expected 1 space but found 0 spaces

        }
        $sql=$this->compile_binds($sql,$bindFormatted,'#:([\w+]+)#');

Equals sign not aligned correctly; expected 1 space but found 0 spaces

        return $sql;
    }

    /**
     * @param mixed $value
     * @return mixed
     */
    private function formatParameter($value)
    {
        if ($value instanceof DateTimeInterface) {
            $value = $value->format('Y-m-d H:i:s');
        }

        if (is_float($value) || is_int($value) || is_bool($value) || $value === null) {
            return $value;
        }

        if (is_object($value) && is_callable([$value, '__toString'])) {

Function is_object() should not be referenced via a fallback global name, but via a use statement.

            $value = (string) $value;
        }

        if (is_string($value)) {
            return $this->formatStringParameter($this->escapeString($value));
        }

        throw UnsupportedParameterType::new($value);
    }

    /**
     * @return string
     */
    private function formatStringParameter($value)

Method \ClickHouseDB\Query\Degeneration\Bindings::formatStringParameter() does not have parameter type hint nor @param annotation for its parameter $value.

Method \ClickHouseDB\Query\Degeneration\Bindings::formatStringParameter() does not have return type hint for its return value but it should be possible to add it based on @return annotation "string".

    {
        return sprintf("'%s'", $value);
    }
}