vendor/doctrine/migrations/lib/Doctrine/Migrations/Metadata/Storage/TableMetadataStorage.php line 225

  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\Migrations\Metadata\Storage;
  7. use DateTimeImmutable;
  8. use Doctrine\DBAL\Connection;
  9. use Doctrine\DBAL\Connections\PrimaryReadReplicaConnection;
  10. use Doctrine\DBAL\Platforms\AbstractPlatform;
  11. use Doctrine\DBAL\Schema\AbstractSchemaManager;
  12. use Doctrine\DBAL\Schema\Table;
  13. use Doctrine\DBAL\Schema\TableDiff;
  14. use Doctrine\DBAL\Types\Types;
  15. use Doctrine\Migrations\Exception\MetadataStorageError;
  16. use Doctrine\Migrations\Metadata\AvailableMigration;
  17. use Doctrine\Migrations\Metadata\ExecutedMigration;
  18. use Doctrine\Migrations\Metadata\ExecutedMigrationsList;
  19. use Doctrine\Migrations\MigrationsRepository;
  20. use Doctrine\Migrations\Query\Query;
  21. use Doctrine\Migrations\Version\Comparator as MigrationsComparator;
  22. use Doctrine\Migrations\Version\Direction;
  23. use Doctrine\Migrations\Version\ExecutionResult;
  24. use Doctrine\Migrations\Version\Version;
  25. use InvalidArgumentException;
  27. use function array_change_key_case;
  28. use function floatval;
  29. use function round;
  30. use function sprintf;
  31. use function strlen;
  32. use function strpos;
  33. use function strtolower;
  34. use function uasort;
  36. use const CASE_LOWER;
  38. final class TableMetadataStorage implements MetadataStorage
  39. {
  40.     private bool $isInitialized = false;
  42.     private bool $schemaUpToDate = false;
  44.     private Connection $connection;
  46.     /** @var AbstractSchemaManager<AbstractPlatform> */
  47.     private AbstractSchemaManager $schemaManager;
  49.     private AbstractPlatform $platform;
  51.     private TableMetadataStorageConfiguration $configuration;
  53.     private ?MigrationsRepository $migrationRepository = null;
  55.     private MigrationsComparator $comparator;
  57.     public function __construct(
  58.         Connection $connection,
  59.         MigrationsComparator $comparator,
  60.         ?MetadataStorageConfiguration $configuration = null,
  61.         ?MigrationsRepository $migrationRepository = null
  62.     ) {
  63.         $this->migrationRepository = $migrationRepository;
  64.         $this->connection          = $connection;
  65.         $this->schemaManager       = $connection->createSchemaManager();
  66.         $this->platform            = $connection->getDatabasePlatform();
  68.         if ($configuration !== null && ! ($configuration instanceof TableMetadataStorageConfiguration)) {
  69.             throw new InvalidArgumentException(sprintf('%s accepts only %s as configuration', self::class, TableMetadataStorageConfiguration::class));
  70.         }
  72.         $this->configuration = $configuration ?? new TableMetadataStorageConfiguration();
  73.         $this->comparator    = $comparator;
  74.     }
  76.     public function getExecutedMigrations(): ExecutedMigrationsList
  77.     {
  78.         if (! $this->isInitialized()) {
  79.             return new ExecutedMigrationsList([]);
  80.         }
  82.         $this->checkInitialization();
  83.         $rows = $this->connection->fetchAllAssociative(sprintf('SELECT * FROM %s', $this->configuration->getTableName()));
  85.         $migrations = [];
  86.         foreach ($rows as $row) {
  87.             $row = array_change_key_case($row, CASE_LOWER);
  89.             $version = new Version($row[strtolower($this->configuration->getVersionColumnName())]);
  91.             $executedAt = $row[strtolower($this->configuration->getExecutedAtColumnName())] ?? '';
  92.             $executedAt = $executedAt !== ''
  93.                 ? DateTimeImmutable::createFromFormat($this->platform->getDateTimeFormatString(), $executedAt)
  94.                 : null;
  96.             $executionTime = isset($row[strtolower($this->configuration->getExecutionTimeColumnName())])
  97.                 ? floatval($row[strtolower($this->configuration->getExecutionTimeColumnName())] / 1000)
  98.                 : null;
  100.             $migration = new ExecutedMigration(
  101.                 $version,
  102.                 $executedAt instanceof DateTimeImmutable ? $executedAt : null,
  103.                 $executionTime
  104.             );
  106.             $migrations[(string) $version] = $migration;
  107.         }
  109.         uasort($migrations, function (ExecutedMigration $a, ExecutedMigration $b): int {
  110.             return $this->comparator->compare($a->getVersion(), $b->getVersion());
  111.         });
  113.         return new ExecutedMigrationsList($migrations);
  114.     }
  116.     public function reset(): void
  117.     {
  118.         $this->checkInitialization();
  120.         $this->connection->executeStatement(
  121.             sprintf(
  122.                 'DELETE FROM %s WHERE 1 = 1',
  123.                 $this->platform->quoteIdentifier($this->configuration->getTableName())
  124.             )
  125.         );
  126.     }
  128.     public function complete(ExecutionResult $result): void
  129.     {
  130.         $this->checkInitialization();
  132.         if ($result->getDirection() === Direction::DOWN) {
  133.             $this->connection->delete($this->configuration->getTableName(), [
  134.                 $this->configuration->getVersionColumnName() => (string) $result->getVersion(),
  135.             ]);
  136.         } else {
  137.             $this->connection->insert($this->configuration->getTableName(), [
  138.                 $this->configuration->getVersionColumnName() => (string) $result->getVersion(),
  139.                 $this->configuration->getExecutedAtColumnName() => $result->getExecutedAt(),
  140.                 $this->configuration->getExecutionTimeColumnName() => $result->getTime() === null ? null : (int) round($result->getTime() * 1000),
  141.             ], [
  142.                 Types::STRING,
  143.                 Types::DATETIME_MUTABLE,
  144.                 Types::INTEGER,
  145.             ]);
  146.         }
  147.     }
  149.     /**
  150.      * @return iterable<Query>
  151.      */
  152.     public function getSql(ExecutionResult $result): iterable
  153.     {
  154.         yield new Query('-- Version ' . (string) $result->getVersion() . ' update table metadata');
  156.         if ($result->getDirection() === Direction::DOWN) {
  157.             yield new Query(sprintf(
  158.                 'DELETE FROM %s WHERE %s = %s',
  159.                 $this->configuration->getTableName(),
  160.                 $this->configuration->getVersionColumnName(),
  161.                 $this->connection->quote((string) $result->getVersion())
  162.             ));
  164.             return;
  165.         }
  167.         yield new Query(sprintf(
  168.             'INSERT INTO %s (%s, %s, %s) VALUES (%s, %s, 0)',
  169.             $this->configuration->getTableName(),
  170.             $this->configuration->getVersionColumnName(),
  171.             $this->configuration->getExecutedAtColumnName(),
  172.             $this->configuration->getExecutionTimeColumnName(),
  173.             $this->connection->quote((string) $result->getVersion()),
  174.             $this->connection->quote(($result->getExecutedAt() ?? new DateTimeImmutable())->format('Y-m-d H:i:s'))
  175.         ));
  176.     }
  178.     public function ensureInitialized(): void
  179.     {
  180.         if (! $this->isInitialized()) {
  181.             $expectedSchemaChangelog = $this->getExpectedTable();
  182.             $this->schemaManager->createTable($expectedSchemaChangelog);
  183.             $this->schemaUpToDate = true;
  184.             $this->isInitialized  = true;
  186.             return;
  187.         }
  189.         $this->isInitialized     = true;
  190.         $expectedSchemaChangelog = $this->getExpectedTable();
  191.         $diff                    = $this->needsUpdate($expectedSchemaChangelog);
  192.         if ($diff === null) {
  193.             $this->schemaUpToDate = true;
  195.             return;
  196.         }
  198.         $this->schemaUpToDate = true;
  199.         $this->schemaManager->alterTable($diff);
  200.         $this->updateMigratedVersionsFromV1orV2toV3();
  201.     }
  203.     private function needsUpdate(Table $expectedTable): ?TableDiff
  204.     {
  205.         if ($this->schemaUpToDate) {
  206.             return null;
  207.         }
  209.         $currentTable = $this->schemaManager->introspectTable($this->configuration->getTableName());
  210.         $diff         = $this->schemaManager->createComparator()->compareTables($currentTable, $expectedTable);
  212.         return $diff->isEmpty() ? null : $diff;
  213.     }
  215.     private function isInitialized(): bool
  216.     {
  217.         if ($this->isInitialized) {
  218.             return $this->isInitialized;
  219.         }
  221.         if ($this->connection instanceof PrimaryReadReplicaConnection) {
  222.             $this->connection->ensureConnectedToPrimary();
  223.         }
  225.         return $this->schemaManager->tablesExist([$this->configuration->getTableName()]);
  226.     }
  228.     private function checkInitialization(): void
  229.     {
  230.         if (! $this->isInitialized()) {
  231.             throw MetadataStorageError::notInitialized();
  232.         }
  234.         $expectedTable = $this->getExpectedTable();
  236.         if ($this->needsUpdate($expectedTable) !== null) {
  237.             throw MetadataStorageError::notUpToDate();
  238.         }
  239.     }
  241.     private function getExpectedTable(): Table
  242.     {
  243.         $schemaChangelog = new Table($this->configuration->getTableName());
  245.         $schemaChangelog->addColumn(
  246.             $this->configuration->getVersionColumnName(),
  247.             'string',
  248.             ['notnull' => true, 'length' => $this->configuration->getVersionColumnLength()]
  249.         );
  250.         $schemaChangelog->addColumn($this->configuration->getExecutedAtColumnName(), 'datetime', ['notnull' => false]);
  251.         $schemaChangelog->addColumn($this->configuration->getExecutionTimeColumnName(), 'integer', ['notnull' => false]);
  253.         $schemaChangelog->setPrimaryKey([$this->configuration->getVersionColumnName()]);
  255.         return $schemaChangelog;
  256.     }
  258.     private function updateMigratedVersionsFromV1orV2toV3(): void
  259.     {
  260.         if ($this->migrationRepository === null) {
  261.             return;
  262.         }
  264.         $availableMigrations = $this->migrationRepository->getMigrations()->getItems();
  265.         $executedMigrations  = $this->getExecutedMigrations()->getItems();
  267.         foreach ($availableMigrations as $availableMigration) {
  268.             foreach ($executedMigrations as $k => $executedMigration) {
  269.                 if ($this->isAlreadyV3Format($availableMigration, $executedMigration)) {
  270.                     continue;
  271.                 }
  273.                 $this->connection->update(
  274.                     $this->configuration->getTableName(),
  275.                     [
  276.                         $this->configuration->getVersionColumnName() => (string) $availableMigration->getVersion(),
  277.                     ],
  278.                     [
  279.                         $this->configuration->getVersionColumnName() => (string) $executedMigration->getVersion(),
  280.                     ]
  281.                 );
  282.                 unset($executedMigrations[$k]);
  283.             }
  284.         }
  285.     }
  287.     private function isAlreadyV3Format(AvailableMigration $availableMigration, ExecutedMigration $executedMigration): bool
  288.     {
  289.         return strpos(
  290.             (string) $availableMigration->getVersion(),
  291.             (string) $executedMigration->getVersion()
  292.         ) !== strlen((string) $availableMigration->getVersion()) -
  293.                 strlen((string) $executedMigration->getVersion());
  294.     }
  295. }