PHP AbstractPlatform::getCreateIndexSQL方法代码示例

 public function testGeneratesPartialIndexesSqlOnlyWhenSupportingPartialIndexes()
 {
     $where = 'test IS NULL AND test2 IS NOT NULL';
     $indexDef = new \Doctrine\DBAL\Schema\Index('name', array('test', 'test2'), false, false, array(), array('where' => $where));
     $uniqueIndex = new \Doctrine\DBAL\Schema\Index('name', array('test', 'test2'), true, false, array(), array('where' => $where));
     $expected = ' WHERE ' . $where;
     $actuals = array();
     if ($this->supportsInlineIndexDeclaration()) {
         $actuals[] = $this->_platform->getIndexDeclarationSQL('name', $indexDef);
     }
     $actuals[] = $this->_platform->getUniqueConstraintDeclarationSQL('name', $uniqueIndex);
     $actuals[] = $this->_platform->getCreateIndexSQL($indexDef, 'table');
     foreach ($actuals as $actual) {
         if ($this->_platform->supportsPartialIndexes()) {
             $this->assertStringEndsWith($expected, $actual, 'WHERE clause should be present');
         } else {
             $this->assertStringEndsNotWith($expected, $actual, 'WHERE clause should NOT be present');
         }
     }
 }

 /**
  * {@inheritdoc}
  *
  * Appends SQL Anywhere specific flags if given.
  */
 public function getCreateIndexSQL(Index $index, $table)
 {
     return parent::getCreateIndexSQL($index, $table) . $this->getAdvancedIndexOptionsSQL($index);
 }

 /**
  * Create a new index on a table
  *
  * @param Index     $index
  * @param string    $table         name of the table on which the index is to be created
  */
 public function createIndex(Index $index, $table)
 {
     $this->_execSql($this->_platform->getCreateIndexSQL($index, $table));
 }

 /**
  * {@inheritDoc}
  */
 public function getCreateIndexSQL(Index $index, $table)
 {
     $constraint = parent::getCreateIndexSQL($index, $table);
     if ($index->isUnique() && !$index->isPrimary()) {
         $constraint = $this->_appendUniqueConstraintDefinition($constraint, $index);
     }
     return $constraint;
 }

 /**
  * @param $tables
  * @param $backupPrefix
  *
  * @return array
  *
  * @throws \Doctrine\DBAL\DBALException
  */
 protected function backupExistingSchema($tables, $mauticTables, $backupPrefix)
 {
     $sql = [];
     $sm = $this->db->getSchemaManager();
     //backup existing tables
     $backupRestraints = $backupSequences = $backupIndexes = $backupTables = $dropSequences = $dropTables = [];
     //cycle through the first time to drop all the foreign keys
     foreach ($tables as $t) {
         if (!isset($mauticTables[$t]) && !in_array($t, $mauticTables)) {
             // Not an applicable table
             continue;
         }
         $restraints = $sm->listTableForeignKeys($t);
         if (isset($mauticTables[$t])) {
             //to be backed up
             $backupRestraints[$mauticTables[$t]] = $restraints;
             $backupTables[$t] = $mauticTables[$t];
             $backupIndexes[$t] = $sm->listTableIndexes($t);
         } else {
             //existing backup to be dropped
             $dropTables[] = $t;
         }
         foreach ($restraints as $restraint) {
             $sql[] = $this->platform->getDropForeignKeySQL($restraint, $t);
         }
     }
     //now drop all the backup tables
     foreach ($dropTables as $t) {
         $sql[] = $this->platform->getDropTableSQL($t);
     }
     //now backup tables
     foreach ($backupTables as $t => $backup) {
         //drop old indexes
         /** @var \Doctrine\DBAL\Schema\Index $oldIndex */
         foreach ($backupIndexes[$t] as $indexName => $oldIndex) {
             if ($indexName == 'primary') {
                 continue;
             }
             $oldName = $oldIndex->getName();
             $newName = $this->generateBackupName($this->dbParams['table_prefix'], $backupPrefix, $oldName);
             $newIndex = new Index($newName, $oldIndex->getColumns(), $oldIndex->isUnique(), $oldIndex->isPrimary(), $oldIndex->getFlags());
             $newIndexes[] = $newIndex;
             $sql[] = $this->platform->getDropIndexSQL($oldIndex, $t);
         }
         //rename table
         $tableDiff = new TableDiff($t);
         $tableDiff->newName = $backup;
         $queries = $this->platform->getAlterTableSQL($tableDiff);
         $sql = array_merge($sql, $queries);
         //create new index
         if (!empty($newIndexes)) {
             foreach ($newIndexes as $newIndex) {
                 $sql[] = $this->platform->getCreateIndexSQL($newIndex, $backup);
             }
             unset($newIndexes);
         }
     }
     //apply foreign keys to backup tables
     foreach ($backupRestraints as $table => $oldRestraints) {
         foreach ($oldRestraints as $or) {
             $foreignTable = $or->getForeignTableName();
             $foreignTableName = $this->generateBackupName($this->dbParams['table_prefix'], $backupPrefix, $foreignTable);
             $r = new ForeignKeyConstraint($or->getLocalColumns(), $foreignTableName, $or->getForeignColumns(), $backupPrefix . $or->getName(), $or->getOptions());
             $sql[] = $this->platform->getCreateForeignKeySQL($r, $table);
         }
     }
     return $sql;
 }

 public function testGeneratesUniqueIndexCreationSql()
 {
     $indexDef = new \Doctrine\DBAL\Schema\Index('index_name', array('test', 'test2'), true);
     $sql = $this->_platform->getCreateIndexSQL($indexDef, 'test');
     $this->assertEquals($this->getGenerateUniqueIndexSql(), $sql);
 }