<?php
/*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see
* <http://www.doctrine-project.org>.
*/
namespace Doctrine\DBAL\Migrations;
use Doctrine\DBAL\Migrations\Configuration\Configuration,
Doctrine\DBAL\Schema\Schema;
/**
* Class which wraps a migration version and allows execution of the
* individual migration version up or down method.
*
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.doctrine-project.org
* @since 2.0
* @author Jonathan H. Wage <jonwage@gmail.com>
*/
class Version
{
const STATE_NONE = 0;
const STATE_PRE = 1;
const STATE_EXEC = 2;
const STATE_POST = 3;
/**
* The Migrations Configuration instance for this migration
*
* @var Configuration
*/
private $configuration;
/**
* The OutputWriter object instance used for outputting information
*
* @var OutputWriter
*/
private $outputWriter;
/**
* The version in timestamp format (YYYYMMDDHHMMSS)
*
* @param int
*/
private $version;
/**
* @var AbstractSchemaManager
*/
private $sm;
/**
* @var AbstractPlatform
*/
private $platform;
/**
* The migration instance for this version
*
* @var AbstractMigration
*/
private $migration;
/**
* @var Connection
*/
private $connection;
/**
* @var string
*/
private $class;
/** The array of collected SQL statements for this version */
private $sql = array();
/** The array of collected parameters for SQL statements for this version */
private $params = array();
/** The array of collected types for SQL statements for this version */
private $types = array();
/** The time in seconds that this migration version took to execute */
private $time;
/**
* @var int
*/
private $state = self::STATE_NONE;
public function __construct(Configuration $configuration, $version, $class)
{
$this->configuration = $configuration;
$this->outputWriter = $configuration->getOutputWriter();
$this->class = $class;
$this->connection = $configuration->getConnection();
$this->sm = $this->connection->getSchemaManager();
$this->platform = $this->connection->getDatabasePlatform();
$this->migration = new $class($this);
$this->version = $this->migration->getName() ?: $version;
}
/**
* Returns the string version in the format YYYYMMDDHHMMSS
*
* @return string $version
*/
public function getVersion()
{
return $this->version;
}
/**
* Returns the Migrations Configuration object instance
*
* @return Configuration $configuration
*/
public function getConfiguration()
{
return $this->configuration;
}
/**
* Check if this version has been migrated or not.
*
* @param bool $bool
* @return mixed
*/
public function isMigrated()
{
return $this->configuration->hasVersionMigrated($this);
}
public function markMigrated()
{
$this->configuration->createMigrationTable();
$this->connection->executeQuery("INSERT INTO " . $this->configuration->getMigrationsTableName() . " (version) VALUES (?)", array($this->version));
}
public function markNotMigrated()
{
$this->configuration->createMigrationTable();
$this->connection->executeQuery("DELETE FROM " . $this->configuration->getMigrationsTableName() . " WHERE version = ?", array($this->version));
}
/**
* Add some SQL queries to this versions migration
*
* @param mixed $sql
* @param array $params
* @param array $types
* @return void
*/
public function addSql($sql, array $params = array(), array $types = array())
{
if (is_array($sql)) {
foreach ($sql as $key => $query) {
$this->sql[] = $query;
if (isset($params[$key])) {
$this->params[count($this->sql) - 1] = $params[$key];
$this->types[count($this->sql) - 1] = isset($types[$key]) ? $types[$key] : array();
}
}
} else {
$this->sql[] = $sql;
if ($params) {
$this->params[count($this->sql) - 1] = $params;
$this->types[count($this->sql) - 1] = $types ?: array();
}
}
}
/**
* Write a migration SQL file to the given path
*
* @param string $path The path to write the migration SQL file.
* @param string $direction The direction to execute.
* @return bool $written
*/
public function writeSqlFile($path, $direction = 'up')
{
$queries = $this->execute($direction, true);
$string = sprintf("# Doctrine Migration File Generated on %s\n", date('Y-m-d H:m:s'));
$string .= "\n# Version " . $this->version . "\n";
foreach ($queries as $query) {
$string .= $query . ";\n";
}
if (is_dir($path)) {
$path = realpath($path);
$path = $path . '/doctrine_migration_' . date('YmdHis') . '.sql';
}
$this->outputWriter->write("\n".sprintf('Writing migration file to "<info>%s</info>"', $path));
return file_put_contents($path, $string);
}
/**
* @return AbstractMigration
*/
public function getMigration()
{
return $this->migration;
}
/**
* Execute this migration version up or down and and return the SQL.
*
* @param string $direction The direction to execute the migration.
* @param string $dryRun Whether to not actually execute the migration SQL and just do a dry run.
* @return array $sql
* @throws Exception when migration fails
*/
public function execute($direction, $dryRun = false)
{
$this->sql = array();
$this->connection->beginTransaction();
try {
$start = microtime(true);
$this->state = self::STATE_PRE;
$fromSchema = $this->sm->createSchema();
$this->migration->{'pre' . ucfirst($direction)}($fromSchema);
if ($direction === 'up') {
$this->outputWriter->write("\n" . sprintf(' <info>++</info> migrating <comment>%s</comment>', $this->version) . "\n");
} else {
$this->outputWriter->write("\n" . sprintf(' <info>--</info> reverting <comment>%s</comment>', $this->version) . "\n");
}
$this->state = self::STATE_EXEC;
$toSchema = clone $fromSchema;
$this->migration->$direction($toSchema);
$this->addSql($fromSchema->getMigrateToSql($toSchema, $this->platform));
if ($dryRun === false) {
if ($this->sql) {
foreach ($this->sql as $key => $query) {
if ( ! isset($this->params[$key])) {
$this->outputWriter->write(' <comment>-></comment> ' . $query);
$this->connection->executeQuery($query);
} else {
$this->outputWriter->write(sprintf(' <comment>-</comment> %s (with parameters)', $query));
$this->connection->executeQuery($query, $this->params[$key], $this->types[$key]);
}
}
} else {
$this->outputWriter->write(sprintf('<error>Migration %s was executed but did not result in any SQL statements.</error>', $this->version));
}
if ($direction === 'up') {
$this->markMigrated();
} else {
$this->markNotMigrated();
}
} else {
foreach ($this->sql as $query) {
$this->outputWriter->write(' <comment>-></comment> ' . $query);
}
}
$this->state = self::STATE_POST;
$this->migration->{'post' . ucfirst($direction)}($toSchema);
$end = microtime(true);
$this->time = round($end - $start, 2);
if ($direction === 'up') {
$this->outputWriter->write(sprintf("\n <info>++</info> migrated (%ss)", $this->time));
} else {
$this->outputWriter->write(sprintf("\n <info>--</info> reverted (%ss)", $this->time));
}
$this->connection->commit();
return $this->sql;
} catch(SkipMigrationException $e) {
$this->connection->rollback();
if ($dryRun == false) {
// now mark it as migrated
if ($direction === 'up') {
$this->markMigrated();
} else {
$this->markNotMigrated();
}
}
$this->outputWriter->write(sprintf("\n <info>SS</info> skipped (Reason: %s)", $e->getMessage()));
} catch (\Exception $e) {
$this->outputWriter->write(sprintf(
'<error>Migration %s failed during %s. Error %s</error>',
$this->version, $this->getExecutionState(), $e->getMessage()
));
$this->connection->rollback();
$this->state = self::STATE_NONE;
throw $e;
}
$this->state = self::STATE_NONE;
}
public function getExecutionState()
{
switch($this->state) {
case self::STATE_PRE:
return 'Pre-Checks';
case self::STATE_POST:
return 'Post-Checks';
case self::STATE_EXEC:
return 'Execution';
default:
return 'No State';
}
}
/**
* Returns the time this migration version took to execute
*
* @return integer $time The time this migration version took to execute
*/
public function getTime()
{
return $this->time;
}
public function __toString()
{
return $this->version;
}
}