ClickHouseDB\Client

Complexity

Total Complexity

105

Size/Duplication

Total Lines	958
Duplicated Lines	0 %

Test Coverage

Coverage

60.24%

Importance

Changes

0

55 Methods

Rating	Name	Duplication	Size	Complexity
A	write()	0	3	1
A	enableExtremes()	0	4	1
A	database()	0	4	1
A	select()	0	3	1
A	getSession()	0	3	1
A	enableHttpCompression()	0	4	1
A	enableLogQueries()	0	4	1
A	executeAsync()	0	3	1
A	getConnectHost()	0	3	1
A	cleanQueryDegeneration()	0	3	1
A	insertBatchTSVFiles()	0	3	1
A	setReadOnlyUser()	0	4	1
A	getConnectTimeOut()	0	3	1
B	__construct()	0	59	11
A	streamRead()	0	6	2
A	getConnectUsername()	0	3	1
A	useSession()	0	14	3
A	verbose()	0	3	1
A	getTimeout()	0	3	1
A	addQueryDegeneration()	0	3	1
A	showTables()	0	3	1
A	showCreateTable()	0	3	1
A	setHost()	0	10	2
A	databaseSize()	0	10	1
A	streamWrite()	0	6	2
A	showDatabases()	0	3	1
A	settings()	0	3	1
A	progressFunction()	0	17	4
A	setConnectTimeOut()	0	3	1
A	getTransport()	0	3	1
A	selectAsync()	0	3	1
B	insertBatchFiles()	0	45	11
A	getConnectPassword()	0	3	1
A	transport()	0	6	2
A	tableSize()	0	9	2
A	getCountPendingQueue()	0	3	1
A	setTimeout()	0	3	1
A	prepareInsertAssocBulk()	0	17	5
A	enableQueryConditions()	0	3	1
A	insertBatchStream()	0	22	4
A	getConnectPort()	0	3	1
A	insert()	0	15	3
A	insertAssocBulk()	0	4	1
A	showProcesslist()	0	3	1
A	isExists()	0	7	1
A	ping()	0	3	1
A	getServerVersion()	0	3	1
A	dropOldPartitions()	0	26	5
A	tablesSize()	0	30	2
A	getServerSystemSettings()	0	8	4
A	https()	0	4	1
A	partitions()	0	13	3
A	truncateTable()	0	10	2
A	dropPartition()	0	10	1
A	getServerUptime()	0	3	1

<?php

Missing declare(strict_types = 1).

namespace ClickHouseDB;

use ClickHouseDB\Exception\QueryException;
use ClickHouseDB\Query\Degeneration\Bindings;
use ClickHouseDB\Query\WhereInFile;
use ClickHouseDB\Query\WriteToFile;
use ClickHouseDB\Quote\FormatLine;
use ClickHouseDB\Transport\Http;
use ClickHouseDB\Transport\Stream;

class Client
{
    /**

Found multi-line comment for property \ClickHouseDB\Client::$_transport with single line content, use one-line comment instead.

     * @var Http
     */
    private $_transport = null;

    /**

Found multi-line comment for property \ClickHouseDB\Client::$_connect_username with single line content, use one-line comment instead.

     * @var string
     */
    private $_connect_username = '';

    /**

Found multi-line comment for property \ClickHouseDB\Client::$_connect_password with single line content, use one-line comment instead.

     * @var string
     */
    private $_connect_password = '';

    /**

Found multi-line comment for property \ClickHouseDB\Client::$_connect_host with single line content, use one-line comment instead.

     * @var string
     */
    private $_connect_host = '';

    /**

Found multi-line comment for property \ClickHouseDB\Client::$_connect_port with single line content, use one-line comment instead.

     * @var string
     */
    private $_connect_port = '';

    /**

Found multi-line comment for property \ClickHouseDB\Client::$_connect_user_readonly with single line content, use one-line comment instead.

     * @var bool
     */
    private $_connect_user_readonly = false;
    /**

Found multi-line comment for property \ClickHouseDB\Client::$_support_format with single line content, use one-line comment instead.

     * @var array

@var annotation of property \ClickHouseDB\Client::$_support_format does not specify type hint for its items.

     */
    private $_support_format = ['TabSeparated', 'TabSeparatedWithNames', 'CSV', 'CSVWithNames', 'JSONEachRow'];

    /**
     * Client constructor.

Documentation comment contains forbidden comment "Client constructor.".

     * @param array $connect_params

@param annotation of method \ClickHouseDB\Client::__construct() does not specify type hint for items of its traversable parameter $connect_params.

     * @param array $settings

@param annotation of method \ClickHouseDB\Client::__construct() does not specify type hint for items of its traversable parameter $settings.

     */
    public function __construct($connect_params, $settings = [])

Method \ClickHouseDB\Client::__construct() does not have parameter type hint for its parameter $connect_params but it should be possible to add it based on @param annotation "array".

Method \ClickHouseDB\Client::__construct() does not have parameter type hint for its parameter $settings but it should be possible to add it based on @param annotation "array".

    {
        if (!isset($connect_params['username'])) {

There must be a single space after a NOT operator; 0 found

            throw  new \InvalidArgumentException('not set username');
        }

        if (!isset($connect_params['password'])) {

There must be a single space after a NOT operator; 0 found

            throw  new \InvalidArgumentException('not set password');
        }

        if (!isset($connect_params['port'])) {

There must be a single space after a NOT operator; 0 found

            throw  new \InvalidArgumentException('not set port');
        }

        if (!isset($connect_params['host'])) {

There must be a single space after a NOT operator; 0 found

            throw  new \InvalidArgumentException('not set host');
        }

        if (isset($connect_params['settings']) && is_array($connect_params['settings'])) {

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

            if (empty($settings)) {
                $settings = $connect_params['settings'];
            }
        }

        $this->_connect_username    = $connect_params['username'];

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

        $this->_connect_password    = $connect_params['password'];

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

        $this->_connect_port        = $connect_params['port'];

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 8 spaces

        $this->_connect_host        = $connect_params['host'];

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 8 spaces

Functions must not contain multiple empty lines in a row; found 2 empty lines

        // init transport class
        $this->_transport = new Http(
            $this->_connect_host,
            $this->_connect_port,
            $this->_connect_username,
            $this->_connect_password
        );

Functions must not contain multiple empty lines in a row; found 2 empty lines

        $this->_transport->addQueryDegeneration(new Bindings());

        // apply settings to transport class
        $this->settings()->database('default');
        if (sizeof($settings)) {

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

The use of function sizeof() is forbidden; use count() instead

            $this->settings()->apply($settings);
        }

Functions must not contain multiple empty lines in a row; found 2 empty lines

        if (isset($connect_params['readonly']))
        {
            $this->setReadOnlyUser($connect_params['readonly']);
        }

        if (isset($connect_params['https']))
        {
            $this->https($connect_params['https']);
        }

        $this->enableHttpCompression();

Functions must not contain multiple empty lines in a row; found 2 empty lines

    }

Function closing brace must go on the next line following the body; found 2 blank lines before brace

    /**
     * if the user has only read in the config file
     *
     * @param bool $flag
     */
    public function setReadOnlyUser($flag)

Method \ClickHouseDB\Client::setReadOnlyUser() does not have parameter type hint for its parameter $flag but it should be possible to add it based on @param annotation "bool".

Method \ClickHouseDB\Client::setReadOnlyUser() does not have void return type hint.

    {
        $this->_connect_user_readonly = $flag;
        $this->settings()->setReadOnlyUser($this->_connect_user_readonly);
    }
    /**
     * Clear Degeneration processing request [template ]
     *
     * @return bool
     */
    public function cleanQueryDegeneration()

Method \ClickHouseDB\Client::cleanQueryDegeneration() does not have return type hint for its return value but it should be possible to add it based on @return annotation "bool".

    {
        return $this->_transport->cleanQueryDegeneration();
    }

    /**
     * add Degeneration processing
     *
     * @param Query\Degeneration $degeneration

Method \ClickHouseDB\Client::addQueryDegeneration() has useless @param annotation for parameter $degeneration.

     * @return bool
     */
    public function addQueryDegeneration(Query\Degeneration $degeneration)

Method \ClickHouseDB\Client::addQueryDegeneration() does not have return type hint for its return value but it should be possible to add it based on @return annotation "bool".

    {
        return $this->_transport->addQueryDegeneration($degeneration);
    }

    /**
     * add Conditions in query
     *
     * @return bool
     */
    public function enableQueryConditions()

Method \ClickHouseDB\Client::enableQueryConditions() does not have return type hint for its return value but it should be possible to add it based on @return annotation "bool".

    {
        return $this->_transport->addQueryDegeneration(new \ClickHouseDB\Query\Degeneration\Conditions());

Class \ClickHouseDB\Query\Degeneration\Conditions should not be referenced via a fully qualified name, but via a use statement.

    }
    /**
     * Set connection host
     *
     * @param string|array $host

@param annotation of method \ClickHouseDB\Client::setHost() does not specify type hint for items of its traversable parameter $host.

     */
    public function setHost($host)

Method \ClickHouseDB\Client::setHost() does not have void return type hint.

    {

Expected 0 blank lines after opening function brace; 1 found

        if (is_array($host))

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

        {
            $host = array_rand(array_flip($host));

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

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

        }

        $this->_connect_host = $host;
        $this->transport()->setHost($host);
    }

    /**
     * Таймаут
     *
     * @param int $timeout
     * @return Settings
     */
    public function setTimeout($timeout)

Method \ClickHouseDB\Client::setTimeout() does not have parameter type hint for its parameter $timeout but it should be possible to add it based on @param annotation "int".

Method \ClickHouseDB\Client::setTimeout() does not have return type hint for its return value but it should be possible to add it based on @return annotation "Settings".

    {
        return $this->settings()->max_execution_time($timeout);
    }

    /**
     * Timeout
     *
     * @return mixed
     */
    public function getTimeout()
    {
        return $this->settings()->getTimeOut();
    }

    /**
     * ConnectTimeOut in seconds ( support 1.5 = 1500ms )
     *
     * @param int $connectTimeOut
     */
    public function setConnectTimeOut($connectTimeOut)

Method \ClickHouseDB\Client::setConnectTimeOut() does not have parameter type hint for its parameter $connectTimeOut but it should be possible to add it based on @param annotation "int".

Method \ClickHouseDB\Client::setConnectTimeOut() does not have void return type hint.

    {
        $this->transport()->setConnectTimeOut($connectTimeOut);
    }

    /**
     * get ConnectTimeOut
     *
     * @return int
     */
    public function getConnectTimeOut()

Method \ClickHouseDB\Client::getConnectTimeOut() does not have return type hint for its return value but it should be possible to add it based on @return annotation "int".

    {
        return $this->transport()->getConnectTimeOut();
    }


    /**
     * transport
     *
     * @return Http
     */
    public function transport()

Method \ClickHouseDB\Client::transport() does not have return type hint for its return value but it should be possible to add it based on @return annotation "Http".

    {
        if (!$this->_transport) {

There must be a single space after a NOT operator; 0 found

            throw  new \InvalidArgumentException('Empty transport class');
        }
        return $this->_transport;
    }

    /**
     * @return string
     */
    public function getConnectHost()

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

    {
        return $this->_connect_host;
    }

    /**
     * @return string
     */
    public function getConnectPassword()

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

    {
        return $this->_connect_password;
    }

    /**
     * @return string
     */
    public function getConnectPort()

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

    {
        return $this->_connect_port;
    }

    /**
     * @return string
     */
    public function getConnectUsername()

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

    {
        return $this->_connect_username;
    }

    /**
     * transport
     *
     * @return Http
     */
    public function getTransport()

Method \ClickHouseDB\Client::getTransport() does not have return type hint for its return value but it should be possible to add it based on @return annotation "Http".

    {
        return $this->_transport;
    }


    /**
     * Режим отладки CURL
     *
     * @return mixed
     */
    public function verbose()
    {
        return $this->transport()->verbose(true);
    }

    /**
     * @return Settings
     */
    public function settings()

Method \ClickHouseDB\Client::settings() does not have return type hint for its return value but it should be possible to add it based on @return annotation "Settings".

    {
        return $this->transport()->settings();
    }

    /**
     * @return $this
     */
    public function useSession($useSessionId = false)

Method \ClickHouseDB\Client::useSession() does not have parameter type hint nor @param annotation for its parameter $useSessionId.

    {
        if (!$this->settings()->getSessionId())

There must be a single space after a NOT operator; 0 found

        {
            if (!$useSessionId)

There must be a single space after a NOT operator; 0 found

            {
                $this->settings()->makeSessionId();
            } else

Expected 1 space(s) after ELSE keyword; newline found

            {
                $this->settings()->session_id($useSessionId);
            }

Blank line found at end of control structure

        }
        return $this;
    }
    /**
     * @return mixed
     */
    public function getSession()
    {
        return $this->settings()->getSessionId();
    }

    /**
     * Query CREATE/DROP
     *
     * @param string $sql
     * @param array $bindings

@param annotation of method \ClickHouseDB\Client::write() does not specify type hint for items of its traversable parameter $bindings.

Expected 2 spaces after parameter type; 1 found

     * @param bool $exception

Expected 3 spaces after parameter type; 1 found

     * @return Statement
     * @throws Exception\TransportException
     */
    public function write($sql, $bindings = [], $exception = true)

Method \ClickHouseDB\Client::write() 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\Client::write() does not have parameter type hint for its parameter $bindings but it should be possible to add it based on @param annotation "array".

Method \ClickHouseDB\Client::write() does not have parameter type hint for its parameter $exception but it should be possible to add it based on @param annotation "bool".

Method \ClickHouseDB\Client::write() does not have return type hint for its return value but it should be possible to add it based on @return annotation "Statement".

    {
        return $this->transport()->write($sql, $bindings, $exception);
    }

    /**
     * set db name
     * @param string $db
     * @return $this
     */
    public function database($db)

Method \ClickHouseDB\Client::database() does not have parameter type hint for its parameter $db but it should be possible to add it based on @param annotation "string".

    {
        $this->settings()->database($db);
        return $this;
    }

    /**
     * Write to system.query_log
     *
     * @param bool $flag
     * @return $this
     */
    public function enableLogQueries($flag = true)

Method \ClickHouseDB\Client::enableLogQueries() does not have parameter type hint for its parameter $flag but it should be possible to add it based on @param annotation "bool".

    {
        $this->settings()->set('log_queries', intval($flag));

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

        return $this;
    }

    /**
     * Compress the result if the HTTP client said that it understands data compressed with gzip or deflate
     *
     * @param bool $flag
     * @return $this
     */
    public function enableHttpCompression($flag = true)

Method \ClickHouseDB\Client::enableHttpCompression() does not have parameter type hint for its parameter $flag but it should be possible to add it based on @param annotation "bool".

    {
        $this->settings()->enableHttpCompression($flag);
        return $this;
    }

    /**
     * Enable / Disable HTTPS
     *
     * @param bool $flag
     * @return $this
     */
    public function https($flag = true)

Method \ClickHouseDB\Client::https() does not have parameter type hint for its parameter $flag but it should be possible to add it based on @param annotation "bool".

    {
        $this->settings()->https($flag);
        return $this;
    }

    /**
     * Read extremes of the result columns. They can be output in JSON-formats.
     *
     * @param bool $flag
     * @return $this
     */
    public function enableExtremes($flag = true)

Method \ClickHouseDB\Client::enableExtremes() does not have parameter type hint for its parameter $flag but it should be possible to add it based on @param annotation "bool".

    {
        $this->settings()->set('extremes', intval($flag));

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

        return $this;
    }

    /**
     * SELECT
     *
     * @param string $sql

Expected 11 spaces after parameter type; 1 found

     * @param array $bindings

@param annotation of method \ClickHouseDB\Client::select() does not specify type hint for items of its traversable parameter $bindings.

Expected 12 spaces after parameter type; 1 found

     * @param null|WhereInFile $whereInFile
     * @param null|WriteToFile $writeToFile
     * @return Statement
     * @throws Exception\TransportException
     * @throws \Exception
     */
    public function select($sql, $bindings = [], $whereInFile = null, $writeToFile = null)

Method \ClickHouseDB\Client::select() 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\Client::select() does not have parameter type hint for its parameter $bindings but it should be possible to add it based on @param annotation "array".

Method \ClickHouseDB\Client::select() does not have parameter type hint for its parameter $whereInFile but it should be possible to add it based on @param annotation "null|WhereInFile".

Method \ClickHouseDB\Client::select() does not have parameter type hint for its parameter $writeToFile but it should be possible to add it based on @param annotation "null|WriteToFile".

Method \ClickHouseDB\Client::select() does not have return type hint for its return value but it should be possible to add it based on @return annotation "Statement".

    {
        return $this->transport()->select($sql, $bindings, $whereInFile, $writeToFile);
    }

    /**
     * execute run
     *
     * @return bool
     * @throws Exception\TransportException
     */
    public function executeAsync()

Method \ClickHouseDB\Client::executeAsync() does not have return type hint for its return value but it should be possible to add it based on @return annotation "bool".

    {
        return $this->transport()->executeAsync();
    }

    /**
     * set progressFunction
     *
     * @param callable $callback
     */
    public function progressFunction($callback)

Method \ClickHouseDB\Client::progressFunction() does not have parameter type hint for its parameter $callback but it should be possible to add it based on @param annotation "callable".

Method \ClickHouseDB\Client::progressFunction() does not have void return type hint.

    {
        if (!is_callable($callback)) {

There must be a single space after a NOT operator; 0 found

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

            throw new \InvalidArgumentException('Not is_callable progressFunction');
        }

        if (!$this->settings()->is('send_progress_in_http_headers'))

There must be a single space after a NOT operator; 0 found

        {
            $this->settings()->set('send_progress_in_http_headers', 1);
        }
        if (!$this->settings()->is('http_headers_progress_interval_ms'))

There must be a single space after a NOT operator; 0 found

        {
            $this->settings()->set('http_headers_progress_interval_ms', 100);
        }

Functions must not contain multiple empty lines in a row; found 2 empty lines

        $this->transport()->setProgressFunction($callback);
    }

    /**
     * prepare select
     *
     * @param string $sql

Expected 11 spaces after parameter type; 1 found

     * @param array $bindings

@param annotation of method \ClickHouseDB\Client::selectAsync() does not specify type hint for items of its traversable parameter $bindings.

Expected 12 spaces after parameter type; 1 found

     * @param null|WhereInFile $whereInFile
     * @param null|WriteToFile $writeToFile
     * @return Statement
     * @throws Exception\TransportException
     * @throws \Exception
     */
    public function selectAsync($sql, $bindings = [], $whereInFile = null, $writeToFile = null)

Method \ClickHouseDB\Client::selectAsync() 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\Client::selectAsync() does not have parameter type hint for its parameter $bindings but it should be possible to add it based on @param annotation "array".

Method \ClickHouseDB\Client::selectAsync() does not have parameter type hint for its parameter $whereInFile but it should be possible to add it based on @param annotation "null|WhereInFile".

Method \ClickHouseDB\Client::selectAsync() does not have parameter type hint for its parameter $writeToFile but it should be possible to add it based on @param annotation "null|WriteToFile".

Method \ClickHouseDB\Client::selectAsync() does not have return type hint for its return value but it should be possible to add it based on @return annotation "Statement".

    {
        return $this->transport()->selectAsync($sql, $bindings, $whereInFile, $writeToFile);
    }

    /**
     * SHOW PROCESSLIST
     *
     * @return array

@return annotation of method \ClickHouseDB\Client::showProcesslist() does not specify type hint for items of its traversable return value.

     * @throws Exception\TransportException
     * @throws \Exception
     */
    public function showProcesslist()

Method \ClickHouseDB\Client::showProcesslist() does not have return type hint for its return value but it should be possible to add it based on @return annotation "array".

    {
        return $this->select('SHOW PROCESSLIST')->rows();
    }

    /**
     * show databases
     *
     * @return array

@return annotation of method \ClickHouseDB\Client::showDatabases() does not specify type hint for items of its traversable return value.

     * @throws Exception\TransportException
     * @throws \Exception
     */
    public function showDatabases()

Method \ClickHouseDB\Client::showDatabases() does not have return type hint for its return value but it should be possible to add it based on @return annotation "array".

    {
        return $this->select('show databases')->rows();
    }

    /**
     * statement = SHOW CREATE TABLE
     *
     * @param string $table
     * @return mixed
     * @throws Exception\TransportException
     * @throws \Exception
     */
    public function showCreateTable($table)

Method \ClickHouseDB\Client::showCreateTable() does not have parameter type hint for its parameter $table but it should be possible to add it based on @param annotation "string".

    {
        return ($this->select('SHOW CREATE TABLE ' . $table)->fetchOne('statement'));

Usage of language construct "return" with parentheses is disallowed.

    }

    /**
     * SHOW TABLES
     *
     * @return array

@return annotation of method \ClickHouseDB\Client::showTables() does not specify type hint for items of its traversable return value.

     * @throws Exception\TransportException
     * @throws \Exception
     */
    public function showTables()

Method \ClickHouseDB\Client::showTables() does not have return type hint for its return value but it should be possible to add it based on @return annotation "array".

    {
        return $this->select('SHOW TABLES')->rowsAsTree('name');
    }

    /**
     * Get the number of simultaneous/Pending requests
     *
     * @return int
     */
    public function getCountPendingQueue()

Method \ClickHouseDB\Client::getCountPendingQueue() does not have return type hint for its return value but it should be possible to add it based on @return annotation "int".

    {
        return $this->transport()->getCountPendingQueue();
    }

    /**
     * Insert Array
     *
     * @param string $table
     * @param array $values

@param annotation of method \ClickHouseDB\Client::insert() does not specify type hint for items of its traversable parameter $values.

Expected 2 spaces after parameter type; 1 found

     * @param array $columns

@param annotation of method \ClickHouseDB\Client::insert() does not specify type hint for items of its traversable parameter $columns.

Expected 2 spaces after parameter type; 1 found

     * @return Statement
     * @throws Exception\TransportException
     */
    public function insert($table, $values, $columns = [])

Method \ClickHouseDB\Client::insert() does not have parameter type hint for its parameter $table but it should be possible to add it based on @param annotation "string".

Method \ClickHouseDB\Client::insert() does not have parameter type hint for its parameter $values but it should be possible to add it based on @param annotation "array".

Method \ClickHouseDB\Client::insert() does not have parameter type hint for its parameter $columns but it should be possible to add it based on @param annotation "array".

Method \ClickHouseDB\Client::insert() does not have return type hint for its return value but it should be possible to add it based on @return annotation "Statement".

    {
        $sql = 'INSERT INTO `' . $table . "`";

The string literal ` does not require double quotes, as per coding-style, please use single quotes.

        if (0 !== count($columns)) {

Yoda comparisons are disallowed.

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

            $sql .= ' (`' . implode('`,`', $columns) . '`) ';

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

        }

        $sql .= ' VALUES ';

        foreach ($values as $row) {
            $sql .= ' (' . FormatLine::Insert($row) . '), ';
        }
        $sql = trim($sql, ', ');

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

        return $this->transport()->write($sql);
    }

    /**
      * Prepares the values to insert from the associative array.
      * There may be one or more lines inserted, but then the keys inside the array list must match (including in the sequence)
      *
      * @param array $values - array column_name => value (if we insert one row) or array list column_name => value if we insert many lines
      * @return array - list of arrays - 0 => fields, 1 => list of value arrays for insertion
      */
    public function prepareInsertAssocBulk(array $values)

Method \ClickHouseDB\Client::prepareInsertAssocBulk() does not have @param annotation for its traversable parameter $values.

Method \ClickHouseDB\Client::prepareInsertAssocBulk() does not have return type hint nor @return annotation for its return value.

    {
        if (isset($values[0]) && is_array($values[0])) { //случай, когда много строк вставляется

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

            $preparedFields = array_keys($values[0]);

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

            $preparedValues = [];
            foreach ($values as $idx => $row) {
                $_fields = array_keys($row);

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

                if ($_fields !== $preparedFields) {
                    throw new QueryException("Fields not match: " . implode(',', $_fields) . " and " . implode(',', $preparedFields) . " on element $idx");

The string literal Fields not match: does not require double quotes, as per coding-style, please use single quotes.

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

The string literal and does not require double quotes, as per coding-style, please use single quotes.

Variable "%s" not allowed in double quoted string; use sprintf() or concatenation instead

                }
                $preparedValues[] = array_values($row);

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

            }
        } else { //одна строка
            $preparedFields = array_keys($values);

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

            $preparedValues = [array_values($values)];

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

        }
        return [$preparedFields, $preparedValues];
    }

    /**
     * Inserts one or more rows from an associative array.
     * If there is a discrepancy between the keys of the value arrays (or their order) - throws an exception.
     *
     * @param string $table - table name

Expected 2 spaces after parameter name; 1 found

     * @param array $values - array column_name => value (if we insert one row) or array list column_name => value if we insert many lines

@param annotation of method \ClickHouseDB\Client::insertAssocBulk() does not specify type hint for items of its traversable parameter $values.

Expected 2 spaces after parameter type; 1 found

     * @return Statement
     * @throws QueryException
     * @throws Exception\TransportException
     */
    public function insertAssocBulk($table, array $values)

Method \ClickHouseDB\Client::insertAssocBulk() does not have parameter type hint for its parameter $table but it should be possible to add it based on @param annotation "string".

Method \ClickHouseDB\Client::insertAssocBulk() does not have return type hint for its return value but it should be possible to add it based on @return annotation "Statement".

    {
        list($columns, $vals) = $this->prepareInsertAssocBulk($values);
        return $this->insert($table, $vals, $columns);
    }

    /**
     * insert TabSeparated files
     *
     * @param string $table_name

Expected 7 spaces after parameter type; 1 found

     * @param string|array $file_names

@param annotation of method \ClickHouseDB\Client::insertBatchTSVFiles() does not specify type hint for items of its traversable parameter $file_names.

     * @param array $columns_array

@param annotation of method \ClickHouseDB\Client::insertBatchTSVFiles() does not specify type hint for items of its traversable parameter $columns_array.

Expected 8 spaces after parameter type; 1 found

     * @return mixed
     * @throws Exception\TransportException
     */
    public function insertBatchTSVFiles($table_name, $file_names, $columns_array=[])

Method \ClickHouseDB\Client::insertBatchTSVFiles() does not have parameter type hint for its parameter $table_name but it should be possible to add it based on @param annotation "string".

Incorrect spacing between argument "$columns_array" and equals sign; expected 1 but found 0

Incorrect spacing between default value and equals sign for argument "$columns_array"; expected 1 but found 0

    {
        return $this->insertBatchFiles($table_name, $file_names, $columns_array, 'TabSeparated');
    }

    /**
     * insert Batch Files
     *
     * @param string $table_name

Expected 7 spaces after parameter type; 1 found

     * @param string|array $file_names

@param annotation of method \ClickHouseDB\Client::insertBatchFiles() does not specify type hint for items of its traversable parameter $file_names.

     * @param array $columns_array

@param annotation of method \ClickHouseDB\Client::insertBatchFiles() does not specify type hint for items of its traversable parameter $columns_array.

Expected 8 spaces after parameter type; 1 found

     * @param string $format ['TabSeparated','TabSeparatedWithNames','CSV','CSVWithNames']

Expected 7 spaces after parameter type; 1 found

Expected 8 spaces after parameter name; 1 found

     * @return array

@return annotation of method \ClickHouseDB\Client::insertBatchFiles() does not specify type hint for items of its traversable return value.

     * @throws Exception\TransportException
     */
    public function insertBatchFiles($table_name, $file_names, $columns_array=[], $format = "CSV")

Method \ClickHouseDB\Client::insertBatchFiles() does not have parameter type hint for its parameter $table_name but it should be possible to add it based on @param annotation "string".

Method \ClickHouseDB\Client::insertBatchFiles() does not have return type hint for its return value but it should be possible to add it based on @return annotation "array".

Incorrect spacing between argument "$columns_array" and equals sign; expected 1 but found 0

Incorrect spacing between default value and equals sign for argument "$columns_array"; expected 1 but found 0

The string literal CSV does not require double quotes, as per coding-style, please use single quotes.

    {
        if (is_string($file_names))

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

        {
            $file_names = [$file_names];
        }
        if ($this->getCountPendingQueue() > 0) {
            throw new QueryException('Queue must be empty, before insertBatch, need executeAsync');
        }

        if (!in_array($format, $this->_support_format))

There must be a single space after a NOT operator; 0 found

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

        {
            throw new QueryException('Format not support in insertBatchFiles');
        }

        $result = [];

        foreach ($file_names as $fileName) {
            if (!is_file($fileName) || !is_readable($fileName)) {

There must be a single space after a NOT operator; 0 found

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

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

                throw  new QueryException('Cant read file: ' . $fileName . ' ' . (is_file($fileName) ? '' : ' is not file'));

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

            }

            if (empty($columns_array))
            {
                $sql = 'INSERT INTO ' . $table_name . ' FORMAT ' . $format;

Blank line found at end of control structure

            } else

Expected 1 space(s) after ELSE keyword; newline found

            {
                $sql = 'INSERT INTO ' . $table_name . ' ( ' . implode(',', $columns_array) . ' ) FORMAT ' . $format;

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

Blank line found at end of control structure

            }
            $result[$fileName] = $this->transport()->writeAsyncCSV($sql, $fileName);
        }

        // exec
        $this->executeAsync();

        // fetch resutl
        foreach ($file_names as $fileName) {
            if ($result[$fileName]->isError()) {

Use early exit to reduce code nesting.

                $result[$fileName]->error();
            }
        }

        return $result;
    }

    /**
     * insert Batch Stream
     *
     * @param string $table_name
     * @param array $columns_array

@param annotation of method \ClickHouseDB\Client::insertBatchStream() does not specify type hint for items of its traversable parameter $columns_array.

Expected 2 spaces after parameter type; 1 found

     * @param string $format ['TabSeparated','TabSeparatedWithNames','CSV','CSVWithNames']

Expected 8 spaces after parameter name; 1 found

     * @return Transport\CurlerRequest
     */
    public function insertBatchStream($table_name, $columns_array=[], $format = "CSV")

Method \ClickHouseDB\Client::insertBatchStream() does not have parameter type hint for its parameter $table_name but it should be possible to add it based on @param annotation "string".

Method \ClickHouseDB\Client::insertBatchStream() does not have parameter type hint for its parameter $columns_array but it should be possible to add it based on @param annotation "array".

Method \ClickHouseDB\Client::insertBatchStream() does not have parameter type hint for its parameter $format but it should be possible to add it based on @param annotation "string".

Method \ClickHouseDB\Client::insertBatchStream() does not have return type hint for its return value but it should be possible to add it based on @return annotation "Transport\CurlerRequest".

Incorrect spacing between argument "$columns_array" and equals sign; expected 1 but found 0

Incorrect spacing between default value and equals sign for argument "$columns_array"; expected 1 but found 0

The string literal CSV does not require double quotes, as per coding-style, please use single quotes.

    {
        if ($this->getCountPendingQueue() > 0) {
            throw new QueryException('Queue must be empty, before insertBatch, need executeAsync');
        }

        if (!in_array($format, $this->_support_format))

There must be a single space after a NOT operator; 0 found

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

        {
            throw new QueryException('Format not support in insertBatchFiles');
        }

        if (empty($columns_array))
        {
            $sql = 'INSERT INTO ' . $table_name . ' FORMAT ' . $format;

Blank line found at end of control structure

        } else

Expected 1 space(s) after ELSE keyword; newline found

        {
            $sql = 'INSERT INTO ' . $table_name . ' ( ' . implode(',', $columns_array) . ' ) FORMAT ' . $format;

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

Blank line found at end of control structure

        }

        return $this->transport()->writeStreamData($sql);
    }


    /**
     * stream Write
     *
     * @param Stream $stream

Method \ClickHouseDB\Client::streamWrite() has useless @param annotation for parameter $stream.

     * @param string $sql
     * @param array $bind

@param annotation of method \ClickHouseDB\Client::streamWrite() does not specify type hint for items of its traversable parameter $bind.

Expected 2 spaces after parameter type; 1 found

     * @return Statement
     * @throws Exception\TransportException
     */
    public function streamWrite(Stream $stream,$sql,$bind=[])

Method \ClickHouseDB\Client::streamWrite() 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\Client::streamWrite() does not have parameter type hint for its parameter $bind but it should be possible to add it based on @param annotation "array".

Method \ClickHouseDB\Client::streamWrite() does not have return type hint for its return value but it should be possible to add it based on @return annotation "Statement".

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

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

Incorrect spacing between argument "$bind" and equals sign; expected 1 but found 0

Incorrect spacing between default value and equals sign for argument "$bind"; expected 1 but found 0

    {
        if ($this->getCountPendingQueue() > 0) {
            throw new QueryException('Queue must be empty, before streamWrite');
        }
        return $this->transport()->streamWrite($stream,$sql,$bind);
    }


    /**
     * stream Read
     *
     * @param Stream $streamRead

Method \ClickHouseDB\Client::streamRead() has useless @param annotation for parameter $streamRead.

     * @param string $sql
     * @param array $bind

@param annotation of method \ClickHouseDB\Client::streamRead() does not specify type hint for items of its traversable parameter $bind.

Expected 2 spaces after parameter type; 1 found

     * @return Statement
     * @throws Exception\TransportException
     */
    public function streamRead(Stream $streamRead,$sql,$bind=[])

Method \ClickHouseDB\Client::streamRead() 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\Client::streamRead() does not have parameter type hint for its parameter $bind but it should be possible to add it based on @param annotation "array".

Method \ClickHouseDB\Client::streamRead() does not have return type hint for its return value but it should be possible to add it based on @return annotation "Statement".

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

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

Incorrect spacing between argument "$bind" and equals sign; expected 1 but found 0

Incorrect spacing between default value and equals sign for argument "$bind"; expected 1 but found 0

    {
        if ($this->getCountPendingQueue() > 0) {
            throw new QueryException('Queue must be empty, before streamWrite');
        }
        return $this->transport()->streamRead($streamRead,$sql,$bind);
    }

    /**
     * Size of database
     *
     * @return mixed|null
     * @throws Exception\TransportException
     * @throws \Exception
     */
    public function databaseSize()
    {
        $b = $this->settings()->getDatabase();

        return $this->select('
            SELECT database,formatReadableSize(sum(bytes)) as size
            FROM system.parts
            WHERE active AND database=:database
            GROUP BY database
        ', ['database' => $b])->fetchOne();
    }

    /**
     * Size of tables
     *
     * @param string $tableName
     * @return mixed
     * @throws Exception\TransportException
     * @throws \Exception
     */
    public function tableSize($tableName)

Method \ClickHouseDB\Client::tableSize() does not have parameter type hint for its parameter $tableName but it should be possible to add it based on @param annotation "string".

    {
        $tables = $this->tablesSize();

        if (isset($tables[$tableName])) {
            return $tables[$tableName];
        }

        return null;
    }

    /**
     * Ping server
     *
     * @return bool
     * @throws Exception\TransportException
     */
    public function ping()

Method \ClickHouseDB\Client::ping() does not have return type hint for its return value but it should be possible to add it based on @return annotation "bool".

    {
        return $this->transport()->ping();
    }

    /**
     * Tables sizes
     *
     * @param bool $flatList
     * @return array

@return annotation of method \ClickHouseDB\Client::tablesSize() does not specify type hint for items of its traversable return value.

     * @throws Exception\TransportException
     * @throws \Exception
     */
    public function tablesSize($flatList = false)

Method \ClickHouseDB\Client::tablesSize() does not have parameter type hint for its parameter $flatList but it should be possible to add it based on @param annotation "bool".

Method \ClickHouseDB\Client::tablesSize() does not have return type hint for its return value but it should be possible to add it based on @return annotation "array".

    {
        $z = $this->select('
        SELECT name as table,database,
            max(sizebytes) as sizebytes,
            max(size) as size,
            min(min_date) as min_date,
            max(max_date) as max_date
            FROM system.tables
            ANY LEFT JOIN 
            (
            SELECT table,database,
                        formatReadableSize(sum(bytes)) as size,
                        sum(bytes) as sizebytes,
                        min(min_date) as min_date,
                        max(max_date) as max_date
                        FROM system.parts 
                        WHERE active AND database=:database
                        GROUP BY table,database
            ) USING ( table,database )
            WHERE database=:database
            GROUP BY table,database
        ', ['database'=>$this->settings()->getDatabase()]);

Expected 1 space between "'database'" and double arrow; 0 found

Expected 1 space between double arrow and "$this"; 0 found

        if ($flatList) {
            return $z->rows();
        }

Functions must not contain multiple empty lines in a row; found 2 empty lines

        return $z->rowsAsTree('table');

Functions must not contain multiple empty lines in a row; found 2 empty lines

    }

Function closing brace must go on the next line following the body; found 2 blank lines before brace

    /**
     * isExists
     *
     * @param string $database
     * @param string $table
     * @return array

@return annotation of method \ClickHouseDB\Client::isExists() does not specify type hint for items of its traversable return value.

     * @throws Exception\TransportException
     * @throws \Exception
     */
    public function isExists($database, $table)

Method \ClickHouseDB\Client::isExists() does not have parameter type hint for its parameter $database but it should be possible to add it based on @param annotation "string".

Method \ClickHouseDB\Client::isExists() does not have parameter type hint for its parameter $table but it should be possible to add it based on @param annotation "string".

Method \ClickHouseDB\Client::isExists() does not have return type hint for its return value but it should be possible to add it based on @return annotation "array".

    {
        return $this->select('
            SELECT *
            FROM system.tables 
            WHERE name=\''.$table . '\' AND database=\'' . $database . '\''

Concat operator must be surrounded by a single space

        )->rowsAsTree('name');
    }


    /**
     * List of partitions
     *
     * @return mixed[][]
     */
    public function partitions(string $table, int $limit = null, bool $active = null)

Method \ClickHouseDB\Client::partitions() does not have return type hint for its return value but it should be possible to add it based on @return annotation "mixed[][]".

Parameter $limit has null default value, but is not marked as nullable.

Parameter $active has null default value, but is not marked as nullable.

    {
        $database = $this->settings()->getDatabase();

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

        $whereActiveClause = $active===null ? '' : sprintf(' AND active = %s', (int) $active);

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

        $limitClause=$limit !== null ? ' LIMIT ' . $limit : '';

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

        return $this->select(<<<CLICKHOUSE
SELECT *
FROM system.parts 
WHERE like(table,'%$table%') AND database='$database'$whereActiveClause
ORDER BY max_date $limitClause
CLICKHOUSE
        )->rowsAsTree('name');
    }

    /**
     * dropPartition
     * @deprecated
     * @param string $dataBaseTableName database_name.table_name
     * @param string $partition_id
     * @return Statement
     * @throws Exception\TransportException
     */
    public function dropPartition($dataBaseTableName, $partition_id)

Method \ClickHouseDB\Client::dropPartition() does not have parameter type hint for its parameter $dataBaseTableName but it should be possible to add it based on @param annotation "string".

Method \ClickHouseDB\Client::dropPartition() does not have parameter type hint for its parameter $partition_id but it should be possible to add it based on @param annotation "string".

Method \ClickHouseDB\Client::dropPartition() does not have return type hint for its return value but it should be possible to add it based on @return annotation "Statement".

    {

Expected 0 blank lines after opening function brace; 1 found

        $partition_id = trim($partition_id, '\'');

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

        $this->settings()->set('replication_alter_partitions_sync', 2);
        $state = $this->write('ALTER TABLE {dataBaseTableName} DROP PARTITION :partion_id', [
            'dataBaseTableName'  => $dataBaseTableName,
            'partion_id' => $partition_id

Multiline arrays must have a trailing comma after the last element.

        ]);
        return $state;
    }

    /**
     * Truncate ( drop all partitions )
     * @deprecated
     * @param string $tableName
     * @return array

@return annotation of method \ClickHouseDB\Client::truncateTable() does not specify type hint for items of its traversable return value.

     * @throws Exception\TransportException
     * @throws \Exception
     */
    public function truncateTable($tableName)

Method \ClickHouseDB\Client::truncateTable() does not have parameter type hint for its parameter $tableName but it should be possible to add it based on @param annotation "string".

Method \ClickHouseDB\Client::truncateTable() does not have return type hint for its return value but it should be possible to add it based on @return annotation "array".

    {
        $partions = $this->partitions($tableName);
        $out = [];

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

        foreach ($partions as $part_key=>$part)

Expected 1 space before "=>"; 0 found

Expected 1 space after "=>"; 0 found

        {
            $part_id = $part['partition'];

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

            $out[$part_id] = $this->dropPartition($tableName, $part_id);

The function ClickHouseDB\Client::dropPartition() has been deprecated.

        }
        return $out;
    }

    /**
     * Returns the server's uptime in seconds.
     *
     * @return array

@return annotation of method \ClickHouseDB\Client::getServerUptime() does not specify type hint for items of its traversable return value.

     * @throws Exception\TransportException
     */
    public function getServerUptime()

Method \ClickHouseDB\Client::getServerUptime() does not have return type hint for its return value but it should be possible to add it based on @return annotation "array".

    {
        return $this->select('SELECT uptime() as uptime')->fetchOne('uptime');
    }

    /**
     * Returns string with the server version.
     *
     * @throws Exception\TransportException
     */
    public function getServerVersion() : string
    {
        return (string) $this->select('SELECT version() as version')->fetchOne('version');
    }


    /**
     * Read system.settings table
     *
     * @param string $like
     * @return array

@return annotation of method \ClickHouseDB\Client::getServerSystemSettings() does not specify type hint for items of its traversable return value.

     * @throws Exception\TransportException
     */
    public function getServerSystemSettings($like='')

Method \ClickHouseDB\Client::getServerSystemSettings() does not have parameter type hint for its parameter $like but it should be possible to add it based on @param annotation "string".

Method \ClickHouseDB\Client::getServerSystemSettings() does not have return type hint for its return value but it should be possible to add it based on @return annotation "array".

Incorrect spacing between argument "$like" and equals sign; expected 1 but found 0

Incorrect spacing between default value and equals sign for argument "$like"; expected 1 but found 0

    {
        $l=[];

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

        $list=$this->select('SELECT * FROM system.settings'.($like ? ' WHERE name LIKE :like':'' ),['like'=>'%'.$like.'%'])->rows();

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

Concat operator must be surrounded by a single space

Expected 1 space between "'like'" and double arrow; 0 found

Expected 1 space between double arrow and "'%'"; 0 found

        foreach ($list as $row) {
            if (isset($row['name'])) {$n=$row['name']; unset($row['name']) ; $l[$n]=$row;}

Use early exit to reduce code nesting.

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

It is generally recommended to place each PHP statement on a line by itself.

        }
        return $l;
    }



    /**
     * dropOldPartitions by day_ago
     * @deprecated
     *
     * @param string $table_name
     * @param int $days_ago

Expected 4 spaces after parameter type; 1 found

     * @param int $count_partitons_per_one

Expected 4 spaces after parameter type; 1 found

     * @return array

@return annotation of method \ClickHouseDB\Client::dropOldPartitions() does not specify type hint for items of its traversable return value.

     * @throws Exception\TransportException
     * @throws \Exception
     */
    public function dropOldPartitions($table_name, $days_ago, $count_partitons_per_one = 100)

Method \ClickHouseDB\Client::dropOldPartitions() does not have parameter type hint for its parameter $table_name but it should be possible to add it based on @param annotation "string".

Method \ClickHouseDB\Client::dropOldPartitions() does not have parameter type hint for its parameter $days_ago but it should be possible to add it based on @param annotation "int".

Method \ClickHouseDB\Client::dropOldPartitions() does not have parameter type hint for its parameter $count_partitons_per_one but it should be possible to add it based on @param annotation "int".

Method \ClickHouseDB\Client::dropOldPartitions() does not have return type hint for its return value but it should be possible to add it based on @return annotation "array".

    {
        $days_ago = strtotime(date('Y-m-d 00:00:00', strtotime('-' . $days_ago . ' day')));

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

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

        $drop = [];

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

        $list_patitions = $this->partitions($table_name, $count_partitons_per_one);

        foreach ($list_patitions as $partion_id => $partition) {
            if (stripos($partition['engine'], 'mergetree') === false) {

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

                continue;
            }

            // $min_date = strtotime($partition['min_date']);
            $max_date = strtotime($partition['max_date']);

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

            if ($max_date < $days_ago) {

Use early exit to reduce code nesting.

                $drop[] = $partition['partition'];
            }
        }

        $result = [];
        foreach ($drop as $partition_id) {
            $result[$partition_id] = $this->dropPartition($table_name, $partition_id);

The function ClickHouseDB\Client::dropPartition() has been deprecated.

        }

        return $result;
    }
}