PHP AbstractSchemaManager::createSchema方法代码示例

 /**
  * Migrates the database.
  *
  * @return Schema
  */
 public function migrate()
 {
     $diff = Comparator::compareSchemas($this->manager->createSchema(), $this->schema);
     foreach ($diff->toSaveSql($this->connection->getDatabasePlatform()) as $query) {
         $this->connection->executeQuery($query);
     }
 }

    public function testCreateSchema()
    {
        $this->createTestTable('test_table');

        $schema = $this->_sm->createSchema();

        $this->assertTrue($schema->hasTable('test_table'));
    }

 /**
  * Drop all tables.
  *
  * @param array $metadata
  * @return array
  */
 public function drop(array $metadata)
 {
     $visitor = new DropSchemaSqlCollector($this->platform);
     $schema = $this->getSchemaFromMetadata($metadata);
     $fullSchema = $this->schemaManager->createSchema();
     foreach ($fullSchema->getTables() as $table) {
         if ($schema->hasTable($table->getName())) {
             $visitor->acceptTable($table);
         }
     }
     $statements = $visitor->getQueries();
     $this->build($statements);
     return $statements;
 }

 public function constraintName($table, $column, $constraintType)
 {
     $schema = $this->schemaManager->createSchema();
     $unique = $primaryKey = $index = $foreignKey = null;
     extract($constraintType);
     $fieldConstraints = [];
     if ($foreignKey) {
         $foreignKeys = $schema->getTable($table)->getForeignKeys();
         /** @var $fk ForeignKeyConstraint */
         foreach ($foreignKeys as $fk) {
             if (in_array($column, $fk->getLocalColumns())) {
                 $fieldConstraints[] = $fk->getName();
             }
         }
     }
     return $fieldConstraints;
 }

 /**
  * Execute this migration version up or down and and return the SQL.
  *
  * @param string  $direction      The direction to execute the migration.
  * @param boolean $dryRun         Whether to not actually execute the migration SQL and just do a dry run.
  * @param boolean $timeAllQueries Measuring or not the execution time of each SQL query.
  *
  * @return array $sql
  *
  * @throws \Exception when migration fails
  */
 public function execute($direction, $dryRun = false, $timeAllQueries = false)
 {
     $this->sql = array();
     $transaction = $this->migration->isTransactional();
     if ($transaction) {
         //only start transaction if in transactional mode
         $this->connection->beginTransaction();
     }
     try {
         $migrationStart = 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) {
             if (!empty($this->sql)) {
                 foreach ($this->sql as $key => $query) {
                     $queryStart = microtime(true);
                     if (!isset($this->params[$key])) {
                         $this->outputWriter->write('     <comment>-></comment> ' . $query);
                         $this->connection->exec($query);
                     } else {
                         $this->outputWriter->write(sprintf('    <comment>-</comment> %s (with parameters)', $query));
                         $this->connection->executeQuery($query, $this->params[$key], $this->types[$key]);
                     }
                     $this->outputQueryTime($queryStart, $timeAllQueries);
                 }
             } 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);
         $migrationEnd = microtime(true);
         $this->time = round($migrationEnd - $migrationStart, 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));
         }
         if ($transaction) {
             //commit only if running in transactional mode
             $this->connection->commit();
         }
         $this->state = self::STATE_NONE;
         return $this->sql;
     } catch (SkipMigrationException $e) {
         if ($transaction) {
             //only rollback transaction if in transactional mode
             $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()));
         $this->state = self::STATE_NONE;
         return array();
     } catch (\Exception $e) {
         $this->outputWriter->write(sprintf('<error>Migration %s failed during %s. Error %s</error>', $this->version, $this->getExecutionState(), $e->getMessage()));
         if ($transaction) {
             //only rollback transaction if in transactional mode
             $this->connection->rollback();
         }
         $this->state = self::STATE_NONE;
         throw $e;
     }
 }

 /**
  * Constructor.
  *
  * @param Connection $connection
  */
 public function __construct(Connection $connection)
 {
     $this->connection = $connection;
     $this->manager = $this->connection->getSchemaManager();
     $this->schema = $this->manager->createSchema();
 }

 /**
  * Execute this migration version up or down and and return the SQL.
  *
  * @param string  $direction      The direction to execute the migration.
  * @param boolean $dryRun         Whether to not actually execute the migration SQL and just do a dry run.
  * @param boolean $timeAllQueries Measuring or not the execution time of each SQL query.
  *
  * @return array $sql
  *
  * @throws \Exception when migration fails
  */
 public function execute($direction, $dryRun = false, $timeAllQueries = false)
 {
     $this->sql = [];
     $transaction = $this->migration->isTransactional();
     if ($transaction) {
         //only start transaction if in transactional mode
         $this->connection->beginTransaction();
     }
     try {
         $migrationStart = microtime(true);
         $this->state = self::STATE_PRE;
         $fromSchema = $this->sm->createSchema();
         $this->migration->{'pre' . ucfirst($direction)}($fromSchema);
         if ($direction === self::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));
         $this->executeRegisteredSql($dryRun, $timeAllQueries);
         $this->state = self::STATE_POST;
         $this->migration->{'post' . ucfirst($direction)}($toSchema);
         $this->executeRegisteredSql($dryRun, $timeAllQueries);
         if (!$dryRun) {
             if ($direction === self::DIRECTION_UP) {
                 $this->markMigrated();
             } else {
                 $this->markNotMigrated();
             }
         }
         $migrationEnd = microtime(true);
         $this->time = round($migrationEnd - $migrationStart, 2);
         if ($direction === self::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));
         }
         if ($transaction) {
             //commit only if running in transactional mode
             $this->connection->commit();
         }
         $this->state = self::STATE_NONE;
         return $this->sql;
     } catch (SkipMigrationException $e) {
         if ($transaction) {
             //only rollback transaction if in transactional mode
             $this->connection->rollback();
         }
         if ($dryRun === false) {
             // now mark it as migrated
             if ($direction === self::DIRECTION_UP) {
                 $this->markMigrated();
             } else {
                 $this->markNotMigrated();
             }
         }
         $this->outputWriter->write(sprintf("\n  <info>SS</info> skipped (Reason: %s)", $e->getMessage()));
         $this->state = self::STATE_NONE;
         return [];
     } catch (\Exception $e) {
         $this->outputWriter->write(sprintf('<error>Migration %s failed during %s. Error %s</error>', $this->version, $this->getExecutionState(), $e->getMessage()));
         if ($transaction) {
             //only rollback transaction if in transactional mode
             $this->connection->rollback();
         }
         $this->state = self::STATE_NONE;
         throw $e;
     }
 }

 /**
  * Get schema the database is currently in.
  * @return Schema
  */
 public function getCurrentSchema()
 {
     return $this->schemaManager->createSchema();
 }

 /**
  * @return Schema
  */
 public function createFromSchema()
 {
     return $this->schemaManager->createSchema();
 }