SwooleTW\Http\Coroutine\PDO

Complexity

Total Complexity

45

Size/Duplication

Total Lines	230
Duplicated Lines	0 %

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
C	getAttribute()	0	22	13
A	errorInfo()	0	6	1
A	beginTransaction()	0	4	1
A	checkDriver()	0	4	2
A	commit()	0	4	1
A	connect()	0	12	4
A	getAvailableDrivers()	0	3	1
A	getOptions()	0	31	5
A	query()	0	10	2
A	__destruct()	0	3	1
A	inTransaction()	0	3	1
A	setClient()	0	3	2
A	__construct()	0	8	1
A	quote()	0	3	1
A	rollBack()	0	4	1
A	rewriteToPosition()	0	2	1
A	exec()	0	5	1
A	prepare()	0	25	4
A	lastInsertId()	0	3	1
A	errorCode()	0	3	1

<?php

/**
 * Copyright: Swlib
 * Author: Twosee <twose@qq.com>
 * Modifier: Albert Chen
 * License: Apache 2.0
 */

namespace SwooleTW\Http\Coroutine;

use Exception;
use PDO as BasePDO;
use Illuminate\Database\QueryException;
use SwooleTW\Http\Coroutine\PDOStatement;
use SwooleTW\Http\Coroutine\StatementException;
use SwooleTW\Http\Coroutine\ConnectionException;

class PDO extends BasePDO
{
    public static $keyMap = [
        'dbname' => 'database'
    ];

    private static $defaultOptions = [
        'host' => '',
        'port' => 3306,
        'user' => '',
        'password' => '',
        'database' => '',
        'charset' => 'utf8mb4',
        'strict_type' => true
    ];

    /** @var \Swoole\Coroutine\Mysql */
    public $client;

    public $inTransaction = false;

    public function __construct(
        string $dsn,
        string $username = '',
        string $password = '',
        array $driverOptions = []
    ) {
        $this->setClient();
        $this->connect($this->getOptions(...func_get_args()));
    }

    protected function setClient($client = null)
    {
        $this->client = $client ?: new \Swoole\Coroutine\Mysql();
    }

    protected function connect(array $options = [])
    {
        $this->client->connect($options);

        if (! $this->client->connected) {
            $message = $this->client->connect_error ?: $this->client->error;
            $errorCode = $this->client->connect_errno ?: $this->client->errno;

            throw new ConnectionException($message, $errorCode);
        }

        return $this;
    }

    protected function getOptions($dsn, $username, $password, $driverOptions)
    {
        $dsn = explode(':', $dsn);
        $driver = ucwords(array_shift($dsn));
        $dsn = explode(';', implode(':', $dsn));
        $options = [];

        static::checkDriver($driver);

        foreach ($dsn as $kv) {
            $kv = explode('=', $kv);

$kv of type string[] is incompatible with the type string expected by parameter $string of explode().

            if ($kv) {

The expression $kv of type string[] 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.

                $options[$kv[0]] = $kv[1] ?? '';
            }
        }

        $authorization = [
            'user' => $username,
            'password' => $password,
        ];

        $options = $driverOptions + $authorization + $options;

        foreach (static::$keyMap as $pdoKey => $swpdoKey) {
            if (isset($options[$pdoKey])) {
                $options[$swpdoKey] = $options[$pdoKey];
                unset($options[$pdoKey]);
            }
        }

        return $options + static::$defaultOptions;

Since $defaultOptions is declared private, accessing it with static will lead to errors in possible sub-classes; you can either use self, or increase the visibility of $defaultOptions to at least protected.

    }

    public static function checkDriver(string $driver)
    {
        if (! in_array($driver, static::getAvailableDrivers())) {
            throw new \InvalidArgumentException("{$driver} driver is not supported yet.");
        }
    }

    public static function getAvailableDrivers()
    {
        return ['Mysql'];
    }

    public function beginTransaction()
    {
        $this->client->begin();
        $this->inTransaction = true;
    }

    public function rollBack()
    {
        $this->client->rollback();
        $this->inTransaction = false;
    }

    public function commit()
    {
        $this->client->commit();
        $this->inTransaction = true;
    }

    public function inTransaction()
    {
        return $this->inTransaction;
    }

    public function lastInsertId($seqname = null)
    {
        return $this->client->insert_id;
    }

    public function errorCode()
    {
        $this->client->errno;
    }

    public function errorInfo()
    {
        return [
            $this->client->errno,
            $this->client->errno,
            $this->client->error,
        ];
    }

    public function exec($statement): int
    {
        $this->query($statement);

        return $this->client->affected_rows;
    }

    public function query(string $statement, float $timeout = -1)
    {
        $result = $this->client->query($statement, $timeout);

        if ($result === false) {
            $exception = new Exception($this->client->error, $this->client->errno);
            throw new QueryException($statement, [], $exception);
        }

        return $result;
    }

    private function rewriteToPosition(string $statement)

The parameter $statement is not used and could be removed.

The method rewriteToPosition() is not used, and could be removed.

    {
        //
    }

    public function prepare($statement, $driverOptions = null)
    {
        $driverOptions = is_null($driverOptions) ? [] : $driverOptions;
        if (strpos($statement, ':') !== false) {
            $i = 0;
            $bindKeyMap = [];
            $statement = preg_replace_callback(
                '/:(\w+)\b/',
                function ($matches) use (&$i, &$bindKeyMap) {
                    $bindKeyMap[$matches[1]] = $i++;

                    return '?';
                },
                $statement
            );
        }

        $stmtObj = $this->client->prepare($statement);

        if ($stmtObj) {

$stmtObj is of type Swoole\Coroutine\Mysql\Statement, thus it always evaluated to true.

            $stmtObj->bindKeyMap = $bindKeyMap ?? [];

The property bindKeyMap does not seem to exist on Swoole\Coroutine\Mysql\Statement.

            return new PDOStatement($this, $stmtObj, $driverOptions);
        } else {
            $statementException = new StatementException($this->client->error, $this->client->errno);
            throw new QueryException($statement, [], $statementException);
        }
    }

    public function getAttribute($attribute)
    {
        switch ($attribute) {
            case \PDO::ATTR_AUTOCOMMIT:
                return true;
            case \PDO::ATTR_CASE:
            case \PDO::ATTR_CLIENT_VERSION:
            case \PDO::ATTR_CONNECTION_STATUS:
                return $this->client->connected;
            case \PDO::ATTR_DRIVER_NAME:
            case \PDO::ATTR_ERRMODE:
                return 'Swoole Style';
            case \PDO::ATTR_ORACLE_NULLS:
            case \PDO::ATTR_PERSISTENT:
            case \PDO::ATTR_PREFETCH:
            case \PDO::ATTR_SERVER_INFO:
                return $this->serverInfo['timeout'] ?? static::$defaultOptions['timeout'];

Since $defaultOptions is declared private, accessing it with static will lead to errors in possible sub-classes; you can either use self, or increase the visibility of $defaultOptions to at least protected.

The property serverInfo does not exist on SwooleTW\Http\Coroutine\PDO. Did you maybe forget to declare it?

            case \PDO::ATTR_SERVER_VERSION:
                return 'Swoole Mysql';
            case \PDO::ATTR_TIMEOUT:
            default:
                throw new \InvalidArgumentException('Not implemented yet!');
        }
    }

    public function quote($string, $paramtype = null)
    {
        throw new \BadMethodCallException(<<<TXT
If you are using this function to build SQL statements,
you are strongly recommended to use PDO::prepare() to prepare SQL statements
with bound parameters instead of using PDO::quote() to interpolate user input into an SQL statement.
Prepared statements with bound parameters are not only more portable, more convenient,
immune to SQL injection, but are often much faster to execute than interpolated queries,
as both the server and client side can cache a compiled form of the query.
TXT
        );
    }

    public function __destruct()
    {
        $this->client->close();
    }
}