Transaction::begin() - Code Metrics - Inspection of "Updated G++ to 4.8 for Firebird Master;" - edgardmessias/yii2-firebird - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 4b2e55...537f36 )

by Edgard

created 2017-02-07 10:34 UTC

Transaction::begin() B

↳ Parent: Transaction

Complexity

Conditions	6
Paths	5

Size

Total Lines	31
Code Lines	21

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	18
CRAP Score	6.0359

Importance

Changes

Metric	Value
dl	0
loc	31
ccs	18
cts	20
cp	0.9
rs	8.439
c	0
b	0
f	0
cc	6
eloc	21
nc	5
nop	1
crap	6.0359

<?php

/**
 * @link http://www.yiiframework.com/
 * @copyright Copyright (c) 2008 Yii Software LLC
 * @license http://www.yiiframework.com/license/
 */

namespace edgardmessias\db\firebird;

use Yii;
use yii\base\InvalidConfigException;
use yii\db\Exception;

/**
 * Transaction represents a DB transaction.
 *
 * It is usually created by calling [[Connection::beginTransaction()]].
 *
 * The following code is a typical example of using transactions (note that some
 * DBMS may not support transactions):
 *
 * ~~~
 * $transaction = $connection->beginTransaction();
 * try {
 *     $connection->createCommand($sql1)->execute();
 *     $connection->createCommand($sql2)->execute();
 *     //.... other SQL executions
 *     $transaction->commit();
 * } catch (Exception $e) {
 *     $transaction->rollBack();
 * }
 * ~~~
 *
 * @property boolean $isActive Whether this transaction is active. Only an active transaction can [[commit()]]
 * or [[rollBack()]]. This property is read-only.
 * @property string $isolationLevel The transaction isolation level to use for this transaction. This can be
 * one of [[READ_UNCOMMITTED]], [[READ_COMMITTED]], [[REPEATABLE_READ]] and [[SERIALIZABLE]] but also a string
 * containing DBMS specific syntax to be used after `SET TRANSACTION ISOLATION LEVEL`. This property is
 * write-only.
 *
 * @author Edgard Lorraine Messias <[email protected]>
 * @since 1.0
 */
class Transaction extends \yii\db\Transaction
{

    /**
     * @var integer the nesting level of the transaction. 0 means the outermost level.
     */
    private $_level = 0;

    /**
     * Returns a value indicating whether this transaction is active.
     * @return boolean whether this transaction is active. Only an active transaction
     * can [[commit()]] or [[rollBack()]].
     */
    public function getIsActive()
    {
        return $this->_level > 0 && $this->db && $this->db->isActive;
    }

    /**
     * Begins a transaction.
     * @param string|null $isolationLevel The [isolation level][] to use for this transaction.
     * This can be one of [[READ_UNCOMMITTED]], [[READ_COMMITTED]], [[REPEATABLE_READ]] and [[SERIALIZABLE]] but
     * also a string containing DBMS specific syntax to be used after `SET TRANSACTION ISOLATION LEVEL`.
     * If not specified (`null`) the isolation level will not be set explicitly and the DBMS default will be used.
     *
     * > Note: This setting does not work for PostgreSQL, where setting the isolation level before the transaction
     * has no effect. You have to call [[setIsolationLevel()]] in this case after the transaction has started.
     *
     * > Note: Some DBMS allow setting of the isolation level only for the whole connection so subsequent transactions
     * may get the same isolation level even if you did not specify any. When using this feature
     * you may need to set the isolation level for all transactions explicitly to avoid conflicting settings.
     * At the time of this writing affected DBMS are MSSQL and SQLite.
     *
     * [isolation level]: http://en.wikipedia.org/wiki/Isolation_%28database_systems%29#Isolation_levels
     * @throws InvalidConfigException if [[db]] is `null`.
     */
    public function begin($isolationLevel = null)
    {
        if ($this->db === null) {
            throw new InvalidConfigException('Transaction::db must be set.');
        }
        $this->db->open();

        if ($this->_level == 0) {
            Yii::trace('Begin transaction' . ($isolationLevel ? ' with isolation level ' . $isolationLevel : ''), __METHOD__);

            $this->db->trigger(Connection::EVENT_BEGIN_TRANSACTION);
            if ($isolationLevel !== null) {
                $this->db->pdo->beginTransaction(false);
                $this->db->getSchema()->setTransactionIsolationLevel($isolationLevel);
            } else {
                $this->db->pdo->beginTransaction();
            }
            $this->_level = 1;

            return;
        }

        $schema = $this->db->getSchema();
        if ($schema->supportsSavepoint()) {
            Yii::trace('Set savepoint ' . $this->_level, __METHOD__);
            $schema->createSavepoint('LEVEL' . $this->_level);
        } else {
            Yii::info('Transaction not started: nested transaction not supported', __METHOD__);
        }
        $this->_level++;
    }

    /**
     * Commits a transaction.
     * @throws Exception if the transaction is not active
     */
    public function commit()
    {
        if (!$this->getIsActive()) {
            throw new Exception('Failed to commit transaction: transaction was inactive.');
        }

        $this->_level--;
        if ($this->_level == 0) {
            Yii::trace('Commit transaction', __METHOD__);
            $this->db->pdo->commit();
            $this->db->trigger(Connection::EVENT_COMMIT_TRANSACTION);
            return;
        }

        $schema = $this->db->getSchema();
        if ($schema->supportsSavepoint()) {
            Yii::trace('Release savepoint ' . $this->_level, __METHOD__);
            $schema->releaseSavepoint('LEVEL' . $this->_level);
        } else {
            Yii::info('Transaction not committed: nested transaction not supported', __METHOD__);
        }
    }

    /**
     * Rolls back a transaction.
     * @throws Exception if the transaction is not active
     */
    public function rollBack()
    {
        if (!$this->getIsActive()) {
            // do nothing if transaction is not active: this could be the transaction is committed
            // but the event handler to "commitTransaction" throw an exception
            return;
        }

        $this->_level--;
        if ($this->_level == 0) {
            Yii::trace('Roll back transaction', __METHOD__);
            $this->db->pdo->rollBack();
            $this->db->trigger(Connection::EVENT_ROLLBACK_TRANSACTION);
            return;
        }

        $schema = $this->db->getSchema();
        if ($schema->supportsSavepoint()) {
            Yii::trace('Roll back to savepoint ' . $this->_level, __METHOD__);
            $schema->rollBackSavepoint('LEVEL' . $this->_level);
        } else {
            Yii::info('Transaction not rolled back: nested transaction not supported', __METHOD__);
            // throw an exception to fail the outer transaction
            throw new Exception('Roll back failed: nested transaction not supported.');
        }
    }

    /**
     * Sets the transaction isolation level for this transaction.
     *
     * This method can be used to set the isolation level while the transaction is already active.
     * However this is not supported by all DBMS so you might rather specify the isolation level directly
     * when calling [[begin()]].
     * @param string $level The transaction isolation level to use for this transaction.
     * This can be one of [[READ_UNCOMMITTED]], [[READ_COMMITTED]], [[REPEATABLE_READ]] and [[SERIALIZABLE]] but
     * also a string containing DBMS specific syntax to be used after `SET TRANSACTION ISOLATION LEVEL`.
     * @throws Exception if the transaction is not active
     * @see http://en.wikipedia.org/wiki/Isolation_%28database_systems%29#Isolation_levels
     */
    public function setIsolationLevel($level)
    {
        if (!$this->getIsActive()) {
            throw new Exception('Failed to set isolation level: transaction was inactive.');
        }
        Yii::trace('Setting transaction isolation level to ' . $level, __METHOD__);
        $this->db->getSchema()->setTransactionIsolationLevel($level);
    }

    /**
     * @return integer The current nesting level of the transaction.
     * @since 2.0.8
     */
    public function getLevel()
    {
        return $this->_level;
    }
}


1		<?php
2
3		/**
4		* @link http://www.yiiframework.com/
5		* @copyright Copyright (c) 2008 Yii Software LLC
6		* @license http://www.yiiframework.com/license/
7		*/
8
9		namespace edgardmessias\db\firebird;
10
11		use Yii;
12		use yii\base\InvalidConfigException;
13		use yii\db\Exception;
14
15		/**
16		* Transaction represents a DB transaction.
17		*
18		* It is usually created by calling [[Connection::beginTransaction()]].
19		*
20		* The following code is a typical example of using transactions (note that some
21		* DBMS may not support transactions):
22		*
23		* ~~~
24		* $transaction = $connection->beginTransaction();
25		* try {
26		* $connection->createCommand($sql1)->execute();
27		* $connection->createCommand($sql2)->execute();
28		* //.... other SQL executions
29		* $transaction->commit();
30		* } catch (Exception $e) {
31		* $transaction->rollBack();
32		* }
33		* ~~~
34		*
35		* @property boolean $isActive Whether this transaction is active. Only an active transaction can [[commit()]]
36		* or [[rollBack()]]. This property is read-only.
37		* @property string $isolationLevel The transaction isolation level to use for this transaction. This can be
38		* one of [[READ_UNCOMMITTED]], [[READ_COMMITTED]], [[REPEATABLE_READ]] and [[SERIALIZABLE]] but also a string
39		* containing DBMS specific syntax to be used after `SET TRANSACTION ISOLATION LEVEL`. This property is
40		* write-only.
41		*
42		* @author Edgard Lorraine Messias <[email protected]>
43		* @since 1.0
44		*/
45		class Transaction extends \yii\db\Transaction
46		{
47
48		/**
49		* @var integer the nesting level of the transaction. 0 means the outermost level.
50		*/
51		private $_level = 0;
52
53		/**
54		* Returns a value indicating whether this transaction is active.
55		* @return boolean whether this transaction is active. Only an active transaction
56		* can [[commit()]] or [[rollBack()]].
57		*/
58	6	public function getIsActive()
59		{
60	6	return $this->_level > 0 && $this->db && $this->db->isActive;
61		}
62
63		/**
64		* Begins a transaction.
65		* @param string\|null $isolationLevel The [isolation level][] to use for this transaction.
66		* This can be one of [[READ_UNCOMMITTED]], [[READ_COMMITTED]], [[REPEATABLE_READ]] and [[SERIALIZABLE]] but
67		* also a string containing DBMS specific syntax to be used after `SET TRANSACTION ISOLATION LEVEL`.
68		* If not specified (`null`) the isolation level will not be set explicitly and the DBMS default will be used.
69		*
70		* > Note: This setting does not work for PostgreSQL, where setting the isolation level before the transaction
71		* has no effect. You have to call [[setIsolationLevel()]] in this case after the transaction has started.
72		*
73		* > Note: Some DBMS allow setting of the isolation level only for the whole connection so subsequent transactions
74		* may get the same isolation level even if you did not specify any. When using this feature
75		* you may need to set the isolation level for all transactions explicitly to avoid conflicting settings.
76		* At the time of this writing affected DBMS are MSSQL and SQLite.
77		*
78		* [isolation level]: http://en.wikipedia.org/wiki/Isolation_%28database_systems%29#Isolation_levels
79		* @throws InvalidConfigException if [[db]] is `null`.
80		*/
81	6	public function begin($isolationLevel = null)
82		{
83	6	if ($this->db === null) {
84		throw new InvalidConfigException('Transaction::db must be set.');
85		}
86	6	$this->db->open();
87
88	6	if ($this->_level == 0) {
89	6	Yii::trace('Begin transaction' . ($isolationLevel ? ' with isolation level ' . $isolationLevel : ''), __METHOD__);
90
91	6	$this->db->trigger(Connection::EVENT_BEGIN_TRANSACTION);
92	6	if ($isolationLevel !== null) {
93	2	$this->db->pdo->beginTransaction(false);
94	2	$this->db->getSchema()->setTransactionIsolationLevel($isolationLevel);
95		} else {
96	4	$this->db->pdo->beginTransaction();
97		}
98	6	$this->_level = 1;
99
100	6	return;
101		}
102
103	1	$schema = $this->db->getSchema();
104	1	if ($schema->supportsSavepoint()) {
105	1	Yii::trace('Set savepoint ' . $this->_level, __METHOD__);
106	1	$schema->createSavepoint('LEVEL' . $this->_level);
107		} else {
108		Yii::info('Transaction not started: nested transaction not supported', __METHOD__);
109		}
110	1	$this->_level++;
111	1	}
112
113		/**
114		* Commits a transaction.
115		* @throws Exception if the transaction is not active
116		*/
117	5	public function commit()
118		{
119	5	if (!$this->getIsActive()) {
120		throw new Exception('Failed to commit transaction: transaction was inactive.');
121		}
122
123	5	$this->_level--;
124	5	if ($this->_level == 0) {
125	5	Yii::trace('Commit transaction', __METHOD__);
126	5	$this->db->pdo->commit();
127	5	$this->db->trigger(Connection::EVENT_COMMIT_TRANSACTION);
128	5	return;
129		}
130
131		$schema = $this->db->getSchema();
132		if ($schema->supportsSavepoint()) {
133		Yii::trace('Release savepoint ' . $this->_level, __METHOD__);
134		$schema->releaseSavepoint('LEVEL' . $this->_level);
135		} else {
136		Yii::info('Transaction not committed: nested transaction not supported', __METHOD__);
137		}
138		}
139
140		/**
141		* Rolls back a transaction.
142		* @throws Exception if the transaction is not active
143		*/
144	3	public function rollBack()
145		{
146	3	if (!$this->getIsActive()) {
147		// do nothing if transaction is not active: this could be the transaction is committed
148		// but the event handler to "commitTransaction" throw an exception
149		return;
150		}
151
152	3	$this->_level--;
153	3	if ($this->_level == 0) {
154	2	Yii::trace('Roll back transaction', __METHOD__);
155	2	$this->db->pdo->rollBack();
156	2	$this->db->trigger(Connection::EVENT_ROLLBACK_TRANSACTION);
157	2	return;
158		}
159
160	1	$schema = $this->db->getSchema();
161	1	if ($schema->supportsSavepoint()) {
162	1	Yii::trace('Roll back to savepoint ' . $this->_level, __METHOD__);
163	1	$schema->rollBackSavepoint('LEVEL' . $this->_level);
164		} else {
165		Yii::info('Transaction not rolled back: nested transaction not supported', __METHOD__);
166		// throw an exception to fail the outer transaction
167		throw new Exception('Roll back failed: nested transaction not supported.');
168		}
169	1	}
170
171		/**
172		* Sets the transaction isolation level for this transaction.
173		*
174		* This method can be used to set the isolation level while the transaction is already active.
175		* However this is not supported by all DBMS so you might rather specify the isolation level directly
176		* when calling [[begin()]].
177		* @param string $level The transaction isolation level to use for this transaction.
178		* This can be one of [[READ_UNCOMMITTED]], [[READ_COMMITTED]], [[REPEATABLE_READ]] and [[SERIALIZABLE]] but
179		* also a string containing DBMS specific syntax to be used after `SET TRANSACTION ISOLATION LEVEL`.
180		* @throws Exception if the transaction is not active
181		* @see http://en.wikipedia.org/wiki/Isolation_%28database_systems%29#Isolation_levels
182		*/
183		public function setIsolationLevel($level)
184		{
185		if (!$this->getIsActive()) {
186		throw new Exception('Failed to set isolation level: transaction was inactive.');
187		}
188		Yii::trace('Setting transaction isolation level to ' . $level, __METHOD__);
189		$this->db->getSchema()->setTransactionIsolationLevel($level);
190		}
191
192		/**
193		* @return integer The current nesting level of the transaction.
194		* @since 2.0.8
195		*/
196	4	public function getLevel()
197		{
198	4	return $this->_level;
199		}
200		}
201

edgardmessias / yii2-firebird

Push — master ( 4b2e55...537f36 )

Transaction::begin() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like