Transaction::run() - Code Metrics - spiral/orm - Measure and Improve Code Quality continuously with Scrutinizer

Transaction::run() F
last analyzed 2018-08-29 15:23 UTC

↳ Parent: Transaction

Complexity

Conditions	16
Paths	404

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	70
rs	2.2277
c	0
b	0
f	0
cc	16
nc	404
nop	2

How to fix Long Method Complexity

<?php
/**
 * Spiral, Core Components
 *
 * @author Wolfy-J
 */

namespace Spiral\ORM;

use Spiral\Database\Entities\Driver;
use Spiral\ORM\Exceptions\RecordException;

/**
 * Singular ORM transaction with ability to automatically open transaction for all involved
 * drivers.
 *
 * Drivers will be automatically fetched from commands. Potentially Transaction can be improved
 * to optimize commands inside it (batch insert, batch delete and etc).
 *
 * Technically Transaction can work as classic UnitOfWork with ability to watch entities, but it's
 * recommended to create additional abstraction at top with proper business rules.
 */
final class Transaction implements TransactionInterface
{
    /**
     * @var CommandInterface[]
     */
    private $commands = [];

    /**
     * Store entity information (update or insert).
     *
     * @param RecordInterface $record
     * @param bool            $queueRelations
     *
     * @throws RecordException
     */
    public function store(RecordInterface $record, bool $queueRelations = true)
    {
        $this->addCommand($record->queueStore($queueRelations));
    }

    /**
     * Delete entity from database.
     *
     * @param RecordInterface $record
     *
     * @throws RecordException
     */
    public function delete(RecordInterface $record)
    {
        $this->addCommand($record->queueDelete());
    }

    /**
     * {@inheritdoc}
     */
    public function addCommand(CommandInterface $command)
    {
        $this->commands[] = $command;
    }

    /**
     * Will return flattened list of commands.
     *
     * @return \Generator
     */
    public function getCommands()
    {
        foreach ($this->commands as $command) {
            if ($command instanceof \Traversable) {
                //Nested commands
                yield from $command;
            }

            yield $command;
        }
    }

    /**
     * {@inheritdoc}
     *
     * @param bool $forceTransaction When set to false transaction would not be started when only
     *                               single command is presented inside (all commands are flatten
     *                               before appearing inside this method).
     * @param bool $clean            When set to true - transaction will be cleaned after
     *                               execution, default behaviour.
     */
    public function run(bool $forceTransaction = false, bool $clean = true)
    {
        /**
         * @var Driver[]           $drivers
         * @var CommandInterface[] $commands
         */
        $drivers = $commands = [];

        foreach ($this->getCommands() as $command) {
            if ($command instanceof SQLCommandInterface) {
                $driver = $command->getDriver();
                if (!empty($driver) && !in_array($driver, $drivers)) {
                    $drivers[] = $driver;
                }
            }

            $commands[] = $command;
        }

        if (empty($commands)) {
            return;
        }

        //Commands we executed and drivers with started transactions
        $executedCommands = $wrappedDrivers = [];

        try {
            if ($forceTransaction || count($commands) > 1) {
                //Starting transactions
                foreach ($drivers as $driver) {
                    $driver->beginTransaction();
                    $wrappedDrivers[] = $driver;
                }
            }

            //Run commands
            foreach ($commands as $command) {
                $command->execute();
                $executedCommands[] = $command;
            }
        } catch (\Throwable $e) {
            foreach (array_reverse($wrappedDrivers) as $driver) {
                /** @var Driver $driver */
                $driver->rollbackTransaction();
            }

            foreach (array_reverse($executedCommands) as $command) {
                /** @var CommandInterface $command */
                $command->rollBack();
            }

            $this->commands = [];
            throw $e;
        }

        foreach (array_reverse($wrappedDrivers) as $driver) {
            /** @var Driver $driver */
            $driver->commitTransaction();
        }

        foreach ($executedCommands as $command) {
            //This is the point when record will get related PK and FKs filled
            $command->complete();
        }

        //Clean transaction
        if ($clean) {
            $this->commands = [];
        }
    }
}


1			<?php
2			/**
3			* Spiral, Core Components
4			*
5			* @author Wolfy-J
6			*/
7
8			namespace Spiral\ORM;
9
10			use Spiral\Database\Entities\Driver;
11			use Spiral\ORM\Exceptions\RecordException;
12
13			/**
14			* Singular ORM transaction with ability to automatically open transaction for all involved
15			* drivers.
16			*
17			* Drivers will be automatically fetched from commands. Potentially Transaction can be improved
18			* to optimize commands inside it (batch insert, batch delete and etc).
19			*
20			* Technically Transaction can work as classic UnitOfWork with ability to watch entities, but it's
21			* recommended to create additional abstraction at top with proper business rules.
22			*/
23			final class Transaction implements TransactionInterface
24			{
25			/**
26			* @var CommandInterface[]
27			*/
28			private $commands = [];
29
30			/**
31			* Store entity information (update or insert).
32			*
33			* @param RecordInterface $record
34			* @param bool $queueRelations
35			*
36			* @throws RecordException
37			*/
38			public function store(RecordInterface $record, bool $queueRelations = true)
39			{
40			$this->addCommand($record->queueStore($queueRelations));
41			}
42
43			/**
44			* Delete entity from database.
45			*
46			* @param RecordInterface $record
47			*
48			* @throws RecordException
49			*/
50			public function delete(RecordInterface $record)
51			{
52			$this->addCommand($record->queueDelete());
53			}
54
55			/**
56			* {@inheritdoc}
57			*/
58			public function addCommand(CommandInterface $command)
59			{
60			$this->commands[] = $command;
61			}
62
63			/**
64			* Will return flattened list of commands.
65			*
66			* @return \Generator
67			*/
68			public function getCommands()
69			{
70			foreach ($this->commands as $command) {
71			if ($command instanceof \Traversable) {
72			//Nested commands
73			yield from $command;
74			}
75
76			yield $command;
77			}
78			}
79
80			/**
81			* {@inheritdoc}
82			*
83			* @param bool $forceTransaction When set to false transaction would not be started when only
84			* single command is presented inside (all commands are flatten
85			* before appearing inside this method).
86			* @param bool $clean When set to true - transaction will be cleaned after
87			* execution, default behaviour.
88			*/
89			public function run(bool $forceTransaction = false, bool $clean = true)
90			{
91			/**
92			* @var Driver[] $drivers
93			* @var CommandInterface[] $commands
94			*/
95			$drivers = $commands = [];
96
97			foreach ($this->getCommands() as $command) {
98			if ($command instanceof SQLCommandInterface) {
99			$driver = $command->getDriver();
100			if (!empty($driver) && !in_array($driver, $drivers)) {
101			$drivers[] = $driver;
102			}
103			}
104
105			$commands[] = $command;
106			}
107
108			if (empty($commands)) {
109			return;
110			}
111
112			//Commands we executed and drivers with started transactions
113			$executedCommands = $wrappedDrivers = [];
114
115			try {
116			if ($forceTransaction \|\| count($commands) > 1) {
117			//Starting transactions
118			foreach ($drivers as $driver) {
119			$driver->beginTransaction();
120			$wrappedDrivers[] = $driver;
121			}
122			}
123
124			//Run commands
125			foreach ($commands as $command) {
126			$command->execute();
127			$executedCommands[] = $command;
128			}
129			} catch (\Throwable $e) {
130			foreach (array_reverse($wrappedDrivers) as $driver) {
131			/** @var Driver $driver */
132			$driver->rollbackTransaction();
133			}
134
135			foreach (array_reverse($executedCommands) as $command) {
136			/** @var CommandInterface $command */
137			$command->rollBack();
138			}
139
140			$this->commands = [];
141			throw $e;
142			}
143
144			foreach (array_reverse($wrappedDrivers) as $driver) {
145			/** @var Driver $driver */
146			$driver->commitTransaction();
147			}
148
149			foreach ($executedCommands as $command) {
150			//This is the point when record will get related PK and FKs filled
151			$command->complete();
152			}
153
154			//Clean transaction
155			if ($clean) {
156			$this->commands = [];
157			}
158			}
159			}
160

spiral / orm

Transaction::run() F last analyzed 2018-08-29 15:23 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

Transaction::run() F
last analyzed 2018-08-29 15:23 UTC