Ivory\Connection\TransactionControl::txConfigToSql()

Complexity

Conditions	11
Paths	92

Size

Total Lines	38
Code Lines	27

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	TransactionControl::commitPreparedTransaction()	9	9	2
A	TransactionControl::rollbackPreparedTransaction()	9	9	2
A	TransactionControl::listPreparedTransactions()	0	4	1
A	TransactionControl::quoteString()	0	8	2

<?php
namespace Ivory\Connection;

use Ivory\Exception\InternalException;
use Ivory\Exception\InvalidStateException;
use Ivory\Result\IQueryResult;
use Ivory\Type\Std\StringType;

class TransactionControl implements IObservableTransactionControl
{
    private $connCtl;
    private $stmtExec;
    /** @var ITransactionControlObserver[] */
    private $observers = [];


    public function __construct(ConnectionControl $connCtl, IStatementExecution $stmtExec)
    {
        $this->connCtl = $connCtl;
        $this->stmtExec = $stmtExec;
    }

    public function inTransaction(): bool
    {
        $connHandler = $this->connCtl->requireConnection();
        $txStat = pg_transaction_status($connHandler);
        return ($txStat == PGSQL_TRANSACTION_INTRANS || $txStat == PGSQL_TRANSACTION_INERROR);
    }

    public function startTransaction($transactionOptions = 0): ITxHandle
    {
        if ($this->inTransaction()) {
            throw new InvalidStateException('A transaction is already active, cannot start a new one.');
        }

        $txConfig = TxConfig::create($transactionOptions);
        $txSql = $txConfig->toSql();

        $command = 'START TRANSACTION';
        if (strlen($txSql) > 0) {
            $command .= ' ' . $txSql;
        }

        $this->stmtExec->rawCommand($command);
        $this->notifyTransactionStart();

        return new TxHandle($this->stmtExec, $this); // TODO: use a factory method, abstracting from the specific class
    }

    public function setupSubsequentTransactions($transactionOptions)
    {
        $txConfig = TxConfig::create($transactionOptions);
        $this->stmtExec->rawCommand('SET SESSION CHARACTERISTICS AS TRANSACTION ' . $txConfig->toSql());
    }

    public function commitPreparedTransaction(string $name)

This method seems to be duplicated in your project.

    {
        if ($this->inTransaction()) {
            throw new InvalidStateException('Cannot commit a prepared transaction while inside another transaction.');
        }

        $this->stmtExec->rawCommand("COMMIT PREPARED {$this->quoteString($name)}");
        $this->notifyPreparedTransactionCommit($name);
    }

    public function rollbackPreparedTransaction(string $name)

This method seems to be duplicated in your project.

    {
        if ($this->inTransaction()) {
            throw new InvalidStateException('Cannot rollback a prepared transaction while inside another transaction.');
        }

        $this->stmtExec->rawCommand("ROLLBACK PREPARED {$this->quoteString($name)}");
        $this->notifyPreparedTransactionRollback($name);
    }

    public function listPreparedTransactions(): IQueryResult
    {
        return $this->stmtExec->rawQuery('SELECT * FROM pg_catalog.pg_prepared_xacts');
    }

    private function quoteString(string $str)
    {
        static $stringSerializer = null;
        if ($stringSerializer === null) {
            $stringSerializer = new StringType('pg_catalog', 'text');
        }
        return $stringSerializer->serializeValue($str);
    }


    //region IObservableTransactionControl

    public function addObserver(ITransactionControlObserver $observer)
    {
        $hash = spl_object_hash($observer);
        $this->observers[$hash] = $observer;
    }

    public function removeObserver(ITransactionControlObserver $observer)
    {
        $hash = spl_object_hash($observer);
        unset($this->observers[$hash]);
    }

    public function removeAllObservers()
    {
        $this->observers = [];
    }

    public function notifyTransactionStart()
    {
        foreach ($this->observers as $observer) {
            $observer->handleTransactionStart();
        }
    }

    public function notifyTransactionCommit()
    {
        foreach ($this->observers as $observer) {
            $observer->handleTransactionCommit();
        }
    }

    public function notifyTransactionRollback()
    {
        foreach ($this->observers as $observer) {
            $observer->handleTransactionRollback();
        }
    }

    public function notifySavepointSaved(string $name)
    {
        foreach ($this->observers as $observer) {
            $observer->handleSavepointSaved($name);
        }
    }

    public function notifySavepointReleased(string $name)
    {
        foreach ($this->observers as $observer) {
            $observer->handleSavepointReleased($name);
        }
    }

    public function notifyRollbackToSavepoint(string $name)
    {
        foreach ($this->observers as $observer) {
            $observer->handleRollbackToSavepoint($name);
        }
    }

    public function notifyTransactionPrepared(string $name)
    {
        foreach ($this->observers as $observer) {
            $observer->handleTransactionPrepared($name);
        }
    }

    public function notifyPreparedTransactionCommit(string $name)
    {
        foreach ($this->observers as $observer) {
            $observer->handlePreparedTransactionCommit($name);
        }
    }

    public function notifyPreparedTransactionRollback(string $name)
    {
        foreach ($this->observers as $observer) {
            $observer->handlePreparedTransactionRollback($name);
        }
    }

    //endregion
}