PHP AbstractPlatform::supportsSequences方法代码示例

 /**
  * {@inheritdoc}
  */
 public function up(Schema $schema, QueryBag $queries)
 {
     /**
      * After v1_3 migration
      * Undefined table: 7 ERROR:  relation "oro_dashboard_active_id_seq" does not exist
      */
     if ($this->platform->supportsSequences()) {
         $queries->addPostQuery('ALTER SEQUENCE IF EXISTS oro_dashboard_active_copy_id_seq RENAME TO oro_dashboard_active_id_seq;');
     }
 }

 /**
  * Create a schema instance for the current database.
  * 
  * @return Schema
  */
 public function createSchema()
 {
     $sequences = array();
     if ($this->_platform->supportsSequences()) {
         $sequences = $this->listSequences();
     }
     $tables = $this->listTables();
     return new Schema($tables, $sequences, $this->createSchemaConfig());
 }

 private function getRevisionId()
 {
     if ($this->revisionId === null) {
         $this->conn->insert($this->config->getRevisionTableName(), array('timestamp' => date_create('now'), 'username' => $this->config->getCurrentUsername()), array(Type::DATETIME, Type::STRING));
         $sequenceName = $this->platform->supportsSequences() ? $this->platform->getIdentitySequenceName($this->config->getRevisionTableName(), 'id') : null;
         $this->revisionId = $this->conn->lastInsertId($sequenceName);
     }
     return $this->revisionId;
 }

 protected function getRevisionId()
 {
     if ($this->revisionId === null) {
         $this->auditEm->getConnection()->insert($this->config->getRevisionTableName(), array('timestamp' => date_create('now'), 'username' => $this->config->getCurrentUsername()), array(Type::DATETIME, Type::STRING));
         $sequenceName = $this->platform->supportsSequences() ? 'REVISIONS_ID_SEQ' : null;
         $this->revisionId = $this->auditEm->getConnection()->lastInsertId($sequenceName);
     }
     return $this->revisionId;
 }

    /**
     *
     * @param array $classes
     * @return array
     */
    public function getDropSchemaSQL(array $classes)
    {
        $sm = $this->_em->getConnection()->getSchemaManager();
        
        $sql = array();
        $orderedTables = array();

        foreach ($classes AS $class) {
            if ($class->isIdGeneratorSequence() && $class->name == $class->rootEntityName && $this->_platform->supportsSequences()) {
                $sql[] = $this->_platform->getDropSequenceSQL($class->sequenceGeneratorDefinition['sequenceName']);
            }
        }

        $commitOrder = $this->_getCommitOrder($classes);
        $associationTables = $this->_getAssociationTables($commitOrder);

        // Drop association tables first
        foreach ($associationTables as $associationTable) {
            if (!in_array($associationTable, $orderedTables)) {
                $orderedTables[] = $associationTable;
            }
        }

        // Drop tables in reverse commit order
        for ($i = count($commitOrder) - 1; $i >= 0; --$i) {
            $class = $commitOrder[$i];

            if (($class->isInheritanceTypeSingleTable() && $class->name != $class->rootEntityName)
                || $class->isMappedSuperclass) {
                continue;
            }

            if (!in_array($class->getTableName(), $orderedTables)) {
                $orderedTables[] = $class->getTableName();
            }
        }

        $dropTablesSql = array();
        foreach ($orderedTables AS $tableName) {
            /* @var $sm \Doctrine\DBAL\Schema\AbstractSchemaManager */
            $foreignKeys = $sm->listTableForeignKeys($tableName);
            foreach ($foreignKeys AS $foreignKey) {
                $sql[] = $this->_platform->getDropForeignKeySQL($foreignKey, $tableName);
            }
            $dropTablesSql[] = $this->_platform->getDropTableSQL($tableName);
        }

        return array_merge($sql, $dropTablesSql);
    }

 /**
  * Get SQL to drop the tables defined by the passed classes.
  * 
  * @param array $classes
  * @return array
  */
 public function getDropSchemaSQL(array $classes)
 {
     $visitor = new \Doctrine\DBAL\Schema\Visitor\DropSchemaSqlCollector($this->_platform);
     $schema = $this->getSchemaFromMetadata($classes);
     $sm = $this->_em->getConnection()->getSchemaManager();
     $fullSchema = $sm->createSchema();
     foreach ($fullSchema->getTables() as $table) {
         if (!$schema->hasTable($table->getName())) {
             foreach ($table->getForeignKeys() as $foreignKey) {
                 /* @var $foreignKey \Doctrine\DBAL\Schema\ForeignKeyConstraint */
                 if ($schema->hasTable($foreignKey->getForeignTableName())) {
                     $visitor->acceptForeignKey($table, $foreignKey);
                 }
             }
         } else {
             $visitor->acceptTable($table);
             foreach ($table->getForeignKeys() as $foreignKey) {
                 $visitor->acceptForeignKey($table, $foreignKey);
             }
         }
     }
     if ($this->_platform->supportsSequences()) {
         foreach ($schema->getSequences() as $sequence) {
             $visitor->acceptSequence($sequence);
         }
         foreach ($schema->getTables() as $table) {
             /* @var $sequence Table */
             foreach ($table->getIndexes() as $index) {
                 if ($index->isPrimary()) {
                     $columns = $index->getColumns();
                     if (count($columns) == 1) {
                         $checkSequence = $table->getName() . "_" . $columns[0] . "_seq";
                         if ($fullSchema->hasSequence($checkSequence)) {
                             $visitor->acceptSequence($fullSchema->getSequence($checkSequence));
                         }
                     }
                 }
             }
         }
     }
     return $visitor->getQueries();
 }

 /**
  * Get the SQL Statements to drop the given schema from underlying db.
  *
  * @param Schema $dropSchema
  * @return array
  */
 public function getDropSchema(Schema $dropSchema)
 {
     $visitor = new DropSchemaSqlCollector($this->platform);
     $sm = $this->conn->getSchemaManager();
     $fullSchema = $sm->createSchema();
     foreach ($fullSchema->getTables() as $table) {
         if ($dropSchema->hasTable($table->getName())) {
             $visitor->acceptTable($table);
         }
         foreach ($table->getForeignKeys() as $foreignKey) {
             if (!$dropSchema->hasTable($table->getName())) {
                 continue;
             }
             if (!$dropSchema->hasTable($foreignKey->getForeignTableName())) {
                 continue;
             }
             $visitor->acceptForeignKey($table, $foreignKey);
         }
     }
     if (!$this->platform->supportsSequences()) {
         return $visitor->getQueries();
     }
     foreach ($dropSchema->getSequences() as $sequence) {
         $visitor->acceptSequence($sequence);
     }
     foreach ($dropSchema->getTables() as $table) {
         /* @var $sequence Table */
         if (!$table->hasPrimaryKey()) {
             continue;
         }
         $columns = $table->getPrimaryKey()->getColumns();
         if (count($columns) > 1) {
             continue;
         }
         $checkSequence = $table->getName() . "_" . $columns[0] . "_seq";
         if ($fullSchema->hasSequence($checkSequence)) {
             $visitor->acceptSequence($fullSchema->getSequence($checkSequence));
         }
     }
     return $visitor->getQueries();
 }

 /**
  * @param \Doctrine\DBAL\Platforms\AbstractPlatform $platform
  * @param boolean                                   $saveMode
  *
  * @return array
  */
 protected function _toSql(AbstractPlatform $platform, $saveMode = false)
 {
     $sql = array();
     if ($platform->supportsSchemas()) {
         foreach ($this->newNamespaces as $newNamespace) {
             $sql[] = $platform->getCreateSchemaSQL($newNamespace);
         }
     }
     if ($platform->supportsForeignKeyConstraints() && $saveMode == false) {
         foreach ($this->orphanedForeignKeys as $orphanedForeignKey) {
             $sql[] = $platform->getDropForeignKeySQL($orphanedForeignKey, $orphanedForeignKey->getLocalTableName());
         }
     }
     if ($platform->supportsSequences() == true) {
         foreach ($this->changedSequences as $sequence) {
             $sql[] = $platform->getAlterSequenceSQL($sequence);
         }
         if ($saveMode === false) {
             foreach ($this->removedSequences as $sequence) {
                 $sql[] = $platform->getDropSequenceSQL($sequence);
             }
         }
         foreach ($this->newSequences as $sequence) {
             $sql[] = $platform->getCreateSequenceSQL($sequence);
         }
     }
     $foreignKeySql = array();
     foreach ($this->newTables as $table) {
         $sql = array_merge($sql, $platform->getCreateTableSQL($table, AbstractPlatform::CREATE_INDEXES));
         if ($platform->supportsForeignKeyConstraints()) {
             foreach ($table->getForeignKeys() as $foreignKey) {
                 $foreignKeySql[] = $platform->getCreateForeignKeySQL($foreignKey, $table);
             }
         }
     }
     $sql = array_merge($sql, $foreignKeySql);
     if ($saveMode === false) {
         foreach ($this->removedTables as $table) {
             $sql[] = $platform->getDropTableSQL($table);
         }
     }
     foreach ($this->changedTables as $tableDiff) {
         $sql = array_merge($sql, $platform->getAlterTableSQL($tableDiff));
     }
     return $sql;
 }