DbalExecutor - Code Metrics - doctrine/migrations - Measure and Improve Code Quality continuously with Scrutinizer

DbalExecutor A
last analyzed 2020-06-22 08:38 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	319
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	15

Test Coverage

Coverage

97.35%

Importance

Changes

Metric	Value
wmc	37
lcom	1
cbo	15
dl	0
loc	319
ccs	147
cts	151
cp	0.9735
rs	9.44
c	0
b	0
f	0

13 Methods

Rating	Name	Size	Complexity
A	__construct()	17	1
A	getSql()	4	1
A	addSql()	4	1
A	execute()	30	3
A	startMigration()	19	2
C	executeMigration()	88	9
A	getMigrationHeader()	17	3
A	migrationEnd()	17	2
A	logResult()	22	3
A	executeResult()	18	3
A	outputSqlQuery()	16	2
A	getFromSchema()	9	3
A	getExecutionStateAsString()	13	4

<?php

declare(strict_types=1);

namespace Doctrine\Migrations\Version;

use DateTimeImmutable;
use Doctrine\DBAL\Connection;
use Doctrine\DBAL\Schema\Schema;
use Doctrine\Migrations\AbstractMigration;
use Doctrine\Migrations\EventDispatcher;
use Doctrine\Migrations\Events;
use Doctrine\Migrations\Exception\SkipMigration;
use Doctrine\Migrations\Metadata\MigrationPlan;
use Doctrine\Migrations\Metadata\Storage\MetadataStorage;
use Doctrine\Migrations\MigratorConfiguration;
use Doctrine\Migrations\ParameterFormatter;
use Doctrine\Migrations\Provider\SchemaDiffProvider;
use Doctrine\Migrations\Query\Query;
use Doctrine\Migrations\Tools\BytesFormatter;
use Psr\Log\LoggerInterface;
use Psr\Log\LogLevel;
use Symfony\Component\Stopwatch\Stopwatch;
use Throwable;
use function count;
use function ucfirst;

/**
 * The DbalExecutor class is responsible for executing a single migration version.
 *
 * @internal
 */
final class DbalExecutor implements Executor
{
    /** @var Connection */
    private $connection;

    /** @var SchemaDiffProvider */
    private $schemaProvider;

    /** @var ParameterFormatter */
    private $parameterFormatter;

    /** @var Stopwatch */
    private $stopwatch;

    /** @var Query[] */
    private $sql = [];

    /** @var MetadataStorage */
    private $metadataStorage;

    /** @var LoggerInterface */
    private $logger;

    /** @var EventDispatcher */
    private $dispatcher;

    public function __construct(
        MetadataStorage $metadataStorage,
        EventDispatcher $dispatcher,
        Connection $connection,
        SchemaDiffProvider $schemaProvider,
        LoggerInterface $logger,
        ParameterFormatter $parameterFormatter,
        Stopwatch $stopwatch
    ) {
        $this->connection         = $connection;
        $this->schemaProvider     = $schemaProvider;
        $this->parameterFormatter = $parameterFormatter;
        $this->stopwatch          = $stopwatch;
        $this->metadataStorage    = $metadataStorage;
        $this->logger             = $logger;
        $this->dispatcher         = $dispatcher;
    }

    /**
     * @return Query[]
     */
    public function getSql() : array
    {
        return $this->sql;
    }

    public function addSql(Query $sqlQuery) : void
    {
        $this->sql[] = $sqlQuery;
    }

    public function execute(
        MigrationPlan $plan,
        MigratorConfiguration $configuration
    ) : ExecutionResult {
        $result = new ExecutionResult($plan->getVersion(), $plan->getDirection(), new DateTimeImmutable());

        $this->startMigration($plan, $configuration);

        try {
            $this->executeMigration(
                $plan,
                $result,
                $configuration
            );

            $result->setSql($this->sql);
        } catch (SkipMigration $e) {
            $result->setSkipped(true);

            $this->migrationEnd($e, $plan, $result, $configuration);
        } catch (Throwable $e) {
            $result->setError(true, $e);

            $this->migrationEnd($e, $plan, $result, $configuration);

            throw $e;
        }

        return $result;
    }

    private function startMigration(
        MigrationPlan $plan,
        MigratorConfiguration $configuration
    ) : void {
        $this->sql = [];

        $this->dispatcher->dispatchVersionEvent(
            Events::onMigrationsVersionExecuting,
            $plan,
            $configuration
        );

        if (! $plan->getMigration()->isTransactional()) {
            return;
        }

        // only start transaction if in transactional mode
        $this->connection->beginTransaction();
    }

    private function executeMigration(
        MigrationPlan $plan,
        ExecutionResult $result,
        MigratorConfiguration $configuration
    ) : ExecutionResult {
        $stopwatchEvent = $this->stopwatch->start('execute');

        $migration = $plan->getMigration();
        $direction = $plan->getDirection();

        $result->setState(State::PRE);

        $fromSchema = $this->getFromSchema($configuration);

        $migration->{'pre' . ucfirst($direction)}($fromSchema);

        $this->logger->info(...$this->getMigrationHeader($plan, $migration, $direction));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $result->setState(State::EXEC);

        $toSchema = $this->schemaProvider->createToSchema($fromSchema);

        $result->setToSchema($toSchema);

        $migration->$direction($toSchema);

        foreach ($migration->getSql() as $sqlQuery) {
            $this->addSql($sqlQuery);
        }

        foreach ($this->schemaProvider->getSqlDiffToMigrate($fromSchema, $toSchema) as $sql) {
            $this->addSql(new Query($sql));
        }

        if (count($this->sql) !== 0) {
            if (! $configuration->isDryRun()) {
                $this->executeResult($configuration);
            } else {
                foreach ($this->sql as $query) {
                    $this->outputSqlQuery($query, $configuration);
                }
            }
        } else {
            $this->logger->warning('Migration {version} was executed but did not result in any SQL statements.', [
                'version' => (string) $plan->getVersion(),
            ]);
        }

        $result->setState(State::POST);

        $migration->{'post' . ucfirst($direction)}($toSchema);

        $stopwatchEvent->stop();
        $periods    = $stopwatchEvent->getPeriods();
        $lastPeriod = $periods[count($periods) -1];

        $result->setTime((float) $lastPeriod->getDuration()/1000);
        $result->setMemory($lastPeriod->getMemory());

        $params = [
            'version' => (string) $plan->getVersion(),
            'time' => $lastPeriod->getDuration(),
            'memory' => BytesFormatter::formatBytes($lastPeriod->getMemory()),
            'direction' => $direction === Direction::UP ? 'migrated' : 'reverted',
        ];

        $this->logger->info('Migration {version} {direction} (took {time}ms, used {memory} memory)', $params);

        if (! $configuration->isDryRun()) {
            $this->metadataStorage->complete($result);
        }

        if ($migration->isTransactional()) {
            //commit only if running in transactional mode
            $this->connection->commit();
        }

        $plan->markAsExecuted($result);
        $result->setState(State::NONE);

        $this->dispatcher->dispatchVersionEvent(
            Events::onMigrationsVersionExecuted,
            $plan,
            $configuration
        );

        return $result;
    }

    /**
     * @return mixed[]
     */
    private function getMigrationHeader(MigrationPlan $planItem, AbstractMigration $migration, string $direction) : array
    {
        $versionInfo = (string) $planItem->getVersion();
        $description = $migration->getDescription();

        if ($description !== '') {
            $versionInfo .= ' (' . $description . ')';
        }

        $params = ['version_name' => $versionInfo];

        if ($direction === Direction::UP) {
            return ['++ migrating {version_name}', $params];
        }

        return ['++ reverting {version_name}', $params];
    }

    private function migrationEnd(Throwable $e, MigrationPlan $plan, ExecutionResult $result, MigratorConfiguration $configuration) : void
    {
        $migration = $plan->getMigration();
        if ($migration->isTransactional()) {
            //only rollback transaction if in transactional mode
            $this->connection->rollBack();
        }

        $plan->markAsExecuted($result);
        $this->logResult($e, $result, $plan);

        $this->dispatcher->dispatchVersionEvent(
            Events::onMigrationsVersionSkipped,
            $plan,
            $configuration
        );
    }

    private function logResult(Throwable $e, ExecutionResult $result, MigrationPlan $plan) : void
    {
        if ($result->isSkipped()) {
            $this->logger->error(
                'Migration {version} skipped during {state}. Reason: "{reason}"',
                [
                    'version' => (string) $plan->getVersion(),
                    'reason' => $e->getMessage(),
                    'state' => $this->getExecutionStateAsString($result->getState()),
                ]
            );
        } elseif ($result->hasError()) {
            $this->logger->error(
                'Migration {version} failed during {state}. Error: "{error}"',
                [
                    'version' => (string) $plan->getVersion(),
                    'error' => $e->getMessage(),
                    'state' => $this->getExecutionStateAsString($result->getState()),
                ]
            );
        }
    }

    private function executeResult(MigratorConfiguration $configuration) : void
    {
        foreach ($this->sql as $key => $query) {
            $this->outputSqlQuery($query, $configuration);

            $stopwatchEvent = $this->stopwatch->start('query');
            $this->connection->executeUpdate($query->getStatement(), $query->getParameters(), $query->getTypes());
            $stopwatchEvent->stop();

            if (! $configuration->getTimeAllQueries()) {
                continue;
            }

            $this->logger->notice('Query took {duration}ms', [
                'duration' => $stopwatchEvent->getDuration(),
            ]);
        }
    }

    private function outputSqlQuery(Query $query, MigratorConfiguration $configuration) : void
    {
        $params = $this->parameterFormatter->formatParameters(
            $query->getParameters(),
            $query->getTypes()
        );

        $this->logger->log(
            $configuration->getTimeAllQueries() ? LogLevel::NOTICE : LogLevel::DEBUG,
            '{query} {params}',
            [
                'query'  => $query->getStatement(),
                'params' => $params,
            ]
        );
    }

    private function getFromSchema(MigratorConfiguration $configuration) : Schema
    {
        // if we're in a dry run, use the from Schema instead of reading the schema from the database
        if ($configuration->isDryRun() && $configuration->getFromSchema() !== null) {
            return $configuration->getFromSchema();
        }

        return $this->schemaProvider->createFromSchema();
    }

    private function getExecutionStateAsString(int $state) : string
    {
        switch ($state) {
            case State::PRE:
                return 'Pre-Checks';
            case State::POST:
                return 'Post-Checks';
            case State::EXEC:
                return 'Execution';
            default:
                return 'No State';
        }
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Doctrine\Migrations\Version;
6
7		use DateTimeImmutable;
8		use Doctrine\DBAL\Connection;
9		use Doctrine\DBAL\Schema\Schema;
10		use Doctrine\Migrations\AbstractMigration;
11		use Doctrine\Migrations\EventDispatcher;
12		use Doctrine\Migrations\Events;
13		use Doctrine\Migrations\Exception\SkipMigration;
14		use Doctrine\Migrations\Metadata\MigrationPlan;
15		use Doctrine\Migrations\Metadata\Storage\MetadataStorage;
16		use Doctrine\Migrations\MigratorConfiguration;
17		use Doctrine\Migrations\ParameterFormatter;
18		use Doctrine\Migrations\Provider\SchemaDiffProvider;
19		use Doctrine\Migrations\Query\Query;
20		use Doctrine\Migrations\Tools\BytesFormatter;
21		use Psr\Log\LoggerInterface;
22		use Psr\Log\LogLevel;
23		use Symfony\Component\Stopwatch\Stopwatch;
24		use Throwable;
25		use function count;
26		use function ucfirst;
27
28		/**
29		* The DbalExecutor class is responsible for executing a single migration version.
30		*
31		* @internal
32		*/
33		final class DbalExecutor implements Executor
34		{
35		/** @var Connection */
36		private $connection;
37
38		/** @var SchemaDiffProvider */
39		private $schemaProvider;
40
41		/** @var ParameterFormatter */
42		private $parameterFormatter;
43
44		/** @var Stopwatch */
45		private $stopwatch;
46
47		/** @var Query[] */
48		private $sql = [];
49
50		/** @var MetadataStorage */
51		private $metadataStorage;
52
53		/** @var LoggerInterface */
54		private $logger;
55
56		/** @var EventDispatcher */
57		private $dispatcher;
58	17
59		public function __construct(
60		MetadataStorage $metadataStorage,
61		EventDispatcher $dispatcher,
62		Connection $connection,
63		SchemaDiffProvider $schemaProvider,
64		LoggerInterface $logger,
65		ParameterFormatter $parameterFormatter,
66		Stopwatch $stopwatch
67	17	) {
68	17	$this->connection = $connection;
69	17	$this->schemaProvider = $schemaProvider;
70	17	$this->parameterFormatter = $parameterFormatter;
71	17	$this->stopwatch = $stopwatch;
72	17	$this->metadataStorage = $metadataStorage;
73	17	$this->logger = $logger;
74	17	$this->dispatcher = $dispatcher;
75		}
76
77		/**
78		* @return Query[]
79	1	*/
80		public function getSql() : array
81	1	{
82		return $this->sql;
83		}
84	11
85		public function addSql(Query $sqlQuery) : void
86	11	{
87	11	$this->sql[] = $sqlQuery;
88		}
89	15
90		public function execute(
91		MigrationPlan $plan,
92		MigratorConfiguration $configuration
93	15	) : ExecutionResult {
94		$result = new ExecutionResult($plan->getVersion(), $plan->getDirection(), new DateTimeImmutable());
95	15
96		$this->startMigration($plan, $configuration);
97
98	15	try {
99	15	$this->executeMigration(
100	15	$plan,
101	15	$result,
102		$configuration
103		);
104	11
105	4	$result->setSql($this->sql);
106	1	} catch (SkipMigration $e) {
107		$result->setSkipped(true);
108	1
109	3	$this->migrationEnd($e, $plan, $result, $configuration);
110	3	} catch (Throwable $e) {
111		$result->setError(true, $e);
112	3
113		$this->migrationEnd($e, $plan, $result, $configuration);
114	3
115		throw $e;
116		}
117	12
118		return $result;
119		}
120	15
121		private function startMigration(
122		MigrationPlan $plan,
123		MigratorConfiguration $configuration
124	15	) : void {
125		$this->sql = [];
126	15
127	15	$this->dispatcher->dispatchVersionEvent(
128	15	Events::onMigrationsVersionExecuting,
129	15	$plan,
130		$configuration
131		);
132	15
133	1	if (! $plan->getMigration()->isTransactional()) {
134		return;
135		}
136
137	14	// only start transaction if in transactional mode
138	14	$this->connection->beginTransaction();
139		}
140	15
141		private function executeMigration(
142		MigrationPlan $plan,
143		ExecutionResult $result,
144		MigratorConfiguration $configuration
145	15	) : ExecutionResult {
146		$stopwatchEvent = $this->stopwatch->start('execute');
147	15
148	15	$migration = $plan->getMigration();
149		$direction = $plan->getDirection();
150	15
151		$result->setState(State::PRE);
152	15
153		$fromSchema = $this->getFromSchema($configuration);
154	15
155		$migration->{'pre' . ucfirst($direction)}($fromSchema);
156	15
157		$this->logger->info(...$this->getMigrationHeader($plan, $migration, $direction));
		0 ignored issues – show Documentation introduced 2020-06-19 04:08 UTC by Report Bug Copy Issue Report `$this->getMigrationHeade...$migration, $direction)` is of type `array<integer,*>`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
158	15
159		$result->setState(State::EXEC);
160	15
161		$toSchema = $this->schemaProvider->createToSchema($fromSchema);
162	15
163		$result->setToSchema($toSchema);
164	15
165		$migration->$direction($toSchema);
166	12
167	10	foreach ($migration->getSql() as $sqlQuery) {
168		$this->addSql($sqlQuery);
169		}
170	12
171		foreach ($this->schemaProvider->getSqlDiffToMigrate($fromSchema, $toSchema) as $sql) {
172		$this->addSql(new Query($sql));
173		}
174	12
175	10	if (count($this->sql) !== 0) {
176	9	if (! $configuration->isDryRun()) {
177		$this->executeResult($configuration);
178	10	} else {
179	1	foreach ($this->sql as $query) {
180		$this->outputSqlQuery($query, $configuration);
181		}
182		}
183	2	} else {
184	2	$this->logger->warning('Migration {version} was executed but did not result in any SQL statements.', [
185		'version' => (string) $plan->getVersion(),
186		]);
187		}
188	12
189		$result->setState(State::POST);
190	12
191		$migration->{'post' . ucfirst($direction)}($toSchema);
192	12
193	12	$stopwatchEvent->stop();
194	12	$periods = $stopwatchEvent->getPeriods();
195		$lastPeriod = $periods[count($periods) -1];
196	12
197	12	$result->setTime((float) $lastPeriod->getDuration()/1000);
198		$result->setMemory($lastPeriod->getMemory());
199
200	12	$params = [
201	12	'version' => (string) $plan->getVersion(),
202	12	'time' => $lastPeriod->getDuration(),
203	12	'memory' => BytesFormatter::formatBytes($lastPeriod->getMemory()),
204		'direction' => $direction === Direction::UP ? 'migrated' : 'reverted',
205		];
206	12
207		$this->logger->info('Migration {version} {direction} (took {time}ms, used {memory} memory)', $params);
208	12
209	11	if (! $configuration->isDryRun()) {
210		$this->metadataStorage->complete($result);
211		}
212	11
213		if ($migration->isTransactional()) {
214	10	//commit only if running in transactional mode
215		$this->connection->commit();
216		}
217	11
218	11	$plan->markAsExecuted($result);
219		$result->setState(State::NONE);
220	11
221	11	$this->dispatcher->dispatchVersionEvent(
222	11	Events::onMigrationsVersionExecuted,
223	11	$plan,
224		$configuration
225		);
226	11
227		return $result;
228		}
229
230		/**
231		* @return mixed[]
232	15	*/
233		private function getMigrationHeader(MigrationPlan $planItem, AbstractMigration $migration, string $direction) : array
234	15	{
235	15	$versionInfo = (string) $planItem->getVersion();
236		$description = $migration->getDescription();
237	15
238	1	if ($description !== '') {
239		$versionInfo .= ' (' . $description . ')';
240		}
241	15
242		$params = ['version_name' => $versionInfo];
243	15
244	13	if ($direction === Direction::UP) {
245		return ['++ migrating {version_name}', $params];
246		}
247	2
248		return ['++ reverting {version_name}', $params];
249		}
250	4
251		private function migrationEnd(Throwable $e, MigrationPlan $plan, ExecutionResult $result, MigratorConfiguration $configuration) : void
252	4	{
253	4	$migration = $plan->getMigration();
254		if ($migration->isTransactional()) {
255	4	//only rollback transaction if in transactional mode
256		$this->connection->rollBack();
257		}
258	4
259	4	$plan->markAsExecuted($result);
260		$this->logResult($e, $result, $plan);
261	4
262	4	$this->dispatcher->dispatchVersionEvent(
263	4	Events::onMigrationsVersionSkipped,
264	4	$plan,
265		$configuration
266	4	);
267		}
268	4
269		private function logResult(Throwable $e, ExecutionResult $result, MigrationPlan $plan) : void
270	4	{
271	1	if ($result->isSkipped()) {
272	1	$this->logger->error(
273		'Migration {version} skipped during {state}. Reason: "{reason}"',
274	1	[
275	1	'version' => (string) $plan->getVersion(),
276	1	'reason' => $e->getMessage(),
277		'state' => $this->getExecutionStateAsString($result->getState()),
278		]
279	3	);
280	3	} elseif ($result->hasError()) {
281	3	$this->logger->error(
282		'Migration {version} failed during {state}. Error: "{error}"',
283	3	[
284	3	'version' => (string) $plan->getVersion(),
285	3	'error' => $e->getMessage(),
286		'state' => $this->getExecutionStateAsString($result->getState()),
287		]
288		);
289	4	}
290		}
291	9
292		private function executeResult(MigratorConfiguration $configuration) : void
293	9	{
294	9	foreach ($this->sql as $key => $query) {
295		$this->outputSqlQuery($query, $configuration);
296	9
297	9	$stopwatchEvent = $this->stopwatch->start('query');
298	9	$this->connection->executeUpdate($query->getStatement(), $query->getParameters(), $query->getTypes());
299		$stopwatchEvent->stop();
300	9
301	2	if (! $configuration->getTimeAllQueries()) {
302		continue;
303		}
304	7
305	7	$this->logger->notice('Query took {duration}ms', [
306		'duration' => $stopwatchEvent->getDuration(),
307		]);
308	9	}
309		}
310	10
311		private function outputSqlQuery(Query $query, MigratorConfiguration $configuration) : void
312	10	{
313	10	$params = $this->parameterFormatter->formatParameters(
314	10	$query->getParameters(),
315		$query->getTypes()
316		);
317	10
318	10	$this->logger->log(
319	10	$configuration->getTimeAllQueries() ? LogLevel::NOTICE : LogLevel::DEBUG,
320		'{query} {params}',
321	10	[
322		'query' => $query->getStatement(),
323	15	'params' => $params,
324		]
325		);
326	15	}
327
328		private function getFromSchema(MigratorConfiguration $configuration) : Schema
329		{
330	15	// if we're in a dry run, use the from Schema instead of reading the schema from the database
331		if ($configuration->isDryRun() && $configuration->getFromSchema() !== null) {
332		return $configuration->getFromSchema();
333	4	}
334
335		return $this->schemaProvider->createFromSchema();
336	4	}
337
338	4	private function getExecutionStateAsString(int $state) : string
339	1	{
340	3	switch ($state) {
341	3	case State::PRE:
342		return 'Pre-Checks';
343		case State::POST:
344		return 'Post-Checks';
345		case State::EXEC:
346		return 'Execution';
347		default:
348		return 'No State';
349		}
350		}
351		}
352

doctrine / migrations

DbalExecutor A last analyzed 2020-06-22 08:38 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

13 Methods

Duplication Side-by-Side

Filter issues like

DbalExecutor A
last analyzed 2020-06-22 08:38 UTC