Dazzle\PgSQL\Connection\Connector

Complexity

Total Complexity

18

Size/Duplication

Total Lines	128
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

0%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getStream()	0	4	1
A	getSock()	0	4	1
A	getConnection()	0	13	1
C	connect()	0	38	8
A	prepare()	0	8	1
A	query()	0	8	1
A	execute()	0	4	1
A	appendQuery()	0	4	1
A	poll()	0	4	1
A	isConnected()	0	4	1

<?php
namespace Dazzle\PgSQL\Connection;

use Dazzle\Promise\Deferred;
use Dazzle\PgSQL\Statement\Query;
use Dazzle\PgSQL\Statement\PrepareQuery;
use Dazzle\PgSQL\Statement\Statement;
use Dazzle\Throwable\Exception;

class Connector implements ConnectorInterface
{
    protected $connected;

    protected $queryQueue;

    protected $retQueue;

    /**
     * @var Connection $conn
     */
    protected $conn;

    protected $stream;

    public function __construct($config)
    {
        $this->stream = pg_connect($config, \PGSQL_CONNECT_ASYNC|\PGSQL_CONNECT_FORCE_NEW);
        $this->conn = new Connection();
    }

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

    public function getSock()
    {
        return \pg_socket($this->stream);
    }

    public function getConnection()
    {
        //rfc: could passed stream to each connection,add connection resolver and pool
        $connection = $this->conn;
        $promise = $this->conn->getPromise();

        return $promise
               ->success(function (ConnectorInterface $connector) use ($connection) {
                   $connection->setConnector($connector);

                   return $connection;
               });
    }

    public function connect()
    {
        switch ($polled = $this->poll()) {

$polled is not used, you could remove the assignment.

            case \PGSQL_POLLING_FAILED:
                return;
            case \PGSQL_POLLING_OK:
                if ($this->isConnected() != true) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison !== instead.

                    $this->connected = true;
                    $this->conn->resolve($this);

                    return;
                }
                $retRsrc = \pg_get_result($this->stream);
                if ($retRsrc) {
                    if (empty($this->retQueue)) {
                        
                        return;
                    }
                    $ret = array_shift($this->retQueue);
                    $ret->resolve($ret->handle($retRsrc));
                } else {
                    if (empty($this->queryQueue)) {

                        return;
                    }
                    $query = array_shift($this->queryQueue);
                    $ok = $query->execute($this);
                    if (!$ok) {
                        $query->reject(new \Exception('failed'));

                        return;
                    }
                    $this->retQueue[] = $query;
                }

                return;
        }
    }

    public function prepare($sql)
    {        
        $prepare = new PrepareQuery($sql);
        $this->appendQuery($prepare);
        $promise = $prepare->getPromise();

        return $promise;
    }

    /**
     * @inheritDoc
     */
    public function query($sql, $sqlParams = [])
    {
        $stmt = new Query($sql, $sqlParams);
        $promise = $stmt->getPromise();
        $this->appendQuery($stmt);

        return $promise;
    }

    /**
     * @inheritDoc
     */
    public function execute($sql, $sqlParams = [])
    {
        return $this->query($sql, $sqlParams);
    }

    public function appendQuery(Statement $stmt)
    {
        $this->queryQueue[] = $stmt;
    }

    protected function poll()
    {
        return \pg_connect_poll($this->stream);
    }

    protected function isConnected()
    {
        return $this->connected;
    }
}